Combined updates giving effect to latest proposals

Author: eggyal

crates/backend/src/ast.rs

@@ -139,10 +139,17 @@ pub enum ImportFunctionKind {
     Normal,
 }
 
+#[cfg_attr(feature = "extra-traits", derive(Debug))]
+#[derive(Clone)]
+pub enum SuperArgs {
+    Constant(syn::ExprArray),
+    Dynamic(syn::Path),
+}
+
 #[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq))]
 #[derive(Clone)]
 pub enum MethodKind {
-    Constructor,
+    Constructor(Option<SuperArgs>),
     Operation(Operation),
 }
 

crates/backend/src/codegen.rs

@@ -13,6 +13,10 @@ use wasm_bindgen_shared as shared;
 pub trait TryToTokens {
     fn try_to_tokens(&self, tokens: &mut TokenStream) -> Result<(), Diagnostic>;
 
+    fn try_identifier_to_tokens(&self, _: &mut TokenStream) -> Result<(), Diagnostic> {
+        Ok(())
+    }
+
     fn try_to_token_stream(&self) -> Result<TokenStream, Diagnostic> {
         let mut tokens = TokenStream::new();
         self.try_to_tokens(&mut tokens)?;
@@ -101,11 +105,8 @@ impl TryToTokens for ast::Program {
         prefix_bytes.push((prefix_json.len() >> 24) as u8);
         prefix_bytes.extend_from_slice(prefix_json.as_bytes());
 
-        let generated_static_length =
-            prefix_bytes.len() +
-            custom_section.iter().map(encode::EncodePart::len).sum::<usize>()
-        ;
-        
+        let generated_static_length = prefix_bytes.len() + encoded.size as usize;
+
         // We already consumed the contents of included files when generating
         // the custom section, but we want to make sure that updates to the
         // generated files will cause this macro to rerun incrementally. To do
@@ -128,25 +129,37 @@ impl TryToTokens for ast::Program {
             pub static #generated_static_name: [u8; #generated_static_length] = {
                 static _INCLUDED_FILES: &[&str] = &[#(#file_dependencies),*];
 
-                [ #(#prefix_bytes),* , #(#custom_section),* ]
+                [ #(#prefix_bytes),* , #custom_section ]
             };
 
         })
         .to_tokens(tokens);
 
         Ok(())
     }
+
+    fn try_identifier_to_tokens(&self, tokens: &mut TokenStream) -> Result<(), Diagnostic> {
+        let mut errors = Vec::new();
+
+        for export in self.exports.iter() {
+            if let Err(e) = export.try_identifier_to_tokens(tokens) {
+                errors.push(e);
+            }
+        }
+        
+        Diagnostic::from_vec(errors)?;
+        Ok(())
+    }
 }
 
 fn gen_id() -> [u8; 8] {
-    use ::std::time::{SystemTime, UNIX_EPOCH};
-
-    let duration = SystemTime::now().duration_since(UNIX_EPOCH).unwrap();
-    
-    let mut bytes = duration.as_secs().to_be_bytes();
-    bytes[0..4].copy_from_slice(&duration.subsec_nanos().to_be_bytes());
-    
-    bytes
+    static CNT: AtomicUsize = AtomicUsize::new(0);
+    u64::from_str_radix(
+        &ShortHash(CNT.fetch_add(1, Ordering::SeqCst)).to_string(),
+        16
+    )
+    .unwrap()
+    .to_be_bytes()
 }
 
 impl ToTokens for ast::Struct {
@@ -277,6 +290,29 @@ impl ToTokens for ast::Struct {
         })
         .to_tokens(tokens);
 
+        if let Some(parent) = &self.parent {
+            (quote!{
+                impl From<#name> for #parent {
+                    fn from(child: #name) -> #parent {
+                        unimplemented!()
+                    }
+                }
+
+                impl AsRef<#parent> for #name {
+                    fn as_ref(&self) -> &#parent {
+                        unimplemented!()
+                    }
+                }
+
+                impl AsMut<#parent> for #name {
+                    fn as_mut(&mut self) -> &mut #parent {
+                        unimplemented!()
+                    }
+                }
+            })
+            .to_tokens(tokens);
+        }
+
         for field in self.fields.iter() {
             field.to_tokens(tokens);
         }
@@ -481,6 +517,11 @@ impl TryToTokens for ast::Export {
             quote! {}
         };
 
+        let const_name = encode::lookup_constant_for_fn(name);
+        let id_bytes = gen_id();
+
+        (quote! { const #const_name: [u8; 8] = [#(#id_bytes),*]; }).to_tokens(into);
+
         (quote! {
             #(#attrs)*
             #[export_name = #export_name]
@@ -532,6 +573,15 @@ impl TryToTokens for ast::Export {
 
         Ok(())
     }
+
+    fn try_identifier_to_tokens(self: &ast::Export, into: &mut TokenStream) -> Result<(), Diagnostic> {
+        let const_name = encode::lookup_constant_for_fn(&self.rust_name);
+        let id_bytes = gen_id();
+
+        (quote! { const #const_name: [u8; 8] = [#(#id_bytes),*]; }).to_tokens(into);
+
+        Ok(())
+    }
 }
 
 impl TryToTokens for ast::ImportKind {
@@ -1014,7 +1064,12 @@ impl TryToTokens for ast::ImportFunction {
             &self.rust_name,
         );
 
+        let const_name = encode::lookup_constant_for_fn(&self.rust_name);
+        let id_bytes = gen_id();
+
         let invocation = quote! {
+            const #const_name: [u8; 8] = [#(#id_bytes),*];
+
             #(#attrs)*
             #[allow(bad_style)]
             #[doc = #doc_comment]