Fix the newtype attribute for VmType derive

Author: Marwes

base/src/ast.rs

@@ -988,6 +988,7 @@ pub fn walk_ast_type<'a, 'ast, V: ?Sized + $trait_name<'a, 'ast>>(
             ref $($mut)* rest,
         } => {
             for field in & $($mut)* **fields {
+                v.visit_spanned_ident(& $($mut)* field.name);
                 v.visit_ast_type(&$($mut)* field.typ);
             }
             v.visit_ast_type(rest);
@@ -997,6 +998,7 @@ pub fn walk_ast_type<'a, 'ast, V: ?Sized + $trait_name<'a, 'ast>>(
             ref $($mut)* rest,
         } => {
             for field in & $($mut)* **types {
+                v.visit_spanned_ident(& $($mut)* field.name);
                 if let Some(alias) = field.typ.$try_get_alias() {
                     v.visit_ast_type(alias.$unresolved_type());
                 }

check/src/metadata.rs

@@ -304,15 +304,15 @@ pub fn metadata(
                         let maybe_metadata =
                             MaybeMetadata::merge_base(&field.metadata, &maybe_metadata);
                         if let MaybeMetadata::Data(metadata) = maybe_metadata {
-                            let field_name = String::from(field.name.value.as_ref() as &str);
+                            let field_name = String::from(field.name.value.as_pretty_str());
                             module.insert(field_name, metadata);
                         }
                     }
 
                     for field in &**types {
                         let maybe_metadata = self.metadata(&field.name.value);
                         if let MaybeMetadata::Data(metadata) = maybe_metadata.into() {
-                            let name = Name::new(field.name.value.as_ref() as &str).name().as_str();
+                            let name = Name::new(field.name.value.as_pretty_str()).name().as_str();
                             module.insert(String::from(name), metadata);
                         }
                     }
@@ -399,7 +399,8 @@ pub fn metadata(
                         }
                         None => field_metadata,
                     };
-                    field_metadata.map(|m| (field.name.to_string(), Arc::new(m)))
+                    field_metadata
+                        .map(|m| (String::from(field.name.value.as_pretty_str()), Arc::new(m)))
                 })
                 .collect();
 

codegen/src/vm_type.rs

@@ -183,8 +183,8 @@ fn gen_impl(container: &Container, ident: Ident, generics: Generics, data: &Data
         });
 
         quote! {
-            let ty = if let Ok(ty) = vm.find_type_info(stringify!(#ident)) {
-                ty.into_type()
+            let ty = if let Some(ty) = vm.get_cache_alias(stringify!(#ident)) {
+                ty
             } else {
                 let ty = _gluon_base::types::Alias::new(
                     _gluon_base::symbol::Symbol::from(stringify!(#ident)),

src/std_lib/regex.rs

@@ -87,7 +87,8 @@ pub fn load(vm: &Thread) -> vm::Result<ExternModule> {
             new => primitive!(1, std::regex::prim::new),
             is_match => primitive!(2, std::regex::prim::is_match),
             find => primitive!(2, std::regex::prim::find),
-            captures => primitive!(2, std::regex::prim::captures),
+            // Workaround MIR bug in rustc
+            captures => primitive!(2, "std.regex.prim.captures", |x, y| std::regex::prim::captures(x, y)),
             error_to_string => primitive!(1, std::regex::prim::error_to_string)
         },
     )

vm/src/api/record.rs

@@ -84,7 +84,12 @@ where
         let field_name = Symbol::from(alias_name.declared_name());
 
         let mut rhs_is_equivalent = None;
-        if let Type::App(f, a) = &*typ {
+        {
+            let (f, a) = if let Type::App(f, a) = &*typ {
+                (f, &a[..])
+            } else {
+                (&typ, &[][..])
+            };
             if let Type::Alias(f) = &**f {
                 if f.name.declared_name() == field_name.declared_name()
                     && args.len() == a.len()

vm/src/thread.rs

@@ -890,6 +890,10 @@ impl Thread {
         self.global_env().register_type_as(name, alias, id)
     }
 
+    pub fn get_cache_alias(&self, name: &str) -> Option<ArcType> {
+        self.global_env().get_cache_alias(name)
+    }
+
     pub fn cache_alias(&self, alias: Alias<Symbol, ArcType>) -> ArcType {
         self.global_env().cache_alias(alias)
     }

vm/src/vm.rs

@@ -661,6 +661,17 @@ impl GlobalVmState {
         Ok(t)
     }
 
+    #[doc(hidden)]
+    pub fn get_cache_alias(&self, name: &str) -> Option<ArcType> {
+        let env = self.env.read();
+        env
+            .type_infos
+            .id_to_type
+            .get(name)
+            .map(|alias| alias.clone().into_type())
+    }
+
+    #[doc(hidden)]
     pub fn cache_alias(&self, alias: Alias<Symbol, ArcType>) -> ArcType {
         let mut env = self.env.write();
         let type_infos = &mut env.type_infos;