Update

Author: Victorious3

src/builtins.pr

@@ -182,7 +182,7 @@ scope::create_variable(
 )
 
 // This one gets set by toolchain
-export var File_: typechecking::TypeId
+//export var File_: typechecking::TypeId
 
 export var Type_: typechecking::TypeId
 export def type_t -> typechecking::TypeId {

src/compiler.pr

@@ -1085,7 +1085,9 @@ def make_return_type(rtpe: &typechecking::Type) -> typechecking::TypeId {
         return type_registry_return_types(rtpe.id).id
     }
 
-    assert typechecking::is_tuple(rtpe)
+    if not typechecking::is_tuple(rtpe) {
+        return 0
+    }
     let length = vector::length(rtpe.return_t)
     let fields = vector::make(typechecking::StructMember)
 
@@ -4130,6 +4132,10 @@ type Member = struct {
 
 // This list needs to be reversed to find the actual indices
 def resolve_member(vec: &Vector(Member), tpe: &typechecking::Type, name: Str) -> bool {
+    if not tpe { return false }
+    if tpe.kind == typechecking::TypeKind::REFERENCE {
+        tpe = tpe.tpe.resolve()
+    }
     let fields = tpe.fields
     if not fields { return false }
     for var i in 0..fields.length() {
@@ -6336,8 +6342,12 @@ def walk_Assert(node: &parser::Node, state: &State) {
     import_structures(scope::get(state.scope, parser::make_identifier("fprintf")).get_type(), state.module)
 
     let std_module = toolchain::find_module("std")
+    if not std_module { return }
     let stderr_fun = scope::get(std_module.scope, parser::make_identifier("stderr"))
     let print_stacktrace_fun = scope::get(std_module.scope, parser::make_identifier("print_stacktrace"))
+    predeclare_function(stderr_fun.fdef, state.module)
+    predeclare_function(print_stacktrace_fun.fdef, state.module)
+    
     //let fun = predeclare_function(stderr_fun, std_module)
     //state.module.result.functions[stderr_fun.type_name] = fun
 
@@ -6396,7 +6406,9 @@ def walk_Assert(node: &parser::Node, state: &State) {
         fmt = "%s:%d:%s: Unreachable!\n"
     }
 
-    let stderr = make_local_value(builtins::File_, null, state)
+    let file = stderr_fun.fdef.to_type().resolve().return_t(0)
+    import_structures(file, state.module)
+    let stderr = make_local_value(file, null, state)
     let mcall = make_insn_dbg(InsnKind::CALL, loc)
     mcall.value.call = [
         name = [
@@ -6421,7 +6433,7 @@ def walk_Assert(node: &parser::Node, state: &State) {
     args(4) = charp(function_name, state)
 
     let proto = allocate_ref(typechecking::NamedParameter, 3)
-    proto(0) = [ tpe = builtins::File_ ] !typechecking::NamedParameter
+    proto(0) = [ tpe = file ] !typechecking::NamedParameter
     proto(1) = [ tpe = typechecking::pointer(builtins::char_) ] !typechecking::NamedParameter
     proto(2) = [ varargs = true ] !typechecking::NamedParameter
 
@@ -7159,6 +7171,7 @@ export def predeclare_function(function: &Function, scpe: &scope::Scope, overwri
     function.args = vector::make(typechecking::NamedParameter)
     for var i in 0..vector::length(fdef.parameter_t) {
         let np = fdef.parameter_t(i)
+        if np.kw == parser::VarDecl::TYPE { continue }
         let restpe = np.tpe.resolve(scpe)
         if restpe {
             let resnp = [
@@ -9273,12 +9286,12 @@ def generate_reflection_data_2(tpe: &typechecking::Type, data: &ByteStream, stri
     case typechecking::TypeKind::INTERFACE
         for var member in tpe.members {
             for var np in member.parameter_t {
-                assert np.tpe.tpe
-                data.write(np.tpe.tpe !uint64)
+                assert np.tpe
+                data.write(np.tpe !uint64)
             }
             for var t in member.return_t {
-                assert t.tpe.tpe
-                data.write(t.tpe.tpe !uint64)
+                assert t
+                data.write(t !uint64)
             }
         }
     case typechecking::TypeKind::POINTER, typechecking::TypeKind::REFERENCE,
@@ -9521,7 +9534,7 @@ def generate_vtable_function(function: &Function, fdef: typechecking::FunctionDe
                 }
             }
 
-            if kind != 0 and implementor.kind != typechecking::TypeKind::STRUCT { continue }
+            if kind != 0 and implementor.kind != typechecking::TypeKind::REFERENCE { continue }
 
             if not consteval::is_static {
                 import_structure(implementor, state.module)

src/consteval.pr

@@ -814,6 +814,8 @@ export def compile_function(value: &scope::Value, context: &scope::Scope, argume
     var node = value.node
     var module = value.module
 
+    if not node { return value }
+
     /*var is_repurposed = false // When There's no node and we find a new function we don't need to typecheck anymore
     if not node {
         if not arguments { return value }
@@ -863,7 +865,7 @@ export def compile_function(value: &scope::Value, context: &scope::Scope, argume
             let prev_context = state.context
             state.context = node.scope
             //node.tpe = value.tpe = typechecking::lookup_parameters(node, state)
-            print(node.tpe.type_name, "\n")
+            //print(node.tpe.type_name, "\n")
             typechecking::walk_Def(node, state)
             state.context = prev_context
         }
@@ -1229,9 +1231,7 @@ export def consteval(module: &toolchain::Module) {
     module.state = state
     consteval(state)
 
-    if module.module == "std" {
-        toolchain::load_file_type()
-    } else if module.module == "reflection" {
+    if module.module == "reflection" {
         builtins::TypeT_ = module.scope.get_type_id(parser::make_identifier("Type"))
     }
 }

src/eval.pr

@@ -1125,7 +1125,7 @@ def eval_Inttoptr(insn: &compiler::Insn, state: &State) {
 
 def eval_insn(insn: &compiler::Insn, state: &State) {
     if toolchain::trace_consteval {
-        codegen::emit(std::stdout(), insn)
+        //codegen::emit(std::stdout(), insn)
     }
     switch insn.kind !int {
         case compiler::InsnKind::INSERTVALUE

src/scope.pr

@@ -978,7 +978,7 @@ export def generate_function(scope: &Scope, node: &parser::Node, parameter_t: &V
             // Switch to strong reference
             // TODO this removes the reference's canonical name but this is needed to only create one function
             // We should really get rid of the string name creating a hash
-            ftpe = reference(ftpe.tpe).resolve()
+            //ftpe = reference(ftpe.tpe).resolve()
 
             //let equals = get(toolchain::runtime_.scope, parser::make_identifier("equals"))
             //consteval::compile_function(equals, scope)
@@ -1975,7 +1975,11 @@ export def create_impl(
     // is a forward declared type, it will be resolved later
     // and the equality check looks at the patterns
 
-    if left.resolve(scope, error_on_fail = false) { 
+    // TODO Should impls be unique? The problem with looking up types here is
+    // that they might recursively resolve other stuff and fail because of
+    // types that aren't resolvable yet
+
+    /*if left.resolve(scope, error_on_fail = false) { 
         right.resolve(scope, error_on_fail = false)
     }
 
@@ -1987,7 +1991,7 @@ export def create_impl(
             errors::errorn(node, "Duplicate impl for `", typechecking::generic_to_string(left), "`")
             return
         }
-    }
+    }*/
 
     scope.impls.push(impl)
 }
@@ -2087,6 +2091,39 @@ export def trigger_impl(scope: &Scope, tpe: &typechecking::Type) {
                     parameter_t.push(param)
                 }
 
+                var struct_tpe = tpe
+                if tpe and tpe.kind == typechecking::TypeKind::REFERENCE {
+                    struct_tpe = tpe.tpe.resolve()
+                }
+                if struct_tpe and struct_tpe.kind == typechecking::TypeKind::STRUCT or 
+                    struct_tpe.kind == typechecking::TypeKind::UNION {
+                    // Check for fields
+
+                    let fields = typechecking::flatten_fields(null, struct_tpe)
+
+                    var found = false
+                    if typechecking::is_getter(member) {
+                        for var field in fields {
+                            if field.name == member.name and equals(member.return_t(0), field.tpe) { 
+                                found = true
+                                break
+                            }
+                        }
+                    } else if typechecking::is_setter(member) {
+                        let name = member.name.slice(6, member.name.length() - 2)
+                        for var field in fields {
+                            if field.name == name and equals(member.parameter_t(0).tpe, field.tpe) { 
+                                found = true
+                                break
+                            }
+                        }
+                    }
+                    
+                    if found {
+                        continue
+                    }
+                }
+
                 let name_node = parser::make_identifier(member.name)
                 let fun = get_function(impl.module.scope, name_node, parameter_t, dry_run = true)
                 var res = fun != null

src/serialize.pr

@@ -1470,9 +1470,6 @@ export def dependency_pass(module: &toolchain::Module) {
     if module.is_dirty and module.stage !int < toolchain::Stage::TYPECHECKING !int {
         toolchain::reset_and_consteval(module)
     }
-    if module.module == "std" {
-        toolchain::load_file_type()
-    }
 
     toolchain::progress_update(module, toolchain::ProgressUpdate::END)
 }

src/toolchain.pr

@@ -706,15 +706,6 @@ export def create_types_main {
     types.imported.add(main_def.name)
 }
 
-export def load_file_type {
-    if no_stdlib or builtins::File_ != null { return }
-    var std_module = find_module("std")
-    if not std_module {
-        std_module = create_module_if_absent(find_module_file("/std", null), "std") 
-    }
-    builtins::File_ = scope::get_type_id(std_module.scope, parser::make_identifier("File"))
-}
-
 export def reset_types {
     types.scope = scope::enter_scope(null !&scope::Scope, types, true)
     types.code = compiler::make_block()