PyStrKind

Author: youknowone

benches/microbenchmarks.rs

@@ -132,7 +132,7 @@ fn bench_rustpy_code(group: &mut BenchmarkGroup<WallTime>, bench: &MicroBenchmar
             if let Some(idx) = iterations {
                 scope
                     .locals
-                    .set_item(vm.ctx.new_str("ITERATIONS"), vm.ctx.new_int(idx), vm)
+                    .set_item(vm.ctx.new_ascii_str(b"ITERATIONS"), vm.ctx.new_int(idx), vm)
                     .expect("Error adding ITERATIONS local variable");
             }
             let setup_result = vm.run_code_obj(setup_code.clone(), scope.clone());

derive/src/pymodule.rs

@@ -268,7 +268,7 @@ impl ModuleItem for FunctionItem {
                 vm.ctx.make_funcdef(#py_name, #ident)
                     #doc
                     .into_function()
-                    .with_module(vm.ctx.new_str(#module.to_owned()))
+                    .with_module(vm.ctx.new_utf8_str(#module.to_owned()))
                     .build(&vm.ctx)
             );
             quote! {
@@ -324,7 +324,7 @@ impl ModuleItem for ClassItem {
                 );
                 let item = quote! {
                     let new_class = #new_class;
-                    new_class.set_str_attr("__module__", vm.ctx.new_str(#module_name));
+                    new_class.set_str_attr("__module__", vm.ctx.new_utf8_str(#module_name));
                     vm.__module_set_attr(&module, #py_name, new_class).unwrap();
                 };
 

src/lib.rs

@@ -588,7 +588,7 @@ fn _run_string(vm: &VirtualMachine, scope: Scope, source: &str, source_path: Str
     // trace!("Code object: {:?}", code_obj.borrow());
     scope
         .globals
-        .set_item("__file__", vm.ctx.new_str(source_path), vm)?;
+        .set_item("__file__", vm.ctx.new_utf8_str(source_path), vm)?;
     vm.run_code_obj(code_obj, scope)
 }
 

vm/src/builtins/code.rs

@@ -88,7 +88,7 @@ impl ConstantBag for PyObjBag<'_> {
             bytecode::ConstantData::Str { value } if value.len() <= 20 => {
                 vm.intern_string(value).into_object()
             }
-            bytecode::ConstantData::Str { value } => vm.ctx.new_str(value),
+            bytecode::ConstantData::Str { value } => vm.ctx.new_utf8_str(value),
             bytecode::ConstantData::Bytes { value } => ctx.new_bytes(value.to_vec()),
             bytecode::ConstantData::Boolean { value } => ctx.new_bool(value),
             bytecode::ConstantData::Code { code } => {
@@ -116,7 +116,7 @@ impl ConstantBag for PyObjBag<'_> {
             bytecode::BorrowedConstant::Str { value } if value.len() <= 20 => {
                 vm.intern_string(value).into_object()
             }
-            bytecode::BorrowedConstant::Str { value } => vm.ctx.new_str(value),
+            bytecode::BorrowedConstant::Str { value } => vm.ctx.new_utf8_str(value),
             bytecode::BorrowedConstant::Bytes { value } => ctx.new_bytes(value.to_vec()),
             bytecode::BorrowedConstant::Boolean { value } => ctx.new_bool(value),
             bytecode::BorrowedConstant::Code { code } => {

vm/src/builtins/dict.rs

@@ -113,7 +113,7 @@ impl PyDict {
         }
 
         for (key, value) in kwargs.into_iter() {
-            dict.insert(vm, vm.ctx.new_str(key), value)?;
+            dict.insert(vm, vm.ctx.new_utf8_str(key), value)?;
         }
         Ok(())
     }
@@ -364,7 +364,7 @@ impl PyDict {
         if let Some((key, value)) = self.entries.pop_back() {
             Ok(vm.ctx.new_tuple(vec![key, value]))
         } else {
-            let err_msg = vm.ctx.new_str("popitem(): dictionary is empty");
+            let err_msg = vm.ctx.new_ascii_str(b"popitem(): dictionary is empty");
             Err(vm.new_key_error(err_msg))
         }
     }
@@ -373,7 +373,7 @@ impl PyDict {
         let dict = DictContentType::default();
 
         for (key, value) in attrs {
-            dict.insert(vm, vm.ctx.new_str(key), value)?;
+            dict.insert(vm, vm.ctx.new_utf8_str(key), value)?;
         }
 
         Ok(PyDict { entries: dict })

vm/src/builtins/function.rs

@@ -545,7 +545,7 @@ impl PyBoundMethod {
             // is the only instance of `builtin_function_or_method_type`.
             let obj_name = vm.get_attribute_opt(self.object.clone(), "__qualname__")?;
             let obj_name: Option<PyStrRef> = obj_name.and_then(|o| o.downcast().ok());
-            return Ok(vm.ctx.new_str(format!(
+            return Ok(vm.ctx.new_utf8_str(format!(
                 "{}.__new__",
                 obj_name.as_ref().map_or("?", |s| s.as_str())
             )));

vm/src/builtins/make_module.rs

@@ -382,7 +382,7 @@ mod decl {
             let prompt = prompt.as_ref().map_or("", |s| s.as_str());
             let mut readline = Readline::new(());
             match readline.readline(prompt) {
-                ReadlineResult::Line(s) => Ok(vm.ctx.new_str(s)),
+                ReadlineResult::Line(s) => Ok(vm.ctx.new_utf8_str(s)),
                 ReadlineResult::Eof => {
                     Err(vm.new_exception_empty(vm.ctx.exceptions.eof_error.clone()))
                 }
@@ -535,7 +535,7 @@ mod decl {
             format!("0o{:o}", n)
         };
 
-        Ok(vm.ctx.new_str(s))
+        Ok(vm.ctx.new_utf8_str(s))
     }
 
     #[pyfunction]
@@ -812,7 +812,7 @@ mod decl {
         vm: &VirtualMachine,
     ) -> PyResult {
         let name = qualified_name.as_str().split('.').next_back().unwrap();
-        let name_obj = vm.ctx.new_str(name);
+        let name_obj = vm.ctx.new_utf8_str(name);
 
         let mut metaclass = if let Some(metaclass) = kwargs.pop_kwarg("metaclass") {
             PyTypeRef::try_from_object(vm, metaclass)?