Get rid of proc-macro-hacky stuff for py_compile_bytecode

derive/src/compile_bytecode.rs

@@ -274,6 +274,8 @@ pub fn impl_py_compile_bytecode(input: TokenStream2) -> Result<TokenStream2, Dia
     let crate_name = args.crate_name;
     let code_map = args.source.compile(args.mode, args.module_name)?;
 
+    let modules_len = code_map.len();
+
     let modules = code_map
         .into_iter()
         .map(|(module_name, FrozenModule { code, package })| {
@@ -281,22 +283,21 @@ pub fn impl_py_compile_bytecode(input: TokenStream2) -> Result<TokenStream2, Dia
             let bytes = code.to_bytes();
             let bytes = LitByteStr::new(&bytes, Span::call_site());
             quote! {
-                #module_name.into() => ::#crate_name::bytecode::FrozenModule {
+                m.insert(#module_name.into(), ::#crate_name::bytecode::FrozenModule {
                     code: ::#crate_name::bytecode::CodeObject::from_bytes(
                         #bytes
                     ).expect("Deserializing CodeObject failed"),
                     package: #package,
-                }
+                });
             }
         });
 
     let output = quote! {
-        ({
-            use ::#crate_name::__exports::hashmap;
-            hashmap! {
-                #(#modules),*
-            }
-        })
+        {
+            let mut m = ::std::collections::HashMap::with_capacity(#modules_len);
+            #(#modules)*
+            m
+        }
     };
 
     Ok(output)

derive/src/lib.rs

@@ -59,17 +59,7 @@ pub fn pystruct_sequence(attr: TokenStream, item: TokenStream) -> TokenStream {
     result_to_tokens(pyclass::impl_pystruct_sequence(attr, item))
 }
 
-fn result_to_tokens_expr(result: Result<TokenStream2, Diagnostic>) -> TokenStream {
-    let tokens2 = result.unwrap_or_else(ToTokens::into_token_stream);
-    let ret = quote::quote! {
-        macro_rules! __proc_macro_call {
-            () => {{ #tokens2 }}
-        }
-    };
-    ret.into()
-}
-
 #[proc_macro]
 pub fn py_compile_bytecode(input: TokenStream) -> TokenStream {
-    result_to_tokens_expr(compile_bytecode::impl_py_compile_bytecode(input.into()))
+    result_to_tokens(compile_bytecode::impl_py_compile_bytecode(input.into()))
 }

vm/src/lib.rs

@@ -33,20 +33,6 @@ extern crate self as rustpython_vm;
 
 pub use rustpython_derive::*;
 
-#[doc(hidden)]
-pub use rustpython_derive::py_compile_bytecode as _py_compile_bytecode;
-
-#[macro_export]
-macro_rules! py_compile_bytecode {
-    ($($arg:tt)*) => {{
-        #[macro_use]
-        mod __m {
-            $crate::_py_compile_bytecode!($($arg)*);
-        }
-        __proc_macro_call!()
-    }};
-}
-
 //extern crate eval; use eval::eval::*;
 // use py_code_object::{Function, NativeType, PyCodeObject};
 
@@ -90,6 +76,5 @@ pub use rustpython_common as common;
 
 #[doc(hidden)]
 pub mod __exports {
-    pub use maplit::hashmap;
     pub use smallbox::smallbox;
 }