Merge pull request RustPython#240 from coolreader18/json-error

Have the json ser/de functions throw an exception instead of panicking

Author: windelbouwman

vm/src/exceptions.rs

@@ -107,90 +107,37 @@ impl ExceptionZoo {
         let base_exception_type =
             create_type("BaseException", &type_type, &object_type, &dict_type);
 
-        let exception_type = create_type(
-            &String::from("Exception"),
-            &type_type,
-            &base_exception_type,
-            &dict_type,
-        );
-        let syntax_error = create_type(
-            &String::from("SyntaxError"),
-            &type_type,
-            &exception_type,
-            &dict_type,
-        );
-        let assertion_error = create_type(
-            &String::from("AssertionError"),
-            &type_type,
-            &exception_type,
-            &dict_type,
-        );
+        let exception_type = create_type("Exception", &type_type, &base_exception_type, &dict_type);
+        let syntax_error = create_type("SyntaxError", &type_type, &exception_type, &dict_type);
+        let assertion_error =
+            create_type("AssertionError", &type_type, &exception_type, &dict_type);
         let attribute_error = create_type(
-            &String::from("AttributeError"),
+            "AttributeError",
             &type_type,
             &exception_type.clone(),
             &dict_type,
         );
         let index_error = create_type(
-            &String::from("IndexError"),
+            "IndexError",
             &type_type,
             &exception_type.clone(),
             &dict_type,
         );
-        let key_error = create_type(
-            &String::from("KeyError"),
-            &type_type,
-            &exception_type.clone(),
-            &dict_type,
-        );
-        let name_error = create_type(
-            &String::from("NameError"),
-            &type_type,
-            &exception_type.clone(),
-            &dict_type,
-        );
-        let runtime_error = create_type(
-            &String::from("RuntimeError"),
-            &type_type,
-            &exception_type,
-            &dict_type,
-        );
+        let key_error = create_type("KeyError", &type_type, &exception_type.clone(), &dict_type);
+        let name_error = create_type("NameError", &type_type, &exception_type.clone(), &dict_type);
+        let runtime_error = create_type("RuntimeError", &type_type, &exception_type, &dict_type);
         let not_implemented_error = create_type(
-            &String::from("NotImplementedError"),
+            "NotImplementedError",
             &type_type,
             &runtime_error,
             &dict_type,
         );
-        let stop_iteration = create_type(
-            &String::from("StopIteration"),
-            &type_type,
-            &exception_type,
-            &dict_type,
-        );
-        let type_error = create_type(
-            &String::from("TypeError"),
-            &type_type,
-            &exception_type,
-            &dict_type,
-        );
-        let value_error = create_type(
-            &String::from("ValueError"),
-            &type_type,
-            &exception_type,
-            &dict_type,
-        );
-        let import_error = create_type(
-            &String::from("ImportError"),
-            &type_type,
-            &exception_type,
-            &dict_type,
-        );
-        let module_not_found_error = create_type(
-            &String::from("ModuleNotFoundError"),
-            &type_type,
-            &import_error,
-            &dict_type,
-        );
+        let stop_iteration = create_type("StopIteration", &type_type, &exception_type, &dict_type);
+        let type_error = create_type("TypeError", &type_type, &exception_type, &dict_type);
+        let value_error = create_type("ValueError", &type_type, &exception_type, &dict_type);
+        let import_error = create_type("ImportError", &type_type, &exception_type, &dict_type);
+        let module_not_found_error =
+            create_type("ModuleNotFoundError", &type_type, &import_error, &dict_type);
 
         ExceptionZoo {
             base_exception_type: base_exception_type,

vm/src/stdlib/json.rs

@@ -7,7 +7,8 @@ use serde_json;
 
 use super::super::obj::{objbool, objdict, objfloat, objint, objsequence, objstr, objtype};
 use super::super::pyobject::{
-    PyContext, PyFuncArgs, PyObjectKind, PyObjectRef, PyResult, TypeProtocol,
+    create_type, DictProtocol, PyContext, PyFuncArgs, PyObjectKind, PyObjectRef, PyResult,
+    TypeProtocol,
 };
 use super::super::VirtualMachine;
 use num_bigint::ToBigInt;
@@ -69,10 +70,10 @@ impl<'s> serde::Serialize for PyObjectSerializer<'s> {
         } else if let PyObjectKind::None = self.pyobject.borrow().kind {
             serializer.serialize_none()
         } else {
-            unimplemented!(
+            Err(serde::ser::Error::custom(format!(
                 "Object of type '{:?}' is not serializable",
                 self.pyobject.typ()
-            );
+            )))
         }
     }
 }
@@ -190,31 +191,57 @@ impl<'de> serde::de::DeserializeSeed<'de> for PyObjectDeserializer<'de> {
 fn dumps(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
     // TODO: Implement non-trivial serialisation case
     arg_check!(vm, args, required = [(obj, None)]);
-    // TODO: Raise an exception for serialisation errors
-    let serializer = PyObjectSerializer {
-        pyobject: obj,
-        ctx: &vm.ctx,
+    let res = {
+        let serializer = PyObjectSerializer {
+            pyobject: obj,
+            ctx: &vm.ctx,
+        };
+        serde_json::to_string(&serializer)
     };
-    let string = serde_json::to_string(&serializer).unwrap();
+    let string = res.map_err(|err| vm.new_type_error(format!("{}", err)))?;
     Ok(vm.context().new_str(string))
 }
 
 fn loads(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
     // TODO: Implement non-trivial deserialisation case
     arg_check!(vm, args, required = [(string, Some(vm.ctx.str_type()))]);
-    // TODO: Raise an exception for deserialisation errors
-    let de = PyObjectDeserializer { ctx: &vm.ctx };
-    // TODO: Support deserializing string sub-classes
-    Ok(de
-        .deserialize(&mut serde_json::Deserializer::from_str(&objstr::get_value(
+    let res = {
+        let de = PyObjectDeserializer { ctx: &vm.ctx };
+        // TODO: Support deserializing string sub-classes
+        de.deserialize(&mut serde_json::Deserializer::from_str(&objstr::get_value(
             &string,
         )))
-        .unwrap())
+    };
+
+    res.map_err(|err| {
+        let json_decode_error = vm
+            .sys_module
+            .get_item("modules")
+            .unwrap()
+            .get_item("json")
+            .unwrap()
+            .get_item("JSONDecodeError")
+            .unwrap();
+        let exc = vm.new_exception(json_decode_error, format!("{}", err));
+        vm.ctx
+            .set_item(&exc, "lineno", vm.ctx.new_int(err.line().into()));
+        vm.ctx
+            .set_item(&exc, "colno", vm.ctx.new_int(err.column().into()));
+        exc
+    })
 }
 
 pub fn mk_module(ctx: &PyContext) -> PyObjectRef {
     let json_mod = ctx.new_module(&"json".to_string(), ctx.new_scope(None));
     ctx.set_attr(&json_mod, "dumps", ctx.new_rustfunc(dumps));
     ctx.set_attr(&json_mod, "loads", ctx.new_rustfunc(loads));
+    // TODO: Make this a proper type with a constructor
+    let json_decode_error = create_type(
+        "JSONDecodeError",
+        &ctx.type_type,
+        &ctx.exceptions.exception_type,
+        &ctx.dict_type,
+    );
+    ctx.set_attr(&json_mod, "JSONDecodeError", json_decode_error);
     json_mod
 }