Semantic: qualified call stub

nois-lang · Apr 1, 2024 · ac66c4e · ac66c4e
1 parent 8eb8d76
commit ac66c4e
Show file tree

Hide file tree

Showing 3 changed files with 37 additions and 13 deletions.
diff --git a/src/semantic/expr.ts b/src/semantic/expr.ts
@@ -451,6 +451,17 @@ export const checkResolvedClosureExpr = (
     }
 }
 
+export const checkQualifiedMethodCall = (
+    def: MethodDef,
+    ctx: Context,
+    operand: Operand,
+    inferredType: VirtualFnType
+): VirtualType => {
+    const genericMaps = [instanceGenericMap(def.rel.instanceDef, ctx)]
+    const fnType = def.fn.type!
+    return resolveType(fnType, genericMaps, ctx)
+}
+
 export const checkCall = (unaryExpr: UnaryExpr, ctx: Context): void => {
     const call = <CallOp>unaryExpr.op
     const operand = unaryExpr.operand
@@ -536,7 +547,7 @@ export const checkVariantCall = (
 
 export const checkCall_ = (call: CallOp, operand: Operand, args: Expr[], ctx: Context): VirtualType => {
     if (operand.type?.kind === 'malleable-type') {
-        const closureType: VirtualFnType = {
+        const inferredType: VirtualFnType = {
             kind: 'fn-type',
             generics: [],
             paramTypes: args.map(arg => arg.type ?? unknownType),
@@ -545,10 +556,16 @@ export const checkCall_ = (call: CallOp, operand: Operand, args: Expr[], ctx: Co
         switch (operand.type.operand.kind) {
             case 'closure-expr':
                 const closure = operand.type.operand
-                operand.type = checkResolvedClosureExpr(closure, ctx, operand, closureType)
+                operand.type = checkResolvedClosureExpr(closure, ctx, operand, inferredType)
+                break
+            case 'identifier':
+                // TODO: properly
+                const ref = operand.type!.operand.ref
+                if (ref?.def.kind !== 'method-def') return unreachable()
+                operand.type = checkQualifiedMethodCall(ref.def, ctx, operand, inferredType)
                 break
             default:
-                unreachable()
+                unreachable(operand.type.operand.kind)
         }
     }
     if (operand.type?.kind === 'unknown-type') {
@@ -698,7 +715,7 @@ export const makeFnGenericMaps = (
 ): Map<string, VirtualType>[] => {
     const fnTypeArgMap = makeFnTypeArgGenericMap(fnType, typeArgs)
     const instScope = instanceScope(ctx)
-    const instanceMap = instScope ? instanceGenericMap(instScope, ctx) : new Map()
+    const instanceMap = instScope ? instanceGenericMap(instScope.def, ctx) : new Map()
     const fnMap = makeFnGenericMap(fnType, args)
     return [instanceMap, fnTypeArgMap, fnMap]
 }

diff --git a/src/semantic/index.ts b/src/semantic/index.ts
@@ -51,7 +51,7 @@ import {
     unspecifiedParamTypeError,
     vidResolveToModuleError
 } from './error'
-import { checkExpr, checkResolvedClosureExpr } from './expr'
+import { checkExpr, checkQualifiedMethodCall, checkResolvedClosureExpr } from './expr'
 import { checkPattern } from './match'
 import { typeNames } from './type-def'
 import { Upcast, UpcastFn, makeUpcast, upcast } from './upcast'
@@ -345,7 +345,7 @@ const checkFnDef = (fnDef: FnDef, ctx: Context): void => {
     }
 
     const instScope = instanceScope(ctx)
-    const genericMaps = instScope ? [instanceGenericMap(instScope, ctx)] : []
+    const genericMaps = instScope ? [instanceGenericMap(instScope.def, ctx)] : []
     const returnTypeResolved = resolveType(returnType, genericMaps, ctx)
 
     if (ctx.check && !module.compiled) {
@@ -605,7 +605,7 @@ const checkVarDef = (varDef: VarDef, ctx: Context): void => {
         const instScope = instanceScope(ctx)
         varType = resolveType(
             typeToVirtual(varDef.varType, ctx),
-            instScope ? [instanceGenericMap(instScope, ctx)] : [],
+            instScope ? [instanceGenericMap(instScope.def, ctx)] : [],
             ctx
         )
     }
@@ -688,7 +688,11 @@ export const checkIdentifier = (identifier: Identifier, ctx: Context): void => {
                 }
                 if (name.type === selfType) {
                     const instScope = instanceScope(ctx)
-                    identifier.type = resolveType(name.type, instScope ? [instanceGenericMap(instScope, ctx)] : [], ctx)
+                    identifier.type = resolveType(
+                        name.type,
+                        instScope ? [instanceGenericMap(instScope.def, ctx)] : [],
+                        ctx
+                    )
                 } else {
                     identifier.type = name.type
                 }
@@ -775,8 +779,10 @@ export const resolveMallebleType = (arg: Operand, paramType: VirtualType, ctx: C
                 arg.type! = checkResolvedClosureExpr(closure, ctx, arg, paramType)
                 break
             case 'identifier':
-                // TODO
-                arg.type! = unknownType
+                // TODO: properly
+                const ref = arg.type!.operand.ref
+                if (ref?.def.kind !== 'method-def') return unreachable()
+                arg.type = checkQualifiedMethodCall(ref.def, ctx, arg, paramType)
                 break
             default:
                 unreachable()

diff --git a/src/typecheck/generic.ts b/src/typecheck/generic.ts
@@ -1,4 +1,5 @@
-import { Context, InstanceScope } from '../scope'
+import { ImplDef, TraitDef } from '../ast/statement'
+import { Context } from '../scope'
 import { getInstanceForType } from '../scope/trait'
 import { merge } from '../util/map'
 import { assert } from '../util/todo'
@@ -145,8 +146,8 @@ export const getTypeParams = (virtualType: VirtualType): VirtualType[] => {
     }
 }
 
-export const instanceGenericMap = (instScope: InstanceScope, ctx: Context): Map<string, VirtualType> => {
-    return new Map([[selfType.key, getInstanceForType(instScope.def, ctx)]])
+export const instanceGenericMap = (def: ImplDef | TraitDef, ctx: Context): Map<string, VirtualType> => {
+    return new Map([[selfType.key, getInstanceForType(def, ctx)]])
 }
 
 /**