Some left overs

Author: Victorious3

src/scope.pr

@@ -469,17 +469,17 @@ def find_functions(value: &Value, resolved: &SMap(&Vector(typechecking::Function
 def find_functions(scope: &Scope, name: Str, ret: &Vector(&Value), params: &Vector(typechecking::TypeId) = null, check_export: bool = false) {
     for var key in @scope.fields.keys() {
         var value = scope.fields(key)
-        let value_tpe = value.tpe.resolve()
-        if key == name and value.modifier == parser::VarDecl::CONST and value.kind == ValueKind::FUNCTION {
+        if key == name and value.kind == ValueKind::FUNCTION {
+            let value_def = value.fdef
             while value {
                 if params {
-                    if value_tpe.parameter_t.length < params.length {
+                    if value_def.sig.parameter_t.length < params.length {
                         continue
                     }
                     var parameter_mismatch = false
                     for var i in 0..params.length {
                         let param = params(i)
-                        if not typechecking::is_assignable(value_tpe.parameter_t(i).tpe, param, scope.module) {
+                        if not typechecking::is_assignable(value_def.sig.parameter_t(i).tpe, param, scope.module) {
                             parameter_mismatch = true
                             break
                         }
@@ -531,14 +531,13 @@ def find_functions(scope: &Scope, tpe: &typechecking::Type, ret: &Vector(&Value)
     for var key in @scope.fields.keys() {
         var value = scope.fields(key)
         if check_export and not (value.share !int & parser::ShareMarker::EXPORT !int) { continue }
-        let value_tpe = value.tpe.resolve()
-        if value.modifier == parser::VarDecl::CONST and value_tpe and
-            value_tpe.kind == typechecking::TypeKind::FUNCTION {
+        if value.kind == ValueKind::FUNCTION {
+            let value_def = value.fdef
             while value {
-                if value_tpe.parameter_t.length > 0 and
-                    typechecking::is_assignable(value_tpe.parameter_t(0).tpe, tpe, scope.module) {
-                    if not set::contains(found, value_tpe.type_name) {
-                        set::add(found, value_tpe.type_name)
+                if value_def.sig.parameter_t.length > 0 and
+                    typechecking::is_assignable(value_def.sig.parameter_t(0).tpe, tpe, scope.module) {
+                    if not set::contains(found, value_def.name) {
+                        set::add(found, value_def.name)
                         ret.push(value)
                     }
                 }
@@ -763,10 +762,11 @@ export def find_implicit_function(scope: &Scope, parameter_t: &Vector(typechecki
             /*if v.node and v.state {
                 v.tpe = typechecking::lookup_parameters(v.node, v.state)
             }*/
-            let vtpe = v.tpe.resolve()
+            assert v.kind == ValueKind::FUNCTION
+            let fdef = v.fdef
 
-            if not typechecking::equals(vtpe.return_t(0), r) { continue }
-            let s = typechecking::convert_type_score(vtpe.parameter_t(0).get_generic(), parameter_t(0).tpe, context.module, impl = false)
+            if not typechecking::equals(fdef.sig.return_t(0), r) { continue }
+            let s = typechecking::convert_type_score(fdef.sig.parameter_t(0).get_generic(), parameter_t(0).tpe, context.module, impl = false)
             if s == @score {
                 d = true
             } else if s >= 0 and s < @score {
@@ -814,9 +814,9 @@ export def find_implicit_function(scope: &Scope, parameter_t: &Vector(typechecki
 
     if value and value.phase == Phase::DEFINED and value.node and force_compile {
         // TODO Factor this out
-        assert is_function(value.tpe)
-        let fun_tpe = value.tpe.resolve()
-        if typechecking::is_polymorph(fun_tpe.parameter_t) {
+        assert value.kind == ValueKind::FUNCTION
+        let fdef = value.fdef
+        if typechecking::is_polymorph(fdef.sig.parameter_t) {
             typechecking::walk_Def_with_type_argument(value.node, parameter_t, scope, typechecking::make_state(value.module))
         } else {
             let state = typechecking::make_state(value.module)
@@ -1061,9 +1061,10 @@ export def create_underscore(scope: &Scope, name_node: &parser::Node, tpe: typec
 }
 
 export def typecheck_function(value: &Value, parameter_t: &Vector(typechecking::NamedParameter), context: &Scope) -> &Value {
+    assert value.kind == ValueKind::FUNCTION
     value.phase = Phase::COMPILED
     //let tpe = typechecking::lookup_parameters(value.node, value.state)
-    if typechecking::is_polymorph(value.tpe.resolve().parameter_t) {
+    if typechecking::is_polymorph(value.fdef.sig.parameter_t) {
         let node = typechecking::walk_Def_with_type_argument(value.node, parameter_t, context, typechecking::make_state(value.module))
         let value = node.value.def_.function.value
         return value
@@ -1081,9 +1082,10 @@ export def typecheck(value: &Value) {
     value.phase = Phase::COMPILED
     let state = typechecking::make_state(value.module)
     if value.node.kind == parser::NodeKind::DEF {
+        assert value.kind == ValueKind::FUNCTION
         //let tpe = typechecking::lookup_parameters(value.node, value.state)
-        let tpe = value.tpe.resolve()
-        if tpe.kind == typechecking::TypeKind::FUNCTION and not typechecking::is_polymorph(tpe.parameter_t) {
+        let fdef = value.fdef
+        if not typechecking::is_polymorph(fdef.sig.parameter_t) {
             state.context = value.node.scope
             typechecking::walk_Def(value.node, state)
             value.tpe = value.node.tpe
@@ -1178,7 +1180,7 @@ export def get_function_check(
         }
 
         // Check for polymorphic instances
-        if is_global(scope) and (not first_function or typechecking::is_polymorph(first_function.tpe.resolve().parameter_t)) {
+        if is_global(scope) and (not first_function or typechecking::is_polymorph(first_function.fdef.sig.parameter_t)) {
             var root_scope = context.module.scope
             var new_score = std::MAX_INT32
 
@@ -1199,7 +1201,7 @@ export def get_function_check(
                             }
                         }
                     }
-                } else if first_function and typechecking::is_polymorph(first_function.tpe.resolve().parameter_t) {
+                } else if first_function and typechecking::is_polymorph(first_function.fdef.sig.parameter_t) {
                     if root_scope.polymorphics.contains(first_function.module.filename) {
                         // We found the function and we should only look into the polymorphs from this module
                         let poly_scope = root_scope.polymorphics(first_function.module.filename)