Make structs work again

Author: Victorious3

src/typechecking.pr

@@ -293,37 +293,37 @@ export def resolve(typeref: &TypeRef, scpe: &Scope, error_on_fail: bool = true)
         return typeref.tpe
     }
     if typeref.name {
-        let id = scope::get_type_id(scpe, parser::make_identifier(typeref.name), error_on_fail = error_on_fail)
+        let id = scope::get_type_id(scpe, parser::identifier_from_str(typeref.name), error_on_fail)
         typeref.tpe = id
         return id
     }
     if typeref.pattern {
-        let id = resolve_generic(typeref.pattern, scpe)
+        let id = resolve_generic(typeref.pattern, scpe, error_on_fail)
         typeref.tpe = id
         return id
     }
 }
 
-def resolve_generic(generic: &Pattern, scpe: &Scope) -> TypeId {
+def resolve_generic(generic: &Pattern, scpe: &Scope, error_on_fail: bool = true) -> TypeId {
     switch generic.kind {
         case TypeKind::ARRAY
-            return array(resolve(generic.tpe, scpe))
+            return array(resolve(generic.tpe, scpe, error_on_fail))
         case TypeKind::STATIC_ARRAY
-            return static_array(resolve(generic.tpe, scpe), generic.length, generic.kw)
+            return static_array(resolve(generic.tpe, scpe, error_on_fail), generic.length, generic.kw)
         case TypeKind::POINTER
-            return pointer(resolve(generic.tpe, scpe), generic.kw)
+            return pointer(resolve(generic.tpe, scpe, error_on_fail), generic.kw)
         case TypeKind::REFERENCE
-            return reference(resolve(generic.tpe, scpe), generic.kw)
+            return reference(resolve(generic.tpe, scpe, error_on_fail), generic.kw)
         case TypeKind::WEAK_REF
-            return weak_reference(resolve(generic.tpe, scpe), generic.kw)
+            return weak_reference(resolve(generic.tpe, scpe, error_on_fail), generic.kw)
         case TypeKind::FUNCTION, TypeKind::CLOSURE
             var params: &Vector(NamedParameter) = vector::make(NamedParameter)
             for var param in generic.parameter_t {
-                vector::push(params, [tpe = resolve(param.tpe, scpe)] !NamedParameter)
+                vector::push(params, [tpe = resolve(param.tpe, scpe, error_on_fail)] !NamedParameter)
             }
             var return_ids: &Vector(TypeId) = vector::make(TypeId)
             for var ret in generic.return_t {
-                vector::push(return_ids, resolve(ret, scpe))
+                vector::push(return_ids, resolve(ret, scpe, error_on_fail))
             }
             if generic.kind == TypeKind::CLOSURE {
                 return closure(params, return_ids)
@@ -333,7 +333,7 @@ def resolve_generic(generic: &Pattern, scpe: &Scope) -> TypeId {
         case TypeKind::TUPLE, TypeKind::TUNION
             var param_ids: &Vector(TypeId) = vector::make(TypeId)
             for var param in generic.parameter_t {
-                vector::push(param_ids, resolve(param.tpe, scpe))
+                vector::push(param_ids, resolve(param.tpe, scpe, error_on_fail))
             }
             if generic.kind == TypeKind::TUPLE {
                 return tuple(param_ids)
@@ -345,15 +345,15 @@ def resolve_generic(generic: &Pattern, scpe: &Scope) -> TypeId {
             for var field in generic.fields {
                 vector::push(fields, [
                     name = field.name,
-                    tpe = resolve(field.tpe, scpe),
+                    tpe = resolve(field.tpe, scpe, error_on_fail),
                     properties = field.properties
                 ] !StructMember)
             }
             var const_fields: &Vector(StructMember) = vector::make(StructMember)
             for var field in generic.const_fields {
                 vector::push(const_fields, [
                     name = field.name,
-                    tpe = resolve(field.tpe, scpe),
+                    tpe = resolve(field.tpe, scpe, error_on_fail),
                     properties = field.properties
                 ] !StructMember)
             }
@@ -2347,7 +2347,7 @@ export def convert_type_score(a: &TypeRef, b: &Type, scpe: &scope::Scope, impl:
     if a.pattern {
         return convert_type_score(a.pattern, b, scpe, impl)
     } else if a.name {
-        if scope::get_type(scpe, parser::make_identifier(a.name)) { return 1 }
+        if scope::get_type(scpe, parser::identifier_from_str(a.name)) { return 1 }
     } else {
         return convert_type_score(a.resolve(scpe), b, scpe, impl)
     }
@@ -2360,7 +2360,7 @@ export def convert_type_score(a: &Pattern, b: &Type, scpe: &scope::Scope, impl:
                 return 1
             } else { return -1 }
         } else if a.name {
-            scope::create_type(scpe, parser::make_identifier(a.name), parser::ShareMarker::NONE, make_type_ref(b.id))
+            scope::create_type(scpe, parser::identifier_from_str(a.name), parser::ShareMarker::NONE, make_type_ref(b.id))
         }
         return 1
     }
@@ -3428,9 +3428,9 @@ def do_type_lookup(node: &parser::Node, state: &State, is_type: bool = false) ->
         } else /*if not lookup_default*/ {
             let value = scope::get(state.scope, node)
             if not value {
-                errors::errorn(node, "Unknown identifier `", name, "`")
+                //errors::errorn(node, "Unknown identifier `", name, "`")
                 scope::create_dependency(state.current_value(), scope::make_ident(name))
-                return null
+                return make_type_ref(name)
             } else {
                 if value.modifier != parser::VarDecl::TYPE { return null }
 
@@ -3824,35 +3824,35 @@ def do_type_lookup(node: &parser::Node, state: &State, is_type: bool = false) ->
 
 // Returns the common type of two arithmetic types
 // byte -> ubyte -> short -> ushort -> int -> uint -> long -> ulong
-export def common_type(a: TypeId, b: TypeId) -> TypeId {
+export def common_type(a: &Type, b: &Type) -> TypeId {
     if not a or not b { return 0 }
 
     //TODO Should cause an error
     //assert(is_arithmetic(a) and is_arithmetic(b))
 
     if a.kind == TypeKind::FLOAT and (b.kind == TypeKind::WORD or b.kind == TypeKind::CHAR) {
-        return a
+        return a.id
     } else if (a.kind == TypeKind::WORD or a.kind == TypeKind::CHAR) and b.kind == TypeKind::FLOAT {
-        return b
+        return b.id
     } else if a.kind == TypeKind::BOOL and is_arithmetic(b) {
-        return a
+        return a.id
     } else if b.kind == TypeKind::BOOL and is_arithmetic(a) {
-        return b
+        return b.id
     }
 
     if is_arithmetic(a) and is_arithmetic(b) {
-        let a_size = a.resolve().size
-        let b_size = b.resolve().size
+        let a_size = a.size
+        let b_size = b.size
         if a_size == b_size {
-            if b.resolve().unsig {
-                return b
+            if b.unsig {
+                return b.id
             } else {
-                return a
+                return a.id
             }
         } else if a_size > b_size {
-            return a 
+            return a.id
         } else {
-            return b
+            return b.id
         }
     }
     return 0
@@ -6435,17 +6435,17 @@ def walk_MemberAccess_ucs(node: &parser::Node, state: &State) -> bool {
         }
     }
 }
-
-def resolve_member(tpe: &Type, name: String) -> &Type {
+*/
+def resolve_member(tpe: &Type, name: String) -> TypeId {
     for var member in @tpe.fields {
         if member.name {
             if member.name == name {
-                lookup_struct_member(member)
+                //lookup_struct_member(member)
                 return member.tpe
             }
         } else {
             var tpe = member.tpe
-            if member.is_embed and is_ref(member.tpe) {
+            if member.properties.is_embed and is_ref(member.tpe) {
                 tpe = member.tpe.tpe
             }
             let member = resolve_member(tpe, name)
@@ -6457,8 +6457,8 @@ def resolve_member(tpe: &Type, name: String) -> &Type {
             return member.tpe
         }
     }
-    return null
-}*/
+    return 0
+}
 
 def walk_MemberAccess(node: &parser::Node, state: &State) {
     let left = node.value.bin_op.left
@@ -6519,15 +6519,15 @@ def walk_MemberAccess_aggregate(node: &parser::Node, ucs: bool, state: &State) -
 
     if tpe.kind == TypeKind::STRUCT or tpe.kind == TypeKind::UNION {
         let name = last_ident_to_str(right)
-
-        if not tpe {
+        let rtpe = resolve_member(tpe, name)
+        if not rtpe {
             if ucs {
                 if walk_MemberAccess_ucs(node, state) { return true }
                 errors::errorn(node, "Unknown field `", name, "` on type ", debug::type_to_str(left.tpe))
             }
             return false
         }
-        node.tpe = tpe
+        node.tpe = rtpe
     } else if tpe.kind == TypeKind::ARRAY or tpe.kind == TypeKind::STATIC_ARRAY {
         let name = last_ident_to_str(right)
         if name == "size" {