Work on type replacements

Author: Victorious3

src/scope.pr

@@ -691,7 +691,17 @@ def find_function(scope: &Scope, node: &parser::Node, v: &Value, parameter_t: &V
 
         loop {
             if not v { break }
-            let s = typechecking::overload_score(v.fdef, node.value.identifier.types, context, true)
+            
+            var new_scope = scope
+            if typechecking::is_polymorph(v.fdef.parameter_t) {
+                // Create temporary scope for type lookup
+                // TODO Maybe cache it somewhere instead of creating a new one when creating a polymorphic instance
+                let parents = vector::make(type weak &Scope)
+                parents.push(scope)
+                parents.push(context)
+                new_scope = enter_scope(parents, scope.module)
+            }
+            let s = typechecking::overload_score(v.fdef, node.value.identifier.types, new_scope, true)
             if s == 0 {
                 @score = 0
                 return true, v

src/typechecking.pr

@@ -118,7 +118,9 @@ export def tpe(id: TypeId) -> TypeId {
     return resolve(id).tpe
 }
 export def kind(id: TypeId) -> TypeKind {
-    return resolve(id).kind
+    let tpe = resolve(id)
+    if not tpe { return TypeKind::NULL }
+    return tpe.kind
 }
 export def type_name(id: TypeId) -> Str {
     return resolve(id).type_name
@@ -446,7 +448,9 @@ export def generic_to_string(typeref: &TypeRef) -> Str {
 }
 
 def generic_to_string(generic: &Pattern) -> Str {
-    if generic.kind == TypeKind::REFERENCE {
+    if generic.kind == TypeKind::TYPE_DEF {
+        return "type-def " + generic.name
+    } else if generic.kind == TypeKind::REFERENCE {
         return "&" + generic_to_string(generic.tpe) // FIXME *let kw
     } else if generic.kind == TypeKind::POINTER {
         return "*" + generic_to_string(generic.tpe) // FIXME &let kw
@@ -2306,6 +2310,7 @@ def infer_interface_types(a: &Type, b: &Type, module: &toolchain::Module) -> &Ty
 }*/
 
 export def convert_type_score(a: &TypeRef, b: &Type, scpe: &scope::Scope, impl: bool = true) -> int {
+    print(generic_to_string(a), " <-> ", debug::type_to_str(b), "\n")
     if a.pattern {
         return convert_type_score(a.pattern, b, scpe, impl)
     } else if a.name {
@@ -2316,8 +2321,9 @@ export def convert_type_score(a: &TypeRef, b: &Type, scpe: &scope::Scope, impl:
 }
 
 export def convert_type_score(a: &Pattern, b: &Type, scpe: &scope::Scope, impl: bool = true) -> int {
-    if a.kind == TypeKind::TYPE {
-        return convert_type_score(a.tpe, b, scpe, impl)
+    if a.kind == TypeKind::TYPE_DEF {
+        scope::create_type(scpe, parser::make_identifier(a.name), parser::ShareMarker::NONE, make_type_ref(b.id))
+        return 1
     }
 
     if a.kind == b.kind == TypeKind::STATIC_ARRAY {
@@ -2388,7 +2394,9 @@ export def convert_type_score(a: &Pattern, b: &Type, scpe: &scope::Scope, impl:
         for var i in 0..a.return_t.length {
             let tpe_a = a.return_t(i)
             let tpe_b = b.tc_args(i)
-            if tpe_a != tpe_b { return -1 }
+            if convert_type_score(tpe_a, tpe_b, scpe, impl) < 0 { 
+                return -1 
+            }
         }
         return 1
     }
@@ -3365,9 +3373,8 @@ def do_type_lookup(node: &parser::Node, state: &State, is_type: bool = false) ->
         let name = parser::identifier_to_str(node)
         if is_type {
             // Create type in scope
-            let tr = make_type_ref(name)
-            scope::create_type(state.scope, node, parser::ShareMarker::NONE, tr)
-            return tr
+            scope::create_type(state.scope, node, parser::ShareMarker::NONE, make_type_ref(name))
+            return make_type_ref([ kind = TypeKind::TYPE_DEF, name = name ] !&Pattern)
         } else /*if not lookup_default*/ {
             let value = scope::get(state.scope, node)
             if not value {