more intern_static_str adaption

youknowone · youknowone · commit a7a8444cc485 · 2023-03-21T01:23:46.000+09:00
diff --git a/vm/src/builtins/module.rs b/vm/src/builtins/module.rs
@@ -121,7 +121,7 @@ impl Initializer for PyModule {
             .flags
             .has_feature(crate::types::PyTypeFlags::HAS_DICT));
         zelf.init_module_dict(
-            vm.ctx.intern_str(args.name.as_str()),
+            vm.ctx.intern_str(args.name.str(vm)),
             args.doc.to_pyobject(vm),
             vm,
         );
diff --git a/vm/src/builtins/str.rs b/vm/src/builtins/str.rs
@@ -1269,7 +1269,7 @@ impl PyStr {
 #[pyclass]
 impl PyRef<PyStr> {
     #[pymethod(magic)]
-    fn str(self, vm: &VirtualMachine) -> PyRefExact<PyStr> {
+    pub fn str(self, vm: &VirtualMachine) -> PyRefExact<PyStr> {
         self.into_exact_or(&vm.ctx, |zelf| unsafe {
             // Creating a copy with same kind is safe
             PyStr::new_str_unchecked(zelf.bytes.to_vec(), zelf.kind.kind()).into_exact_ref(&vm.ctx)
diff --git a/vm/src/builtins/tuple.rs b/vm/src/builtins/tuple.rs
@@ -401,7 +401,7 @@ impl Representable for PyTuple {
     #[inline]
     fn repr(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<PyStrRef> {
         let s = if zelf.len() == 0 {
-            vm.ctx.intern_str("()").to_owned()
+            vm.ctx.intern_static_str("()").to_owned()
         } else if let Some(_guard) = ReprGuard::enter(vm, zelf.as_object()) {
             let s = if zelf.len() == 1 {
                 format!("({},)", zelf.elements[0].repr(vm)?)
@@ -410,7 +410,7 @@ impl Representable for PyTuple {
             };
             vm.ctx.new_str(s)
         } else {
-            vm.ctx.intern_str("(...)").to_owned()
+            vm.ctx.intern_static_str("(...)").to_owned()
         };
         Ok(s)
     }
diff --git a/vm/src/stdlib/builtins.rs b/vm/src/stdlib/builtins.rs
@@ -351,7 +351,7 @@ mod builtins {
     fn breakpoint(args: FuncArgs, vm: &VirtualMachine) -> PyResult {
         match vm
             .sys_module
-            .get_attr(vm.ctx.intern_str("breakpointhook"), vm)
+            .get_attr(vm.ctx.intern_static_str("breakpointhook"), vm)
         {
             Ok(hook) => hook.as_ref().call(args, vm),
             Err(_) => Err(vm.new_runtime_error("lost sys.breakpointhook".to_owned())),
diff --git a/vm/src/stdlib/errno.rs b/vm/src/stdlib/errno.rs
@@ -11,7 +11,7 @@ pub fn make_module(vm: &VirtualMachine) -> PyObjectRef {
         "errorcode" => errorcode.clone(),
     });
     for (name, code) in ERROR_CODES {
-        let name = vm.ctx.intern_str(*name);
+        let name = vm.ctx.intern_static_str(*name);
         let code = vm.new_pyobj(*code);
         errorcode
             .set_item(&*code, name.to_owned().into(), vm)
diff --git a/vm/src/stdlib/sys.rs b/vm/src/stdlib/sys.rs
@@ -135,7 +135,7 @@ mod sys {
     fn byteorder(vm: &VirtualMachine) -> PyStrRef {
         // https://doc.rust-lang.org/reference/conditional-compilation.html#target_endian
         vm.ctx
-            .intern_str(if cfg!(target_endian = "little") {
+            .intern_static_str(if cfg!(target_endian = "little") {
                 "little"
             } else if cfg!(target_endian = "big") {
                 "big"
diff --git a/vm/src/vm/mod.rs b/vm/src/vm/mod.rs
@@ -194,9 +194,9 @@ impl VirtualMachine {
         PyRc::get_mut(&mut vm.state).unwrap().frozen = frozen;
 
         vm.builtins
-            .init_module_dict(vm.ctx.intern_str("builtins"), vm.ctx.none(), &vm);
+            .init_module_dict(vm.ctx.intern_static_str("builtins"), vm.ctx.none(), &vm);
         vm.sys_module
-            .init_module_dict(vm.ctx.intern_str("sys"), vm.ctx.none(), &vm);
+            .init_module_dict(vm.ctx.intern_static_str("sys"), vm.ctx.none(), &vm);
 
         vm
     }
@@ -263,14 +263,14 @@ impl VirtualMachine {
                 // builtins.open to io.OpenWrapper, but this is easier, since it doesn't
                 // require the Python stdlib to be present
                 let io = import::import_builtin(self, "_io")?;
-                let set_stdio = |name, fd, mode: &str| {
+                let set_stdio = |name, dunder_name, fd, mode: &str| {
                     let stdio = crate::stdlib::io::open(
                         self.ctx.new_int(fd).into(),
                         Some(mode),
                         Default::default(),
                         self,
                     )?;
-                    let dunder_name = self.ctx.intern_str(format!("__{name}__"));
+                    let dunder_name = self.ctx.intern_static_str(dunder_name);
                     self.sys_module.set_attr(
                         dunder_name, // e.g. __stdin__
                         stdio.clone(),
@@ -279,9 +279,9 @@ impl VirtualMachine {
                     self.sys_module.set_attr(name, stdio, self)?;
                     Ok(())
                 };
-                set_stdio("stdin", 0, "r")?;
-                set_stdio("stdout", 1, "w")?;
-                set_stdio("stderr", 2, "w")?;
+                set_stdio("stdin", "__stdin__", 0, "r")?;
+                set_stdio("stdout", "__stdout__", 1, "w")?;
+                set_stdio("stderr", "__stderr__", 2, "w")?;
 
                 let io_open = io.get_attr("open", self)?;
                 self.builtins.set_attr("open", io_open, self)?;

Original file line number	Diff line number	Diff line change
`@@ -351,7 +351,7 @@ mod builtins {`
`351`	`351`	`fn breakpoint(args: FuncArgs, vm: &VirtualMachine) -> PyResult {`
`352`	`352`	`match vm`
`353`	`353`	`.sys_module`
`354`		`- .get_attr(vm.ctx.intern_str("breakpointhook"), vm)`
	`354`	`+ .get_attr(vm.ctx.intern_static_str("breakpointhook"), vm)`
`355`	`355`	`{`
`356`	`356`	`Ok(hook) => hook.as_ref().call(args, vm),`
`357`	`357`	`Err(_) => Err(vm.new_runtime_error("lost sys.breakpointhook".to_owned())),`