&str::to_string -> &str::to_owned for variables

RustPython · coolreader18 · Feb 6, 2020 · Oct 26, 2019 · Dec 14, 2019 · Feb 1, 2020
commit 7d0d313aa573bada831fa3d8181df3fc34212393
diff --git a/compiler/src/compile.rs b/compiler/src/compile.rs
@@ -290,15 +290,15 @@ impl<O: OutputStream> Compiler<O> {
     fn load_name(&mut self, name: &str) {
         let scope = self.scope_for_name(name);
         self.emit(Instruction::LoadName {
-            name: name.to_string(),
+            name: name.to_owned(),
             scope,
         });
     }
 
     fn store_name(&mut self, name: &str) {
         let scope = self.scope_for_name(name);
         self.emit(Instruction::StoreName {
-            name: name.to_string(),
+            name: name.to_owned(),
             scope,
         });
     }
@@ -359,7 +359,7 @@ impl<O: OutputStream> Compiler<O> {
                     for name in names {
                         // import symbol from module:
                         self.emit(Instruction::ImportFrom {
-                            name: name.symbol.to_string(),
+                            name: name.symbol.to_owned(),
                         });
 
                         // Store module under proper name:
@@ -619,13 +619,13 @@ impl<O: OutputStream> Compiler<O> {
         match &expression.node {
             ast::ExpressionType::Identifier { name } => {
                 self.emit(Instruction::DeleteName {
-                    name: name.to_string(),
+                    name: name.to_owned(),
                 });
             }
             ast::ExpressionType::Attribute { value, name } => {
                 self.compile_expression(value)?;
                 self.emit(Instruction::DeleteAttr {
-                    name: name.to_string(),
+                    name: name.to_owned(),
                 });
             }
             ast::ExpressionType::Subscript { a, b } => {
@@ -701,7 +701,7 @@ impl<O: OutputStream> Compiler<O> {
             compile_varargs(&args.kwarg),
             self.source_path.clone().unwrap(),
             line_number,
-            name.to_string(),
+            name.to_owned(),
         ));
         self.enter_scope();
 
@@ -909,7 +909,7 @@ impl<O: OutputStream> Compiler<O> {
             if let Some(annotation) = &arg.annotation {
                 self.emit(Instruction::LoadConst {
                     value: bytecode::Constant::String {
-                        value: arg.arg.to_string(),
+                        value: arg.arg.to_owned(),
                     },
                 });
                 self.compile_expression(&annotation)?;
@@ -982,7 +982,7 @@ impl<O: OutputStream> Compiler<O> {
             Varargs::None,
             self.source_path.clone().unwrap(),
             line_number,
-            name.to_string(),
+            name.to_owned(),
         ));
         self.enter_scope();
 
@@ -1022,7 +1022,7 @@ impl<O: OutputStream> Compiler<O> {
         });
         self.emit(Instruction::LoadConst {
             value: bytecode::Constant::String {
-                value: name.to_string(),
+                value: name.to_owned(),
             },
         });
 
@@ -1044,7 +1044,7 @@ impl<O: OutputStream> Compiler<O> {
             for keyword in keywords {
                 if let Some(name) = &keyword.name {
                     kwarg_names.push(bytecode::Constant::String {
-                        value: name.to_string(),
+                        value: name.to_owned(),
                     });
                 } else {
                     // This means **kwargs!
@@ -1308,7 +1308,7 @@ impl<O: OutputStream> Compiler<O> {
             });
             self.emit(Instruction::LoadConst {
                 value: bytecode::Constant::String {
-                    value: name.to_string(),
+                    value: name.to_owned(),
                 },
             });
             self.emit(Instruction::StoreSubscript);
@@ -1332,7 +1332,7 @@ impl<O: OutputStream> Compiler<O> {
             ast::ExpressionType::Attribute { value, name } => {
                 self.compile_expression(value)?;
                 self.emit(Instruction::StoreAttr {
-                    name: name.to_string(),
+                    name: name.to_owned(),
                 });
             }
             ast::ExpressionType::List { elements } | ast::ExpressionType::Tuple { elements } => {
@@ -1605,7 +1605,7 @@ impl<O: OutputStream> Compiler<O> {
             Attribute { value, name } => {
                 self.compile_expression(value)?;
                 self.emit(Instruction::LoadAttr {
-                    name: name.to_string(),
+                    name: name.to_owned(),
                 });
             }
             Compare { vals, ops } => {
@@ -1795,7 +1795,7 @@ impl<O: OutputStream> Compiler<O> {
                     if let Some(name) = &keyword.name {
                         self.emit(Instruction::LoadConst {
                             value: bytecode::Constant::String {
-                                value: name.to_string(),
+                                value: name.to_owned(),
                             },
                         });
                         self.compile_expression(&keyword.value)?;
@@ -1858,7 +1858,7 @@ impl<O: OutputStream> Compiler<O> {
                 for keyword in keywords {
                     if let Some(name) = &keyword.name {
                         kwarg_names.push(bytecode::Constant::String {
-                            value: name.to_string(),
+                            value: name.to_owned(),
                         });
                     } else {
                         // This means **kwargs!
@@ -1927,7 +1927,7 @@ impl<O: OutputStream> Compiler<O> {
             ast::ComprehensionKind::Set { .. } => "<setcomp>",
             ast::ComprehensionKind::Dict { .. } => "<dictcomp>",
         }
-        .to_string();
+        .to_owned();
 
         let line_number = self.get_source_line_number();
         // Create magnificent function <listcomp>:
@@ -2099,7 +2099,7 @@ impl<O: OutputStream> Compiler<O> {
                 ast::StringGroup::Constant { value } => {
                     self.emit(Instruction::LoadConst {
                         value: bytecode::Constant::String {
-                            value: value.to_string(),
+                            value: value.to_owned(),
                         },
                     });
                 }
@@ -2266,7 +2266,7 @@ mod tests {
         let mut compiler: Compiler = Default::default();
         compiler.source_path = Some("source_path".to_owned());
         compiler.push_new_code_object("<module>".to_owned());
-        let ast = parser::parse_program(&source.to_string()).unwrap();
+        let ast = parser::parse_program(source).unwrap();
         let symbol_scope = make_symbol_table(&ast).unwrap();
         compiler.compile_program(&ast, symbol_scope).unwrap();
         compiler.pop_code_object()

diff --git a/compiler/src/symboltable.rs b/compiler/src/symboltable.rs
@@ -105,7 +105,7 @@ pub struct Symbol {
 impl Symbol {
     fn new(name: &str) -> Self {
         Symbol {
-            name: name.to_string(),
+            name: name.to_owned(),
             // table,
             scope: SymbolScope::Unknown,
             is_param: false,
@@ -304,7 +304,7 @@ impl SymbolTableBuilder {
     }
 
     fn enter_scope(&mut self, name: &str, typ: SymbolTableType, line_number: usize) {
-        let table = SymbolTable::new(name.to_string(), typ, line_number);
+        let table = SymbolTable::new(name.to_owned(), typ, line_number);
         self.tables.push(table);
     }
 
@@ -793,7 +793,7 @@ impl SymbolTableBuilder {
         // Insert symbol when required:
         if !containing {
             let symbol = Symbol::new(name);
-            table.symbols.insert(name.to_string(), symbol);
+            table.symbols.insert(name.to_owned(), symbol);
         }
 
         // Set proper flags on symbol:

diff --git a/derive/src/compile_bytecode.rs b/derive/src/compile_bytecode.rs
@@ -128,7 +128,7 @@ impl CompilationSource {
                 let module_name = if is_init {
                     parent.clone()
                 } else if parent.is_empty() {
-                    stem.to_string()
+                    stem.to_owned()
                 } else {
                     format!("{}.{}", parent, stem)
                 };

diff --git a/derive/src/pyclass.rs b/derive/src/pyclass.rs
@@ -620,7 +620,7 @@ fn generate_class_def(
             let meta = attr.parse_meta().expect("expected doc attr to be a meta");
             if let Meta::NameValue(name_value) = meta {
                 if let Lit::Str(s) = name_value.lit {
-                    let val = s.value().trim().to_string();
+                    let val = s.value().trim().to_owned();
                     match doc {
                         Some(ref mut doc) => doc.push(val),
                         None => doc = Some(vec![val]),

diff --git a/parser/src/fstring.rs b/parser/src/fstring.rs
@@ -83,7 +83,7 @@ impl<'a> FStringParser<'a> {
                         }))
                     } else {
                         spec = Some(Box::new(Constant {
-                            value: spec_expression.to_string(),
+                            value: spec_expression.to_owned(),
                         }))
                     }
                 }

diff --git a/src/main.rs b/src/main.rs
@@ -364,7 +364,7 @@ fn run_rustpython(vm: &VirtualMachine, matches: &ArgMatches) -> PyResult<()> {
 
     // Figure out if a -c option was given:
     if let Some(command) = matches.value_of("c") {
-        run_command(&vm, scope, command.to_string())?;
+        run_command(&vm, scope, command.to_owned())?;
     } else if let Some(module) = matches.value_of("m") {
         run_module(&vm, module)?;
     } else if let Some(filename) = matches.value_of("script") {
@@ -426,13 +426,13 @@ fn run_script(vm: &VirtualMachine, scope: Scope, script_file: &str) -> PyResult<
         process::exit(1);
     };
 
-    let dir = file_path.parent().unwrap().to_str().unwrap().to_string();
+    let dir = file_path.parent().unwrap().to_str().unwrap().to_owned();
     let sys_path = vm.get_attribute(vm.sys_module.clone(), "path").unwrap();
     vm.call_method(&sys_path, "insert", vec![vm.new_int(0), vm.new_str(dir)])?;
 
     match util::read_file(&file_path) {
         Ok(source) => {
-            _run_string(vm, scope, &source, file_path.to_str().unwrap().to_string())?;
+            _run_string(vm, scope, &source, file_path.to_str().unwrap().to_owned())?;
         }
         Err(err) => {
             error!(

diff --git a/vm/src/builtins.rs b/vm/src/builtins.rs
@@ -146,7 +146,7 @@ fn builtin_compile(args: CompileArgs, vm: &VirtualMachine) -> PyResult {
                 .parse::<compile::Mode>()
                 .map_err(|err| vm.new_value_error(err.to_string()))?;
 
-            vm.compile(&source, mode, args.filename.as_str().to_string())
+            vm.compile(&source, mode, args.filename.as_str().to_owned())
                 .map(|o| o.into_object())
                 .map_err(|err| vm.new_syntax_error(&err))
         }
@@ -920,7 +920,7 @@ pub fn builtin_build_class_(
     vm: &VirtualMachine,
 ) -> PyResult {
     let name = qualified_name.as_str().split('.').next_back().unwrap();
-    let name_obj = vm.new_str(name.to_string());
+    let name_obj = vm.new_str(name.to_owned());
 
     let mut metaclass = if let Some(metaclass) = kwargs.pop_kwarg("metaclass") {
         PyClassRef::try_from_object(vm, metaclass)?

diff --git a/vm/src/dictdatatype.rs b/vm/src/dictdatatype.rs
@@ -344,7 +344,7 @@ impl DictKey for &PyObjectRef {
 impl DictKey for &str {
     fn do_hash(self, _vm: &VirtualMachine) -> PyResult<HashValue> {
         // follow a similar route as the hashing of PyStringRef
-        let raw_hash = pyhash::hash_value(&self.to_string()).to_bigint().unwrap();
+        let raw_hash = pyhash::hash_value(&self.to_owned()).to_bigint().unwrap();
         let raw_hash = pyhash::hash_bigint(&raw_hash);
         let mut hasher = DefaultHasher::new();
         raw_hash.hash(&mut hasher);
@@ -362,7 +362,7 @@ impl DictKey for &str {
             Ok(py_str_value.as_str() == self)
         } else {
             // Fall back to PyString implementation.
-            let s = vm.new_str(self.to_string());
+            let s = vm.new_str(self.to_owned());
             s.do_eq(vm, other_key)
         }
     }
@@ -438,7 +438,7 @@ mod tests {
     fn check_hash_equivalence(text: &str) {
         let vm: VirtualMachine = Default::default();
         let value1 = text;
-        let value2 = vm.new_str(value1.to_string());
+        let value2 = vm.new_str(value1.to_owned());
 
         let hash1 = value1.do_hash(&vm).expect("Hash should not fail.");
         let hash2 = value2.do_hash(&vm).expect("Hash should not fail.");

diff --git a/vm/src/eval.rs b/vm/src/eval.rs
@@ -4,7 +4,7 @@ use crate::vm::VirtualMachine;
 use rustpython_compiler::compile;
 
 pub fn eval(vm: &VirtualMachine, source: &str, scope: Scope, source_path: &str) -> PyResult {
-    match vm.compile(source, compile::Mode::Eval, source_path.to_string()) {
+    match vm.compile(source, compile::Mode::Eval, source_path.to_owned()) {
         Ok(bytecode) => {
             debug!("Code object: {:?}", bytecode);
             vm.run_code_obj(bytecode, scope)

diff --git a/vm/src/exceptions.rs b/vm/src/exceptions.rs
@@ -225,7 +225,7 @@ fn print_source_line<W: Write>(output: &mut W, filename: &str, lineno: usize) ->
 
 /// Print exception occurrence location from traceback element
 fn write_traceback_entry<W: Write>(output: &mut W, tb_entry: &PyTracebackRef) -> io::Result<()> {
-    let filename = tb_entry.frame.code.source_path.to_string();
+    let filename = tb_entry.frame.code.source_path.to_owned();
     writeln!(
         output,
         r##"  File "{}", line {}, in {}"##,

diff --git a/vm/src/format.rs b/vm/src/format.rs
@@ -614,7 +614,7 @@ impl FormatString {
         let arg_part = parts[0];
 
         let format_spec = if parts.len() > 1 {
-            parts[1].to_string()
+            parts[1].to_owned()
         } else {
             String::new()
         };
@@ -638,7 +638,7 @@ impl FormatString {
         if let Ok(index) = arg_part.parse::<usize>() {
             Ok(FormatPart::IndexSpec(index, format_spec))
         } else {
-            Ok(FormatPart::KeywordSpec(arg_part.to_string(), format_spec))
+            Ok(FormatPart::KeywordSpec(arg_part.to_owned(), format_spec))
         }
     }
 

diff --git a/vm/src/frame.rs b/vm/src/frame.rs
@@ -1154,7 +1154,7 @@ impl Frame {
             .new_pyfunction(code_obj, scope, defaults, kw_only_defaults);
 
         let name = qualified_name.as_str().split('.').next_back().unwrap();
-        vm.set_attr(&func_obj, "__name__", vm.new_str(name.to_string()))?;
+        vm.set_attr(&func_obj, "__name__", vm.new_str(name.to_owned()))?;
         vm.set_attr(&func_obj, "__qualname__", qualified_name)?;
         let module = self
             .scope
@@ -1319,13 +1319,13 @@ impl Frame {
     fn store_attr(&self, vm: &VirtualMachine, attr_name: &str) -> FrameResult {
         let parent = self.pop_value();
         let value = self.pop_value();
-        vm.set_attr(&parent, vm.new_str(attr_name.to_string()), value)?;
+        vm.set_attr(&parent, vm.new_str(attr_name.to_owned()), value)?;
         Ok(None)
     }
 
     fn delete_attr(&self, vm: &VirtualMachine, attr_name: &str) -> FrameResult {
         let parent = self.pop_value();
-        let name = vm.ctx.new_str(attr_name.to_string());
+        let name = vm.ctx.new_str(attr_name.to_owned());
         vm.del_attr(&parent, name)?;
         Ok(None)
     }

diff --git a/vm/src/import.rs b/vm/src/import.rs
@@ -91,7 +91,7 @@ pub fn import_codeobj(
     set_file_attr: bool,
 ) -> PyResult {
     let attrs = vm.ctx.new_dict();
-    attrs.set_item("__name__", vm.new_str(module_name.to_string()), vm)?;
+    attrs.set_item("__name__", vm.new_str(module_name.to_owned()), vm)?;
     if set_file_attr {
         attrs.set_item("__file__", vm.new_str(code_obj.source_path.to_owned()), vm)?;
     }

diff --git a/vm/src/obj/objbool.rs b/vm/src/obj/objbool.rs
@@ -96,7 +96,7 @@ The class bool is a subclass of the class int, and cannot be subclassed.";
         "__rand__" => context.new_method(bool_and),
         "__xor__" => context.new_method(bool_xor),
         "__rxor__" => context.new_method(bool_xor),
-        "__doc__" => context.new_str(bool_doc.to_string()),
+        "__doc__" => context.new_str(bool_doc.to_owned()),
     });
 }
 

diff --git a/vm/src/obj/objbyteinner.rs b/vm/src/obj/objbyteinner.rs
@@ -442,7 +442,7 @@ impl PyByteInner {
                 i @ PyMemoryView => Ok(i.try_value().unwrap()),
                 _ => Err(vm.new_index_error(
                     "can assign only bytes, buffers, or iterables of ints in range(0, 256)"
-                        .to_string()
+                        .to_owned()
                 )),
             }),
         };

diff --git a/vm/src/obj/objdict.rs b/vm/src/obj/objdict.rs
@@ -524,7 +524,7 @@ macro_rules! dict_iterator {
                     let mut str_parts = vec![];
                     for (key, value) in zelf.dict.clone() {
                         let s = vm.to_repr(&$result_fn(vm, &key, &value))?;
-                        str_parts.push(s.as_str().to_string());
+                        str_parts.push(s.as_str().to_owned());
                     }
                     format!("{}([{}])", $class_name, str_parts.join(", "))
                 } else {

diff --git a/vm/src/obj/objint.rs b/vm/src/obj/objint.rs
@@ -94,7 +94,7 @@ macro_rules! impl_try_from_object_int {
                         vm.new_overflow_error(concat!(
                             "Int value cannot fit into Rust ",
                             stringify!($t)
-                        ).to_string())
+                        ).to_owned())
                     ),
                 }
             }

diff --git a/vm/src/obj/objlist.rs b/vm/src/obj/objlist.rs
@@ -453,7 +453,7 @@ impl PyList {
             let mut str_parts = Vec::with_capacity(zelf.elements.borrow().len());
             for elem in zelf.elements.borrow().iter() {
                 let s = vm.to_repr(elem)?;
-                str_parts.push(s.as_str().to_string());
+                str_parts.push(s.as_str().to_owned());
             }
             format!("[{}]", str_parts.join(", "))
         } else {