more intern_static_str adaption

youknowone · youknowone · commit d1817ac88c5a · 2025-03-30T13:47:41.000+09:00
diff --git a/vm/src/builtins/tuple.rs b/vm/src/builtins/tuple.rs
@@ -430,7 +430,7 @@ impl Representable for PyTuple {
     #[inline]
     fn repr(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<PyStrRef> {
         let s = if zelf.is_empty() {
-            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)?)
@@ -439,7 +439,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/builtins/type.rs b/vm/src/builtins/type.rs
@@ -323,12 +323,12 @@ impl PyType {
     // This is used for class initialisation where the vm is not yet available.
     pub fn set_str_attr<V: Into<PyObjectRef>>(
         &self,
-        attr_name: &str,
+        attr_name: &'static str,
         value: V,
         ctx: impl AsRef<Context>,
     ) {
         let ctx = ctx.as_ref();
-        let attr_name = ctx.intern_str(attr_name);
+        let attr_name = ctx.intern_static_str(attr_name);
         self.set_attr(attr_name, value.into())
     }
 
diff --git a/vm/src/stdlib/builtins.rs b/vm/src/stdlib/builtins.rs
@@ -406,7 +406,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
@@ -12,7 +12,7 @@ pub fn make_module(vm: &VirtualMachine) -> PyRef<PyModule> {
         "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
@@ -149,7 +149,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
@@ -206,12 +206,20 @@ impl VirtualMachine {
 
         vm.builtins.init_dict(
             vm.ctx.intern_str("builtins"),
-            Some(vm.ctx.intern_str(stdlib::builtins::DOC.unwrap()).to_owned()),
+            Some(
+                vm.ctx
+                    .intern_static_str(stdlib::builtins::DOC.unwrap())
+                    .to_owned(),
+            ),
             &vm,
         );
         vm.sys_module.init_dict(
             vm.ctx.intern_str("sys"),
-            Some(vm.ctx.intern_str(stdlib::sys::DOC.unwrap()).to_owned()),
+            Some(
+                vm.ctx
+                    .intern_static_str(stdlib::sys::DOC.unwrap())
+                    .to_owned(),
+            ),
             &vm,
         );
         // let name = vm.sys_module.get_attr("__name__", &vm).unwrap();
@@ -300,7 +308,7 @@ impl VirtualMachine {
             #[cfg(any(not(target_arch = "wasm32"), target_os = "wasi"))]
             {
                 let io = import::import_builtin(self, "_io")?;
-                let set_stdio = |name, fd, write| {
+                let set_stdio = |name, dunder_name, fd, write| {
                     let buffered_stdio = self.state.settings.buffered_stdio;
                     let unbuffered = write && !buffered_stdio;
                     let buf = crate::stdlib::io::open(
@@ -332,7 +340,7 @@ impl VirtualMachine {
                     let mode = if write { "w" } else { "r" };
                     stdio.set_attr("mode", self.ctx.new_str(mode), 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(),
@@ -341,9 +349,9 @@ impl VirtualMachine {
                     self.sys_module.set_attr(name, stdio, self)?;
                     Ok(())
                 };
-                set_stdio("stdin", 0, false)?;
-                set_stdio("stdout", 1, true)?;
-                set_stdio("stderr", 2, true)?;
+                set_stdio("stdin", "__stdin__", 0, false)?;
+                set_stdio("stdout", "__stdout__", 1, true)?;
+                set_stdio("stderr", "__stderr__", 2, true)?;
 
                 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
`@@ -406,7 +406,7 @@ mod builtins {`
`406`	`406`	`fn breakpoint(args: FuncArgs, vm: &VirtualMachine) -> PyResult {`
`407`	`407`	`match vm`
`408`	`408`	`.sys_module`
`409`		`- .get_attr(vm.ctx.intern_str("breakpointhook"), vm)`
	`409`	`+ .get_attr(vm.ctx.intern_static_str("breakpointhook"), vm)`
`410`	`410`	`{`
`411`	`411`	`Ok(hook) => hook.as_ref().call(args, vm),`
`412`	`412`	`Err(_) => Err(vm.new_runtime_error("lost sys.breakpointhook".to_owned())),`