Remove lazy_static, just store as a CodeObject

Author: coolreader18

derive/src/compile_bytecode.rs

@@ -51,17 +51,11 @@ struct PyCompileInput {
     metas: Vec<Meta>,
 }
 
-struct PyCompileResult {
-    code_obj: CodeObject,
-    lazy_static: bool,
-}
-
 impl PyCompileInput {
-    fn compile(&self) -> Result<PyCompileResult, Diagnostic> {
+    fn compile(&self) -> Result<CodeObject, Diagnostic> {
         let mut source_path = None;
         let mut mode = None;
         let mut source: Option<CompilationSource> = None;
-        let mut lazy_static = false;
 
         fn assert_source_empty(source: &Option<CompilationSource>) -> Result<(), Diagnostic> {
             if let Some(source) = source {
@@ -114,16 +108,11 @@ impl PyCompileInput {
                         });
                     }
                 }
-                Meta::Word(ident) => {
-                    if ident == "lazy_static" {
-                        lazy_static = true;
-                    }
-                }
                 _ => {}
             }
         }
 
-        let code_obj = source
+        source
             .ok_or_else(|| {
                 Diagnostic::span_error(
                     self.span.clone(),
@@ -133,12 +122,7 @@ impl PyCompileInput {
             .compile(
                 &mode.unwrap_or(compile::Mode::Exec),
                 source_path.unwrap_or_else(|| "frozen".to_string()),
-            )?;
-
-        Ok(PyCompileResult {
-            code_obj,
-            lazy_static,
-        })
+            )
     }
 }
 
@@ -156,10 +140,7 @@ impl Parse for PyCompileInput {
 pub fn impl_py_compile_bytecode(input: TokenStream2) -> Result<TokenStream2, Diagnostic> {
     let input: PyCompileInput = parse2(input)?;
 
-    let PyCompileResult {
-        code_obj,
-        lazy_static,
-    } = input.compile()?;
+    let code_obj = input.compile()?;
 
     let bytes = bincode::serialize(&code_obj).expect("Failed to serialize");
     let bytes = LitByteStr::new(&bytes, Span::call_site());
@@ -172,17 +153,5 @@ pub fn impl_py_compile_bytecode(input: TokenStream2) -> Result<TokenStream2, Dia
         })
     };
 
-    if lazy_static {
-        Ok(quote! {
-            ({
-                use ::lazy_static::lazy_static;
-                lazy_static! {
-                    static ref STATIC: ::rustpython_vm::bytecode::CodeObject = #output;
-                }
-                &*STATIC
-            })
-        })
-    } else {
-        Ok(output)
-    }
+    Ok(output)
 }

vm/src/frozen.rs

@@ -1,18 +1,15 @@
 use crate::bytecode::CodeObject;
 use std::collections::HashMap;
 
-pub fn get_module_inits() -> HashMap<&'static str, &'static CodeObject> {
+pub fn get_module_inits() -> HashMap<String, CodeObject> {
     hashmap! {
-        "__hello__" => py_compile_bytecode!(
-            lazy_static,
+        "__hello__".into() => py_compile_bytecode!(
             source = "initialized = True; print(\"Hello world!\")\n",
         ),
-        "_frozen_importlib" => py_compile_bytecode!(
-            lazy_static,
+        "_frozen_importlib".into() => py_compile_bytecode!(
             file = "../Lib/importlib/_bootstrap.py",
         ),
-        "_frozen_importlib_external" => py_compile_bytecode!(
-            lazy_static,
+        "_frozen_importlib_external".into() => py_compile_bytecode!(
             file = "../Lib/importlib/_bootstrap_external.py",
         ),
     }

vm/src/import.rs

@@ -25,7 +25,7 @@ pub fn init_importlib(vm: &VirtualMachine) -> PyResult {
 }
 
 pub fn import_frozen(vm: &VirtualMachine, module_name: &str) -> PyResult {
-    if let Some(&frozen) = vm.frozen.borrow().get(module_name) {
+    if let Some(frozen) = vm.frozen.borrow().get(module_name) {
         let mut frozen = frozen.clone();
         frozen.source_path = format!("frozen {}", module_name);
         import_codeobj(vm, module_name, frozen)

vm/src/stdlib/imp.rs

@@ -58,7 +58,7 @@ fn imp_get_frozen_object(name: PyStringRef, vm: &VirtualMachine) -> PyResult<PyC
     vm.frozen
         .borrow()
         .get(name.as_str())
-        .map(|&frozen| {
+        .map(|frozen| {
             let mut frozen = frozen.clone();
             frozen.source_path = format!("frozen {}", name.as_str());
             PyCode::new(frozen)

vm/src/vm.rs

@@ -53,7 +53,7 @@ pub struct VirtualMachine {
     pub frames: RefCell<Vec<FrameRef>>,
     pub wasm_id: Option<String>,
     pub exceptions: RefCell<Vec<PyObjectRef>>,
-    pub frozen: RefCell<HashMap<&'static str, &'static bytecode::CodeObject>>,
+    pub frozen: RefCell<HashMap<String, bytecode::CodeObject>>,
     pub import_func: RefCell<PyObjectRef>,
 }