Fix some stuff

Author: Victorious3

src/consteval.pr

@@ -577,6 +577,14 @@ export def walk_TypeDecl(node: &parser::Node, state: &typechecking::State) {
                 typechecking::register(tpe, enum_tpe)
             } else {
                 left.svalue = scope::create_type(state.scope, name, share, typechecking::make_type_ref(tpe), scope::Phase::DEFINED, typedef)
+                // Register stub type that can be replaced later on demand
+                let stub = [ 
+                    kind = typechecking::TypeKind::STUB, 
+                    id = tpe,
+                    defmodule = state.module, 
+                    type_name = parser::identifier_to_str(name) 
+                ] !&typechecking::Type
+                register(tpe, stub)
             }
             value.tpe = tpe
         } else {

src/toolchain.pr

@@ -859,6 +859,7 @@ export def compile_main_file(filename: String) {
             let filename = keys(i)
             let module = modules(filename)
             if module.module == "builtin" or not (module.is_dirty or no_incremental) { continue }
+            if no_stdlib and (module.module == "runtime" or module.module == "optional") { continue }
             codegen::gen(module)
         }
 
@@ -894,6 +895,7 @@ export def compile_main_file(filename: String) {
             let filename = keys(i)
             let module = modules(filename)
             if module.module == "builtin" or not (module.is_dirty or no_incremental) { continue }
+            if no_stdlib and (module.module == "runtime" or module.module == "optional") { continue }
 
             var combine = false
             if module.module != "type" and module.is_dirty and not no_incremental {
@@ -965,6 +967,7 @@ export def compile_main_file(filename: String) {
             let filename = keys2(i)
             let module = modules(filename)
             if module.module == "builtin" { continue }
+            if no_stdlib and (module.module == "runtime" or module.module == "optional") { continue }
             link_command += outfolder + "/" + module.file + ".o "
         }
 

src/typechecking.pr

@@ -44,8 +44,8 @@ export type TypeKind = enum {
     TYPE_CONSTRUCTOR
     // For patterns that are type instances
     TYPE_INSTANCE
-    // Forward declaration
-    // STUB
+    // Type placeholder for types that haven't been compiled yet
+    STUB
     // Placeholder for arguments with polymorphic type parameter in function definition
     TYPE_DEF
     // Reference to a type
@@ -335,6 +335,13 @@ export def kind(typeref: &TypeRef) -> TypeKind {
 export def resolve(typeref: &TypeRef, scpe: &Scope, error_on_fail: bool = true) -> TypeId {
     if not typeref { return 0 }
     if typeref.tpe {
+        let actual = typeref.tpe.resolve()
+        if actual and actual.kind == TypeKind::STUB {
+            // Lookup stub types on demand
+            let id = scope::get_type_id(actual.defmodule.scope, parser::identifier_from_str(actual.type_name), error_on_fail)
+            assert id == typeref.tpe           
+            return id
+        }
         return typeref.tpe
     }
     if typeref.name {
@@ -570,7 +577,7 @@ export def equals(this: &Pattern, other: &Pattern, env: &EqEnv = null) -> bool {
                 }
             }
             return true
-        case TypeKind::TUPLE, TypeKind::TUNION
+        case TypeKind::TUPLE, TypeKind::TUNION, TypeKind::TYPE_INSTANCE
             if this.return_t.length() != other.return_t.length() {
                 return false
             }
@@ -2532,9 +2539,9 @@ export def convert_type_score(a: &TypeRef, b: &Type, scpe: &scope::Scope, impl:
     if not a or not b { return 0 }
     if a.pattern {
         return convert_type_score(a.pattern, b, scpe, impl)
-    } /*else if a.name {
+    } else if a.name {
         if scope::get_type(scpe, parser::identifier_from_str(a.name)) { return 1 }
-    }*/ else {
+    } else {
         return convert_type_score(a.resolve(scpe), b, scpe, impl)
     }
 }
@@ -2977,12 +2984,17 @@ export def is_polymorph(tpe: &TypeRef) -> bool {
             } else {
                 return is_polymorph(pattern.tpe)
             }
-        } else if pattern.kind == TypeKind::TUPLE or pattern.kind == TypeKind::TUNION {
+        } else if pattern.kind == TypeKind::TUPLE or 
+            pattern.kind == TypeKind::TUNION or 
+            pattern.kind == TypeKind::TYPE_INSTANCE {
+                
             for var tpe in pattern.return_t {
                 if is_polymorph(tpe) { return true }
             }
             return false
         }
+    } else if tpe.name {
+        return true
     }
     return false
 }
@@ -5696,7 +5708,7 @@ export def walk_TypeDecl(node: &parser::Node, state: &State) {
             type_value.defmodule = state.module
 
             type_value.name = parser::identifier_to_str(name)
-            print("Registered type ", type_value.name, " with id ", tpe, "\n")
+            //print("Registered type ", type_value.name, " with id ", tpe, "\n")
             if value.kind != parser::NodeKind::TYPE_CONSTRUCTOR {
                 type_value.type_name = append_module(type_value.name, node.loc.module)
             }
@@ -7499,14 +7511,14 @@ export def typecheck(state: &State) {
     //lookup_stub_types(state)
 
     // Typcheck Type decls
-    for var i in 0..vector::length(node.body) {
+    /*for var i in 0..vector::length(node.body) {
         let n = node.body(i)
         switch n.kind !int {
             case parser::NodeKind::TYPE_DECL
                 n.parent = node
                 walk_TypeDecl(n, state)
         }
-    }
+    }*/
 
     typecheck(node, state)