Semantic: use generic key for generic maps; relations refactoring

src/ast/type.ts

@@ -36,6 +36,7 @@ export const buildTypeBounds = (node: ParseNode): TypeBounds => {
 
 export interface Generic extends AstNode<'generic'> {
     name: Name
+    key?: string
     bounds: Identifier[]
 }
 

src/scope/index.ts

@@ -47,6 +47,7 @@ export type DefinitionMap = Map<string, Definition>
 export interface InstanceScope {
     kind: 'instance'
     definitions: DefinitionMap
+    def: TraitDef | ImplDef
     rel?: InstanceRelation
 }
 

src/scope/trait.ts

@@ -67,7 +67,7 @@ export const buildInstanceRelations = (ctx: Context): InstanceRelation[] => {
         )
     return impls.flatMap(([module, impl]) => {
         ctx.moduleStack.push(module)
-        const implRel = getImplRel(impl, ctx)
+        const implRel = getRel(impl, ctx)
         ctx.moduleStack.pop()
         return implRel ? [implRel] : []
     })
@@ -76,19 +76,23 @@ export const buildInstanceRelations = (ctx: Context): InstanceRelation[] => {
 /**
  * Construct instance relation from instance definition
  */
-const getImplRel = (instance: TraitDef | ImplDef, ctx: Context): InstanceRelation | undefined => {
+const getRel = (instance: TraitDef | ImplDef, ctx: Context): InstanceRelation | undefined => {
     const module = ctx.moduleStack.at(-1)!
-    module.scopeStack.push({ kind: 'instance', definitions: new Map(instance.generics.map(g => [defKey(g), g])) })
+    module.scopeStack.push({
+        kind: 'instance',
+        def: instance,
+        definitions: new Map(instance.generics.map(g => [defKey(g), g]))
+    })
 
     const implRel =
-        instance.kind === 'trait-def' ? getTraitImplRel(instance, module, ctx) : getImplImplRel(instance, module, ctx)
+        instance.kind === 'trait-def' ? getTraitRel(instance, module, ctx) : getImplRel(instance, module, ctx)
 
     module.scopeStack.pop()
 
     return implRel
 }
 
-const getTraitImplRel = (instance: TraitDef, module: Module, ctx: Context): InstanceRelation | undefined => {
+const getTraitRel = (instance: TraitDef, module: Module, ctx: Context): InstanceRelation | undefined => {
     const generics = instance.generics.filter(g => g.name.value !== 'Self').map(g => genericToVirtual(g, ctx))
     const traitType: VirtualType = {
         kind: 'vid-type',
@@ -111,7 +115,8 @@ const getTraitImplRel = (instance: TraitDef, module: Module, ctx: Context): Inst
     }
 }
 
-const getImplImplRel = (instance: ImplDef, module: Module, ctx: Context): InstanceRelation | undefined => {
+const getImplRel = (instance: ImplDef, module: Module, ctx: Context): InstanceRelation | undefined => {
+    const generics = instance.generics.filter(g => g.name.value !== 'Self').map(g => genericToVirtual(g, ctx))
     const implVid = idToVid(instance.identifier)
     const ref = resolveVid(implVid, ctx, ['trait-def', 'type-def'])
     if (!ref || (ref.def.kind !== 'trait-def' && ref.def.kind !== 'type-def')) {
@@ -140,7 +145,7 @@ const getImplImplRel = (instance: ImplDef, module: Module, ctx: Context): Instan
         implDef: <VirtualIdentifierMatch<TypeDef | TraitDef>>ref,
         forDef: forDef,
         instanceDef: instance,
-        generics: instance.generics.map(g => genericToVirtual(g, ctx)),
+        generics,
         inherent: !instance.forTrait
     }
 }

src/semantic/error.ts

@@ -292,4 +292,3 @@ export const unexpectedRefutablePatternError = (ctx: Context, patternExpr: Patte
     const msg = `unexpected refutable pattern`
     return semanticError(41, ctx, patternExpr, msg)
 }
-

src/semantic/index.ts

@@ -421,6 +421,7 @@ const checkTraitDef = (traitDef: TraitDef, ctx: Context) => {
 
     const scope: InstanceScope = {
         kind: 'instance',
+        def: rel.instanceDef,
         rel,
         definitions: new Map(traitDef.generics.map(g => [defKey(g), g]))
     }
@@ -448,7 +449,7 @@ const checkImplDef = (implDef: ImplDef, ctx: Context) => {
 
     const scope: InstanceScope = {
         kind: 'instance',
-        rel: implDef.rel,
+        def: implDef,
         definitions: new Map(implDef.generics.map(g => [defKey(g), g]))
     }
     module.scopeStack.push(scope)
@@ -699,6 +700,7 @@ export const checkIdentifier = (identifier: Identifier, ctx: Context): void => {
                 const instScope: InstanceScope = {
                     kind: 'instance',
                     rel: ref.def.rel,
+                    def: ref.def.rel.instanceDef,
                     definitions: new Map(ref.def.rel.instanceDef.generics.map(g => [defKey(g), g]))
                 }
 

src/semantic/upcast.ts

@@ -23,7 +23,7 @@ export const makeUpcast = (type: VirtualType, traitType: VirtualType, ctx: Conte
     const upcast: Upcast = { self: { [relTypeName(res.trait)]: res.impl }, generics: [] }
     for (const g of res.impl.generics) {
         const gUpcast: Upcast = { self: {}, generics: [] }
-        const concreteG = genericMap.get(g.name)
+        const concreteG = genericMap.get(g.key)
         if (concreteG) {
             for (const b of g.bounds) {
                 const gUp = makeUpcast(concreteG, b, ctx)

src/typecheck/generic.ts

@@ -1,4 +1,5 @@
 import { Context, InstanceScope } from '../scope'
+import { getInstanceForType } from '../scope/trait'
 import { fold } from '../util/array'
 import { merge } from '../util/map'
 import { assert, unreachable } from '../util/todo'
@@ -43,7 +44,7 @@ export const makeGenericMapOverStructure = (arg: VirtualType, param: VirtualType
                 break
             }
         }
-        map.set(param.name, arg)
+        map.set(param.key, arg)
         return map
     }
     if (arg.kind === 'unknown-type' || param.kind === 'unknown-type') {
@@ -146,7 +147,7 @@ export const getTypeParams = (virtualType: VirtualType): VirtualType[] => {
 }
 
 export const instanceGenericMap = (instScope: InstanceScope, ctx: Context): Map<string, VirtualType> => {
-    return new Map([[selfType.name, instScope.rel!.forType]])
+    return new Map([[selfType.key, getInstanceForType(instScope.def, ctx)]])
 }
 
 /**
@@ -174,7 +175,7 @@ const resolveGenericMap = (
                 typeArgs: virtualType.typeArgs.map(g => resolveGenericMap(g, genericMap, ctx))
             }
         case 'generic':
-            const mapped = genericMap.get(virtualType.name)
+            const mapped = genericMap.get(virtualType.key)
             const res = mapped ?? virtualType
             if (res.kind === 'generic') {
                 return {

src/typecheck/index.ts

@@ -1,6 +1,5 @@
 import { Operand } from '../ast/operand'
 import { Generic, Type } from '../ast/type'
-import { jsRelName } from '../codegen/js'
 import { Context, addError } from '../scope'
 import { InstanceRelation, findSuperRelChains, getConcreteTrait } from '../scope/trait'
 import { idToVid, vidEq, vidToString } from '../scope/util'
@@ -127,10 +126,13 @@ export const typeToVirtual = (type: Type, ctx: Context): VirtualType => {
 }
 
 export const genericToVirtual = (generic: Generic, ctx: Context): VirtualGeneric => {
+    if (!generic.key) {
+        generic.key = genericKey(generic, ctx)
+    }
     return {
         kind: 'generic',
         name: generic.name.value,
-        key: genericKey(generic, ctx),
+        key: generic.key,
         bounds: generic.bounds.map(b => typeToVirtual(b, ctx))
     }
 }
@@ -151,21 +153,23 @@ export const genericKey = (generic: Generic, ctx: Context): string => {
                             return `closure`
                     }
                 case 'instance':
-                    if (s.rel) {
-                        return `instance_${jsRelName(s.rel)}`
-                    } else {
-                        return `instance`
+                    switch (s.def.kind) {
+                        case 'trait-def':
+                            return `trait_${s.def.name.value}`
+                        case 'impl-def':
+                            return `impl`
                     }
                 default:
                     return undefined
             }
         })
         .filter(s => !!s)
         .join('_')
-    return `${scopeName}_${generic}`
+    return `${scopeName}_${generic.name.value}`
 }
 
 export const isAssignable = (t: VirtualType, target: VirtualType, ctx: Context): boolean => {
+    if (t === target) return true
     if (t.kind === 'unknown-type' || target.kind === 'unknown-type') return true
     if (t.kind === 'hole-type' || target.kind === 'hole-type') return true
     if (t.kind === 'vid-type' && vidToString(t.identifier) === 'std::never::Never') return true