new_{utf8_str, ascii_literal} -> new_str again

benches/microbenchmarks.rs

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

common/src/str.rs

@@ -1,3 +1,4 @@
+use ascii::AsciiString;
 use std::ops::{Bound, RangeBounds};
 
 #[cfg(not(target_arch = "wasm32"))]
@@ -62,11 +63,11 @@ pub fn zfill(bytes: &[u8], width: usize) -> Vec<u8> {
 
 /// Convert a string to ascii compatible, escaping unicodes into escape
 /// sequences.
-pub fn to_ascii(value: &str) -> String {
-    let mut ascii = String::new();
+pub fn to_ascii(value: &str) -> AsciiString {
+    let mut ascii = Vec::new();
     for c in value.chars() {
         if c.is_ascii() {
-            ascii.push(c)
+            ascii.push(c as u8);
         } else {
             let c = c as i64;
             let hex = if c < 0x100 {
@@ -76,10 +77,10 @@ pub fn to_ascii(value: &str) -> String {
             } else {
                 format!("\\U{:08x}", c)
             };
-            ascii.push_str(&hex)
+            ascii.append(&mut hex.into_bytes());
         }
     }
-    ascii
+    unsafe { AsciiString::from_ascii_unchecked(ascii) }
 }
 
 #[doc(hidden)]

derive/src/pymodule.rs

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

src/lib.rs

@@ -613,7 +613,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_utf8_str(source_path), vm)?;
+        .set_item("__file__", vm.new_pyobj(source_path), vm)?;
     vm.run_code_obj(code_obj, scope)
 }
 
@@ -637,7 +637,7 @@ fn get_importer(path: &str, vm: &VirtualMachine) -> PyResult<Option<PyObjectRef>
     if let Some(importer) = path_importer_cache.get_item_option(path, vm)? {
         return Ok(Some(importer));
     }
-    let path = vm.ctx.new_utf8_str(path);
+    let path = vm.ctx.new_str(path);
     let path_hooks = vm.get_attribute(vm.sys_module.clone(), "path_hooks")?;
     let mut importer = None;
     let path_hooks: Vec<PyObjectRef> = vm.extract_elements(&path_hooks)?;
@@ -652,7 +652,7 @@ fn get_importer(path: &str, vm: &VirtualMachine) -> PyResult<Option<PyObjectRef>
         }
     }
     Ok(if let Some(imp) = importer {
-        let imp = path_importer_cache.get_or_insert(vm, path, || imp.clone())?;
+        let imp = path_importer_cache.get_or_insert(vm, path.into(), || imp.clone())?;
         Some(imp)
     } else {
         None
@@ -668,17 +668,14 @@ fn insert_sys_path(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult<()> {
 fn run_script(vm: &VirtualMachine, scope: Scope, script_file: &str) -> PyResult<()> {
     debug!("Running file {}", script_file);
     if get_importer(script_file, vm)?.is_some() {
-        insert_sys_path(vm, vm.ctx.new_utf8_str(script_file))?;
+        insert_sys_path(vm, vm.ctx.new_str(script_file).into())?;
         let runpy = vm.import("runpy", None, 0)?;
         let run_module_as_main = vm.get_attribute(runpy, "_run_module_as_main")?;
-        vm.invoke(
-            &run_module_as_main,
-            (vm.ctx.new_utf8_str("__main__"), false),
-        )?;
+        vm.invoke(&run_module_as_main, (vm.ctx.new_str("__main__"), false))?;
         return Ok(());
     }
     let dir = Path::new(script_file).parent().unwrap().to_str().unwrap();
-    insert_sys_path(vm, vm.ctx.new_utf8_str(dir))?;
+    insert_sys_path(vm, vm.ctx.new_str(dir).into())?;
 
     match std::fs::read_to_string(script_file) {
         Ok(source) => {

stdlib/src/array.rs

@@ -28,8 +28,8 @@ mod array {
             AsBuffer, AsMapping, Comparable, Iterable, IteratorIterable, PyComparisonOp,
             SlotConstructor, SlotIterator,
         },
-        IdProtocol, PyComparisonValue, PyObjectRef, PyObjectWrap, PyRef, PyResult, PyValue,
-        TryFromObject, TypeProtocol, VirtualMachine,
+        IdProtocol, PyComparisonValue, PyObjectRef, PyRef, PyResult, PyValue, TryFromObject,
+        TypeProtocol, VirtualMachine,
     };
     use crossbeam_utils::atomic::AtomicCell;
     use itertools::Itertools;
@@ -1122,8 +1122,8 @@ mod array {
                 return Self::reduce(zelf, vm);
             }
             let array = zelf.read();
-            let cls = zelf.as_object().clone_class().into_object();
-            let typecode = vm.ctx.new_utf8_str(array.typecode_str());
+            let cls = zelf.as_object().clone_class();
+            let typecode = vm.ctx.new_str(array.typecode_str());
             let bytes = vm.ctx.new_bytes(array.get_bytes().to_vec());
             let code = MachineFormatCode::from_typecode(array.typecode()).unwrap();
             let code = PyInt::from(u8::from(code)).into_object(vm);
@@ -1142,8 +1142,8 @@ mod array {
             vm: &VirtualMachine,
         ) -> PyResult<(PyObjectRef, PyTupleRef, Option<PyDictRef>)> {
             let array = zelf.read();
-            let cls = zelf.as_object().clone_class().into_object();
-            let typecode = vm.ctx.new_utf8_str(array.typecode_str());
+            let cls = zelf.as_object().clone_class();
+            let typecode = vm.ctx.new_str(array.typecode_str());
             let values = if array.typecode() == 'u' {
                 let s = Self::_wchar_bytes_to_string(array.get_bytes(), array.itemsize(), vm)?;
                 s.chars().map(|x| x.into_pyobject(vm)).collect()
@@ -1152,7 +1152,7 @@ mod array {
             };
             let values = vm.ctx.new_list(values);
             Ok((
-                cls,
+                cls.into(),
                 vm.new_tuple((typecode, values)),
                 zelf.as_object().dict(),
             ))

stdlib/src/csv.rs

@@ -157,10 +157,10 @@ impl SlotIterator for Reader {
             .map(|&end| {
                 let range = prev_end..end;
                 prev_end = end;
-                std::str::from_utf8(&buffer[range])
-                    .map(|s| vm.ctx.new_utf8_str(s.to_owned()))
+                let s = std::str::from_utf8(&buffer[range])
                     // not sure if this is possible - the input was all strings
-                    .map_err(|_e| vm.new_unicode_decode_error("csv not utf8".to_owned()))
+                    .map_err(|_e| vm.new_unicode_decode_error("csv not utf8".to_owned()))?;
+                Ok(vm.ctx.new_str(s).into())
             })
             .collect::<Result<_, _>>()?;
         Ok(PyIterReturn::Return(vm.ctx.new_list(out)))

stdlib/src/dis.rs

@@ -33,7 +33,7 @@ mod decl {
     fn compiler_flag_names(vm: &VirtualMachine) -> PyDictRef {
         let dict = vm.ctx.new_dict();
         for (name, flag) in CodeFlags::NAME_MAPPING {
-            dict.set_item(vm.new_pyobj(flag.bits()), vm.ctx.new_utf8_str(name), vm)
+            dict.set_item(vm.new_pyobj(flag.bits()), vm.ctx.new_str(*name).into(), vm)
                 .unwrap();
         }
         dict

stdlib/src/keyword.rs

@@ -22,7 +22,7 @@ mod keyword {
             lexer::KEYWORDS
                 .keys()
                 .sorted()
-                .map(|k| vm.ctx.new_utf8_str(k))
+                .map(|&k| vm.ctx.new_str(k).into())
                 .collect(),
         )
     }

stdlib/src/pyexpat.rs

@@ -131,7 +131,7 @@ mod _pyexpat {
                         for attribute in attributes {
                             dict.set_item(
                                 attribute.name.local_name.as_str(),
-                                vm.ctx.new_utf8_str(attribute.value),
+                                vm.ctx.new_str(attribute.value).into(),
                                 vm,
                             )
                             .unwrap();

stdlib/src/re.rs

@@ -189,12 +189,12 @@ mod re {
                 1 => {
                     let full = captures.get(0).unwrap().as_bytes();
                     let full = String::from_utf8_lossy(full).into_owned();
-                    vm.ctx.new_utf8_str(full)
+                    vm.ctx.new_str(full).into()
                 }
                 2 => {
                     let capture = captures.get(1).unwrap().as_bytes();
                     let capture = String::from_utf8_lossy(capture).into_owned();
-                    vm.ctx.new_utf8_str(capture)
+                    vm.ctx.new_str(capture).into()
                 }
                 _ => {
                     let out = captures
@@ -204,7 +204,7 @@ mod re {
                             let s = m
                                 .map(|m| String::from_utf8_lossy(m.as_bytes()).into_owned())
                                 .unwrap_or_default();
-                            vm.ctx.new_utf8_str(s)
+                            vm.ctx.new_str(s).into()
                         })
                         .collect();
                     vm.ctx.new_tuple(out).into()
@@ -253,7 +253,7 @@ mod re {
             .into_iter()
             .map(|v| {
                 vm.unwrap_or_none(
-                    v.map(|v| vm.ctx.new_utf8_str(String::from_utf8_lossy(v).into_owned())),
+                    v.map(|v| vm.ctx.new_str(String::from_utf8_lossy(v).into_owned()).into()),
                 )
             })
             .collect();
@@ -330,12 +330,12 @@ mod re {
         }
 
         #[pymethod]
-        fn sub(&self, repl: PyStrRef, text: PyStrRef, vm: &VirtualMachine) -> PyResult {
+        fn sub(&self, repl: PyStrRef, text: PyStrRef, vm: &VirtualMachine) -> PyResult<PyStrRef> {
             let replaced_text = self
                 .regex
                 .replace_all(text.as_str().as_bytes(), repl.as_str().as_bytes());
             let replaced_text = String::from_utf8_lossy(&replaced_text).into_owned();
-            Ok(vm.ctx.new_utf8_str(replaced_text))
+            Ok(vm.ctx.new_str(replaced_text))
         }
 
         #[pymethod]
@@ -344,8 +344,8 @@ mod re {
         }
 
         #[pyproperty]
-        fn pattern(&self, vm: &VirtualMachine) -> PyResult {
-            Ok(vm.ctx.new_utf8_str(self.pattern.clone()))
+        fn pattern(&self, vm: &VirtualMachine) -> PyResult<PyStrRef> {
+            Ok(vm.ctx.new_str(self.pattern.clone()))
         }
 
         #[pymethod]

stdlib/src/scproxy.rs

@@ -108,7 +108,7 @@ mod _scproxy {
                     } else {
                         format!("http://{}", h)
                     };
-                    result.set_item(proto, vm.ctx.new_utf8_str(v), vm)?;
+                    result.set_item(proto, vm.new_pyobj(v), vm)?;
                 }
             }
             Ok(())

stdlib/src/socket.rs

@@ -1026,8 +1026,7 @@ fn get_addr_tuple(addr: &socket2::SockAddr, vm: &VirtualMachine) -> PyObjectRef
             } else {
                 let len = memchr::memchr(b'\0', path_u8).unwrap_or_else(|| path_u8.len());
                 let path = &path_u8[..len];
-                vm.ctx
-                    .new_utf8_str(String::from_utf8_lossy(path).into_owned())
+                vm.ctx.new_str(String::from_utf8_lossy(path)).into()
             }
         }
         // TODO: support more address families
@@ -1035,10 +1034,10 @@ fn get_addr_tuple(addr: &socket2::SockAddr, vm: &VirtualMachine) -> PyObjectRef
     }
 }
 
-fn _socket_gethostname(vm: &VirtualMachine) -> PyResult {
+fn _socket_gethostname(vm: &VirtualMachine) -> PyResult<PyStrRef> {
     gethostname()
         .into_string()
-        .map(|hostname| vm.ctx.new_utf8_str(hostname))
+        .map(|hostname| vm.ctx.new_str(hostname))
         .map_err(|err| vm.new_os_error(err.into_string().unwrap()))
 }
 
@@ -1055,11 +1054,11 @@ fn _socket_inet_aton(ip_string: PyStrRef, vm: &VirtualMachine) -> PyResult<Vec<u
         .map_err(|_| vm.new_os_error("illegal IP address string passed to inet_aton".to_owned()))
 }
 
-fn _socket_inet_ntoa(packed_ip: ArgBytesLike, vm: &VirtualMachine) -> PyResult {
+fn _socket_inet_ntoa(packed_ip: ArgBytesLike, vm: &VirtualMachine) -> PyResult<PyStrRef> {
     let packed_ip = packed_ip.borrow_buf();
     let packed_ip = <&[u8; 4]>::try_from(&*packed_ip)
         .map_err(|_| vm.new_os_error("packed IP wrong length for inet_ntoa".to_owned()))?;
-    Ok(vm.ctx.new_utf8_str(Ipv4Addr::from(*packed_ip).to_string()))
+    Ok(vm.ctx.new_str(Ipv4Addr::from(*packed_ip).to_string()))
 }
 
 fn cstr_opt_as_ptr(x: &OptionalArg<ffi::CString>) -> *const libc::c_char {
@@ -1290,7 +1289,7 @@ fn _socket_gethostbyaddr(
         hostname,
         vm.ctx.new_list(vec![]),
         vm.ctx
-            .new_list(vec![vm.ctx.new_utf8_str(addr.ip().to_string())]),
+            .new_list(vec![vm.ctx.new_str(addr.ip().to_string()).into()]),
     ))
 }
 
@@ -1726,7 +1725,7 @@ fn convert_socket_error(
     };
     vm.new_exception(
         exception_cls.get().unwrap().clone(),
-        vec![vm.new_pyobj(err.error_num()), vm.ctx.new_utf8_str(strerr)],
+        vec![vm.new_pyobj(err.error_num()), vm.ctx.new_str(strerr).into()],
     )
 }
 

stdlib/src/ssl.rs

@@ -187,14 +187,14 @@ fn _ssl_enum_certificates(store_name: PyStrRef, vm: &VirtualMachine) -> PyResult
             (*ptr).dwCertEncodingType
         };
         let enc_type = match enc_type {
-            wincrypt::X509_ASN_ENCODING => vm.ctx.new_ascii_literal(ascii!("x509_asn")),
-            wincrypt::PKCS_7_ASN_ENCODING => vm.ctx.new_ascii_literal(ascii!("pkcs_7_asn")),
-            other => vm.ctx.new_int(other).into(),
+            wincrypt::X509_ASN_ENCODING => vm.new_pyobj(ascii!("x509_asn")),
+            wincrypt::PKCS_7_ASN_ENCODING => vm.new_pyobj(ascii!("pkcs_7_asn")),
+            other => vm.new_pyobj(other),
         };
         let usage: PyObjectRef = match c.valid_uses()? {
             ValidUses::All => vm.ctx.new_bool(true).into(),
             ValidUses::Oids(oids) => {
-                PyFrozenSet::from_iter(vm, oids.into_iter().map(|oid| vm.ctx.new_utf8_str(oid)))
+                PyFrozenSet::from_iter(vm, oids.into_iter().map(|oid| vm.ctx.new_str(oid).into()))
                     .unwrap()
                     .into_ref(vm)
                     .into()
@@ -991,7 +991,7 @@ fn convert_openssl_error(vm: &VirtualMachine, err: ErrorStack) -> PyBaseExceptio
             let reason = sys::ERR_GET_REASON(e.code());
             vm.new_exception(
                 cls,
-                vec![vm.ctx.new_int(reason).into(), vm.ctx.new_utf8_str(msg)],
+                vec![vm.ctx.new_int(reason).into(), vm.ctx.new_str(msg).into()],
             )
         }
         None => vm.new_exception_empty(cls),
@@ -1073,7 +1073,7 @@ fn cert_to_py(vm: &VirtualMachine, cert: &X509Ref, binary: bool) -> PyResult {
                 .entries()
                 .map(|entry| {
                     let txt = obj2txt(entry.object(), false).into_pyobject(vm);
-                    let data = vm.ctx.new_utf8_str(entry.data().as_utf8()?.to_owned());
+                    let data = vm.ctx.new_str(entry.data().as_utf8()?.to_owned());
                     Ok(vm.new_tuple(((txt, data),)).into())
                 })
                 .collect::<Result<_, _>>()
@@ -1092,18 +1092,18 @@ fn cert_to_py(vm: &VirtualMachine, cert: &X509Ref, binary: bool) -> PyResult {
             .map_err(|e| convert_openssl_error(vm, e))?;
         dict.set_item(
             "serialNumber",
-            vm.ctx.new_utf8_str(serial_num.to_owned()),
+            vm.ctx.new_str(serial_num.to_owned()).into(),
             vm,
         )?;
 
         dict.set_item(
             "notBefore",
-            vm.ctx.new_utf8_str(cert.not_before().to_string()),
+            vm.ctx.new_str(cert.not_before().to_string()).into(),
             vm,
         )?;
         dict.set_item(
             "notAfter",
-            vm.ctx.new_utf8_str(cert.not_after().to_string()),
+            vm.ctx.new_str(cert.not_after().to_string()).into(),
             vm,
         )?;
 
@@ -1209,11 +1209,11 @@ pub fn make_module(vm: &VirtualMachine) -> PyObjectRef {
         "_test_decode_cert" => named_function!(ctx, _ssl, _test_decode_cert),
 
         // Constants
-        "OPENSSL_VERSION" => ctx.new_utf8_str(openssl::version::version()),
+        "OPENSSL_VERSION" => ctx.new_str(openssl::version::version()),
         "OPENSSL_VERSION_NUMBER" => ctx.new_int(openssl::version::number()),
         "OPENSSL_VERSION_INFO" => parse_version_info(openssl::version::number()).into_pyobject(vm),
         "_OPENSSL_API_VERSION" => parse_version_info(openssl_api_version).into_pyobject(vm),
-        "_DEFAULT_CIPHERS" => ctx.new_utf8_str(DEFAULT_CIPHER_STRING),
+        "_DEFAULT_CIPHERS" => ctx.new_str(DEFAULT_CIPHER_STRING),
         // "PROTOCOL_SSLv2" => ctx.new_int(SslVersion::Ssl2 as u32), unsupported
         // "PROTOCOL_SSLv3" => ctx.new_int(SslVersion::Ssl3 as u32),
         "PROTOCOL_SSLv23" => ctx.new_int(SslVersion::Tls as u32),

stdlib/src/termios.rs

@@ -99,7 +99,7 @@ mod termios {
             error_type(vm),
             vec![
                 err.raw_os_error().into_pyobject(vm),
-                vm.ctx.new_utf8_str(err.to_string()),
+                vm.ctx.new_str(err.to_string()).into(),
             ],
         )
     }

stdlib/src/unicodedata.rs

@@ -37,7 +37,7 @@ pub fn make_module(vm: &VirtualMachine) -> PyObjectRef {
         "ucd_3_2_0" => ucd_3_2_0,
         // we do unidata_version here because the getter tries to do PyUCD::class() before
         // the module is in the VM
-        "unidata_version" => ctx.new_utf8_str(PyUCD::default().unic_version.to_string()),
+        "unidata_version" => ctx.new_str(PyUCD::default().unic_version.to_string()),
     });
 
     for attr in ["category", "lookup", "name", "bidirectional", "normalize"]
@@ -116,7 +116,7 @@ impl PyUCD {
         if let Some(c) = c {
             if self.check_age(c) {
                 if let Some(name) = unicode_names2::name(c) {
-                    return Ok(vm.ctx.new_utf8_str(name.to_string()));
+                    return Ok(vm.ctx.new_str(name.to_string()).into());
                 }
             }
         }

vm/src/builtins/code.rs

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

vm/src/builtins/dict.rs

@@ -326,7 +326,7 @@ impl PyDict {
             Self::merge_object(&self.entries, dict_obj, vm)?;
         }
         for (key, value) in kwargs.into_iter() {
-            self.entries.insert(vm, vm.ctx.new_utf8_str(key), value)?;
+            self.entries.insert(vm, vm.new_pyobj(key), value)?;
         }
         Ok(())
     }
@@ -377,7 +377,8 @@ impl PyDict {
         let (key, value) = self.entries.pop_back().ok_or_else(|| {
             let err_msg = vm
                 .ctx
-                .new_ascii_literal(ascii!("popitem(): dictionary is empty"));
+                .new_str(ascii!("popitem(): dictionary is empty"))
+                .into();
             vm.new_key_error(err_msg)
         })?;
         Ok((key, value))
@@ -387,7 +388,7 @@ impl PyDict {
         let dict = DictContentType::default();
 
         for (key, value) in attrs {
-            dict.insert(vm, vm.ctx.new_utf8_str(key), value)?;
+            dict.insert(vm, vm.new_pyobj(key), value)?;
         }
 
         Ok(PyDict { entries: dict })

vm/src/builtins/function.rs

@@ -545,10 +545,13 @@ impl PyBoundMethod {
             // We need to add object's part manually.
             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_utf8_str(format!(
-                "{}.__new__",
-                obj_name.as_ref().map_or("?", |s| s.as_str())
-            )));
+            return Ok(vm
+                .ctx
+                .new_str(format!(
+                    "{}.__new__",
+                    obj_name.as_ref().map_or("?", |s| s.as_str())
+                ))
+                .into());
         }
 
         vm.get_attribute(self.function.clone(), "__qualname__")

vm/src/builtins/memory.rs

@@ -210,7 +210,7 @@ impl PyMemoryView {
     #[pyproperty]
     fn format(&self, vm: &VirtualMachine) -> PyResult<PyStr> {
         self.try_not_released(vm)
-            .map(|_| PyStr::from(&self.buffer.options.format))
+            .map(|_| PyStr::from(self.buffer.options.format.clone()))
     }
 
     #[pymethod(magic)]

vm/src/builtins/pystr.rs

@@ -109,12 +109,9 @@ impl AsRef<str> for PyStrRef {
     }
 }
 
-impl<T> From<&T> for PyStr
-where
-    T: AsRef<str> + ?Sized,
-{
-    fn from(s: &T) -> PyStr {
-        s.as_ref().to_owned().into()
+impl<'a> From<&'a AsciiStr> for PyStr {
+    fn from(s: &'a AsciiStr) -> Self {
+        s.to_owned().into()
     }
 }
 
@@ -124,12 +121,24 @@ impl From<AsciiString> for PyStr {
     }
 }
 
+impl<'a> From<&'a str> for PyStr {
+    fn from(s: &'a str) -> Self {
+        s.to_owned().into()
+    }
+}
+
 impl From<String> for PyStr {
     fn from(s: String) -> Self {
         s.into_boxed_str().into()
     }
 }
 
+impl<'a> From<std::borrow::Cow<'a, str>> for PyStr {
+    fn from(s: std::borrow::Cow<'a, str>) -> Self {
+        s.into_owned().into()
+    }
+}
+
 impl From<Box<str>> for PyStr {
     #[inline]
     fn from(value: Box<str>) -> Self {
@@ -621,9 +630,9 @@ impl PyStr {
             PyStrKind::Utf8 => self.as_str().py_split(
                 args,
                 vm,
-                |v, s, vm| v.split(s).map(|s| vm.ctx.new_utf8_str(s)).collect(),
-                |v, s, n, vm| v.splitn(n, s).map(|s| vm.ctx.new_utf8_str(s)).collect(),
-                |v, n, vm| v.py_split_whitespace(n, |s| vm.ctx.new_utf8_str(s)),
+                |v, s, vm| v.split(s).map(|s| vm.ctx.new_str(s).into()).collect(),
+                |v, s, n, vm| v.splitn(n, s).map(|s| vm.ctx.new_str(s).into()).collect(),
+                |v, n, vm| v.py_split_whitespace(n, |s| vm.ctx.new_str(s).into()),
             ),
         }?;
         Ok(vm.ctx.new_list(elements))
@@ -634,9 +643,9 @@ impl PyStr {
         let mut elements = self.as_str().py_split(
             args,
             vm,
-            |v, s, vm| v.rsplit(s).map(|s| vm.ctx.new_utf8_str(s)).collect(),
-            |v, s, n, vm| v.rsplitn(n, s).map(|s| vm.ctx.new_utf8_str(s)).collect(),
-            |v, n, vm| v.py_rsplit_whitespace(n, |s| vm.ctx.new_utf8_str(s)),
+            |v, s, vm| v.rsplit(s).map(|s| vm.ctx.new_str(s).into()).collect(),
+            |v, s, n, vm| v.rsplitn(n, s).map(|s| vm.ctx.new_str(s).into()).collect(),
+            |v, n, vm| v.py_rsplit_whitespace(n, |s| vm.ctx.new_str(s).into()),
         )?;
         // Unlike Python rsplit, Rust rsplitn returns an iterator that
         // starts from the end of the string.
@@ -970,9 +979,9 @@ impl PyStr {
         let partition = (
             self.new_substr(front),
             if has_mid {
-                sep.into()
+                sep
             } else {
-                vm.ctx.new_ascii_literal(ascii!(""))
+                vm.ctx.new_str(ascii!(""))
             },
             self.new_substr(back),
         );
@@ -989,9 +998,9 @@ impl PyStr {
         Ok((
             self.new_substr(front),
             if has_mid {
-                sep.into()
+                sep
             } else {
-                vm.ctx.new_ascii_literal(ascii!(""))
+                vm.ctx.new_str(ascii!(""))
             },
             self.new_substr(back),
         )
@@ -1314,31 +1323,37 @@ impl PyValue for PyStr {
 
 impl IntoPyObject for String {
     fn into_pyobject(self, vm: &VirtualMachine) -> PyObjectRef {
-        vm.ctx.new_utf8_str(self)
+        vm.ctx.new_str(self).into()
     }
 }
 
 impl IntoPyObject for char {
     fn into_pyobject(self, vm: &VirtualMachine) -> PyObjectRef {
-        vm.ctx.new_utf8_str(self.to_string())
+        vm.ctx.new_str(self.to_string()).into()
     }
 }
 
 impl IntoPyObject for &str {
     fn into_pyobject(self, vm: &VirtualMachine) -> PyObjectRef {
-        vm.ctx.new_utf8_str(self)
+        vm.ctx.new_str(self).into()
     }
 }
 
 impl IntoPyObject for &String {
     fn into_pyobject(self, vm: &VirtualMachine) -> PyObjectRef {
-        vm.ctx.new_utf8_str(self.clone())
+        vm.ctx.new_str(self.clone()).into()
     }
 }
 
 impl IntoPyObject for &AsciiStr {
     fn into_pyobject(self, vm: &VirtualMachine) -> PyObjectRef {
-        vm.ctx.new_ascii_literal(self)
+        vm.ctx.new_str(self).into()
+    }
+}
+
+impl IntoPyObject for AsciiString {
+    fn into_pyobject(self, vm: &VirtualMachine) -> PyObjectRef {
+        vm.ctx.new_str(self).into()
     }
 }
 
@@ -1539,10 +1554,12 @@ mod tests {
     fn str_maketrans_and_translate() {
         Interpreter::default().enter(|vm| {
             let table = vm.ctx.new_dict();
-            table.set_item("a", vm.ctx.new_utf8_str("🎅"), &vm).unwrap();
+            table
+                .set_item("a", vm.ctx.new_str("🎅").into(), &vm)
+                .unwrap();
             table.set_item("b", vm.ctx.none(), &vm).unwrap();
             table
-                .set_item("c", vm.ctx.new_ascii_literal(ascii!("xda")), &vm)
+                .set_item("c", vm.ctx.new_str(ascii!("xda")).into(), &vm)
                 .unwrap();
             let translated = PyStr::maketrans(
                 table.into(),

vm/src/builtins/pysuper.rs

@@ -215,6 +215,6 @@ pub fn init(context: &PyContext) {
                      super().cmeth(arg)\n";
 
     extend_class!(context, super_type, {
-        "__doc__" => context.new_utf8_str(super_doc),
+        "__doc__" => context.new_str(super_doc),
     });
 }

vm/src/builtins/pytype.rs

@@ -384,7 +384,7 @@ impl PyType {
         let attributes: Vec<PyObjectRef> = zelf
             .get_attributes()
             .drain()
-            .map(|(k, _)| vm.ctx.new_utf8_str(k))
+            .map(|(k, _)| vm.ctx.new_str(k).into())
             .collect();
         PyList::from(attributes)
     }
@@ -451,7 +451,7 @@ impl PyType {
                     Some(found)
                 }
             })
-            .unwrap_or_else(|| vm.ctx.new_utf8_str(self.name().deref()))
+            .unwrap_or_else(|| vm.ctx.new_str(self.name().deref()).into())
     }
 
     #[pyproperty(magic)]
@@ -469,7 +469,7 @@ impl PyType {
                     Some(found)
                 }
             })
-            .unwrap_or_else(|| vm.ctx.new_ascii_literal(ascii!("builtins")))
+            .unwrap_or_else(|| vm.ctx.new_str(ascii!("builtins")).into())
     }
 
     #[pyproperty(magic, setter)]

vm/src/builtins/set.rs

@@ -271,7 +271,7 @@ impl PySetInner {
         if let Some((key, _)) = self.content.pop_back() {
             Ok(key)
         } else {
-            let err_msg = vm.ctx.new_ascii_literal(ascii!("pop from an empty set"));
+            let err_msg = vm.ctx.new_str(ascii!("pop from an empty set")).into();
             Err(vm.new_key_error(err_msg))
         }
     }
@@ -534,7 +534,7 @@ impl PySet {
         } else {
             format!("{}(...)", class_name)
         };
-        Ok(vm.ctx.new_utf8_str(s))
+        Ok(vm.ctx.new_str(s).into())
     }
 
     #[pymethod]
@@ -809,7 +809,7 @@ impl PyFrozenSet {
         } else {
             format!("{}(...)", class_name)
         };
-        Ok(vm.ctx.new_utf8_str(s))
+        Ok(vm.ctx.new_str(s).into())
     }
 
     #[pymethod(magic)]

vm/src/codecs.rs

@@ -367,7 +367,7 @@ fn strict_errors(err: PyObjectRef, vm: &VirtualMachine) -> PyResult {
 fn ignore_errors(err: PyObjectRef, vm: &VirtualMachine) -> PyResult<(PyObjectRef, usize)> {
     if is_encode_ish_err(&err, vm) || is_decode_err(&err, vm) {
         let range = extract_unicode_error_range(&err, vm)?;
-        Ok((vm.ctx.new_ascii_literal(ascii!("")), range.end))
+        Ok((vm.ctx.new_str(ascii!("")).into(), range.end))
     } else {
         Err(bad_err_type(err, vm))
     }

vm/src/dictdatatype.rs

@@ -717,7 +717,7 @@ impl DictKey for &str {
             Ok(pystr.as_str() == *self)
         } else {
             // Fall back to PyObjectRef implementation.
-            let s = vm.ctx.new_utf8_str(*self);
+            let s = vm.ctx.new_str(*self);
             s.key_eq(vm, other_key)
         }
     }
@@ -764,12 +764,12 @@ mod tests {
             assert_eq!(0, dict.len());
 
             let key1 = vm.new_pyobj(true);
-            let value1 = vm.ctx.new_ascii_literal(ascii!("abc"));
+            let value1 = vm.new_pyobj(ascii!("abc"));
             dict.insert(&vm, key1.clone(), value1.clone()).unwrap();
             assert_eq!(1, dict.len());
 
-            let key2 = vm.ctx.new_ascii_literal(ascii!("x"));
-            let value2 = vm.ctx.new_ascii_literal(ascii!("def"));
+            let key2 = vm.new_pyobj(ascii!("x"));
+            let value2 = vm.new_pyobj(ascii!("def"));
             dict.insert(&vm, key2.clone(), value2.clone()).unwrap();
             assert_eq!(2, dict.len());
 
@@ -810,7 +810,7 @@ mod tests {
     fn check_hash_equivalence(text: &str) {
         Interpreter::default().enter(|vm| {
             let value1 = text;
-            let value2 = vm.ctx.new_utf8_str(value1.to_owned());
+            let value2 = vm.new_pyobj(value1.to_owned());
 
             let hash1 = value1.key_hash(&vm).expect("Hash should not fail.");
             let hash2 = value2.key_hash(&vm).expect("Hash should not fail.");

vm/src/format.rs

@@ -871,7 +871,7 @@ impl FormatString {
             }
             FieldType::Keyword(keyword) => arguments
                 .get_optional_kwarg(&keyword)
-                .ok_or_else(|| vm.new_key_error(vm.ctx.new_utf8_str(keyword))),
+                .ok_or_else(|| vm.new_key_error(vm.ctx.new_str(keyword).into())),
         })
     }
 
@@ -894,7 +894,7 @@ fn call_object_format(
     let argument = match preconversion_spec.and_then(FormatPreconversor::from_char) {
         Some(FormatPreconversor::Str) => vm.to_str(&argument)?.into(),
         Some(FormatPreconversor::Repr) => vm.to_repr(&argument)?.into(),
-        Some(FormatPreconversor::Ascii) => vm.ctx.new_utf8_str(builtins::ascii(argument, vm)?),
+        Some(FormatPreconversor::Ascii) => vm.ctx.new_str(builtins::ascii(argument, vm)?).into(),
         Some(FormatPreconversor::Bytes) => vm.call_method(&argument, "decode", ())?,
         None => argument,
     };

vm/src/frame.rs

@@ -614,7 +614,7 @@ impl ExecutingFrame<'_> {
                     .iter()
                     .map(|pyobj| pyobj.payload::<PyStr>().unwrap().as_ref())
                     .collect::<String>();
-                let str_obj = vm.ctx.new_utf8_str(s);
+                let str_obj = vm.ctx.new_str(s).into();
                 self.push_value(str_obj);
                 Ok(None)
             }
@@ -1016,7 +1016,7 @@ impl ExecutingFrame<'_> {
                 let value = match conversion {
                     ConversionFlag::Str => vm.to_str(&value)?.into(),
                     ConversionFlag::Repr => vm.to_repr(&value)?.into(),
-                    ConversionFlag::Ascii => vm.ctx.new_utf8_str(builtins::ascii(value, vm)?),
+                    ConversionFlag::Ascii => vm.ctx.new_str(builtins::ascii(value, vm)?).into(),
                     ConversionFlag::None => value,
                 };
 
@@ -1566,7 +1566,7 @@ impl ExecutingFrame<'_> {
         vm.set_attr(&func_obj, "__doc__", vm.ctx.none())?;
 
         let name = qualified_name.as_str().split('.').next_back().unwrap();
-        vm.set_attr(&func_obj, "__name__", vm.ctx.new_utf8_str(name))?;
+        vm.set_attr(&func_obj, "__name__", vm.new_pyobj(name))?;
         vm.set_attr(&func_obj, "__qualname__", qualified_name)?;
         let module = vm.unwrap_or_none(self.globals.get_item_option("__name__", vm)?);
         vm.set_attr(&func_obj, "__module__", module)?;

vm/src/import.rs

@@ -125,9 +125,9 @@ pub fn import_codeobj(
     set_file_attr: bool,
 ) -> PyResult {
     let attrs = vm.ctx.new_dict();
-    attrs.set_item("__name__", vm.ctx.new_utf8_str(module_name), vm)?;
+    attrs.set_item("__name__", vm.ctx.new_str(module_name).into(), vm)?;
     if set_file_attr {
-        attrs.set_item("__file__", vm.ctx.new_utf8_str(&code_obj.source_path), vm)?;
+        attrs.set_item("__file__", code_obj.source_path.as_object().clone(), vm)?;
     }
     let module = vm.new_module(module_name, attrs.clone(), None);
 

vm/src/macros.rs

@@ -224,7 +224,7 @@ macro_rules! named_function {
                 [<$module _ $func>],
             )
             .into_function()
-            .with_module(ctx.new_utf8_str(stringify!($module).to_owned()))
+            .with_module(ctx.new_str(stringify!($module).to_owned()).into())
             .into_ref(ctx)
         }
     }};

vm/src/py_io.rs

@@ -65,7 +65,7 @@ pub fn file_readline(obj: &PyObjectRef, size: Option<usize>, vm: &VirtualMachine
     let eof_err = || {
         vm.new_exception(
             vm.ctx.exceptions.eof_error.clone(),
-            vec![vm.ctx.new_ascii_literal(ascii!("EOF when reading a line"))],
+            vec![vm.ctx.new_str(ascii!("EOF when reading a line")).into()],
         )
     };
     let ret = match_class!(match ret {
@@ -75,7 +75,7 @@ pub fn file_readline(obj: &PyObjectRef, size: Option<usize>, vm: &VirtualMachine
                 return Err(eof_err());
             }
             if let Some(nonl) = sval.strip_suffix('\n') {
-                vm.ctx.new_utf8_str(nonl)
+                vm.ctx.new_str(nonl).into()
             } else {
                 s.into()
             }

vm/src/py_serde.rs

@@ -177,7 +177,7 @@ impl<'de> Visitor<'de> for PyObjectDeserializer<'de> {
     where
         E: serde::de::Error,
     {
-        Ok(self.vm.ctx.new_utf8_str(value))
+        Ok(self.vm.ctx.new_str(value).into())
     }
 
     fn visit_unit<E>(self) -> Result<Self::Value, E>

vm/src/pyobject.rs

@@ -183,22 +183,8 @@ impl PyContext {
         PyRef::new_ref(PyFloat::from(value), self.types.float_type.clone(), None)
     }
 
-    pub fn new_utf8_str<S>(&self, s: S) -> PyObjectRef
-    where
-        S: Into<pystr::PyStr>,
-    {
-        PyObject::new(s.into(), self.types.str_type.clone(), None)
-    }
-
-    #[inline]
-    pub fn new_ascii_literal(&self, s: &ascii::AsciiStr) -> PyObjectRef {
-        PyObject::new(
-            unsafe {
-                pystr::PyStr::new_str_unchecked(s.as_bytes().to_owned(), pystr::PyStrKind::Ascii)
-            },
-            self.types.str_type.clone(),
-            None,
-        )
+    pub fn new_str(&self, s: impl Into<pystr::PyStr>) -> PyRef<PyStr> {
+        pystr::PyStr::new_ref(s, self)
     }
 
     pub fn new_bytes(&self, data: Vec<u8>) -> PyRef<bytes::PyBytes> {
@@ -910,10 +896,10 @@ pub trait PyClassImpl: PyClassDef {
         }
         Self::impl_extend_class(ctx, class);
         if let Some(doc) = Self::DOC {
-            class.set_str_attr("__doc__", ctx.new_utf8_str(doc));
+            class.set_str_attr("__doc__", ctx.new_str(doc));
         }
         if let Some(module_name) = Self::MODULE_NAME {
-            class.set_str_attr("__module__", ctx.new_utf8_str(module_name));
+            class.set_str_attr("__module__", ctx.new_str(module_name));
         }
         if class.slots.new.load().is_some() {
             let bound: PyObjectRef =

vm/src/stdlib/ast.rs

@@ -156,7 +156,7 @@ fn node_add_location(node: &PyObjectRef, location: ast::Location, vm: &VirtualMa
 
 impl Node for String {
     fn ast_to_object(self, vm: &VirtualMachine) -> PyObjectRef {
-        vm.ctx.new_utf8_str(self)
+        vm.ctx.new_str(self).into()
     }
 
     fn ast_from_object(vm: &VirtualMachine, object: PyObjectRef) -> PyResult<Self> {
@@ -189,7 +189,7 @@ impl Node for ast::Constant {
         match self {
             ast::Constant::None => vm.ctx.none(),
             ast::Constant::Bool(b) => vm.ctx.new_bool(b).into(),
-            ast::Constant::Str(s) => vm.ctx.new_utf8_str(s),
+            ast::Constant::Str(s) => vm.ctx.new_str(s).into(),
             ast::Constant::Bytes(b) => vm.ctx.new_bytes(b).into(),
             ast::Constant::Int(i) => vm.ctx.new_int(i).into(),
             ast::Constant::Tuple(t) => vm

vm/src/stdlib/ast/gen.rs

@@ -9,7 +9,7 @@ struct NodeModule;
 impl NodeModule {
     #[extend_class]
     fn extend_class_with_fields(ctx: &PyContext, class: &PyTypeRef) {
-        class.set_str_attr("_fields", ctx.new_list(vec![ctx.new_ascii_literal(ascii!("body")),ctx.new_ascii_literal(ascii!("type_ignores"))]));
+        class.set_str_attr("_fields", ctx.new_list(vec![ctx.new_str(ascii!("body")).into(),ctx.new_str(ascii!("type_ignores")).into()]));
         class.set_str_attr("_attributes", ctx.new_list(vec![]));
     }
 }
@@ -19,7 +19,7 @@ struct NodeInteractive;
 impl NodeInteractive {
     #[extend_class]
     fn extend_class_with_fields(ctx: &PyContext, class: &PyTypeRef) {
-        class.set_str_attr("_fields", ctx.new_list(vec![ctx.new_ascii_literal(ascii!("body"))]));
+        class.set_str_attr("_fields", ctx.new_list(vec![ctx.new_str(ascii!("body")).into()]));
         class.set_str_attr("_attributes", ctx.new_list(vec![]));
     }
 }
@@ -29,7 +29,7 @@ struct NodeExpression;
 impl NodeExpression {
     #[extend_class]
     fn extend_class_with_fields(ctx: &PyContext, class: &PyTypeRef) {
-        class.set_str_attr("_fields", ctx.new_list(vec![ctx.new_ascii_literal(ascii!("body"))]));
+        class.set_str_attr("_fields", ctx.new_list(vec![ctx.new_str(ascii!("body")).into()]));
         class.set_str_attr("_attributes", ctx.new_list(vec![]));
     }
 }
@@ -39,7 +39,7 @@ struct NodeFunctionType;
 impl NodeFunctionType {
     #[extend_class]
     fn extend_class_with_fields(ctx: &PyContext, class: &PyTypeRef) {
-        class.set_str_attr("_fields", ctx.new_list(vec![ctx.new_ascii_literal(ascii!("argtypes")),ctx.new_ascii_literal(ascii!("returns"))]));
+        class.set_str_attr("_fields", ctx.new_list(vec![ctx.new_str(ascii!("argtypes")).into(),ctx.new_str(ascii!("returns")).into()]));
         class.set_str_attr("_attributes", ctx.new_list(vec![]));
     }
 }
@@ -49,8 +49,8 @@ struct NodeFunctionDef;
 impl NodeFunctionDef {
     #[extend_class]
     fn extend_class_with_fields(ctx: &PyContext, class: &PyTypeRef) {
-        class.set_str_attr("_fields", ctx.new_list(vec![ctx.new_ascii_literal(ascii!("name")),ctx.new_ascii_literal(ascii!("args")),ctx.new_ascii_literal(ascii!("body")),ctx.new_ascii_literal(ascii!("decorator_list")),ctx.new_ascii_literal(ascii!("returns")),ctx.new_ascii_literal(ascii!("type_comment"))]));
-        class.set_str_attr("_attributes", ctx.new_list(vec![ctx.new_ascii_literal(ascii!("lineno")),ctx.new_ascii_literal(ascii!("col_offset")),ctx.new_ascii_literal(ascii!("end_lineno")),ctx.new_ascii_literal(ascii!("end_col_offset"))]));
+        class.set_str_attr("_fields", ctx.new_list(vec![ctx.new_str(ascii!("name")).into(),ctx.new_str(ascii!("args")).into(),ctx.new_str(ascii!("body")).into(),ctx.new_str(ascii!("decorator_list")).into(),ctx.new_str(ascii!("returns")).into(),ctx.new_str(ascii!("type_comment")).into()]));
+        class.set_str_attr("_attributes", ctx.new_list(vec![ctx.new_str(ascii!("lineno")).into(),ctx.new_str(ascii!("col_offset")).into(),ctx.new_str(ascii!("end_lineno")).into(),ctx.new_str(ascii!("end_col_offset")).into()]));
     }
 }
 #[pyclass(module = "_ast", name = "AsyncFunctionDef", base = "AstNode")]
@@ -59,8 +59,8 @@ struct NodeAsyncFunctionDef;
 impl NodeAsyncFunctionDef {
     #[extend_class]
     fn extend_class_with_fields(ctx: &PyContext, class: &PyTypeRef) {
-        class.set_str_attr("_fields", ctx.new_list(vec![ctx.new_ascii_literal(ascii!("name")),ctx.new_ascii_literal(ascii!("args")),ctx.new_ascii_literal(ascii!("body")),ctx.new_ascii_literal(ascii!("decorator_list")),ctx.new_ascii_literal(ascii!("returns")),ctx.new_ascii_literal(ascii!("type_comment"))]));
-        class.set_str_attr("_attributes", ctx.new_list(vec![ctx.new_ascii_literal(ascii!("lineno")),ctx.new_ascii_literal(ascii!("col_offset")),ctx.new_ascii_literal(ascii!("end_lineno")),ctx.new_ascii_literal(ascii!("end_col_offset"))]));
+        class.set_str_attr("_fields", ctx.new_list(vec![ctx.new_str(ascii!("name")).into(),ctx.new_str(ascii!("args")).into(),ctx.new_str(ascii!("body")).into(),ctx.new_str(ascii!("decorator_list")).into(),ctx.new_str(ascii!("returns")).into(),ctx.new_str(ascii!("type_comment")).into()]));
+        class.set_str_attr("_attributes", ctx.new_list(vec![ctx.new_str(ascii!("lineno")).into(),ctx.new_str(ascii!("col_offset")).into(),ctx.new_str(ascii!("end_lineno")).into(),ctx.new_str(ascii!("end_col_offset")).into()]));
     }
 }
 #[pyclass(module = "_ast", name = "ClassDef", base = "AstNode")]
@@ -69,8 +69,8 @@ struct NodeClassDef;
 impl NodeClassDef {
     #[extend_class]
     fn extend_class_with_fields(ctx: &PyContext, class: &PyTypeRef) {
-        class.set_str_attr("_fields", ctx.new_list(vec![ctx.new_ascii_literal(ascii!("name")),ctx.new_ascii_literal(ascii!("bases")),ctx.new_ascii_literal(ascii!("keywords")),ctx.new_ascii_literal(ascii!("body")),ctx.new_ascii_literal(ascii!("decorator_list"))]));
-        class.set_str_attr("_attributes", ctx.new_list(vec![ctx.new_ascii_literal(ascii!("lineno")),ctx.new_ascii_literal(ascii!("col_offset")),ctx.new_ascii_literal(ascii!("end_lineno")),ctx.new_ascii_literal(ascii!("end_col_offset"))]));
+        class.set_str_attr("_fields", ctx.new_list(vec![ctx.new_str(ascii!("name")).into(),ctx.new_str(ascii!("bases")).into(),ctx.new_str(ascii!("keywords")).into(),ctx.new_str(ascii!("body")).into(),ctx.new_str(ascii!("decorator_list")).into()]));
+        class.set_str_attr("_attributes", ctx.new_list(vec![ctx.new_str(ascii!("lineno")).into(),ctx.new_str(ascii!("col_offset")).into(),ctx.new_str(ascii!("end_lineno")).into(),ctx.new_str(ascii!("end_col_offset")).into()]));
     }
 }
 #[pyclass(module = "_ast", name = "Return", base = "AstNode")]
@@ -79,8 +79,8 @@ struct NodeReturn;
 impl NodeReturn {
     #[extend_class]
     fn extend_class_with_fields(ctx: &PyContext, class: &PyTypeRef) {
-        class.set_str_attr("_fields", ctx.new_list(vec![ctx.new_ascii_literal(ascii!("value"))]));
-        class.set_str_attr("_attributes", ctx.new_list(vec![ctx.new_ascii_literal(ascii!("lineno")),ctx.new_ascii_literal(ascii!("col_offset")),ctx.new_ascii_literal(ascii!("end_lineno")),ctx.new_ascii_literal(ascii!("end_col_offset"))]));
+        class.set_str_attr("_fields", ctx.new_list(vec![ctx.new_str(ascii!("value")).into()]));
+        class.set_str_attr("_attributes", ctx.new_list(vec![ctx.new_str(ascii!("lineno")).into(),ctx.new_str(ascii!("col_offset")).into(),ctx.new_str(ascii!("end_lineno")).into(),ctx.new_str(ascii!("end_col_offset")).into()]));
     }
 }
 #[pyclass(module = "_ast", name = "Delete", base = "AstNode")]
@@ -89,8 +89,8 @@ struct NodeDelete;
 impl NodeDelete {
     #[extend_class]
     fn extend_class_with_fields(ctx: &PyContext, class: &PyTypeRef) {
-        class.set_str_attr("_fields", ctx.new_list(vec![ctx.new_ascii_literal(ascii!("targets"))]));
-        class.set_str_attr("_attributes", ctx.new_list(vec![ctx.new_ascii_literal(ascii!("lineno")),ctx.new_ascii_literal(ascii!("col_offset")),ctx.new_ascii_literal(ascii!("end_lineno")),ctx.new_ascii_literal(ascii!("end_col_offset"))]));
+        class.set_str_attr("_fields", ctx.new_list(vec![ctx.new_str(ascii!("targets")).into()]));
+        class.set_str_attr("_attributes", ctx.new_list(vec![ctx.new_str(ascii!("lineno")).into(),ctx.new_str(ascii!("col_offset")).into(),ctx.new_str(ascii!("end_lineno")).into(),ctx.new_str(ascii!("end_col_offset")).into()]));
     }
 }
 #[pyclass(module = "_ast", name = "Assign", base = "AstNode")]
@@ -99,8 +99,8 @@ struct NodeAssign;
 impl NodeAssign {
     #[extend_class]
     fn extend_class_with_fields(ctx: &PyContext, class: &PyTypeRef) {
-        class.set_str_attr("_fields", ctx.new_list(vec![ctx.new_ascii_literal(ascii!("targets")),ctx.new_ascii_literal(ascii!("value")),ctx.new_ascii_literal(ascii!("type_comment"))]));
-        class.set_str_attr("_attributes", ctx.new_list(vec![ctx.new_ascii_literal(ascii!("lineno")),ctx.new_ascii_literal(ascii!("col_offset")),ctx.new_ascii_literal(ascii!("end_lineno")),ctx.new_ascii_literal(ascii!("end_col_offset"))]));
+        class.set_str_attr("_fields", ctx.new_list(vec![ctx.new_str(ascii!("targets")).into(),ctx.new_str(ascii!("value")).into(),ctx.new_str(ascii!("type_comment")).into()]));
+        class.set_str_attr("_attributes", ctx.new_list(vec![ctx.new_str(ascii!("lineno")).into(),ctx.new_str(ascii!("col_offset")).into(),ctx.new_str(ascii!("end_lineno")).into(),ctx.new_str(ascii!("end_col_offset")).into()]));
     }
 }
 #[pyclass(module = "_ast", name = "AugAssign", base = "AstNode")]
@@ -109,8 +109,8 @@ struct NodeAugAssign;
 impl NodeAugAssign {
     #[extend_class]
     fn extend_class_with_fields(ctx: &PyContext, class: &PyTypeRef) {
-        class.set_str_attr("_fields", ctx.new_list(vec![ctx.new_ascii_literal(ascii!("target")),ctx.new_ascii_literal(ascii!("op")),ctx.new_ascii_literal(ascii!("value"))]));
-        class.set_str_attr("_attributes", ctx.new_list(vec![ctx.new_ascii_literal(ascii!("lineno")),ctx.new_ascii_literal(ascii!("col_offset")),ctx.new_ascii_literal(ascii!("end_lineno")),ctx.new_ascii_literal(ascii!("end_col_offset"))]));
+        class.set_str_attr("_fields", ctx.new_list(vec![ctx.new_str(ascii!("target")).into(),ctx.new_str(ascii!("op")).into(),ctx.new_str(ascii!("value")).into()]));
+        class.set_str_attr("_attributes", ctx.new_list(vec![ctx.new_str(ascii!("lineno")).into(),ctx.new_str(ascii!("col_offset")).into(),ctx.new_str(ascii!("end_lineno")).into(),ctx.new_str(ascii!("end_col_offset")).into()]));
     }
 }
 #[pyclass(module = "_ast", name = "AnnAssign", base = "AstNode")]
@@ -119,8 +119,8 @@ struct NodeAnnAssign;
 impl NodeAnnAssign {
     #[extend_class]
     fn extend_class_with_fields(ctx: &PyContext, class: &PyTypeRef) {
-        class.set_str_attr("_fields", ctx.new_list(vec![ctx.new_ascii_literal(ascii!("target")),ctx.new_ascii_literal(ascii!("annotation")),ctx.new_ascii_literal(ascii!("value")),ctx.new_ascii_literal(ascii!("simple"))]));
-        class.set_str_attr("_attributes", ctx.new_list(vec![ctx.new_ascii_literal(ascii!("lineno")),ctx.new_ascii_literal(ascii!("col_offset")),ctx.new_ascii_literal(ascii!("end_lineno")),ctx.new_ascii_literal(ascii!("end_col_offset"))]));
+        class.set_str_attr("_fields", ctx.new_list(vec![ctx.new_str(ascii!("target")).into(),ctx.new_str(ascii!("annotation")).into(),ctx.new_str(ascii!("value")).into(),ctx.new_str(ascii!("simple")).into()]));
+        class.set_str_attr("_attributes", ctx.new_list(vec![ctx.new_str(ascii!("lineno")).into(),ctx.new_str(ascii!("col_offset")).into(),ctx.new_str(ascii!("end_lineno")).into(),ctx.new_str(ascii!("end_col_offset")).into()]));
     }
 }
 #[pyclass(module = "_ast", name = "For", base = "AstNode")]
@@ -129,8 +129,8 @@ struct NodeFor;
 impl NodeFor {
     #[extend_class]
     fn extend_class_with_fields(ctx: &PyContext, class: &PyTypeRef) {
-        class.set_str_attr("_fields", ctx.new_list(vec![ctx.new_ascii_literal(ascii!("target")),ctx.new_ascii_literal(ascii!("iter")),ctx.new_ascii_literal(ascii!("body")),ctx.new_ascii_literal(ascii!("orelse")),ctx.new_ascii_literal(ascii!("type_comment"))]));
-        class.set_str_attr("_attributes", ctx.new_list(vec![ctx.new_ascii_literal(ascii!("lineno")),ctx.new_ascii_literal(ascii!("col_offset")),ctx.new_ascii_literal(ascii!("end_lineno")),ctx.new_ascii_literal(ascii!("end_col_offset"))]));
+        class.set_str_attr("_fields", ctx.new_list(vec![ctx.new_str(ascii!("target")).into(),ctx.new_str(ascii!("iter")).into(),ctx.new_str(ascii!("body")).into(),ctx.new_str(ascii!("orelse")).into(),ctx.new_str(ascii!("type_comment")).into()]));
+        class.set_str_attr("_attributes", ctx.new_list(vec![ctx.new_str(ascii!("lineno")).into(),ctx.new_str(ascii!("col_offset")).into(),ctx.new_str(ascii!("end_lineno")).into(),ctx.new_str(ascii!("end_col_offset")).into()]));
     }
 }
 #[pyclass(module = "_ast", name = "AsyncFor", base = "AstNode")]
@@ -139,8 +139,8 @@ struct NodeAsyncFor;
 impl NodeAsyncFor {
     #[extend_class]
     fn extend_class_with_fields(ctx: &PyContext, class: &PyTypeRef) {
-        class.set_str_attr("_fields", ctx.new_list(vec![ctx.new_ascii_literal(ascii!("target")),ctx.new_ascii_literal(ascii!("iter")),ctx.new_ascii_literal(ascii!("body")),ctx.new_ascii_literal(ascii!("orelse")),ctx.new_ascii_literal(ascii!("type_comment"))]));
-        class.set_str_attr("_attributes", ctx.new_list(vec![ctx.new_ascii_literal(ascii!("lineno")),ctx.new_ascii_literal(ascii!("col_offset")),ctx.new_ascii_literal(ascii!("end_lineno")),ctx.new_ascii_literal(ascii!("end_col_offset"))]));
+        class.set_str_attr("_fields", ctx.new_list(vec![ctx.new_str(ascii!("target")).into(),ctx.new_str(ascii!("iter")).into(),ctx.new_str(ascii!("body")).into(),ctx.new_str(ascii!("orelse")).into(),ctx.new_str(ascii!("type_comment")).into()]));
+        class.set_str_attr("_attributes", ctx.new_list(vec![ctx.new_str(ascii!("lineno")).into(),ctx.new_str(ascii!("col_offset")).into(),ctx.new_str(ascii!("end_lineno")).into(),ctx.new_str(ascii!("end_col_offset")).into()]));
     }
 }
 #[pyclass(module = "_ast", name = "While", base = "AstNode")]
@@ -149,8 +149,8 @@ struct NodeWhile;
 impl NodeWhile {
     #[extend_class]
     fn extend_class_with_fields(ctx: &PyContext, class: &PyTypeRef) {
-        class.set_str_attr("_fields", ctx.new_list(vec![ctx.new_ascii_literal(ascii!("test")),ctx.new_ascii_literal(ascii!("body")),ctx.new_ascii_literal(ascii!("orelse"))]));
-        class.set_str_attr("_attributes", ctx.new_list(vec![ctx.new_ascii_literal(ascii!("lineno")),ctx.new_ascii_literal(ascii!("col_offset")),ctx.new_ascii_literal(ascii!("end_lineno")),ctx.new_ascii_literal(ascii!("end_col_offset"))]));
+        class.set_str_attr("_fields", ctx.new_list(vec![ctx.new_str(ascii!("test")).into(),ctx.new_str(ascii!("body")).into(),ctx.new_str(ascii!("orelse")).into()]));
+        class.set_str_attr("_attributes", ctx.new_list(vec![ctx.new_str(ascii!("lineno")).into(),ctx.new_str(ascii!("col_offset")).into(),ctx.new_str(ascii!("end_lineno")).into(),ctx.new_str(ascii!("end_col_offset")).into()]));
     }
 }
 #[pyclass(module = "_ast", name = "If", base = "AstNode")]
@@ -159,8 +159,8 @@ struct NodeIf;
 impl NodeIf {
     #[extend_class]
     fn extend_class_with_fields(ctx: &PyContext, class: &PyTypeRef) {
-        class.set_str_attr("_fields", ctx.new_list(vec![ctx.new_ascii_literal(ascii!("test")),ctx.new_ascii_literal(ascii!("body")),ctx.new_ascii_literal(ascii!("orelse"))]));
-        class.set_str_attr("_attributes", ctx.new_list(vec![ctx.new_ascii_literal(ascii!("lineno")),ctx.new_ascii_literal(ascii!("col_offset")),ctx.new_ascii_literal(ascii!("end_lineno")),ctx.new_ascii_literal(ascii!("end_col_offset"))]));
+        class.set_str_attr("_fields", ctx.new_list(vec![ctx.new_str(ascii!("test")).into(),ctx.new_str(ascii!("body")).into(),ctx.new_str(ascii!("orelse")).into()]));
+        class.set_str_attr("_attributes", ctx.new_list(vec![ctx.new_str(ascii!("lineno")).into(),ctx.new_str(ascii!("col_offset")).into(),ctx.new_str(ascii!("end_lineno")).into(),ctx.new_str(ascii!("end_col_offset")).into()]));
     }
 }
 #[pyclass(module = "_ast", name = "With", base = "AstNode")]
@@ -169,8 +169,8 @@ struct NodeWith;
 impl NodeWith {
     #[extend_class]
     fn extend_class_with_fields(ctx: &PyContext, class: &PyTypeRef) {
-        class.set_str_attr("_fields", ctx.new_list(vec![ctx.new_ascii_literal(ascii!("items")),ctx.new_ascii_literal(ascii!("body")),ctx.new_ascii_literal(ascii!("type_comment"))]));
-        class.set_str_attr("_attributes", ctx.new_list(vec![ctx.new_ascii_literal(ascii!("lineno")),ctx.new_ascii_literal(ascii!("col_offset")),ctx.new_ascii_literal(ascii!("end_lineno")),ctx.new_ascii_literal(ascii!("end_col_offset"))]));
+        class.set_str_attr("_fields", ctx.new_list(vec![ctx.new_str(ascii!("items")).into(),ctx.new_str(ascii!("body")).into(),ctx.new_str(ascii!("type_comment")).into()]));
+        class.set_str_attr("_attributes", ctx.new_list(vec![ctx.new_str(ascii!("lineno")).into(),ctx.new_str(ascii!("col_offset")).into(),ctx.new_str(ascii!("end_lineno")).into(),ctx.new_str(ascii!("end_col_offset")).into()]));
     }
 }
 #[pyclass(module = "_ast", name = "AsyncWith", base = "AstNode")]
@@ -179,8 +179,8 @@ struct NodeAsyncWith;
 impl NodeAsyncWith {
     #[extend_class]
     fn extend_class_with_fields(ctx: &PyContext, class: &PyTypeRef) {
-        class.set_str_attr("_fields", ctx.new_list(vec![ctx.new_ascii_literal(ascii!("items")),ctx.new_ascii_literal(ascii!("body")),ctx.new_ascii_literal(ascii!("type_comment"))]));
-        class.set_str_attr("_attributes", ctx.new_list(vec![ctx.new_ascii_literal(ascii!("lineno")),ctx.new_ascii_literal(ascii!("col_offset")),ctx.new_ascii_literal(ascii!("end_lineno")),ctx.new_ascii_literal(ascii!("end_col_offset"))]));
+        class.set_str_attr("_fields", ctx.new_list(vec![ctx.new_str(ascii!("items")).into(),ctx.new_str(ascii!("body")).into(),ctx.new_str(ascii!("type_comment")).into()]));
+        class.set_str_attr("_attributes", ctx.new_list(vec![ctx.new_str(ascii!("lineno")).into(),ctx.new_str(ascii!("col_offset")).into(),ctx.new_str(ascii!("end_lineno")).into(),ctx.new_str(ascii!("end_col_offset")).into()]));
     }
 }
 #[pyclass(module = "_ast", name = "Raise", base = "AstNode")]
@@ -189,8 +189,8 @@ struct NodeRaise;
 impl NodeRaise {
     #[extend_class]
     fn extend_class_with_fields(ctx: &PyContext, class: &PyTypeRef) {
-        class.set_str_attr("_fields", ctx.new_list(vec![ctx.new_ascii_literal(ascii!("exc")),ctx.new_ascii_literal(ascii!("cause"))]));
-        class.set_str_attr("_attributes", ctx.new_list(vec![ctx.new_ascii_literal(ascii!("lineno")),ctx.new_ascii_literal(ascii!("col_offset")),ctx.new_ascii_literal(ascii!("end_lineno")),ctx.new_ascii_literal(ascii!("end_col_offset"))]));
+        class.set_str_attr("_fields", ctx.new_list(vec![ctx.new_str(ascii!("exc")).into(),ctx.new_str(ascii!("cause")).into()]));
+        class.set_str_attr("_attributes", ctx.new_list(vec![ctx.new_str(ascii!("lineno")).into(),ctx.new_str(ascii!("col_offset")).into(),ctx.new_str(ascii!("end_lineno")).into(),ctx.new_str(ascii!("end_col_offset")).into()]));
     }
 }
 #[pyclass(module = "_ast", name = "Try", base = "AstNode")]
@@ -199,8 +199,8 @@ struct NodeTry;
 impl NodeTry {
     #[extend_class]
     fn extend_class_with_fields(ctx: &PyContext, class: &PyTypeRef) {
-        class.set_str_attr("_fields", ctx.new_list(vec![ctx.new_ascii_literal(ascii!("body")),ctx.new_ascii_literal(ascii!("handlers")),ctx.new_ascii_literal(ascii!("orelse")),ctx.new_ascii_literal(ascii!("finalbody"))]));
-        class.set_str_attr("_attributes", ctx.new_list(vec![ctx.new_ascii_literal(ascii!("lineno")),ctx.new_ascii_literal(ascii!("col_offset")),ctx.new_ascii_literal(ascii!("end_lineno")),ctx.new_ascii_literal(ascii!("end_col_offset"))]));
+        class.set_str_attr("_fields", ctx.new_list(vec![ctx.new_str(ascii!("body")).into(),ctx.new_str(ascii!("handlers")).into(),ctx.new_str(ascii!("orelse")).into(),ctx.new_str(ascii!("finalbody")).into()]));
+        class.set_str_attr("_attributes", ctx.new_list(vec![ctx.new_str(ascii!("lineno")).into(),ctx.new_str(ascii!("col_offset")).into(),ctx.new_str(ascii!("end_lineno")).into(),ctx.new_str(ascii!("end_col_offset")).into()]));
     }
 }
 #[pyclass(module = "_ast", name = "Assert", base = "AstNode")]
@@ -209,8 +209,8 @@ struct NodeAssert;
 impl NodeAssert {
     #[extend_class]
     fn extend_class_with_fields(ctx: &PyContext, class: &PyTypeRef) {
-        class.set_str_attr("_fields", ctx.new_list(vec![ctx.new_ascii_literal(ascii!("test")),ctx.new_ascii_literal(ascii!("msg"))]));
-        class.set_str_attr("_attributes", ctx.new_list(vec![ctx.new_ascii_literal(ascii!("lineno")),ctx.new_ascii_literal(ascii!("col_offset")),ctx.new_ascii_literal(ascii!("end_lineno")),ctx.new_ascii_literal(ascii!("end_col_offset"))]));
+        class.set_str_attr("_fields", ctx.new_list(vec![ctx.new_str(ascii!("test")).into(),ctx.new_str(ascii!("msg")).into()]));
+        class.set_str_attr("_attributes", ctx.new_list(vec![ctx.new_str(ascii!("lineno")).into(),ctx.new_str(ascii!("col_offset")).into(),ctx.new_str(ascii!("end_lineno")).into(),ctx.new_str(ascii!("end_col_offset")).into()]));
     }
 }
 #[pyclass(module = "_ast", name = "Import", base = "AstNode")]
@@ -219,8 +219,8 @@ struct NodeImport;
 impl NodeImport {
     #[extend_class]
     fn extend_class_with_fields(ctx: &PyContext, class: &PyTypeRef) {
-        class.set_str_attr("_fields", ctx.new_list(vec![ctx.new_ascii_literal(ascii!("names"))]));
-        class.set_str_attr("_attributes", ctx.new_list(vec![ctx.new_ascii_literal(ascii!("lineno")),ctx.new_ascii_literal(ascii!("col_offset")),ctx.new_ascii_literal(ascii!("end_lineno")),ctx.new_ascii_literal(ascii!("end_col_offset"))]));
+        class.set_str_attr("_fields", ctx.new_list(vec![ctx.new_str(ascii!("names")).into()]));
+        class.set_str_attr("_attributes", ctx.new_list(vec![ctx.new_str(ascii!("lineno")).into(),ctx.new_str(ascii!("col_offset")).into(),ctx.new_str(ascii!("end_lineno")).into(),ctx.new_str(ascii!("end_col_offset")).into()]));
     }
 }
 #[pyclass(module = "_ast", name = "ImportFrom", base = "AstNode")]
@@ -229,8 +229,8 @@ struct NodeImportFrom;
 impl NodeImportFrom {
     #[extend_class]
     fn extend_class_with_fields(ctx: &PyContext, class: &PyTypeRef) {
-        class.set_str_attr("_fields", ctx.new_list(vec![ctx.new_ascii_literal(ascii!("module")),ctx.new_ascii_literal(ascii!("names")),ctx.new_ascii_literal(ascii!("level"))]));
-        class.set_str_attr("_attributes", ctx.new_list(vec![ctx.new_ascii_literal(ascii!("lineno")),ctx.new_ascii_literal(ascii!("col_offset")),ctx.new_ascii_literal(ascii!("end_lineno")),ctx.new_ascii_literal(ascii!("end_col_offset"))]));
+        class.set_str_attr("_fields", ctx.new_list(vec![ctx.new_str(ascii!("module")).into(),ctx.new_str(ascii!("names")).into(),ctx.new_str(ascii!("level")).into()]));
+        class.set_str_attr("_attributes", ctx.new_list(vec![ctx.new_str(ascii!("lineno")).into(),ctx.new_str(ascii!("col_offset")).into(),ctx.new_str(ascii!("end_lineno")).into(),ctx.new_str(ascii!("end_col_offset")).into()]));
     }
 }
 #[pyclass(module = "_ast", name = "Global", base = "AstNode")]
@@ -239,8 +239,8 @@ struct NodeGlobal;
 impl NodeGlobal {
     #[extend_class]
     fn extend_class_with_fields(ctx: &PyContext, class: &PyTypeRef) {
-        class.set_str_attr("_fields", ctx.new_list(vec![ctx.new_ascii_literal(ascii!("names"))]));
-        class.set_str_attr("_attributes", ctx.new_list(vec![ctx.new_ascii_literal(ascii!("lineno")),ctx.new_ascii_literal(ascii!("col_offset")),ctx.new_ascii_literal(ascii!("end_lineno")),ctx.new_ascii_literal(ascii!("end_col_offset"))]));
+        class.set_str_attr("_fields", ctx.new_list(vec![ctx.new_str(ascii!("names")).into()]));
+        class.set_str_attr("_attributes", ctx.new_list(vec![ctx.new_str(ascii!("lineno")).into(),ctx.new_str(ascii!("col_offset")).into(),ctx.new_str(ascii!("end_lineno")).into(),ctx.new_str(ascii!("end_col_offset")).into()]));
     }
 }
 #[pyclass(module = "_ast", name = "Nonlocal", base = "AstNode")]
@@ -249,8 +249,8 @@ struct NodeNonlocal;
 impl NodeNonlocal {
     #[extend_class]
     fn extend_class_with_fields(ctx: &PyContext, class: &PyTypeRef) {
-        class.set_str_attr("_fields", ctx.new_list(vec![ctx.new_ascii_literal(ascii!("names"))]));
-        class.set_str_attr("_attributes", ctx.new_list(vec![ctx.new_ascii_literal(ascii!("lineno")),ctx.new_ascii_literal(ascii!("col_offset")),ctx.new_ascii_literal(ascii!("end_lineno")),ctx.new_ascii_literal(ascii!("end_col_offset"))]));
+        class.set_str_attr("_fields", ctx.new_list(vec![ctx.new_str(ascii!("names")).into()]));
+        class.set_str_attr("_attributes", ctx.new_list(vec![ctx.new_str(ascii!("lineno")).into(),ctx.new_str(ascii!("col_offset")).into(),ctx.new_str(ascii!("end_lineno")).into(),ctx.new_str(ascii!("end_col_offset")).into()]));
     }
 }
 #[pyclass(module = "_ast", name = "Expr", base = "AstNode")]
@@ -259,8 +259,8 @@ struct NodeExpr;
 impl NodeExpr {
     #[extend_class]
     fn extend_class_with_fields(ctx: &PyContext, class: &PyTypeRef) {
-        class.set_str_attr("_fields", ctx.new_list(vec![ctx.new_ascii_literal(ascii!("value"))]));
-        class.set_str_attr("_attributes", ctx.new_list(vec![ctx.new_ascii_literal(ascii!("lineno")),ctx.new_ascii_literal(ascii!("col_offset")),ctx.new_ascii_literal(ascii!("end_lineno")),ctx.new_ascii_literal(ascii!("end_col_offset"))]));
+        class.set_str_attr("_fields", ctx.new_list(vec![ctx.new_str(ascii!("value")).into()]));
+        class.set_str_attr("_attributes", ctx.new_list(vec![ctx.new_str(ascii!("lineno")).into(),ctx.new_str(ascii!("col_offset")).into(),ctx.new_str(ascii!("end_lineno")).into(),ctx.new_str(ascii!("end_col_offset")).into()]));
     }
 }
 #[pyclass(module = "_ast", name = "Pass", base = "AstNode")]
@@ -270,7 +270,7 @@ impl NodePass {
     #[extend_class]
     fn extend_class_with_fields(ctx: &PyContext, class: &PyTypeRef) {
         class.set_str_attr("_fields", ctx.new_list(vec![]));
-        class.set_str_attr("_attributes", ctx.new_list(vec![ctx.new_ascii_literal(ascii!("lineno")),ctx.new_ascii_literal(ascii!("col_offset")),ctx.new_ascii_literal(ascii!("end_lineno")),ctx.new_ascii_literal(ascii!("end_col_offset"))]));
+        class.set_str_attr("_attributes", ctx.new_list(vec![ctx.new_str(ascii!("lineno")).into(),ctx.new_str(ascii!("col_offset")).into(),ctx.new_str(ascii!("end_lineno")).into(),ctx.new_str(ascii!("end_col_offset")).into()]));
     }
 }
 #[pyclass(module = "_ast", name = "Break", base = "AstNode")]
@@ -280,7 +280,7 @@ impl NodeBreak {
     #[extend_class]
     fn extend_class_with_fields(ctx: &PyContext, class: &PyTypeRef) {
         class.set_str_attr("_fields", ctx.new_list(vec![]));
-        class.set_str_attr("_attributes", ctx.new_list(vec![ctx.new_ascii_literal(ascii!("lineno")),ctx.new_ascii_literal(ascii!("col_offset")),ctx.new_ascii_literal(ascii!("end_lineno")),ctx.new_ascii_literal(ascii!("end_col_offset"))]));
+        class.set_str_attr("_attributes", ctx.new_list(vec![ctx.new_str(ascii!("lineno")).into(),ctx.new_str(ascii!("col_offset")).into(),ctx.new_str(ascii!("end_lineno")).into(),ctx.new_str(ascii!("end_col_offset")).into()]));
     }
 }
 #[pyclass(module = "_ast", name = "Continue", base = "AstNode")]
@@ -290,7 +290,7 @@ impl NodeContinue {
     #[extend_class]
     fn extend_class_with_fields(ctx: &PyContext, class: &PyTypeRef) {
         class.set_str_attr("_fields", ctx.new_list(vec![]));
-        class.set_str_attr("_attributes", ctx.new_list(vec![ctx.new_ascii_literal(ascii!("lineno")),ctx.new_ascii_literal(ascii!("col_offset")),ctx.new_ascii_literal(ascii!("end_lineno")),ctx.new_ascii_literal(ascii!("end_col_offset"))]));
+        class.set_str_attr("_attributes", ctx.new_list(vec![ctx.new_str(ascii!("lineno")).into(),ctx.new_str(ascii!("col_offset")).into(),ctx.new_str(ascii!("end_lineno")).into(),ctx.new_str(ascii!("end_col_offset")).into()]));
     }
 }
 #[pyclass(module = "_ast", name = "BoolOp", base = "AstNode")]
@@ -299,8 +299,8 @@ struct NodeBoolOp;
 impl NodeBoolOp {
     #[extend_class]
     fn extend_class_with_fields(ctx: &PyContext, class: &PyTypeRef) {
-        class.set_str_attr("_fields", ctx.new_list(vec![ctx.new_ascii_literal(ascii!("op")),ctx.new_ascii_literal(ascii!("values"))]));
-        class.set_str_attr("_attributes", ctx.new_list(vec![ctx.new_ascii_literal(ascii!("lineno")),ctx.new_ascii_literal(ascii!("col_offset")),ctx.new_ascii_literal(ascii!("end_lineno")),ctx.new_ascii_literal(ascii!("end_col_offset"))]));
+        class.set_str_attr("_fields", ctx.new_list(vec![ctx.new_str(ascii!("op")).into(),ctx.new_str(ascii!("values")).into()]));
+        class.set_str_attr("_attributes", ctx.new_list(vec![ctx.new_str(ascii!("lineno")).into(),ctx.new_str(ascii!("col_offset")).into(),ctx.new_str(ascii!("end_lineno")).into(),ctx.new_str(ascii!("end_col_offset")).into()]));
     }
 }
 #[pyclass(module = "_ast", name = "NamedExpr", base = "AstNode")]
@@ -309,8 +309,8 @@ struct NodeNamedExpr;
 impl NodeNamedExpr {
     #[extend_class]
     fn extend_class_with_fields(ctx: &PyContext, class: &PyTypeRef) {
-        class.set_str_attr("_fields", ctx.new_list(vec![ctx.new_ascii_literal(ascii!("target")),ctx.new_ascii_literal(ascii!("value"))]));
-        class.set_str_attr("_attributes", ctx.new_list(vec![ctx.new_ascii_literal(ascii!("lineno")),ctx.new_ascii_literal(ascii!("col_offset")),ctx.new_ascii_literal(ascii!("end_lineno")),ctx.new_ascii_literal(ascii!("end_col_offset"))]));
+        class.set_str_attr("_fields", ctx.new_list(vec![ctx.new_str(ascii!("target")).into(),ctx.new_str(ascii!("value")).into()]));
+        class.set_str_attr("_attributes", ctx.new_list(vec![ctx.new_str(ascii!("lineno")).into(),ctx.new_str(ascii!("col_offset")).into(),ctx.new_str(ascii!("end_lineno")).into(),ctx.new_str(ascii!("end_col_offset")).into()]));
     }
 }
 #[pyclass(module = "_ast", name = "BinOp", base = "AstNode")]
@@ -319,8 +319,8 @@ struct NodeBinOp;
 impl NodeBinOp {
     #[extend_class]
     fn extend_class_with_fields(ctx: &PyContext, class: &PyTypeRef) {
-        class.set_str_attr("_fields", ctx.new_list(vec![ctx.new_ascii_literal(ascii!("left")),ctx.new_ascii_literal(ascii!("op")),ctx.new_ascii_literal(ascii!("right"))]));
-        class.set_str_attr("_attributes", ctx.new_list(vec![ctx.new_ascii_literal(ascii!("lineno")),ctx.new_ascii_literal(ascii!("col_offset")),ctx.new_ascii_literal(ascii!("end_lineno")),ctx.new_ascii_literal(ascii!("end_col_offset"))]));
+        class.set_str_attr("_fields", ctx.new_list(vec![ctx.new_str(ascii!("left")).into(),ctx.new_str(ascii!("op")).into(),ctx.new_str(ascii!("right")).into()]));
+        class.set_str_attr("_attributes", ctx.new_list(vec![ctx.new_str(ascii!("lineno")).into(),ctx.new_str(ascii!("col_offset")).into(),ctx.new_str(ascii!("end_lineno")).into(),ctx.new_str(ascii!("end_col_offset")).into()]));
     }
 }
 #[pyclass(module = "_ast", name = "UnaryOp", base = "AstNode")]
@@ -329,8 +329,8 @@ struct NodeUnaryOp;
 impl NodeUnaryOp {
     #[extend_class]
     fn extend_class_with_fields(ctx: &PyContext, class: &PyTypeRef) {
-        class.set_str_attr("_fields", ctx.new_list(vec![ctx.new_ascii_literal(ascii!("op")),ctx.new_ascii_literal(ascii!("operand"))]));
-        class.set_str_attr("_attributes", ctx.new_list(vec![ctx.new_ascii_literal(ascii!("lineno")),ctx.new_ascii_literal(ascii!("col_offset")),ctx.new_ascii_literal(ascii!("end_lineno")),ctx.new_ascii_literal(ascii!("end_col_offset"))]));
+        class.set_str_attr("_fields", ctx.new_list(vec![ctx.new_str(ascii!("op")).into(),ctx.new_str(ascii!("operand")).into()]));
+        class.set_str_attr("_attributes", ctx.new_list(vec![ctx.new_str(ascii!("lineno")).into(),ctx.new_str(ascii!("col_offset")).into(),ctx.new_str(ascii!("end_lineno")).into(),ctx.new_str(ascii!("end_col_offset")).into()]));
     }
 }
 #[pyclass(module = "_ast", name = "Lambda", base = "AstNode")]
@@ -339,8 +339,8 @@ struct NodeLambda;
 impl NodeLambda {
     #[extend_class]
     fn extend_class_with_fields(ctx: &PyContext, class: &PyTypeRef) {
-        class.set_str_attr("_fields", ctx.new_list(vec![ctx.new_ascii_literal(ascii!("args")),ctx.new_ascii_literal(ascii!("body"))]));
-        class.set_str_attr("_attributes", ctx.new_list(vec![ctx.new_ascii_literal(ascii!("lineno")),ctx.new_ascii_literal(ascii!("col_offset")),ctx.new_ascii_literal(ascii!("end_lineno")),ctx.new_ascii_literal(ascii!("end_col_offset"))]));
+        class.set_str_attr("_fields", ctx.new_list(vec![ctx.new_str(ascii!("args")).into(),ctx.new_str(ascii!("body")).into()]));
+        class.set_str_attr("_attributes", ctx.new_list(vec![ctx.new_str(ascii!("lineno")).into(),ctx.new_str(ascii!("col_offset")).into(),ctx.new_str(ascii!("end_lineno")).into(),ctx.new_str(ascii!("end_col_offset")).into()]));
     }
 }
 #[pyclass(module = "_ast", name = "IfExp", base = "AstNode")]
@@ -349,8 +349,8 @@ struct NodeIfExp;
 impl NodeIfExp {
     #[extend_class]
     fn extend_class_with_fields(ctx: &PyContext, class: &PyTypeRef) {
-        class.set_str_attr("_fields", ctx.new_list(vec![ctx.new_ascii_literal(ascii!("test")),ctx.new_ascii_literal(ascii!("body")),ctx.new_ascii_literal(ascii!("orelse"))]));
-        class.set_str_attr("_attributes", ctx.new_list(vec![ctx.new_ascii_literal(ascii!("lineno")),ctx.new_ascii_literal(ascii!("col_offset")),ctx.new_ascii_literal(ascii!("end_lineno")),ctx.new_ascii_literal(ascii!("end_col_offset"))]));
+        class.set_str_attr("_fields", ctx.new_list(vec![ctx.new_str(ascii!("test")).into(),ctx.new_str(ascii!("body")).into(),ctx.new_str(ascii!("orelse")).into()]));
+        class.set_str_attr("_attributes", ctx.new_list(vec![ctx.new_str(ascii!("lineno")).into(),ctx.new_str(ascii!("col_offset")).into(),ctx.new_str(ascii!("end_lineno")).into(),ctx.new_str(ascii!("end_col_offset")).into()]));
     }
 }
 #[pyclass(module = "_ast", name = "Dict", base = "AstNode")]
@@ -359,8 +359,8 @@ struct NodeDict;
 impl NodeDict {
     #[extend_class]
     fn extend_class_with_fields(ctx: &PyContext, class: &PyTypeRef) {
-        class.set_str_attr("_fields", ctx.new_list(vec![ctx.new_ascii_literal(ascii!("keys")),ctx.new_ascii_literal(ascii!("values"))]));
-        class.set_str_attr("_attributes", ctx.new_list(vec![ctx.new_ascii_literal(ascii!("lineno")),ctx.new_ascii_literal(ascii!("col_offset")),ctx.new_ascii_literal(ascii!("end_lineno")),ctx.new_ascii_literal(ascii!("end_col_offset"))]));
+        class.set_str_attr("_fields", ctx.new_list(vec![ctx.new_str(ascii!("keys")).into(),ctx.new_str(ascii!("values")).into()]));
+        class.set_str_attr("_attributes", ctx.new_list(vec![ctx.new_str(ascii!("lineno")).into(),ctx.new_str(ascii!("col_offset")).into(),ctx.new_str(ascii!("end_lineno")).into(),ctx.new_str(ascii!("end_col_offset")).into()]));
     }
 }
 #[pyclass(module = "_ast", name = "Set", base = "AstNode")]
@@ -369,8 +369,8 @@ struct NodeSet;
 impl NodeSet {
     #[extend_class]
     fn extend_class_with_fields(ctx: &PyContext, class: &PyTypeRef) {
-        class.set_str_attr("_fields", ctx.new_list(vec![ctx.new_ascii_literal(ascii!("elts"))]));
-        class.set_str_attr("_attributes", ctx.new_list(vec![ctx.new_ascii_literal(ascii!("lineno")),ctx.new_ascii_literal(ascii!("col_offset")),ctx.new_ascii_literal(ascii!("end_lineno")),ctx.new_ascii_literal(ascii!("end_col_offset"))]));
+        class.set_str_attr("_fields", ctx.new_list(vec![ctx.new_str(ascii!("elts")).into()]));
+        class.set_str_attr("_attributes", ctx.new_list(vec![ctx.new_str(ascii!("lineno")).into(),ctx.new_str(ascii!("col_offset")).into(),ctx.new_str(ascii!("end_lineno")).into(),ctx.new_str(ascii!("end_col_offset")).into()]));
     }
 }
 #[pyclass(module = "_ast", name = "ListComp", base = "AstNode")]
@@ -379,8 +379,8 @@ struct NodeListComp;
 impl NodeListComp {
     #[extend_class]
     fn extend_class_with_fields(ctx: &PyContext, class: &PyTypeRef) {
-        class.set_str_attr("_fields", ctx.new_list(vec![ctx.new_ascii_literal(ascii!("elt")),ctx.new_ascii_literal(ascii!("generators"))]));
-        class.set_str_attr("_attributes", ctx.new_list(vec![ctx.new_ascii_literal(ascii!("lineno")),ctx.new_ascii_literal(ascii!("col_offset")),ctx.new_ascii_literal(ascii!("end_lineno")),ctx.new_ascii_literal(ascii!("end_col_offset"))]));
+        class.set_str_attr("_fields", ctx.new_list(vec![ctx.new_str(ascii!("elt")).into(),ctx.new_str(ascii!("generators")).into()]));
+        class.set_str_attr("_attributes", ctx.new_list(vec![ctx.new_str(ascii!("lineno")).into(),ctx.new_str(ascii!("col_offset")).into(),ctx.new_str(ascii!("end_lineno")).into(),ctx.new_str(ascii!("end_col_offset")).into()]));
     }
 }
 #[pyclass(module = "_ast", name = "SetComp", base = "AstNode")]
@@ -389,8 +389,8 @@ struct NodeSetComp;
 impl NodeSetComp {
     #[extend_class]
     fn extend_class_with_fields(ctx: &PyContext, class: &PyTypeRef) {
-        class.set_str_attr("_fields", ctx.new_list(vec![ctx.new_ascii_literal(ascii!("elt")),ctx.new_ascii_literal(ascii!("generators"))]));
-        class.set_str_attr("_attributes", ctx.new_list(vec![ctx.new_ascii_literal(ascii!("lineno")),ctx.new_ascii_literal(ascii!("col_offset")),ctx.new_ascii_literal(ascii!("end_lineno")),ctx.new_ascii_literal(ascii!("end_col_offset"))]));
+        class.set_str_attr("_fields", ctx.new_list(vec![ctx.new_str(ascii!("elt")).into(),ctx.new_str(ascii!("generators")).into()]));
+        class.set_str_attr("_attributes", ctx.new_list(vec![ctx.new_str(ascii!("lineno")).into(),ctx.new_str(ascii!("col_offset")).into(),ctx.new_str(ascii!("end_lineno")).into(),ctx.new_str(ascii!("end_col_offset")).into()]));
     }
 }
 #[pyclass(module = "_ast", name = "DictComp", base = "AstNode")]
@@ -399,8 +399,8 @@ struct NodeDictComp;
 impl NodeDictComp {
     #[extend_class]
     fn extend_class_with_fields(ctx: &PyContext, class: &PyTypeRef) {
-        class.set_str_attr("_fields", ctx.new_list(vec![ctx.new_ascii_literal(ascii!("key")),ctx.new_ascii_literal(ascii!("value")),ctx.new_ascii_literal(ascii!("generators"))]));
-        class.set_str_attr("_attributes", ctx.new_list(vec![ctx.new_ascii_literal(ascii!("lineno")),ctx.new_ascii_literal(ascii!("col_offset")),ctx.new_ascii_literal(ascii!("end_lineno")),ctx.new_ascii_literal(ascii!("end_col_offset"))]));
+        class.set_str_attr("_fields", ctx.new_list(vec![ctx.new_str(ascii!("key")).into(),ctx.new_str(ascii!("value")).into(),ctx.new_str(ascii!("generators")).into()]));
+        class.set_str_attr("_attributes", ctx.new_list(vec![ctx.new_str(ascii!("lineno")).into(),ctx.new_str(ascii!("col_offset")).into(),ctx.new_str(ascii!("end_lineno")).into(),ctx.new_str(ascii!("end_col_offset")).into()]));
     }
 }
 #[pyclass(module = "_ast", name = "GeneratorExp", base = "AstNode")]
@@ -409,8 +409,8 @@ struct NodeGeneratorExp;
 impl NodeGeneratorExp {
     #[extend_class]
     fn extend_class_with_fields(ctx: &PyContext, class: &PyTypeRef) {
-        class.set_str_attr("_fields", ctx.new_list(vec![ctx.new_ascii_literal(ascii!("elt")),ctx.new_ascii_literal(ascii!("generators"))]));
-        class.set_str_attr("_attributes", ctx.new_list(vec![ctx.new_ascii_literal(ascii!("lineno")),ctx.new_ascii_literal(ascii!("col_offset")),ctx.new_ascii_literal(ascii!("end_lineno")),ctx.new_ascii_literal(ascii!("end_col_offset"))]));
+        class.set_str_attr("_fields", ctx.new_list(vec![ctx.new_str(ascii!("elt")).into(),ctx.new_str(ascii!("generators")).into()]));
+        class.set_str_attr("_attributes", ctx.new_list(vec![ctx.new_str(ascii!("lineno")).into(),ctx.new_str(ascii!("col_offset")).into(),ctx.new_str(ascii!("end_lineno")).into(),ctx.new_str(ascii!("end_col_offset")).into()]));
     }
 }
 #[pyclass(module = "_ast", name = "Await", base = "AstNode")]
@@ -419,8 +419,8 @@ struct NodeAwait;
 impl NodeAwait {
     #[extend_class]
     fn extend_class_with_fields(ctx: &PyContext, class: &PyTypeRef) {
-        class.set_str_attr("_fields", ctx.new_list(vec![ctx.new_ascii_literal(ascii!("value"))]));
-        class.set_str_attr("_attributes", ctx.new_list(vec![ctx.new_ascii_literal(ascii!("lineno")),ctx.new_ascii_literal(ascii!("col_offset")),ctx.new_ascii_literal(ascii!("end_lineno")),ctx.new_ascii_literal(ascii!("end_col_offset"))]));
+        class.set_str_attr("_fields", ctx.new_list(vec![ctx.new_str(ascii!("value")).into()]));
+        class.set_str_attr("_attributes", ctx.new_list(vec![ctx.new_str(ascii!("lineno")).into(),ctx.new_str(ascii!("col_offset")).into(),ctx.new_str(ascii!("end_lineno")).into(),ctx.new_str(ascii!("end_col_offset")).into()]));
     }
 }
 #[pyclass(module = "_ast", name = "Yield", base = "AstNode")]
@@ -429,8 +429,8 @@ struct NodeYield;
 impl NodeYield {
     #[extend_class]
     fn extend_class_with_fields(ctx: &PyContext, class: &PyTypeRef) {
-        class.set_str_attr("_fields", ctx.new_list(vec![ctx.new_ascii_literal(ascii!("value"))]));
-        class.set_str_attr("_attributes", ctx.new_list(vec![ctx.new_ascii_literal(ascii!("lineno")),ctx.new_ascii_literal(ascii!("col_offset")),ctx.new_ascii_literal(ascii!("end_lineno")),ctx.new_ascii_literal(ascii!("end_col_offset"))]));
+        class.set_str_attr("_fields", ctx.new_list(vec![ctx.new_str(ascii!("value")).into()]));
+        class.set_str_attr("_attributes", ctx.new_list(vec![ctx.new_str(ascii!("lineno")).into(),ctx.new_str(ascii!("col_offset")).into(),ctx.new_str(ascii!("end_lineno")).into(),ctx.new_str(ascii!("end_col_offset")).into()]));
     }
 }
 #[pyclass(module = "_ast", name = "YieldFrom", base = "AstNode")]
@@ -439,8 +439,8 @@ struct NodeYieldFrom;
 impl NodeYieldFrom {
     #[extend_class]
     fn extend_class_with_fields(ctx: &PyContext, class: &PyTypeRef) {
-        class.set_str_attr("_fields", ctx.new_list(vec![ctx.new_ascii_literal(ascii!("value"))]));
-        class.set_str_attr("_attributes", ctx.new_list(vec![ctx.new_ascii_literal(ascii!("lineno")),ctx.new_ascii_literal(ascii!("col_offset")),ctx.new_ascii_literal(ascii!("end_lineno")),ctx.new_ascii_literal(ascii!("end_col_offset"))]));
+        class.set_str_attr("_fields", ctx.new_list(vec![ctx.new_str(ascii!("value")).into()]));
+        class.set_str_attr("_attributes", ctx.new_list(vec![ctx.new_str(ascii!("lineno")).into(),ctx.new_str(ascii!("col_offset")).into(),ctx.new_str(ascii!("end_lineno")).into(),ctx.new_str(ascii!("end_col_offset")).into()]));
     }
 }
 #[pyclass(module = "_ast", name = "Compare", base = "AstNode")]
@@ -449,8 +449,8 @@ struct NodeCompare;
 impl NodeCompare {
     #[extend_class]
     fn extend_class_with_fields(ctx: &PyContext, class: &PyTypeRef) {
-        class.set_str_attr("_fields", ctx.new_list(vec![ctx.new_ascii_literal(ascii!("left")),ctx.new_ascii_literal(ascii!("ops")),ctx.new_ascii_literal(ascii!("comparators"))]));
-        class.set_str_attr("_attributes", ctx.new_list(vec![ctx.new_ascii_literal(ascii!("lineno")),ctx.new_ascii_literal(ascii!("col_offset")),ctx.new_ascii_literal(ascii!("end_lineno")),ctx.new_ascii_literal(ascii!("end_col_offset"))]));
+        class.set_str_attr("_fields", ctx.new_list(vec![ctx.new_str(ascii!("left")).into(),ctx.new_str(ascii!("ops")).into(),ctx.new_str(ascii!("comparators")).into()]));
+        class.set_str_attr("_attributes", ctx.new_list(vec![ctx.new_str(ascii!("lineno")).into(),ctx.new_str(ascii!("col_offset")).into(),ctx.new_str(ascii!("end_lineno")).into(),ctx.new_str(ascii!("end_col_offset")).into()]));
     }
 }
 #[pyclass(module = "_ast", name = "Call", base = "AstNode")]
@@ -459,8 +459,8 @@ struct NodeCall;
 impl NodeCall {
     #[extend_class]
     fn extend_class_with_fields(ctx: &PyContext, class: &PyTypeRef) {
-        class.set_str_attr("_fields", ctx.new_list(vec![ctx.new_ascii_literal(ascii!("func")),ctx.new_ascii_literal(ascii!("args")),ctx.new_ascii_literal(ascii!("keywords"))]));
-        class.set_str_attr("_attributes", ctx.new_list(vec![ctx.new_ascii_literal(ascii!("lineno")),ctx.new_ascii_literal(ascii!("col_offset")),ctx.new_ascii_literal(ascii!("end_lineno")),ctx.new_ascii_literal(ascii!("end_col_offset"))]));
+        class.set_str_attr("_fields", ctx.new_list(vec![ctx.new_str(ascii!("func")).into(),ctx.new_str(ascii!("args")).into(),ctx.new_str(ascii!("keywords")).into()]));
+        class.set_str_attr("_attributes", ctx.new_list(vec![ctx.new_str(ascii!("lineno")).into(),ctx.new_str(ascii!("col_offset")).into(),ctx.new_str(ascii!("end_lineno")).into(),ctx.new_str(ascii!("end_col_offset")).into()]));
     }
 }
 #[pyclass(module = "_ast", name = "FormattedValue", base = "AstNode")]
@@ -469,8 +469,8 @@ struct NodeFormattedValue;
 impl NodeFormattedValue {
     #[extend_class]
     fn extend_class_with_fields(ctx: &PyContext, class: &PyTypeRef) {
-        class.set_str_attr("_fields", ctx.new_list(vec![ctx.new_ascii_literal(ascii!("value")),ctx.new_ascii_literal(ascii!("conversion")),ctx.new_ascii_literal(ascii!("format_spec"))]));
-        class.set_str_attr("_attributes", ctx.new_list(vec![ctx.new_ascii_literal(ascii!("lineno")),ctx.new_ascii_literal(ascii!("col_offset")),ctx.new_ascii_literal(ascii!("end_lineno")),ctx.new_ascii_literal(ascii!("end_col_offset"))]));
+        class.set_str_attr("_fields", ctx.new_list(vec![ctx.new_str(ascii!("value")).into(),ctx.new_str(ascii!("conversion")).into(),ctx.new_str(ascii!("format_spec")).into()]));
+        class.set_str_attr("_attributes", ctx.new_list(vec![ctx.new_str(ascii!("lineno")).into(),ctx.new_str(ascii!("col_offset")).into(),ctx.new_str(ascii!("end_lineno")).into(),ctx.new_str(ascii!("end_col_offset")).into()]));
     }
 }
 #[pyclass(module = "_ast", name = "JoinedStr", base = "AstNode")]
@@ -479,8 +479,8 @@ struct NodeJoinedStr;
 impl NodeJoinedStr {
     #[extend_class]
     fn extend_class_with_fields(ctx: &PyContext, class: &PyTypeRef) {
-        class.set_str_attr("_fields", ctx.new_list(vec![ctx.new_ascii_literal(ascii!("values"))]));
-        class.set_str_attr("_attributes", ctx.new_list(vec![ctx.new_ascii_literal(ascii!("lineno")),ctx.new_ascii_literal(ascii!("col_offset")),ctx.new_ascii_literal(ascii!("end_lineno")),ctx.new_ascii_literal(ascii!("end_col_offset"))]));
+        class.set_str_attr("_fields", ctx.new_list(vec![ctx.new_str(ascii!("values")).into()]));
+        class.set_str_attr("_attributes", ctx.new_list(vec![ctx.new_str(ascii!("lineno")).into(),ctx.new_str(ascii!("col_offset")).into(),ctx.new_str(ascii!("end_lineno")).into(),ctx.new_str(ascii!("end_col_offset")).into()]));
     }
 }
 #[pyclass(module = "_ast", name = "Constant", base = "AstNode")]
@@ -489,8 +489,8 @@ struct NodeConstant;
 impl NodeConstant {
     #[extend_class]
     fn extend_class_with_fields(ctx: &PyContext, class: &PyTypeRef) {
-        class.set_str_attr("_fields", ctx.new_list(vec![ctx.new_ascii_literal(ascii!("value")),ctx.new_ascii_literal(ascii!("kind"))]));
-        class.set_str_attr("_attributes", ctx.new_list(vec![ctx.new_ascii_literal(ascii!("lineno")),ctx.new_ascii_literal(ascii!("col_offset")),ctx.new_ascii_literal(ascii!("end_lineno")),ctx.new_ascii_literal(ascii!("end_col_offset"))]));
+        class.set_str_attr("_fields", ctx.new_list(vec![ctx.new_str(ascii!("value")).into(),ctx.new_str(ascii!("kind")).into()]));
+        class.set_str_attr("_attributes", ctx.new_list(vec![ctx.new_str(ascii!("lineno")).into(),ctx.new_str(ascii!("col_offset")).into(),ctx.new_str(ascii!("end_lineno")).into(),ctx.new_str(ascii!("end_col_offset")).into()]));
     }
 }
 #[pyclass(module = "_ast", name = "Attribute", base = "AstNode")]
@@ -499,8 +499,8 @@ struct NodeAttribute;
 impl NodeAttribute {
     #[extend_class]
     fn extend_class_with_fields(ctx: &PyContext, class: &PyTypeRef) {
-        class.set_str_attr("_fields", ctx.new_list(vec![ctx.new_ascii_literal(ascii!("value")),ctx.new_ascii_literal(ascii!("attr")),ctx.new_ascii_literal(ascii!("ctx"))]));
-        class.set_str_attr("_attributes", ctx.new_list(vec![ctx.new_ascii_literal(ascii!("lineno")),ctx.new_ascii_literal(ascii!("col_offset")),ctx.new_ascii_literal(ascii!("end_lineno")),ctx.new_ascii_literal(ascii!("end_col_offset"))]));
+        class.set_str_attr("_fields", ctx.new_list(vec![ctx.new_str(ascii!("value")).into(),ctx.new_str(ascii!("attr")).into(),ctx.new_str(ascii!("ctx")).into()]));
+        class.set_str_attr("_attributes", ctx.new_list(vec![ctx.new_str(ascii!("lineno")).into(),ctx.new_str(ascii!("col_offset")).into(),ctx.new_str(ascii!("end_lineno")).into(),ctx.new_str(ascii!("end_col_offset")).into()]));
     }
 }
 #[pyclass(module = "_ast", name = "Subscript", base = "AstNode")]
@@ -509,8 +509,8 @@ struct NodeSubscript;
 impl NodeSubscript {
     #[extend_class]
     fn extend_class_with_fields(ctx: &PyContext, class: &PyTypeRef) {
-        class.set_str_attr("_fields", ctx.new_list(vec![ctx.new_ascii_literal(ascii!("value")),ctx.new_ascii_literal(ascii!("slice")),ctx.new_ascii_literal(ascii!("ctx"))]));
-        class.set_str_attr("_attributes", ctx.new_list(vec![ctx.new_ascii_literal(ascii!("lineno")),ctx.new_ascii_literal(ascii!("col_offset")),ctx.new_ascii_literal(ascii!("end_lineno")),ctx.new_ascii_literal(ascii!("end_col_offset"))]));
+        class.set_str_attr("_fields", ctx.new_list(vec![ctx.new_str(ascii!("value")).into(),ctx.new_str(ascii!("slice")).into(),ctx.new_str(ascii!("ctx")).into()]));
+        class.set_str_attr("_attributes", ctx.new_list(vec![ctx.new_str(ascii!("lineno")).into(),ctx.new_str(ascii!("col_offset")).into(),ctx.new_str(ascii!("end_lineno")).into(),ctx.new_str(ascii!("end_col_offset")).into()]));
     }
 }
 #[pyclass(module = "_ast", name = "Starred", base = "AstNode")]
@@ -519,8 +519,8 @@ struct NodeStarred;
 impl NodeStarred {
     #[extend_class]
     fn extend_class_with_fields(ctx: &PyContext, class: &PyTypeRef) {
-        class.set_str_attr("_fields", ctx.new_list(vec![ctx.new_ascii_literal(ascii!("value")),ctx.new_ascii_literal(ascii!("ctx"))]));
-        class.set_str_attr("_attributes", ctx.new_list(vec![ctx.new_ascii_literal(ascii!("lineno")),ctx.new_ascii_literal(ascii!("col_offset")),ctx.new_ascii_literal(ascii!("end_lineno")),ctx.new_ascii_literal(ascii!("end_col_offset"))]));
+        class.set_str_attr("_fields", ctx.new_list(vec![ctx.new_str(ascii!("value")).into(),ctx.new_str(ascii!("ctx")).into()]));
+        class.set_str_attr("_attributes", ctx.new_list(vec![ctx.new_str(ascii!("lineno")).into(),ctx.new_str(ascii!("col_offset")).into(),ctx.new_str(ascii!("end_lineno")).into(),ctx.new_str(ascii!("end_col_offset")).into()]));
     }
 }
 #[pyclass(module = "_ast", name = "Name", base = "AstNode")]
@@ -529,8 +529,8 @@ struct NodeName;
 impl NodeName {
     #[extend_class]
     fn extend_class_with_fields(ctx: &PyContext, class: &PyTypeRef) {
-        class.set_str_attr("_fields", ctx.new_list(vec![ctx.new_ascii_literal(ascii!("id")),ctx.new_ascii_literal(ascii!("ctx"))]));
-        class.set_str_attr("_attributes", ctx.new_list(vec![ctx.new_ascii_literal(ascii!("lineno")),ctx.new_ascii_literal(ascii!("col_offset")),ctx.new_ascii_literal(ascii!("end_lineno")),ctx.new_ascii_literal(ascii!("end_col_offset"))]));
+        class.set_str_attr("_fields", ctx.new_list(vec![ctx.new_str(ascii!("id")).into(),ctx.new_str(ascii!("ctx")).into()]));
+        class.set_str_attr("_attributes", ctx.new_list(vec![ctx.new_str(ascii!("lineno")).into(),ctx.new_str(ascii!("col_offset")).into(),ctx.new_str(ascii!("end_lineno")).into(),ctx.new_str(ascii!("end_col_offset")).into()]));
     }
 }
 #[pyclass(module = "_ast", name = "List", base = "AstNode")]
@@ -539,8 +539,8 @@ struct NodeList;
 impl NodeList {
     #[extend_class]
     fn extend_class_with_fields(ctx: &PyContext, class: &PyTypeRef) {
-        class.set_str_attr("_fields", ctx.new_list(vec![ctx.new_ascii_literal(ascii!("elts")),ctx.new_ascii_literal(ascii!("ctx"))]));
-        class.set_str_attr("_attributes", ctx.new_list(vec![ctx.new_ascii_literal(ascii!("lineno")),ctx.new_ascii_literal(ascii!("col_offset")),ctx.new_ascii_literal(ascii!("end_lineno")),ctx.new_ascii_literal(ascii!("end_col_offset"))]));
+        class.set_str_attr("_fields", ctx.new_list(vec![ctx.new_str(ascii!("elts")).into(),ctx.new_str(ascii!("ctx")).into()]));
+        class.set_str_attr("_attributes", ctx.new_list(vec![ctx.new_str(ascii!("lineno")).into(),ctx.new_str(ascii!("col_offset")).into(),ctx.new_str(ascii!("end_lineno")).into(),ctx.new_str(ascii!("end_col_offset")).into()]));
     }
 }
 #[pyclass(module = "_ast", name = "Tuple", base = "AstNode")]
@@ -549,8 +549,8 @@ struct NodeTuple;
 impl NodeTuple {
     #[extend_class]
     fn extend_class_with_fields(ctx: &PyContext, class: &PyTypeRef) {
-        class.set_str_attr("_fields", ctx.new_list(vec![ctx.new_ascii_literal(ascii!("elts")),ctx.new_ascii_literal(ascii!("ctx"))]));
-        class.set_str_attr("_attributes", ctx.new_list(vec![ctx.new_ascii_literal(ascii!("lineno")),ctx.new_ascii_literal(ascii!("col_offset")),ctx.new_ascii_literal(ascii!("end_lineno")),ctx.new_ascii_literal(ascii!("end_col_offset"))]));
+        class.set_str_attr("_fields", ctx.new_list(vec![ctx.new_str(ascii!("elts")).into(),ctx.new_str(ascii!("ctx")).into()]));
+        class.set_str_attr("_attributes", ctx.new_list(vec![ctx.new_str(ascii!("lineno")).into(),ctx.new_str(ascii!("col_offset")).into(),ctx.new_str(ascii!("end_lineno")).into(),ctx.new_str(ascii!("end_col_offset")).into()]));
     }
 }
 #[pyclass(module = "_ast", name = "Slice", base = "AstNode")]
@@ -559,8 +559,8 @@ struct NodeSlice;
 impl NodeSlice {
     #[extend_class]
     fn extend_class_with_fields(ctx: &PyContext, class: &PyTypeRef) {
-        class.set_str_attr("_fields", ctx.new_list(vec![ctx.new_ascii_literal(ascii!("lower")),ctx.new_ascii_literal(ascii!("upper")),ctx.new_ascii_literal(ascii!("step"))]));
-        class.set_str_attr("_attributes", ctx.new_list(vec![ctx.new_ascii_literal(ascii!("lineno")),ctx.new_ascii_literal(ascii!("col_offset")),ctx.new_ascii_literal(ascii!("end_lineno")),ctx.new_ascii_literal(ascii!("end_col_offset"))]));
+        class.set_str_attr("_fields", ctx.new_list(vec![ctx.new_str(ascii!("lower")).into(),ctx.new_str(ascii!("upper")).into(),ctx.new_str(ascii!("step")).into()]));
+        class.set_str_attr("_attributes", ctx.new_list(vec![ctx.new_str(ascii!("lineno")).into(),ctx.new_str(ascii!("col_offset")).into(),ctx.new_str(ascii!("end_lineno")).into(),ctx.new_str(ascii!("end_col_offset")).into()]));
     }
 }
 #[pyclass(module = "_ast", name = "Load", base = "AstNode")]
@@ -889,7 +889,7 @@ struct Nodecomprehension;
 impl Nodecomprehension {
     #[extend_class]
     fn extend_class_with_fields(ctx: &PyContext, class: &PyTypeRef) {
-        class.set_str_attr("_fields", ctx.new_list(vec![ctx.new_ascii_literal(ascii!("target")),ctx.new_ascii_literal(ascii!("iter")),ctx.new_ascii_literal(ascii!("ifs")),ctx.new_ascii_literal(ascii!("is_async"))]));
+        class.set_str_attr("_fields", ctx.new_list(vec![ctx.new_str(ascii!("target")).into(),ctx.new_str(ascii!("iter")).into(),ctx.new_str(ascii!("ifs")).into(),ctx.new_str(ascii!("is_async")).into()]));
         class.set_str_attr("_attributes", ctx.new_list(vec![]));
     }
 }
@@ -899,8 +899,8 @@ struct NodeExceptHandler;
 impl NodeExceptHandler {
     #[extend_class]
     fn extend_class_with_fields(ctx: &PyContext, class: &PyTypeRef) {
-        class.set_str_attr("_fields", ctx.new_list(vec![ctx.new_ascii_literal(ascii!("type")),ctx.new_ascii_literal(ascii!("name")),ctx.new_ascii_literal(ascii!("body"))]));
-        class.set_str_attr("_attributes", ctx.new_list(vec![ctx.new_ascii_literal(ascii!("lineno")),ctx.new_ascii_literal(ascii!("col_offset")),ctx.new_ascii_literal(ascii!("end_lineno")),ctx.new_ascii_literal(ascii!("end_col_offset"))]));
+        class.set_str_attr("_fields", ctx.new_list(vec![ctx.new_str(ascii!("type")).into(),ctx.new_str(ascii!("name")).into(),ctx.new_str(ascii!("body")).into()]));
+        class.set_str_attr("_attributes", ctx.new_list(vec![ctx.new_str(ascii!("lineno")).into(),ctx.new_str(ascii!("col_offset")).into(),ctx.new_str(ascii!("end_lineno")).into(),ctx.new_str(ascii!("end_col_offset")).into()]));
     }
 }
 #[pyclass(module = "_ast", name = "arguments", base = "AstNode")]
@@ -909,7 +909,7 @@ struct Nodearguments;
 impl Nodearguments {
     #[extend_class]
     fn extend_class_with_fields(ctx: &PyContext, class: &PyTypeRef) {
-        class.set_str_attr("_fields", ctx.new_list(vec![ctx.new_ascii_literal(ascii!("posonlyargs")),ctx.new_ascii_literal(ascii!("args")),ctx.new_ascii_literal(ascii!("vararg")),ctx.new_ascii_literal(ascii!("kwonlyargs")),ctx.new_ascii_literal(ascii!("kw_defaults")),ctx.new_ascii_literal(ascii!("kwarg")),ctx.new_ascii_literal(ascii!("defaults"))]));
+        class.set_str_attr("_fields", ctx.new_list(vec![ctx.new_str(ascii!("posonlyargs")).into(),ctx.new_str(ascii!("args")).into(),ctx.new_str(ascii!("vararg")).into(),ctx.new_str(ascii!("kwonlyargs")).into(),ctx.new_str(ascii!("kw_defaults")).into(),ctx.new_str(ascii!("kwarg")).into(),ctx.new_str(ascii!("defaults")).into()]));
         class.set_str_attr("_attributes", ctx.new_list(vec![]));
     }
 }
@@ -919,8 +919,8 @@ struct Nodearg;
 impl Nodearg {
     #[extend_class]
     fn extend_class_with_fields(ctx: &PyContext, class: &PyTypeRef) {
-        class.set_str_attr("_fields", ctx.new_list(vec![ctx.new_ascii_literal(ascii!("arg")),ctx.new_ascii_literal(ascii!("annotation")),ctx.new_ascii_literal(ascii!("type_comment"))]));
-        class.set_str_attr("_attributes", ctx.new_list(vec![ctx.new_ascii_literal(ascii!("lineno")),ctx.new_ascii_literal(ascii!("col_offset")),ctx.new_ascii_literal(ascii!("end_lineno")),ctx.new_ascii_literal(ascii!("end_col_offset"))]));
+        class.set_str_attr("_fields", ctx.new_list(vec![ctx.new_str(ascii!("arg")).into(),ctx.new_str(ascii!("annotation")).into(),ctx.new_str(ascii!("type_comment")).into()]));
+        class.set_str_attr("_attributes", ctx.new_list(vec![ctx.new_str(ascii!("lineno")).into(),ctx.new_str(ascii!("col_offset")).into(),ctx.new_str(ascii!("end_lineno")).into(),ctx.new_str(ascii!("end_col_offset")).into()]));
     }
 }
 #[pyclass(module = "_ast", name = "keyword", base = "AstNode")]
@@ -929,8 +929,8 @@ struct Nodekeyword;
 impl Nodekeyword {
     #[extend_class]
     fn extend_class_with_fields(ctx: &PyContext, class: &PyTypeRef) {
-        class.set_str_attr("_fields", ctx.new_list(vec![ctx.new_ascii_literal(ascii!("arg")),ctx.new_ascii_literal(ascii!("value"))]));
-        class.set_str_attr("_attributes", ctx.new_list(vec![ctx.new_ascii_literal(ascii!("lineno")),ctx.new_ascii_literal(ascii!("col_offset")),ctx.new_ascii_literal(ascii!("end_lineno")),ctx.new_ascii_literal(ascii!("end_col_offset"))]));
+        class.set_str_attr("_fields", ctx.new_list(vec![ctx.new_str(ascii!("arg")).into(),ctx.new_str(ascii!("value")).into()]));
+        class.set_str_attr("_attributes", ctx.new_list(vec![ctx.new_str(ascii!("lineno")).into(),ctx.new_str(ascii!("col_offset")).into(),ctx.new_str(ascii!("end_lineno")).into(),ctx.new_str(ascii!("end_col_offset")).into()]));
     }
 }
 #[pyclass(module = "_ast", name = "alias", base = "AstNode")]
@@ -939,7 +939,7 @@ struct Nodealias;
 impl Nodealias {
     #[extend_class]
     fn extend_class_with_fields(ctx: &PyContext, class: &PyTypeRef) {
-        class.set_str_attr("_fields", ctx.new_list(vec![ctx.new_ascii_literal(ascii!("name")),ctx.new_ascii_literal(ascii!("asname"))]));
+        class.set_str_attr("_fields", ctx.new_list(vec![ctx.new_str(ascii!("name")).into(),ctx.new_str(ascii!("asname")).into()]));
         class.set_str_attr("_attributes", ctx.new_list(vec![]));
     }
 }
@@ -949,7 +949,7 @@ struct Nodewithitem;
 impl Nodewithitem {
     #[extend_class]
     fn extend_class_with_fields(ctx: &PyContext, class: &PyTypeRef) {
-        class.set_str_attr("_fields", ctx.new_list(vec![ctx.new_ascii_literal(ascii!("context_expr")),ctx.new_ascii_literal(ascii!("optional_vars"))]));
+        class.set_str_attr("_fields", ctx.new_list(vec![ctx.new_str(ascii!("context_expr")).into(),ctx.new_str(ascii!("optional_vars")).into()]));
         class.set_str_attr("_attributes", ctx.new_list(vec![]));
     }
 }
@@ -959,7 +959,7 @@ struct NodeTypeIgnore;
 impl NodeTypeIgnore {
     #[extend_class]
     fn extend_class_with_fields(ctx: &PyContext, class: &PyTypeRef) {
-        class.set_str_attr("_fields", ctx.new_list(vec![ctx.new_ascii_literal(ascii!("lineno")),ctx.new_ascii_literal(ascii!("tag"))]));
+        class.set_str_attr("_fields", ctx.new_list(vec![ctx.new_str(ascii!("lineno")).into(),ctx.new_str(ascii!("tag")).into()]));
         class.set_str_attr("_attributes", ctx.new_list(vec![]));
     }
 }

vm/src/stdlib/builtins.rs

@@ -63,7 +63,7 @@ mod builtins {
     }
 
     #[pyfunction]
-    pub fn ascii(obj: PyObjectRef, vm: &VirtualMachine) -> PyResult<String> {
+    pub fn ascii(obj: PyObjectRef, vm: &VirtualMachine) -> PyResult<ascii::AsciiString> {
         let repr = vm.to_repr(&obj)?;
         let ascii = to_ascii(repr.as_str());
         Ok(ascii)
@@ -379,7 +379,7 @@ mod builtins {
             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_utf8_str(s)),
+                ReadlineResult::Line(s) => Ok(vm.ctx.new_str(s).into()),
                 ReadlineResult::Eof => {
                     Err(vm.new_exception_empty(vm.ctx.exceptions.eof_error.clone()))
                 }
@@ -538,7 +538,7 @@ mod builtins {
             format!("0o{:o}", n)
         };
 
-        Ok(vm.ctx.new_utf8_str(s))
+        Ok(vm.ctx.new_str(s).into())
     }
 
     #[pyfunction]
@@ -814,7 +814,7 @@ mod builtins {
         vm: &VirtualMachine,
     ) -> PyResult {
         let name = qualified_name.as_str().split('.').next_back().unwrap();
-        let name_obj = vm.ctx.new_utf8_str(name);
+        let name_obj = vm.ctx.new_str(name);
 
         let mut metaclass = if let Some(metaclass) = kwargs.pop_kwarg("metaclass") {
             PyTypeRef::try_from_object(vm, metaclass)?
@@ -875,7 +875,7 @@ mod builtins {
         let prepare = vm.get_attribute(metaclass.clone().into(), "__prepare__")?;
         let namespace = vm.invoke(
             &prepare,
-            FuncArgs::new(vec![name_obj.clone(), bases.clone()], kwargs.clone()),
+            FuncArgs::new(vec![name_obj.clone().into(), bases.clone()], kwargs.clone()),
         )?;
 
         let namespace = PyDictRef::try_from_object(vm, namespace)?;
@@ -889,7 +889,7 @@ mod builtins {
 
         let class = vm.invoke(
             metaclass.as_object(),
-            FuncArgs::new(vec![name_obj, bases, namespace.into()], kwargs),
+            FuncArgs::new(vec![name_obj.into(), bases, namespace.into()], kwargs),
         )?;
 
         if let Some(ref classcell) = classcell {

vm/src/stdlib/codecs.rs

@@ -114,15 +114,15 @@ mod _codecs {
             reason: &str,
         ) -> PyResult<(encodings::EncodeReplace<PyStrRef, PyBytesRef>, usize)> {
             let vm = self.vm;
-            let data_str = vm.ctx.new_utf8_str(data);
+            let data_str = vm.ctx.new_str(data).into();
             let encode_exc = vm.new_exception(
                 vm.ctx.exceptions.unicode_encode_error.clone(),
                 vec![
-                    vm.ctx.new_utf8_str(self.encoding),
+                    vm.ctx.new_str(self.encoding).into(),
                     data_str,
                     vm.ctx.new_int(char_range.start).into(),
                     vm.ctx.new_int(char_range.end).into(),
-                    vm.ctx.new_utf8_str(reason),
+                    vm.ctx.new_str(reason).into(),
                 ],
             );
             let res = vm.invoke(self.handler_func()?, (encode_exc,))?;
@@ -161,11 +161,11 @@ mod _codecs {
             let decode_exc = vm.new_exception(
                 vm.ctx.exceptions.unicode_decode_error.clone(),
                 vec![
-                    vm.ctx.new_utf8_str(self.encoding),
+                    vm.ctx.new_str(self.encoding).into(),
                     data_bytes.clone(),
                     vm.ctx.new_int(byte_range.start).into(),
                     vm.ctx.new_int(byte_range.end).into(),
-                    vm.ctx.new_utf8_str(reason),
+                    vm.ctx.new_str(reason).into(),
                 ],
             );
             let res = vm.invoke(self.handler_func()?, (decode_exc.clone(),))?;
@@ -219,11 +219,11 @@ mod _codecs {
             vm.new_exception(
                 vm.ctx.exceptions.unicode_encode_error.clone(),
                 vec![
-                    vm.ctx.new_utf8_str(self.encoding),
-                    vm.ctx.new_utf8_str(data),
+                    vm.ctx.new_str(self.encoding).into(),
+                    vm.ctx.new_str(data).into(),
                     vm.ctx.new_int(char_range.start).into(),
                     vm.ctx.new_int(char_range.end).into(),
-                    vm.ctx.new_utf8_str(reason),
+                    vm.ctx.new_str(reason).into(),
                 ],
             )
         }

vm/src/stdlib/errno.rs

@@ -7,7 +7,7 @@ pub fn make_module(vm: &VirtualMachine) -> PyObjectRef {
         "errorcode" => errorcode.clone(),
     });
     for (name, code) in ERROR_CODES {
-        let name = vm.ctx.new_utf8_str((*name).to_owned());
+        let name = vm.new_pyobj(*name);
         let code = vm.new_pyobj(*code);
         errorcode.set_item(code.clone(), name.clone(), vm).unwrap();
         vm.set_attr(&module, name, code).unwrap();

vm/src/stdlib/io.rs

@@ -3116,7 +3116,7 @@ mod _io {
         #[pymethod]
         fn getvalue(self, vm: &VirtualMachine) -> PyResult {
             match String::from_utf8(self.buffer(vm)?.getvalue()) {
-                Ok(result) => Ok(vm.ctx.new_utf8_str(result)),
+                Ok(result) => Ok(vm.ctx.new_str(result).into()),
                 Err(_) => Err(vm.new_value_error("Error Retrieving Value".to_owned())),
             }
         }
@@ -3146,7 +3146,7 @@ mod _io {
 
             let value = String::from_utf8(data)
                 .map_err(|_| vm.new_value_error("Error Retrieving Value".to_owned()))?;
-            Ok(vm.ctx.new_utf8_str(value))
+            Ok(vm.ctx.new_str(value).into())
         }
 
         #[pymethod]
@@ -3609,7 +3609,7 @@ mod _io {
                         line_buffering,
                     ),
                 )?;
-                vm.set_attr(&wrapper, "mode", vm.ctx.new_utf8_str(mode_string))?;
+                vm.set_attr(&wrapper, "mode", vm.new_pyobj(mode_string))?;
                 Ok(wrapper)
             }
             EncodeMode::Bytes => Ok(buffered),

vm/src/stdlib/nt.rs

@@ -83,7 +83,7 @@ pub(crate) mod module {
 
         for (key, value) in env::vars() {
             environ
-                .set_item(vm.ctx.new_utf8_str(key), vm.ctx.new_utf8_str(value), vm)
+                .set_item(vm.new_pyobj(key), vm.new_pyobj(value), vm)
                 .unwrap();
         }
         environ

vm/src/stdlib/os.rs

@@ -34,7 +34,7 @@ impl OutputMode {
                 })
             };
             match mode {
-                OutputMode::String => path_as_string(path).map(|s| vm.ctx.new_utf8_str(s)),
+                OutputMode::String => path_as_string(path).map(|s| vm.ctx.new_str(s).into()),
                 OutputMode::Bytes => {
                     #[cfg(any(unix, target_os = "wasi"))]
                     {
@@ -254,7 +254,7 @@ impl IntoPyException for &'_ io::Error {
             },
         };
         let errno = self.raw_os_error().into_pyobject(vm);
-        let msg = vm.ctx.new_utf8_str(self.to_string());
+        let msg = vm.ctx.new_str(self.to_string()).into();
         vm.new_exception(exc_type, vec![errno, msg])
     }
 }

vm/src/stdlib/posix.rs

@@ -967,7 +967,7 @@ pub mod module {
             Err(errno_err(vm))
         } else {
             let name = unsafe { CStr::from_ptr(name) }.to_str().unwrap();
-            Ok(vm.ctx.new_utf8_str(name))
+            Ok(vm.ctx.new_str(name).into())
         }
     }
 

vm/src/stdlib/pwd.rs

@@ -52,7 +52,8 @@ fn pwd_getpwnam(name: PyStrRef, vm: &VirtualMachine) -> PyResult<Passwd> {
             let name_repr = vm.to_repr(name.as_object())?;
             let message = vm
                 .ctx
-                .new_utf8_str(format!("getpwnam(): name not found: {}", name_repr));
+                .new_str(format!("getpwnam(): name not found: {}", name_repr))
+                .into();
             Err(vm.new_key_error(message))
         }
     }
@@ -69,7 +70,8 @@ fn pwd_getpwuid(uid: PyIntRef, vm: &VirtualMachine) -> PyResult<Passwd> {
         None => {
             let message = vm
                 .ctx
-                .new_utf8_str(format!("getpwuid(): uid not found: {}", uid.as_bigint()));
+                .new_str(format!("getpwuid(): uid not found: {}", uid.as_bigint()))
+                .into();
             Err(vm.new_key_error(message))
         }
     }

vm/src/stdlib/sre.rs

@@ -58,7 +58,8 @@ mod _sre {
         match this {
             StrDrive::Str(s) => vm
                 .ctx
-                .new_utf8_str(s.chars().take(end).skip(start).collect::<String>()),
+                .new_str(s.chars().take(end).skip(start).collect::<String>())
+                .into(),
             StrDrive::Bytes(b) => vm
                 .ctx
                 .new_bytes(b.iter().take(end).skip(start).cloned().collect())
@@ -266,11 +267,8 @@ mod _sre {
                             m.get_slice(zelf.groups, state.string, vm)
                                 .unwrap_or_else(|| vm.ctx.none())
                         } else {
-                            m.groups(
-                                OptionalArg::Present(vm.ctx.new_ascii_literal(ascii!(""))),
-                                vm,
-                            )?
-                            .into()
+                            m.groups(OptionalArg::Present(vm.ctx.new_str(ascii!("")).into()), vm)?
+                                .into()
                         };
 
                         matchlist.push(item);
@@ -505,7 +503,7 @@ mod _sre {
                 let join_type = if zelf.isbytes {
                     vm.ctx.new_bytes(vec![]).into()
                 } else {
-                    vm.ctx.new_ascii_literal(ascii!(""))
+                    vm.ctx.new_str(ascii!("")).into()
                 };
                 let ret = vm.call_method(&join_type, "join", (list,))?;
 

vm/src/stdlib/string.rs

@@ -76,7 +76,7 @@ mod _string {
         let field_name = FieldName::parse(text.as_str()).map_err(|e| e.into_pyexception(vm))?;
 
         let first = match field_name.field_type {
-            FieldType::Auto => vm.ctx.new_ascii_literal(ascii!("")),
+            FieldType::Auto => vm.ctx.new_str(ascii!("")).into(),
             FieldType::Index(index) => index.into_pyobject(vm),
             FieldType::Keyword(attribute) => attribute.into_pyobject(vm),
         };

vm/src/stdlib/symtable.rs

@@ -93,7 +93,7 @@ mod symtable {
                 }
                 .into_ref(vm))
             } else {
-                Err(vm.new_key_error(vm.ctx.new_utf8_str(format!("lookup {} failed", name))))
+                Err(vm.new_key_error(vm.ctx.new_str(format!("lookup {} failed", name)).into()))
             }
         }
 
@@ -103,7 +103,7 @@ mod symtable {
                 .symtable
                 .symbols
                 .keys()
-                .map(|s| vm.ctx.new_utf8_str(s))
+                .map(|s| vm.ctx.new_str(s.as_str()).into())
                 .collect();
             Ok(vm.ctx.new_list(symbols))
         }

vm/src/stdlib/sys.rs

@@ -28,7 +28,7 @@ fn argv(vm: &VirtualMachine) -> PyObjectRef {
             .settings
             .argv
             .iter()
-            .map(|arg| vm.ctx.new_utf8_str(arg))
+            .map(|arg| vm.ctx.new_str(arg.clone()).into())
             .collect(),
     )
 }
@@ -38,29 +38,33 @@ fn executable(ctx: &PyContext) -> PyObjectRef {
     {
         if let Some(exec_path) = env::args_os().next() {
             if let Ok(path) = which::which(exec_path) {
-                return ctx.new_utf8_str(
-                    path.into_os_string()
-                        .into_string()
-                        .unwrap_or_else(|p| p.to_string_lossy().into_owned()),
-                );
+                return ctx
+                    .new_str(
+                        path.into_os_string()
+                            .into_string()
+                            .unwrap_or_else(|p| p.to_string_lossy().into_owned()),
+                    )
+                    .into();
             }
         }
     }
     if let Some(exec_path) = env::args().next() {
         let path = path::Path::new(&exec_path);
         if !path.exists() {
-            return ctx.new_ascii_literal(ascii!(""));
+            return ctx.new_str(ascii!("")).into();
         }
         if path.is_absolute() {
-            return ctx.new_utf8_str(exec_path);
+            return ctx.new_str(exec_path).into();
         }
         if let Ok(dir) = env::current_dir() {
             if let Ok(dir) = dir.into_os_string().into_string() {
-                return ctx.new_utf8_str(format!(
-                    "{}/{}",
-                    dir,
-                    exec_path.strip_prefix("./").unwrap_or(&exec_path)
-                ));
+                return ctx
+                    .new_str(format!(
+                        "{}/{}",
+                        dir,
+                        exec_path.strip_prefix("./").unwrap_or(&exec_path)
+                    ))
+                    .into();
             }
         }
     }
@@ -69,7 +73,7 @@ fn executable(ctx: &PyContext) -> PyObjectRef {
 
 fn _base_executable(ctx: &PyContext) -> PyObjectRef {
     if let Ok(var) = env::var("__PYVENV_LAUNCHER__") {
-        ctx.new_utf8_str(var)
+        ctx.new_str(var).into()
     } else {
         executable(ctx)
     }
@@ -520,9 +524,9 @@ pub(crate) fn make_module(vm: &VirtualMachine, module: PyObjectRef, builtins: Py
 
     // TODO Add crate version to this namespace
     let implementation = py_namespace!(vm, {
-        "name" => ctx.new_ascii_literal(ascii!("rustpython")),
-        "cache_tag" => ctx.new_ascii_literal(ascii!("rustpython-01")),
-        "_multiarch" => ctx.new_utf8_str(MULTIARCH.to_owned()),
+        "name" => ctx.new_str(ascii!("rustpython")),
+        "cache_tag" => ctx.new_str(ascii!("rustpython-01")),
+        "_multiarch" => ctx.new_str(MULTIARCH.to_owned()),
         "version" => version_info.clone(),
         "hexversion" => ctx.new_int(version::VERSION_HEX),
     });
@@ -532,7 +536,7 @@ pub(crate) fn make_module(vm: &VirtualMachine, module: PyObjectRef, builtins: Py
             .settings
             .path_list
             .iter()
-            .map(|path| ctx.new_utf8_str(path.clone()))
+            .map(|path| ctx.new_str(path.clone()).into())
             .collect(),
     );
 
@@ -542,7 +546,7 @@ pub(crate) fn make_module(vm: &VirtualMachine, module: PyObjectRef, builtins: Py
     for (key, value) in &vm.state.settings.xopts {
         let value = value.as_ref().map_or_else(
             || ctx.new_bool(true).into(),
-            |s| ctx.new_utf8_str(s.clone()),
+            |s| ctx.new_str(s.clone()).into(),
         );
         xopts.set_item(&**key, value, vm).unwrap();
     }
@@ -552,7 +556,7 @@ pub(crate) fn make_module(vm: &VirtualMachine, module: PyObjectRef, builtins: Py
             .settings
             .warnopts
             .iter()
-            .map(|s| ctx.new_utf8_str(s.clone()))
+            .map(|s| ctx.new_str(s.clone()).into())
             .collect(),
     );
 
@@ -645,7 +649,7 @@ settrace() -- set the global debug tracing function
     let builtin_module_names = ctx.new_tuple(
         module_names
             .into_iter()
-            .map(|n| ctx.new_utf8_str(n.into_owned()))
+            .map(|n| ctx.new_str(n.into_owned()).into())
             .collect(),
     );
     let modules = ctx.new_dict();
@@ -659,11 +663,11 @@ settrace() -- set the global debug tracing function
     let platlibdir = option_env!("RUSTPYTHON_PLATLIBDIR").unwrap_or("lib");
 
     extend_module!(vm, module, {
-      "__name__" => ctx.new_ascii_literal(ascii!("sys")),
+      "__name__" => ctx.new_str(ascii!("sys")),
       "argv" => argv(vm),
       "builtin_module_names" => builtin_module_names,
-      "byteorder" => ctx.new_utf8_str(bytorder),
-      "copyright" => ctx.new_utf8_str(copyright),
+      "byteorder" => ctx.new_str(bytorder),
+      "copyright" => ctx.new_str(copyright),
       "_base_executable" => _base_executable(ctx),
       "executable" => executable(ctx),
       "flags" => flags,
@@ -681,13 +685,13 @@ settrace() -- set the global debug tracing function
       "maxunicode" => ctx.new_int(MAXUNICODE),
       "maxsize" => ctx.new_int(MAXSIZE),
       "path" => path,
-      "ps1" => ctx.new_ascii_literal(ascii!(">>>>> ")),
-      "ps2" => ctx.new_ascii_literal(ascii!("..... ")),
-      "__doc__" => ctx.new_utf8_str(sys_doc),
+      "ps1" => ctx.new_str(ascii!(">>>>> ")),
+      "ps2" => ctx.new_str(ascii!("..... ")),
+      "__doc__" => ctx.new_str(sys_doc),
       "_getframe" => named_function!(ctx, sys, _getframe),
       "modules" => modules.clone(),
-      "platform" => ctx.new_utf8_str(PLATFORM.to_owned()),
-      "_framework" => ctx.new_utf8_str(framework),
+      "platform" => ctx.new_str(PLATFORM.to_owned()),
+      "_framework" => ctx.new_str(framework),
       "meta_path" => ctx.new_list(vec![]),
       "path_hooks" => ctx.new_list(vec![]),
       "path_importer_cache" => ctx.new_dict(),
@@ -696,17 +700,17 @@ settrace() -- set the global debug tracing function
       "setprofile" => named_function!(ctx, sys, setprofile),
       "setrecursionlimit" => named_function!(ctx, sys, setrecursionlimit),
       "settrace" => named_function!(ctx, sys, settrace),
-      "version" => vm.ctx.new_utf8_str(version::get_version()),
+      "version" => vm.ctx.new_str(version::get_version()),
       "version_info" => version_info,
       "_git" => sys_git_info(vm),
       "exc_info" => named_function!(ctx, sys, exc_info),
-      "prefix" => ctx.new_utf8_str(prefix),
-      "base_prefix" => ctx.new_utf8_str(base_prefix),
-      "exec_prefix" => ctx.new_utf8_str(exec_prefix),
-      "base_exec_prefix" => ctx.new_utf8_str(base_exec_prefix),
-      "platlibdir" => ctx.new_utf8_str(platlibdir),
+      "prefix" => ctx.new_str(prefix),
+      "base_prefix" => ctx.new_str(base_prefix),
+      "exec_prefix" => ctx.new_str(exec_prefix),
+      "base_exec_prefix" => ctx.new_str(base_exec_prefix),
+      "platlibdir" => ctx.new_str(platlibdir),
       "exit" => named_function!(ctx, sys, exit),
-      "abiflags" => ctx.new_utf8_str(ABIFLAGS.to_owned()),
+      "abiflags" => ctx.new_str(ABIFLAGS.to_owned()),
       "audit" => named_function!(ctx, sys, audit),
       "displayhook" => named_function!(ctx, sys, displayhook),
       "__displayhook__" => named_function!(ctx, sys, displayhook),
@@ -716,7 +720,7 @@ settrace() -- set the global debug tracing function
       "api_version" => ctx.new_int(0x0), // what C api?
       "float_info" => float_info,
       "int_info" => int_info,
-      "float_repr_style" => ctx.new_ascii_literal(ascii!("short")),
+      "float_repr_style" => ctx.new_str(ascii!("short")),
       "_xoptions" => xopts,
       "warnoptions" => warnopts,
       "_rustpython_debugbuild" => ctx.new_bool(cfg!(debug_assertions)),

vm/src/stdlib/time.rs

@@ -170,7 +170,7 @@ mod time {
     fn asctime(t: OptionalArg<PyStructTime>, vm: &VirtualMachine) -> PyResult {
         let instant = t.naive_or_local(vm)?;
         let formatted_time = instant.format(CFMT).to_string();
-        Ok(vm.ctx.new_utf8_str(formatted_time))
+        Ok(vm.ctx.new_str(formatted_time).into())
     }
 
     #[pyfunction]
@@ -183,7 +183,7 @@ mod time {
     fn strftime(format: PyStrRef, t: OptionalArg<PyStructTime>, vm: &VirtualMachine) -> PyResult {
         let instant = t.naive_or_local(vm)?;
         let formatted_time = instant.format(format.as_str()).to_string();
-        Ok(vm.ctx.new_utf8_str(formatted_time))
+        Ok(vm.ctx.new_str(formatted_time).into())
     }
 
     #[pyfunction]

vm/src/stdlib/winreg.rs

@@ -251,7 +251,7 @@ fn reg_to_py(value: RegValue, vm: &VirtualMachine) -> PyResult {
                 .position(|w| *w == 0)
                 .unwrap_or_else(|| wide_slice.len());
             let s = String::from_utf16_lossy(&wide_slice[..nul_pos]);
-            Ok(vm.ctx.new_utf8_str(s))
+            Ok(vm.ctx.new_str(s).into())
         }
         RegType::REG_MULTI_SZ => {
             if value.bytes.is_empty() {
@@ -269,7 +269,7 @@ fn reg_to_py(value: RegValue, vm: &VirtualMachine) -> PyResult {
             };
             let strings = wide_slice
                 .split(|c| *c == 0)
-                .map(|s| vm.ctx.new_utf8_str(String::from_utf16_lossy(s)))
+                .map(|s| vm.new_pyobj(String::from_utf16_lossy(s)))
                 .collect();
             Ok(vm.ctx.new_list(strings))
         }

vm/src/vm.rs

@@ -305,13 +305,13 @@ impl VirtualMachine {
         module::init_module_dict(
             &vm,
             &builtins_dict,
-            vm.ctx.new_ascii_literal(ascii!("builtins")),
+            vm.ctx.new_str(ascii!("builtins")).into(),
             vm.ctx.none(),
         );
         module::init_module_dict(
             &vm,
             &sysmod_dict,
-            vm.ctx.new_ascii_literal(ascii!("sys")),
+            vm.ctx.new_str(ascii!("sys")).into(),
             vm.ctx.none(),
         );
         vm
@@ -632,7 +632,7 @@ impl VirtualMachine {
     /// [exceptions::invoke]: rustpython_vm::exceptions::invoke
     /// [exceptions::ctor]: rustpython_vm::exceptions::ExceptionCtor
     pub fn new_exception_msg(&self, exc_type: PyTypeRef, msg: String) -> PyBaseExceptionRef {
-        self.new_exception(exc_type, vec![self.ctx.new_utf8_str(msg)])
+        self.new_exception(exc_type, vec![self.ctx.new_str(msg).into()])
     }
 
     pub fn new_lookup_error(&self, msg: String) -> PyBaseExceptionRef {
@@ -775,7 +775,7 @@ impl VirtualMachine {
         self.set_attr(
             syntax_error.as_object(),
             "filename",
-            self.ctx.new_utf8_str(error.source_path.clone()),
+            self.ctx.new_str(error.source_path.clone()),
         )
         .unwrap();
         syntax_error
@@ -1244,7 +1244,7 @@ impl VirtualMachine {
         }
 
         let frame = frame_ref.unwrap().as_object().clone();
-        let event = self.ctx.new_utf8_str(event.to_string());
+        let event = self.ctx.new_str(event.to_string()).into();
         let args = vec![frame, event, self.ctx.none()];
 
         // temporarily disable tracing, during the call to the
@@ -2312,8 +2312,8 @@ mod tests {
     #[test]
     fn test_multiply_str() {
         Interpreter::default().enter(|vm| {
-            let a = vm.ctx.new_ascii_literal(crate::common::ascii!("Hello "));
-            let b = vm.ctx.new_int(4_i32).into();
+            let a = vm.new_pyobj(crate::common::ascii!("Hello "));
+            let b = vm.new_pyobj(4_i32);
             let res = vm._mul(&a, &b).unwrap();
             let value = res.payload::<PyStr>().unwrap();
             assert_eq!(value.as_ref(), "Hello Hello Hello Hello ")

wasm/lib/src/browser_module.rs

@@ -184,7 +184,7 @@ impl Element {
         vm: &VirtualMachine,
     ) -> PyObjectRef {
         match self.elem.get_attribute(attr.as_str()) {
-            Some(s) => vm.ctx.new_utf8_str(s),
+            Some(s) => vm.ctx.new_str(s).into(),
             None => default.unwrap_or_none(vm),
         }
     }

wasm/lib/src/vm_class.rs

@@ -264,7 +264,7 @@ impl WASMVirtualMachine {
                 .map_err(convert::syntax_err)?;
             let attrs = vm.ctx.new_dict();
             attrs
-                .set_item("__name__", vm.ctx.new_utf8_str(&name), vm)
+                .set_item("__name__", vm.new_pyobj(name.as_str()), vm)
                 .into_js(vm)?;
 
             if let Some(imports) = imports {