ascii! macro

Author: youknowone

Cargo.lock

@@ -133,7 +133,7 @@ fn bench_rustpy_code(group: &mut BenchmarkGroup<WallTime>, bench: &MicroBenchmar
                 scope
                     .locals
                     .set_item(
-                        vm.ctx.new_ascii_literal(b"ITERATIONS"),
+                        vm.ctx.new_ascii_literal(crate::utils::ascii!("ITERATIONS")),
                         vm.ctx.new_int(idx),
                         vm,
                     )

benches/microbenchmarks.rs

@@ -113,6 +113,7 @@ flame = { version = "0.2", optional = true }
 flamer = { version = "0.4", optional = true }
 
 rustpython-common = { path = "../common" }
+ascii = "1.0.0"
 
 [target.'cfg(unix)'.dependencies]
 exitcode = "1.1.2"

vm/Cargo.toml

@@ -364,7 +364,9 @@ impl PyDict {
         if let Some((key, value)) = self.entries.pop_back() {
             Ok(vm.ctx.new_tuple(vec![key, value]))
         } else {
-            let err_msg = vm.ctx.new_ascii_literal(b"popitem(): dictionary is empty");
+            let err_msg = vm
+                .ctx
+                .new_ascii_literal(crate::utils::ascii!("popitem(): dictionary is empty"));
             Err(vm.new_key_error(err_msg))
         }
     }

vm/src/builtins/dict.rs

@@ -212,7 +212,11 @@ impl PyStrIterator {
     fn reduce(&self, vm: &VirtualMachine) -> PyResult {
         let iter = vm.get_attribute(vm.builtins.clone(), "iter")?;
         Ok(vm.ctx.new_tuple(match self.status.load() {
-            Exhausted => vec![iter, vm.ctx.new_tuple(vec![vm.ctx.new_ascii_literal(b"")])],
+            Exhausted => vec![
+                iter,
+                vm.ctx
+                    .new_tuple(vec![vm.ctx.new_ascii_literal(crate::utils::ascii!(""))]),
+            ],
             Active => vec![
                 iter,
                 vm.ctx.new_tuple(vec![self.string.clone().into_object()]),
@@ -976,7 +980,7 @@ impl PyStr {
             if has_mid {
                 sep.into_object()
             } else {
-                vm.ctx.new_ascii_literal(b"")
+                vm.ctx.new_ascii_literal(crate::utils::ascii!(""))
             },
             self.new_substr(back),
         )
@@ -995,7 +999,7 @@ impl PyStr {
             if has_mid {
                 sep.into_object()
             } else {
-                vm.ctx.new_ascii_literal(b"")
+                vm.ctx.new_ascii_literal(crate::utils::ascii!(""))
             },
             self.new_substr(back),
         )
@@ -1541,7 +1545,11 @@ mod tests {
             table.set_item("a", vm.ctx.new_utf8_str("🎅"), &vm).unwrap();
             table.set_item("b", vm.ctx.none(), &vm).unwrap();
             table
-                .set_item("c", vm.ctx.new_ascii_literal(b"xda"), &vm)
+                .set_item(
+                    "c",
+                    vm.ctx.new_ascii_literal(crate::utils::ascii!("xda")),
+                    &vm,
+                )
                 .unwrap();
             let translated = PyStr::maketrans(
                 table.into_object(),

vm/src/builtins/pystr.rs

@@ -344,7 +344,7 @@ impl PyType {
                     Some(found)
                 }
             })
-            .unwrap_or_else(|| vm.ctx.new_ascii_literal(b"builtins"))
+            .unwrap_or_else(|| vm.ctx.new_ascii_literal(crate::utils::ascii!("builtins")))
     }
 
     #[pyproperty(magic, setter)]

vm/src/builtins/pytype.rs

@@ -232,7 +232,9 @@ impl PySetInner {
         if let Some((key, _)) = self.content.pop_back() {
             Ok(key)
         } else {
-            let err_msg = vm.ctx.new_ascii_literal(b"pop from an empty set");
+            let err_msg = vm
+                .ctx
+                .new_ascii_literal(crate::utils::ascii!("pop from an empty set"));
             Err(vm.new_key_error(err_msg))
         }
     }

vm/src/builtins/set.rs

@@ -367,7 +367,10 @@ 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(b""), range.end))
+        Ok((
+            vm.ctx.new_ascii_literal(crate::utils::ascii!("")),
+            range.end,
+        ))
     } else {
         Err(bad_err_type(err, vm))
     }

vm/src/codecs.rs

@@ -775,12 +775,12 @@ mod tests {
             assert_eq!(0, dict.len());
 
             let key1 = vm.ctx.new_bool(true);
-            let value1 = vm.ctx.new_ascii_literal(b"abc");
+            let value1 = vm.ctx.new_ascii_literal(crate::utils::ascii!("abc"));
             dict.insert(&vm, key1.clone(), value1.clone()).unwrap();
             assert_eq!(1, dict.len());
 
-            let key2 = vm.ctx.new_ascii_literal(b"x");
-            let value2 = vm.ctx.new_ascii_literal(b"def");
+            let key2 = vm.ctx.new_ascii_literal(crate::utils::ascii!("x"));
+            let value2 = vm.ctx.new_ascii_literal(crate::utils::ascii!("def"));
             dict.insert(&vm, key2.clone(), value2.clone()).unwrap();
             assert_eq!(2, dict.len());
 

vm/src/dictdatatype.rs

@@ -65,7 +65,9 @@ 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(b"EOF when reading a line")],
+            vec![vm
+                .ctx
+                .new_ascii_literal(crate::utils::ascii!("EOF when reading a line"))],
         )
     };
     let ret = match_class!(match ret {

vm/src/py_io.rs

@@ -211,11 +211,10 @@ impl PyContext {
     }
 
     #[inline]
-    pub fn new_ascii_literal(&self, s: &'static [u8]) -> PyObjectRef {
+    pub fn new_ascii_literal(&self, s: &ascii::AsciiStr) -> PyObjectRef {
         PyObject::new(
             unsafe {
-                assert!(s.is_ascii()); // SAFETY
-                pystr::PyStr::new_str_unchecked(s.to_owned(), pystr::PyStrKind::Ascii)
+                pystr::PyStr::new_str_unchecked(s.as_bytes().to_owned(), pystr::PyStrKind::Ascii)
             },
             self.types.str_type.clone(),
             None,