new_{utf8_str, ascii_literal} -> new_str again

Author: youknowone

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,19 +1026,18 @@ 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
         _ => (String::new(), 0).into_pyobject(vm),
     }
 }
 
-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(),
             ],
         )
     }