Turn contants to PyStrInterned

Author: youknowone

vm/src/builtins/code.rs

@@ -4,6 +4,7 @@
 
 use super::{PyStrRef, PyTupleRef, PyTypeRef};
 use crate::{
+    builtins::PyStrInterned,
     bytecode::{self, BorrowedConstant, Constant, ConstantBag},
     class::{PyClassImpl, StaticType},
     convert::ToPyObject,
@@ -63,7 +64,7 @@ fn borrow_obj_constant(obj: &PyObject) -> BorrowedConstant<Literal> {
 }
 
 impl Constant for Literal {
-    type Name = PyStrRef;
+    type Name = &'static PyStrInterned;
     fn borrow_constant(&self) -> BorrowedConstant<Self> {
         borrow_obj_constant(&self.0)
     }
@@ -103,8 +104,8 @@ impl ConstantBag for PyObjBag<'_> {
         Literal(obj)
     }
 
-    fn make_name(&self, name: &str) -> PyStrRef {
-        self.0.intern_str(name).to_owned()
+    fn make_name(&self, name: &str) -> &'static PyStrInterned {
+        self.0.intern_str(name)
     }
 }
 
@@ -190,7 +191,7 @@ impl PyRef<PyCode> {
 
     #[pyproperty]
     fn co_filename(self) -> PyStrRef {
-        self.code.source_path.clone()
+        self.code.source_path.to_owned()
     }
 
     #[pyproperty]
@@ -211,7 +212,7 @@ impl PyRef<PyCode> {
 
     #[pyproperty]
     fn co_name(self) -> PyStrRef {
-        self.code.obj_name.clone()
+        self.code.obj_name.to_owned()
     }
 
     #[pyproperty]
@@ -221,12 +222,7 @@ impl PyRef<PyCode> {
 
     #[pyproperty]
     pub fn co_varnames(self, vm: &VirtualMachine) -> PyTupleRef {
-        let varnames = self
-            .code
-            .varnames
-            .iter()
-            .map(|s| s.clone().into())
-            .collect();
+        let varnames = self.code.varnames.iter().map(|s| s.to_object()).collect();
         vm.ctx.new_tuple(varnames)
     }
 }

vm/src/builtins/function.rs

@@ -42,7 +42,7 @@ impl PyFunction {
         defaults: Option<PyTupleRef>,
         kw_only_defaults: Option<PyDictRef>,
     ) -> Self {
-        let name = PyMutex::new(code.obj_name.clone());
+        let name = PyMutex::new(code.obj_name.to_owned());
         PyFunction {
             code,
             globals,

vm/src/builtins/function/jitfunc.rs

@@ -1,5 +1,5 @@
 use crate::{
-    builtins::{bool_, float, int, PyBaseExceptionRef, PyDictRef, PyFunction, PyStrRef},
+    builtins::{bool_, float, int, PyBaseExceptionRef, PyDictRef, PyFunction, PyStrInterned},
     bytecode::CodeFlags,
     convert::ToPyObject,
     function::FuncArgs,
@@ -153,7 +153,7 @@ pub(crate) fn get_jit_args<'a>(
     // Handle keyword arguments
     for (name, value) in &func_args.kwargs {
         let arg_pos =
-            |args: &[PyStrRef], name: &str| args.iter().position(|arg| arg.as_str() == name);
+            |args: &[&PyStrInterned], name: &str| args.iter().position(|arg| arg.as_str() == name);
         if let Some(arg_idx) = arg_pos(arg_names.args, name) {
             if jit_args.is_set(arg_idx) {
                 return Err(ArgsError::ArgPassedMultipleTimes);

vm/src/frame.rs

@@ -5,7 +5,7 @@ use crate::{
         function::{PyCell, PyCellRef, PyFunction},
         tuple::{PyTuple, PyTupleTyped},
         PyBaseExceptionRef, PyCode, PyCoroutine, PyDict, PyDictRef, PyGenerator, PyList, PySet,
-        PySlice, PyStr, PyStrRef, PyTraceback, PyTypeRef,
+        PySlice, PyStr, PyStrInterned, PyStrRef, PyTraceback, PyTypeRef,
     },
     bytecode,
     convert::{IntoObject, ToPyResult},
@@ -187,7 +187,7 @@ impl FrameRef {
         let j = std::cmp::min(map.len(), code.varnames.len());
         if !code.varnames.is_empty() {
             let fastlocals = self.fastlocals.lock();
-            for (k, v) in itertools::zip(&map[..j], &**fastlocals) {
+            for (&k, v) in itertools::zip(&map[..j], &**fastlocals) {
                 match locals.mapping().ass_subscript(k, v.clone(), vm) {
                     Ok(()) => {}
                     Err(e) if e.fast_isinstance(&vm.ctx.exceptions.key_error) => {}
@@ -196,8 +196,8 @@ impl FrameRef {
             }
         }
         if !code.cellvars.is_empty() || !code.freevars.is_empty() {
-            let map_to_dict = |keys: &[PyStrRef], values: &[PyCellRef]| {
-                for (k, v) in itertools::zip(keys, values) {
+            let map_to_dict = |keys: &[&PyStrInterned], values: &[PyCellRef]| {
+                for (&k, v) in itertools::zip(keys, values) {
                     if let Some(value) = v.get() {
                         locals.mapping().ass_subscript(k, Some(value), vm)?;
                     } else {
@@ -424,19 +424,19 @@ impl ExecutingFrame<'_> {
     }
 
     fn unbound_cell_exception(&self, i: usize, vm: &VirtualMachine) -> PyBaseExceptionRef {
-        if let Some(name) = self.code.cellvars.get(i) {
+        if let Some(&name) = self.code.cellvars.get(i) {
             vm.new_exception_msg(
                 vm.ctx.exceptions.unbound_local_error.clone(),
                 format!("local variable '{}' referenced before assignment", name),
             )
         } else {
-            let name = &self.code.freevars[i - self.code.cellvars.len()];
+            let name = self.code.freevars[i - self.code.cellvars.len()];
             vm.new_name_error(
                 format!(
                     "free variable '{}' referenced before assignment in enclosing scope",
                     name
                 ),
-                name,
+                name.to_owned(),
             )
         }
     }
@@ -471,7 +471,7 @@ impl ExecutingFrame<'_> {
                 Ok(None)
             }
             bytecode::Instruction::ImportName { idx } => {
-                self.import(vm, Some(self.code.names[*idx as usize].clone()))
+                self.import(vm, Some(self.code.names[*idx as usize].to_owned()))
             }
             bytecode::Instruction::ImportNameless => self.import(vm, None),
             bytecode::Instruction::ImportStar => self.import_star(vm),
@@ -495,7 +495,7 @@ impl ExecutingFrame<'_> {
                 Ok(None)
             }
             bytecode::Instruction::LoadNameAny(idx) => {
-                let name = &self.code.names[*idx as usize];
+                let name = self.code.names[*idx as usize];
                 let value = self.locals.mapping().subscript(name, vm).ok();
                 self.push_value(match value {
                     Some(x) => x,
@@ -519,8 +519,8 @@ impl ExecutingFrame<'_> {
             }
             bytecode::Instruction::LoadClassDeref(i) => {
                 let i = *i as usize;
-                let name = self.code.freevars[i - self.code.cellvars.len()].clone();
-                let value = self.locals.mapping().subscript(&name, vm).ok();
+                let name = self.code.freevars[i - self.code.cellvars.len()];
+                let value = self.locals.mapping().subscript(name, vm).ok();
                 self.push_value(match value {
                     Some(v) => v,
                     None => self.cells_frees[i]
@@ -535,15 +535,15 @@ impl ExecutingFrame<'_> {
                 Ok(None)
             }
             bytecode::Instruction::StoreLocal(idx) => {
-                let name = &self.code.names[*idx as usize];
+                let name = self.code.names[*idx as usize];
                 let value = self.pop_value();
                 self.locals.mapping().ass_subscript(name, Some(value), vm)?;
                 Ok(None)
             }
             bytecode::Instruction::StoreGlobal(idx) => {
                 let value = self.pop_value();
                 self.globals
-                    .set_item(&*self.code.names[*idx as usize].clone(), value, vm)?;
+                    .set_item(self.code.names[*idx as usize], value, vm)?;
                 Ok(None)
             }
             bytecode::Instruction::StoreDeref(i) => {
@@ -556,28 +556,30 @@ impl ExecutingFrame<'_> {
                 Ok(None)
             }
             bytecode::Instruction::DeleteLocal(idx) => {
-                let name = &self.code.names[*idx as usize];
+                let name = self.code.names[*idx as usize];
                 let res = self.locals.mapping().ass_subscript(name, None, vm);
 
                 match res {
                     Ok(()) => {}
                     Err(e) if e.fast_isinstance(&vm.ctx.exceptions.key_error) => {
-                        return Err(
-                            vm.new_name_error(format!("name '{}' is not defined", name), name)
-                        )
+                        return Err(vm.new_name_error(
+                            format!("name '{}' is not defined", name),
+                            name.to_owned(),
+                        ))
                     }
                     Err(e) => return Err(e),
                 }
                 Ok(None)
             }
             bytecode::Instruction::DeleteGlobal(idx) => {
-                let name = &self.code.names[*idx as usize];
-                match self.globals.del_item(&**name, vm) {
+                let name = self.code.names[*idx as usize];
+                match self.globals.del_item(name, vm) {
                     Ok(()) => {}
                     Err(e) if e.fast_isinstance(&vm.ctx.exceptions.key_error) => {
-                        return Err(
-                            vm.new_name_error(format!("name '{}' is not defined", name), name)
-                        )
+                        return Err(vm.new_name_error(
+                            format!("name '{}' is not defined", name),
+                            name.to_owned(),
+                        ))
                     }
                     Err(e) => return Err(e),
                 }
@@ -926,8 +928,8 @@ impl ExecutingFrame<'_> {
             }
             bytecode::Instruction::LoadMethod { idx } => {
                 let obj = self.pop_value();
-                let method_name = self.code.names[*idx as usize].clone();
-                let method = PyMethod::get(obj, method_name, vm)?;
+                let method_name = self.code.names[*idx as usize];
+                let method = PyMethod::get(obj, method_name.to_owned(), vm)?;
                 let (target, is_method, func) = match method {
                     PyMethod::Function { target, func } => (target, true, func),
                     PyMethod::Attribute(val) => (vm.ctx.none(), false, val),
@@ -1094,7 +1096,7 @@ impl ExecutingFrame<'_> {
         self.globals
             .get_chain(self.builtins, name, vm)?
             .ok_or_else(|| {
-                vm.new_name_error(format!("name '{}' is not defined", name), &name.to_owned())
+                vm.new_name_error(format!("name '{}' is not defined", name), name.to_owned())
             })
     }
 
@@ -1133,10 +1135,10 @@ impl ExecutingFrame<'_> {
     #[cfg_attr(feature = "flame-it", flame("Frame"))]
     fn import_from(&mut self, vm: &VirtualMachine, idx: bytecode::NameIdx) -> PyResult {
         let module = self.last_value();
-        let name = &self.code.names[idx as usize];
-        let err = || vm.new_import_error(format!("cannot import name '{}'", name), name.clone());
+        let name = self.code.names[idx as usize];
+        let err = || vm.new_import_error(format!("cannot import name '{}'", name), name);
         // Load attribute, and transform any error into import error.
-        if let Some(obj) = vm.get_attribute_opt(module.clone(), name.clone())? {
+        if let Some(obj) = vm.get_attribute_opt(module.clone(), name)? {
             return Ok(obj);
         }
         // fallback to importing '{module.__name__}.{name}' from sys.modules
@@ -1731,23 +1733,23 @@ impl ExecutingFrame<'_> {
     }
 
     fn load_attr(&mut self, vm: &VirtualMachine, attr: bytecode::NameIdx) -> FrameResult {
-        let attr_name = self.code.names[attr as usize].clone();
+        let attr_name = self.code.names[attr as usize];
         let parent = self.pop_value();
         let obj = parent.get_attr(attr_name, vm)?;
         self.push_value(obj);
         Ok(None)
     }
 
     fn store_attr(&mut self, vm: &VirtualMachine, attr: bytecode::NameIdx) -> FrameResult {
-        let attr_name = self.code.names[attr as usize].clone();
+        let attr_name = self.code.names[attr as usize];
         let parent = self.pop_value();
         let value = self.pop_value();
         parent.set_attr(attr_name, value, vm)?;
         Ok(None)
     }
 
     fn delete_attr(&mut self, vm: &VirtualMachine, attr: bytecode::NameIdx) -> FrameResult {
-        let attr_name = self.code.names[attr as usize].clone();
+        let attr_name = self.code.names[attr as usize];
         let parent = self.pop_value();
         parent.del_attr(attr_name, vm)?;
         Ok(None)

vm/src/import.rs

@@ -142,7 +142,7 @@ pub fn import_codeobj(
     if set_file_attr {
         attrs.set_item(
             identifier!(vm, __file__),
-            code_obj.source_path.clone().into(),
+            code_obj.source_path.to_object(),
             vm,
         )?;
     }

vm/src/vm/vm_new.rs

@@ -97,13 +97,10 @@ impl VirtualMachine {
         self.new_exception_msg(type_error, msg)
     }
 
-    pub fn new_name_error(&self, msg: String, name: &PyStrRef) -> PyBaseExceptionRef {
+    pub fn new_name_error(&self, msg: String, name: PyStrRef) -> PyBaseExceptionRef {
         let name_error_type = self.ctx.exceptions.name_error.clone();
         let name_error = self.new_exception_msg(name_error_type, msg);
-        name_error
-            .as_object()
-            .set_attr("name", name.clone(), self)
-            .unwrap();
+        name_error.as_object().set_attr("name", name, self).unwrap();
         name_error
     }