RustPython · coolreader18 · Jun 6, 2020 · Jun 3, 2020 · Jun 3, 2020 · Jun 3, 2020
diff --git a/Lib/test/test_json/test_speedups.py b/Lib/test/test_json/test_speedups.py
@@ -14,8 +14,6 @@ def test_scanstring(self):
         self.assertEqual(self.json.decoder.scanstring.__module__, "_json")
         self.assertIs(self.json.decoder.scanstring, self.json.decoder.c_scanstring)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_encode_basestring_ascii(self):
         self.assertEqual(self.json.encoder.encode_basestring_ascii.__module__,
                          "_json")

diff --git a/compiler/src/compile.rs b/compiler/src/compile.rs
@@ -591,7 +591,7 @@ impl<O: OutputStream> Compiler<O> {
                         {
                             return Err(self.error_loc(
                                 CompileErrorType::AsyncReturnValue,
-                                statement.location.clone(),
+                                statement.location,
                             ));
                         }
                         self.compile_expression(v)?;

diff --git a/vm/Cargo.toml b/vm/Cargo.toml
@@ -120,7 +120,7 @@ libz-sys = "1.0"
 winreg = "0.7"
 schannel = "0.1"
 
-[target."cfg(windows)".dependencies.winapi]
+[target.'cfg(windows)'.dependencies.winapi]
 version = "0.3"
 features = ["winsock2", "handleapi", "ws2def", "std", "winbase", "wincrypt", "fileapi"]
 

diff --git a/vm/src/dictdatatype.rs b/vm/src/dictdatatype.rs
@@ -1,4 +1,4 @@
-use crate::obj::objstr::PyString;
+use crate::obj::objstr::{PyString, PyStringRef};
 use crate::pyhash;
 use crate::pyobject::{IdProtocol, IntoPyObject, PyObjectRef, PyResult};
 use crate::vm::VirtualMachine;
@@ -438,6 +438,26 @@ impl DictKey for &PyObjectRef {
     }
 }
 
+impl DictKey for &PyStringRef {
+    fn do_hash(self, _vm: &VirtualMachine) -> PyResult<HashValue> {
+        Ok(self.hash())
+    }
+
+    fn do_is(self, other: &PyObjectRef) -> bool {
+        self.is(other)
+    }
+
+    fn do_eq(self, vm: &VirtualMachine, other_key: &PyObjectRef) -> PyResult<bool> {
+        if self.is(other_key) {
+            Ok(true)
+        } else if let Some(py_str_value) = other_key.payload::<PyString>() {
+            Ok(py_str_value.as_str() == self.as_str())
+        } else {
+            vm.bool_eq(self.clone().into_object(), other_key.clone())
+        }
+    }
+}
+
 /// Implement trait for the str type, so that we can use strings
 /// to index dictionaries.
 impl DictKey for &str {

diff --git a/vm/src/macros.rs b/vm/src/macros.rs
@@ -328,3 +328,17 @@ macro_rules! class_or_notimplemented {
         }
     };
 }
+
+#[macro_export]
+macro_rules! named_function {
+    ($ctx:expr, $module:ident, $func:ident) => {{
+        paste::expr! {
+            $crate::pyobject::PyContext::new_function_named(
+                &$ctx,
+                [<$module _ $func>],
+                stringify!($module).to_owned(),
+                stringify!($func).to_owned(),
+            )
+        }
+    }};
+}
diff --git a/vm/src/obj/objbuiltinfunc.rs b/vm/src/obj/objbuiltinfunc.rs
@@ -1,6 +1,7 @@
 use std::fmt;
 
 use crate::function::{OptionalArg, PyFuncArgs, PyNativeFunc};
+use crate::obj::objstr::PyStringRef;
 use crate::obj::objtype::PyClassRef;
 use crate::pyobject::{
     IdProtocol, PyClassImpl, PyContext, PyObjectRef, PyResult, PyValue, TypeProtocol,
@@ -11,12 +12,15 @@ use crate::vm::VirtualMachine;
 #[pyclass]
 pub struct PyBuiltinFunction {
     value: PyNativeFunc,
+    module: Option<PyStringRef>,
+    name: Option<PyStringRef>,
 }
 
 impl PyValue for PyBuiltinFunction {
     fn class(vm: &VirtualMachine) -> PyClassRef {
         vm.ctx.builtin_function_or_method_type()
     }
+    const HAVE_DICT: bool = true;
 }
 
 impl fmt::Debug for PyBuiltinFunction {
@@ -27,7 +31,19 @@ impl fmt::Debug for PyBuiltinFunction {
 
 impl PyBuiltinFunction {
     pub fn new(value: PyNativeFunc) -> Self {
-        Self { value }
+        Self {
+            value,
+            module: None,
+            name: None,
+        }
+    }
+
+    pub fn new_with_name(value: PyNativeFunc, module: PyStringRef, name: PyStringRef) -> Self {
+        Self {
+            value,
+            module: Some(module),
+            name: Some(name),
+        }
     }
 
     pub fn as_func(&self) -> &PyNativeFunc {
@@ -42,7 +58,16 @@ impl SlotCall for PyBuiltinFunction {
 }
 
 #[pyimpl(with(SlotCall))]
-impl PyBuiltinFunction {}
+impl PyBuiltinFunction {
+    #[pyproperty(magic)]
+    fn module(&self) -> Option<PyStringRef> {
+        self.module.clone()
+    }
+    #[pyproperty(magic)]
+    fn name(&self) -> Option<PyStringRef> {
+        self.name.clone()
+    }
+}
 
 #[pyclass]
 pub struct PyBuiltinMethod {
@@ -64,7 +89,12 @@ impl fmt::Debug for PyBuiltinMethod {
 impl PyBuiltinMethod {
     pub fn new(value: PyNativeFunc) -> Self {
         Self {
-            function: PyBuiltinFunction { value },
+            function: PyBuiltinFunction::new(value),
+        }
+    }
+    pub fn new_with_name(value: PyNativeFunc, module: PyStringRef, name: PyStringRef) -> Self {
+        Self {
+            function: PyBuiltinFunction::new_with_name(value, module, name),
         }
     }
 
@@ -100,9 +130,14 @@ impl SlotCall for PyBuiltinMethod {
 
 #[pyimpl(with(SlotDescriptor, SlotCall))]
 impl PyBuiltinMethod {
-    // TODO: give builtin functions names
     #[pyproperty(magic)]
-    fn name(&self) {}
+    fn module(&self) -> Option<PyStringRef> {
+        self.function.module.clone()
+    }
+    #[pyproperty(magic)]
+    fn name(&self) -> Option<PyStringRef> {
+        self.function.name.clone()
+    }
 }
 
 pub fn init(context: &PyContext) {

diff --git a/vm/src/obj/objstr.rs b/vm/src/obj/objstr.rs
@@ -292,7 +292,7 @@ impl PyString {
     }
 
     #[pymethod(name = "__hash__")]
-    fn hash(&self) -> pyhash::PyHash {
+    pub(crate) fn hash(&self) -> pyhash::PyHash {
         self.hash.load().unwrap_or_else(|| {
             let hash = pyhash::hash_value(&self.value);
             self.hash.store(Some(hash));

diff --git a/vm/src/obj/objtype.rs b/vm/src/obj/objtype.rs
@@ -274,6 +274,7 @@ impl PyClassRef {
             // Search the bases for the proper metatype to deal with this:
             let winner = calculate_meta_class(metatype.clone(), &bases, vm)?;
             let metatype = if !winner.is(&metatype) {
+                #[allow(clippy::redundant_clone)] // false positive
                 if let Some(ref tp_new) = winner.clone().slots.read().unwrap().new {
                     // Pass it to the winner
 

diff --git a/vm/src/pyobject.rs b/vm/src/pyobject.rs
@@ -138,7 +138,7 @@ impl PyContext {
         let exceptions = exceptions::ExceptionZoo::new(&types.type_type, &types.object_type);
 
         fn create_object<T: PyObjectPayload + PyValue>(payload: T, cls: &PyClassRef) -> PyRef<T> {
-            PyRef::new_ref_unchecked(PyObject::new(payload, cls.clone(), None))
+            PyRef::from_obj_unchecked(PyObject::new(payload, cls.clone(), None))
         }
 
         let none_type = create_type("NoneType", &types.type_type, &types.object_type);
@@ -492,6 +492,18 @@ impl PyContext {
         )
     }
 
+    pub fn new_function_named<F, T, R, VM>(&self, f: F, module: String, name: String) -> PyObjectRef
+    where
+        F: IntoPyNativeFunc<T, R, VM>,
+    {
+        let stringref = |s| PyRef::new_ref(objstr::PyString::from(s), self.str_type(), None);
+        PyObject::new(
+            PyBuiltinFunction::new_with_name(f.into_func(), stringref(module), stringref(name)),
+            self.builtin_function_or_method_type(),
+            None,
+        )
+    }
+
     pub fn new_method<F, T, R, VM>(&self, f: F) -> PyObjectRef
     where
         F: IntoPyNativeFunc<T, R, VM>,
@@ -587,7 +599,7 @@ impl PyContext {
             bytecode::Constant::Complex { ref value } => self.new_complex(*value),
             bytecode::Constant::String { ref value } => self.new_str(value.clone()),
             bytecode::Constant::Bytes { ref value } => self.new_bytes(value.clone()),
-            bytecode::Constant::Boolean { ref value } => self.new_bool(value.clone()),
+            bytecode::Constant::Boolean { value } => self.new_bool(value),
             bytecode::Constant::Code { ref code } => {
                 self.new_code_object(*code.clone()).into_object()
             }
@@ -695,9 +707,14 @@ impl<T> Clone for PyRef<T> {
 }
 
 impl<T: PyValue> PyRef<T> {
-    fn new_ref(obj: PyObjectRef, vm: &VirtualMachine) -> PyResult<Self> {
+    #[allow(clippy::new_ret_no_self)]
+    pub fn new_ref(payload: T, typ: PyClassRef, dict: Option<PyDictRef>) -> Self {
+        Self::from_obj_unchecked(PyObject::new(payload, typ, dict))
+    }
+
+    fn from_obj(obj: PyObjectRef, vm: &VirtualMachine) -> PyResult<Self> {
         if obj.payload_is::<T>() {
-            Ok(Self::new_ref_unchecked(obj))
+            Ok(Self::from_obj_unchecked(obj))
         } else {
             Err(vm.new_runtime_error(format!(
                 "Unexpected payload for type {:?}",
@@ -706,7 +723,7 @@ impl<T: PyValue> PyRef<T> {
         }
     }
 
-    pub(crate) fn new_ref_unchecked(obj: PyObjectRef) -> Self {
+    pub(crate) fn from_obj_unchecked(obj: PyObjectRef) -> Self {
         PyRef {
             obj,
             _payload: PhantomData,
@@ -747,7 +764,7 @@ where
 {
     fn try_from_object(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult<Self> {
         if objtype::isinstance(&obj, &T::class(vm)) {
-            PyRef::new_ref(obj, vm)
+            PyRef::from_obj(obj, vm)
         } else {
             let class = T::class(vm);
             let expected_type = vm.to_pystr(&class)?;
@@ -1084,6 +1101,12 @@ impl<T> IntoPyObject for PyRef<T> {
     }
 }
 
+impl<T> IntoPyObject for &PyRef<T> {
+    fn into_pyobject(self, _vm: &VirtualMachine) -> PyResult {
+        Ok(self.obj.clone())
+    }
+}
+
 impl IntoPyObject for PyCallable {
     fn into_pyobject(self, _vm: &VirtualMachine) -> PyResult {
         Ok(self.into_object())
@@ -1145,7 +1168,7 @@ where
     where
         T: PyValue,
     {
-        PyRef::new_ref_unchecked(self as PyObjectRef)
+        PyRef::from_obj_unchecked(self as PyObjectRef)
     }
 }
 
@@ -1210,7 +1233,7 @@ pub trait PyValue: fmt::Debug + Send + Sync + Sized + 'static {
             } else {
                 Some(vm.ctx.new_dict())
             };
-            PyRef::new_ref(PyObject::new(self, cls, dict), vm)
+            PyRef::from_obj(PyObject::new(self, cls, dict), vm)
         } else {
             let subtype = vm.to_str(&cls.obj)?;
             let basetype = vm.to_str(&class.obj)?;
@@ -1219,7 +1242,7 @@ pub trait PyValue: fmt::Debug + Send + Sync + Sized + 'static {
     }
 
     fn into_ref_with_type_unchecked(self, cls: PyClassRef, dict: Option<PyDictRef>) -> PyRef<Self> {
-        PyRef::new_ref_unchecked(PyObject::new(self, cls, dict))
+        PyRef::from_obj_unchecked(PyObject::new(self, cls, dict))
     }
 }
 

diff --git a/vm/src/scope.rs b/vm/src/scope.rs
@@ -39,7 +39,6 @@ impl Scope {
     ) -> Scope {
         if !globals.contains_key("__builtins__", vm) {
             globals
-                .clone()
                 .set_item("__builtins__", vm.builtins.clone(), vm)
                 .unwrap();
         }

diff --git a/vm/src/stdlib/json.rs b/vm/src/stdlib/json.rs
@@ -7,6 +7,8 @@ use crate::VirtualMachine;
 use num_bigint::BigInt;
 use std::str::FromStr;
 
+mod machinery;
+
 #[pyclass(name = "Scanner")]
 #[derive(Debug)]
 struct JsonScanner {
@@ -209,11 +211,30 @@ impl JsonScanner {
     }
 }
 
+fn encode_string(s: &str, ascii_only: bool) -> String {
+    let mut buf = Vec::<u8>::with_capacity(s.len() + 2);
+    machinery::write_json_string(s, ascii_only, &mut buf)
+        // writing to a vec can't fail
+        .unwrap_or_else(|_| unsafe { std::hint::unreachable_unchecked() });
+    // TODO: verify that the implementation is correct enough to use `from_utf8_unchecked`
+    String::from_utf8(buf).expect("invalid utf-8 in json output")
+}
+
+fn _json_encode_basestring(s: PyStringRef) -> String {
+    encode_string(s.as_str(), false)
+}
+
+fn _json_encode_basestring_ascii(s: PyStringRef) -> String {
+    encode_string(s.as_str(), true)
+}
+
 pub fn make_module(vm: &VirtualMachine) -> PyObjectRef {
     let ctx = &vm.ctx;
     let scanner_cls = JsonScanner::make_class(ctx);
     scanner_cls.set_str_attr("__module__", vm.new_str("_json".to_owned()));
     py_module!(vm, "_json", {
         "make_scanner" => scanner_cls,
+        "encode_basestring" => named_function!(ctx, _json, encode_basestring),
+        "encode_basestring_ascii" => named_function!(ctx, _json, encode_basestring_ascii),
     })
 }