fix(tolk): better handling for recursive types in type inference (#233)

Author: i582

server/src/cache/cache.ts

@@ -16,6 +16,21 @@ export class Cache<TKey, TValue> {
         return value
     }
 
+    public cachedIf(key: TKey, reevaluateIfValue: TValue, cb: () => TValue): TValue {
+        const cached = this.data.get(key)
+        if (cached !== undefined && cached !== reevaluateIfValue) {
+            return cached
+        }
+
+        const value = cb()
+        this.data.set(key, value)
+        return value
+    }
+
+    public setValue(key: TKey, value: TValue): void {
+        this.data.set(key, value)
+    }
+
     public clear(): void {
         this.data.clear()
     }

server/src/languages/tolk/type-inference.ts

@@ -963,15 +963,6 @@ class InferenceWalker {
         return ExprFlow.create(nextFlow, false)
     }
 
-    public lambdaParameters(lambda: SyntaxNode): SyntaxNode[] {
-        const parametersNode = lambda.childForFieldName("parameters")
-        if (!parametersNode) return []
-
-        return parametersNode.children
-            .filter(value => value?.type === "parameter_declaration")
-            .filter(value => value !== null)
-    }
-
     private inferGenericInstantiation(
         node: SyntaxNode,
         flow: FlowContext,
@@ -1271,7 +1262,7 @@ class InferenceWalker {
         this.processMethods(searchName, method => {
             const receiverTypeString = method.receiverTypeString()
             if (qualifierTypeString === receiverTypeString) {
-                // fast path, if types are equal it is exact match, no need to search more methods
+                // fast path, if types are equal, it is an exact match, no need to search for more methods
                 result.push(method)
                 return false
             }
@@ -1287,7 +1278,7 @@ class InferenceWalker {
         this.processMethods(searchName, method => {
             const receiverTypeNode = method.receiverTypeNode()
             if (!receiverTypeNode) return true
-            const receiverType = typeOf(receiverTypeNode, method.file)
+            const receiverType = InferenceWalker.convertType(receiverTypeNode, this.ctx.file)
 
             if (!receiverType?.hasGenerics() && receiverType?.equals(qualifierType)) {
                 result.push(method)
@@ -1304,7 +1295,7 @@ class InferenceWalker {
         this.processMethods(searchName, method => {
             const receiverTypeNode = method.receiverTypeNode()
             if (!receiverTypeNode) return true
-            const receiverType = typeOf(receiverTypeNode, method.file)
+            const receiverType = InferenceWalker.convertType(receiverTypeNode, this.ctx.file)
 
             if (!receiverType?.hasGenerics() && receiverType?.canRhsBeAssigned(qualifierType)) {
                 result.push(method)
@@ -1322,7 +1313,7 @@ class InferenceWalker {
         this.processMethods(searchName, method => {
             const receiverTypeNode = method.receiverTypeNode()
             if (!receiverTypeNode) return true
-            const receiverType = typeOf(receiverTypeNode, method.file)
+            const receiverType = InferenceWalker.convertType(receiverTypeNode, this.ctx.file)
 
             // Foo<T>, but not T
             if (receiverType?.hasGenerics() && !(receiverType instanceof TypeParameterTy)) {
@@ -1354,7 +1345,7 @@ class InferenceWalker {
         this.processMethods(searchName, method => {
             const receiverTypeNode = method.receiverTypeNode()
             if (!receiverTypeNode) return true
-            const receiverType = typeOf(receiverTypeNode, method.file)
+            const receiverType = InferenceWalker.convertType(receiverTypeNode, this.ctx.file)
 
             if (receiverType instanceof TypeParameterTy) {
                 result.push(method)
@@ -2080,9 +2071,11 @@ class InferenceWalker {
         file: TolkFile | null | undefined,
     ): Ty | null {
         if (!typeNode || !file) return null
-        return TOLK_CACHE.typeCache.cached(typeNode.id, () =>
-            InferenceWalker.convertTypeImpl(typeNode, file),
-        )
+        return TOLK_CACHE.typeCache.cached(typeNode.id, () => {
+            // add unknown type to avoid recursion
+            TOLK_CACHE.typeCache.setValue(typeNode.id, UnknownTy.UNKNOWN)
+            return InferenceWalker.convertTypeImpl(typeNode, file)
+        })
     }
 
     private static convertTypeImpl(node: SyntaxNode | null | undefined, file: TolkFile): Ty | null {
@@ -2232,6 +2225,12 @@ class InferenceWalker {
     }
 
     public static namedNodeType(node: NamedNode): Ty | null {
+        return TOLK_CACHE.typeCache.cachedIf(node.node.id, UnknownTy.UNKNOWN, () =>
+            InferenceWalker.namedNodeTypeImpl(node),
+        )
+    }
+
+    public static namedNodeTypeImpl(node: NamedNode): Ty | null {
         if (node instanceof Struct) {
             const fieldTypes = node.fields().map(it => {
                 try {
@@ -2271,10 +2270,9 @@ class InferenceWalker {
             const underlyingType = node.underlyingType()
             if (underlyingType === null) return null
 
-            const underlyingTypeName = underlyingType.text
-            if (underlyingTypeName === "builtin") {
+            if (underlyingType.type === "builtin_specifier") {
                 const name = node.name()
-                const type = InferenceWalker.asPrimitiveType(node.name())
+                const type = InferenceWalker.asPrimitiveType(name)
                 if (type) {
                     return type
                 }