BorrowValue for PyString

Author: youknowone

src/shell.rs

@@ -6,7 +6,7 @@ use rustpython_vm::readline::{Readline, ReadlineResult};
 use rustpython_vm::{
     exceptions::{print_exception, PyBaseExceptionRef},
     obj::objtype,
-    pyobject::PyResult,
+    pyobject::{BorrowValue, PyResult},
     scope::Scope,
     VirtualMachine,
 };
@@ -61,7 +61,7 @@ pub fn run_shell(vm: &VirtualMachine, scope: Scope) -> PyResult<()> {
             .get_attribute(vm.sys_module.clone(), prompt_name)
             .and_then(|prompt| vm.to_str(&prompt));
         let prompt = match prompt {
-            Ok(ref s) => s.as_str(),
+            Ok(ref s) => s.borrow_value(),
             Err(_) => "",
         };
         let result = match repl.readline(prompt) {

src/shell/helper.rs

@@ -1,5 +1,5 @@
 use rustpython_vm::obj::objstr::PyStringRef;
-use rustpython_vm::pyobject::{PyIterable, PyResult, TryFromObject};
+use rustpython_vm::pyobject::{BorrowValue, PyIterable, PyResult, TryFromObject};
 use rustpython_vm::scope::{NameProtocol, Scope};
 use rustpython_vm::VirtualMachine;
 
@@ -104,7 +104,7 @@ impl<'vm> ShellHelper<'vm> {
             .filter(|res| {
                 res.as_ref()
                     .ok()
-                    .map_or(true, |s| s.as_str().starts_with(word_start))
+                    .map_or(true, |s| s.borrow_value().starts_with(word_start))
             })
             .collect::<Result<Vec<_>, _>>()
             .ok()?;
@@ -117,7 +117,7 @@ impl<'vm> ShellHelper<'vm> {
             let no_underscore = all_completions
                 .iter()
                 .cloned()
-                .filter(|s| !s.as_str().starts_with('_'))
+                .filter(|s| !s.borrow_value().starts_with('_'))
                 .collect::<Vec<_>>();
 
             // if there are only completions that start with a '_', give them all of the
@@ -130,13 +130,13 @@ impl<'vm> ShellHelper<'vm> {
         };
 
         // sort the completions alphabetically
-        completions.sort_by(|a, b| std::cmp::Ord::cmp(a.as_str(), b.as_str()));
+        completions.sort_by(|a, b| std::cmp::Ord::cmp(a.borrow_value(), b.borrow_value()));
 
         Some((
             startpos,
             completions
                 .into_iter()
-                .map(|s| s.as_str().to_owned())
+                .map(|s| s.borrow_value().to_owned())
                 .collect(),
         ))
     }

vm/src/builtins.rs

@@ -70,7 +70,7 @@ mod decl {
     #[pyfunction]
     fn ascii(obj: PyObjectRef, vm: &VirtualMachine) -> PyResult<String> {
         let repr = vm.to_repr(&obj)?;
-        let ascii = to_ascii(repr.as_str());
+        let ascii = to_ascii(repr.borrow_value());
         Ok(ascii)
     }
 
@@ -121,11 +121,11 @@ mod decl {
     fn compile(args: CompileArgs, vm: &VirtualMachine) -> PyResult {
         // TODO: compile::compile should probably get bytes
         let source = match &args.source {
-            Either::A(string) => string.as_str(),
+            Either::A(string) => string.borrow_value(),
             Either::B(bytes) => std::str::from_utf8(bytes).unwrap(),
         };
 
-        let mode_str = args.mode.as_str();
+        let mode_str = args.mode.borrow_value();
 
         let flags = args
             .flags
@@ -138,7 +138,7 @@ mod decl {
                     .parse::<compile::Mode>()
                     .map_err(|err| vm.new_value_error(err.to_string()))?;
 
-                vm.compile(&source, mode, args.filename.as_str().to_owned())
+                vm.compile(&source, mode, args.filename.borrow_value().to_owned())
                     .map(|o| o.into_object())
                     .map_err(|err| vm.new_syntax_error(&err))
             } else {
@@ -230,7 +230,7 @@ mod decl {
         // Determine code object:
         let code_obj = match source {
             Either::A(string) => vm
-                .compile(string.as_str(), mode, "<string>".to_owned())
+                .compile(string.borrow_value(), mode, "<string>".to_owned())
                 .map_err(|err| vm.new_syntax_error(&err))?,
             Either::B(code_obj) => code_obj,
         };
@@ -355,7 +355,7 @@ mod decl {
 
     #[pyfunction]
     fn input(prompt: OptionalArg<PyStringRef>, vm: &VirtualMachine) -> PyResult<String> {
-        let prompt = prompt.as_ref().map_or("", |s| s.as_str());
+        let prompt = prompt.as_ref().map_or("", |s| s.borrow_value());
         let mut readline = Readline::new(());
         match readline.readline(prompt) {
             ReadlineResult::Line(s) => Ok(s),
@@ -568,7 +568,7 @@ mod decl {
                 Ok(u32::from(bytes[0]))
             }),
             Either::B(string) => {
-                let string = string.as_str();
+                let string = string.borrow_value();
                 let string_len = string.chars().count();
                 if string_len != 1 {
                     return Err(vm.new_type_error(format!(
@@ -779,7 +779,11 @@ mod decl {
         mut kwargs: KwArgs,
         vm: &VirtualMachine,
     ) -> PyResult {
-        let name = qualified_name.as_str().split('.').next_back().unwrap();
+        let name = qualified_name
+            .borrow_value()
+            .split('.')
+            .next_back()
+            .unwrap();
         let name_obj = vm.new_str(name.to_owned());
 
         let mut metaclass = if let Some(metaclass) = kwargs.pop_kwarg("metaclass") {

vm/src/cformat.rs

@@ -2,7 +2,9 @@
 /// [https://docs.python.org/3/library/stdtypes.html#printf-style-string-formatting]
 use crate::format::get_num_digits;
 use crate::obj::{objfloat, objint, objstr, objtuple, objtype};
-use crate::pyobject::{ItemProtocol, PyObjectRef, PyResult, TryFromObject, TypeProtocol};
+use crate::pyobject::{
+    BorrowValue, ItemProtocol, PyObjectRef, PyResult, TryFromObject, TypeProtocol,
+};
 use crate::vm::VirtualMachine;
 use num_bigint::{BigInt, Sign};
 use num_traits::cast::ToPrimitive;
@@ -295,7 +297,7 @@ impl CFormatSpec {
                         vm.call_method(&obj.clone(), "decode", vec![])?,
                     )?,
                 };
-                Ok(self.format_string(result.as_str().to_owned()))
+                Ok(self.format_string(result.borrow_value().to_owned()))
             }
             CFormatType::Number(number_type) => {
                 if !objtype::isinstance(&obj, &vm.ctx.types.int_type) {

vm/src/dictdatatype.rs

@@ -4,7 +4,7 @@
 /// And: http://code.activestate.com/recipes/578375/
 use crate::common::cell::{PyRwLock, PyRwLockReadGuard, PyRwLockWriteGuard};
 use crate::obj::objstr::{PyString, PyStringRef};
-use crate::pyobject::{IdProtocol, IntoPyObject, PyObjectRef, PyResult};
+use crate::pyobject::{BorrowValue, IdProtocol, IntoPyObject, PyObjectRef, PyResult};
 use crate::vm::VirtualMachine;
 use rustpython_common::hash;
 use std::collections::HashMap;
@@ -447,7 +447,7 @@ impl DictKey for PyStringRef {
         if self.is(other_key) {
             Ok(true)
         } else if let Some(py_str_value) = other_key.payload::<PyString>() {
-            Ok(py_str_value.as_str() == self.as_str())
+            Ok(py_str_value.borrow_value() == self.borrow_value())
         } else {
             vm.bool_eq(self.clone().into_object(), other_key.clone())
         }
@@ -472,7 +472,7 @@ impl DictKey for &str {
 
     fn key_eq(&self, vm: &VirtualMachine, other_key: &PyObjectRef) -> PyResult<bool> {
         if let Some(py_str_value) = other_key.payload::<PyString>() {
-            Ok(py_str_value.as_str() == *self)
+            Ok(py_str_value.borrow_value() == *self)
         } else {
             // Fall back to PyObjectRef implementation.
             let s = vm.ctx.new_str(*self);

vm/src/frame.rs

@@ -24,7 +24,8 @@ use crate::obj::objtraceback::PyTraceback;
 use crate::obj::objtuple::PyTuple;
 use crate::obj::objtype::{self, PyClassRef};
 use crate::pyobject::{
-    IdProtocol, ItemProtocol, PyObjectRef, PyRef, PyResult, PyValue, TryFromObject, TypeProtocol,
+    BorrowValue, IdProtocol, ItemProtocol, PyObjectRef, PyRef, PyResult, PyValue, TryFromObject,
+    TypeProtocol,
 };
 use crate::scope::{NameProtocol, Scope};
 use crate::vm::VirtualMachine;
@@ -795,7 +796,7 @@ impl ExecutingFrame<'_> {
         if let Some(dict) = module.dict() {
             for (k, v) in &dict {
                 let k = vm.to_str(&k)?;
-                let k = k.as_str();
+                let k = k.borrow_value();
                 if !k.starts_with('_') {
                     self.scope.store_name(&vm, k, v);
                 }
@@ -991,7 +992,7 @@ impl ExecutingFrame<'_> {
                             let key_repr = vm.to_repr(&key)?;
                             let msg = format!(
                                 "got multiple values for keyword argument {}",
-                                key_repr.as_str()
+                                key_repr.borrow_value()
                             );
                             return Err(vm.new_type_error(msg));
                         }
@@ -1066,7 +1067,7 @@ impl ExecutingFrame<'_> {
                     let mut kwargs = IndexMap::new();
                     for (key, value) in kw_dict.into_iter() {
                         if let Some(key) = key.payload_if_subclass::<objstr::PyString>(vm) {
-                            kwargs.insert(key.as_str().to_owned(), value);
+                            kwargs.insert(key.borrow_value().to_owned(), value);
                         } else {
                             return Err(vm.new_type_error("keywords must be strings".to_owned()));
                         }
@@ -1285,7 +1286,11 @@ impl ExecutingFrame<'_> {
             .ctx
             .new_pyfunction(code_obj, scope, defaults, kw_only_defaults);
 
-        let name = qualified_name.as_str().split('.').next_back().unwrap();
+        let name = qualified_name
+            .borrow_value()
+            .split('.')
+            .next_back()
+            .unwrap();
         vm.set_attr(&func_obj, "__name__", vm.new_str(name.to_owned()))?;
         vm.set_attr(&func_obj, "__qualname__", qualified_name)?;
         let module = self

vm/src/obj/objbool.rs

@@ -103,7 +103,7 @@ impl PyBool {
         format_spec: PyStringRef,
         vm: &VirtualMachine,
     ) -> PyResult<PyStringRef> {
-        if format_spec.as_str().is_empty() {
+        if format_spec.borrow_value().is_empty() {
             vm.to_str(&obj)
         } else {
             Err(vm.new_type_error("unsupported format string passed to bool.__format__".to_owned()))

vm/src/obj/objbytearray.rs

@@ -256,7 +256,7 @@ impl PyByteArray {
 
     #[pymethod]
     fn fromhex(string: PyStringRef, vm: &VirtualMachine) -> PyResult<PyByteArray> {
-        Ok(PyBytesInner::fromhex(string.as_str(), vm)?.into())
+        Ok(PyBytesInner::fromhex(string.borrow_value(), vm)?.into())
     }
 
     #[pymethod(name = "center")]
@@ -590,7 +590,7 @@ impl PyByteArray {
                 vm.new_type_error(format!(
                     "'{}' decoder returned '{}' instead of 'str'; use codecs.encode() to \
                      encode arbitrary types",
-                    encoding.as_ref().map_or("utf-8", |s| s.as_str()),
+                    encoding.as_ref().map_or("utf-8", |s| s.borrow_value()),
                     obj.lease_class().name,
                 ))
             })

vm/src/obj/objbytes.rs

@@ -238,7 +238,7 @@ impl PyBytes {
 
     #[pymethod]
     fn fromhex(string: PyStringRef, vm: &VirtualMachine) -> PyResult<PyBytes> {
-        Ok(PyBytesInner::fromhex(string.as_str(), vm)?.into())
+        Ok(PyBytesInner::fromhex(string.borrow_value(), vm)?.into())
     }
 
     #[pymethod(name = "center")]
@@ -481,7 +481,7 @@ impl PyBytes {
                 vm.new_type_error(format!(
                     "'{}' decoder returned '{}' instead of 'str'; use codecs.encode() to \
                      encode arbitrary types",
-                    encoding.as_ref().map_or("utf-8", |s| s.as_str()),
+                    encoding.as_ref().map_or("utf-8", |s| s.borrow_value()),
                     obj.lease_class().name,
                 ))
             })

vm/src/obj/objcomplex.rs

@@ -245,7 +245,7 @@ impl PyComplex {
                             "complex() can't take second arg if first is a string".to_owned(),
                         ));
                     }
-                    let value = Complex64::from_str(s.as_str())
+                    let value = Complex64::from_str(s.borrow_value())
                         .map_err(|err| vm.new_value_error(err.to_string()))?;
                     return PyComplex { value }.into_ref_with_type(vm, cls);
                 }