feat(hover): show TL-B types in field documentation (#125)

Fixes #65

Author: i582

server/src/TypeInferer.ts

@@ -103,6 +103,12 @@ export class TypeInferer {
                 return this.primitiveType("Int")
             }
 
+            if (resolved.node.type === "field" || resolved.node.type === "storage_variable") {
+                const typeNode = resolved.node.childForFieldName("type")
+                if (!typeNode) return null
+                return this.inferTypeMaybeTlB(typeNode, resolved)
+            }
+
             if (isTypeOwnerNode(resolved.node)) {
                 const typeNode = resolved.node.childForFieldName("type")
                 if (!typeNode) return null
@@ -125,6 +131,22 @@ export class TypeInferer {
             const valueTy = this.inferChildFieldType(node, "value")
             if (valueTy === null) return null
 
+            if (keyTy instanceof PrimitiveTy) {
+                const tlb = node.node.childForFieldName("tlb_key")
+                const tlbType = tlb?.childForFieldName("type")
+                if (tlbType) {
+                    keyTy.tlb = tlbType.text
+                }
+            }
+
+            if (valueTy instanceof PrimitiveTy) {
+                const tlb = node.node.childForFieldName("tlb_value")
+                const tlbType = tlb?.childForFieldName("type")
+                if (tlbType) {
+                    valueTy.tlb = tlbType.text
+                }
+            }
+
             return new MapTy(keyTy, valueTy)
         }
 
@@ -314,7 +336,7 @@ export class TypeInferer {
     private primitiveType(name: string) {
         const node = index.elementByName(IndexKey.Primitives, name)
         if (!node) return null
-        return new PrimitiveTy(name, node)
+        return new PrimitiveTy(name, node, null)
     }
 
     private inferTypeMaybeOption(typeNode: SyntaxNode, resolved: Node) {
@@ -325,9 +347,21 @@ export class TypeInferer {
         return inferred
     }
 
+    private inferTypeMaybeTlB(typeNode: SyntaxNode, resolved: Node) {
+        const inferredType = this.inferTypeMaybeOption(typeNode, resolved)
+        if (inferredType instanceof PrimitiveTy) {
+            const tlb = resolved.node.childForFieldName("tlb")
+            const tlbType = tlb?.childForFieldName("type")
+            if (tlbType) {
+                inferredType.tlb = tlbType.text
+            }
+        }
+        return inferredType
+    }
+
     private inferTypeFromResolved(resolved: NamedNode): Ty | null {
         if (resolved instanceof Primitive) {
-            return new PrimitiveTy(resolved.name(), resolved)
+            return new PrimitiveTy(resolved.name(), resolved, null)
         }
         if (resolved instanceof Struct) {
             return new StructTy(resolved.name(), resolved)

server/src/completion/CompletionContext.ts

@@ -170,6 +170,12 @@ export class CompletionContext {
             this.isInitOfName = true
         }
 
+        if (parent.type === "ERROR" && parent.parent?.type === "map_type") {
+            this.isType = true
+            this.isExpression = false
+            this.isStatement = false
+        }
+
         if (parent.type === "ERROR" && parent.parent?.type === "parameter_list") {
             this.inParameter = true
         }

server/src/completion/providers/KeywordsCompletionProvider.ts

@@ -9,7 +9,7 @@ import {
 import {NullTy, PrimitiveTy} from "@server/types/BaseTy"
 
 export class KeywordsCompletionProvider implements CompletionProvider {
-    boolTy: PrimitiveTy = new PrimitiveTy("Bool", null)
+    boolTy: PrimitiveTy = new PrimitiveTy("Bool", null, null)
     nullTy: NullTy = new NullTy()
 
     isAvailable(ctx: CompletionContext): boolean {

server/src/e2e/suite/testcases/documentation/structs.test

@@ -123,3 +123,57 @@ fun foo() {
 struct Foo
 field: Int = 0
 ```
+
+========================================================================
+Field declaration with type with TL-B
+========================================================================
+primitive Int;
+
+struct Foo {
+    field: Int as uint8;
+}
+
+fun foo() {
+    let f = Foo { <caret>field: 10 };
+}
+------------------------------------------------------------------------
+```
+struct Foo
+field: Int as uint8
+```
+
+========================================================================
+Field declaration with type with TL-B 2
+========================================================================
+primitive Slice;
+
+struct Foo {
+    field: Slice as remaining;
+}
+
+fun foo() {
+    let f = Foo { <caret>field: 10 };
+}
+------------------------------------------------------------------------
+```
+struct Foo
+field: Slice as remaining
+```
+
+========================================================================
+Field declaration with type with TL-B 3
+========================================================================
+primitive Int;
+
+struct Foo {
+    field: map<Int as uint8, Int>;
+}
+
+fun foo() {
+    let f = Foo { <caret>field: 10 };
+}
+------------------------------------------------------------------------
+```
+struct Foo
+field: map<Int as uint8, Int>
+```

server/src/e2e/suite/testcases/types/fields.test

@@ -0,0 +1,64 @@
+========================================================================
+Message field type with Tl-B
+========================================================================
+primitive Int;
+
+message Point {
+    x: Int as coins;
+//! ^ Int as coins
+    y: Int;
+}
+------------------------------------------------------------------------
+ok
+
+========================================================================
+Message field type with Tl-B 2
+========================================================================
+primitive Int;
+
+message Point {
+    x: Int as coins;
+    y: Slice as remaining;
+//! ^ Slice as remaining
+}
+------------------------------------------------------------------------
+type inference error at line 5:4: expected Slice as remaining, got unknown
+
+========================================================================
+Message field map type with Tl-B
+========================================================================
+primitive Int;
+
+message Point {
+    x: Int as coins;
+    y: map<Int as uint8, Int>;
+//! ^ map<Int as uint8, Int>
+}
+------------------------------------------------------------------------
+ok
+
+========================================================================
+Message field map type with Tl-B 2
+========================================================================
+primitive Int;
+
+message Point {
+    x: Int as coins;
+    y: map<Int as uint8, Int as uint16>;
+//! ^ map<Int as uint8, Int as uint16>
+}
+------------------------------------------------------------------------
+ok
+
+========================================================================
+Message field map type with Tl-B 3
+========================================================================
+primitive Int;
+
+message Point {
+    x: Int as coins;
+    y: map<Int, Int as uint16>;
+//! ^ map<Int, Int as uint16>
+}
+------------------------------------------------------------------------
+ok

server/src/psi/Reference.ts

@@ -181,7 +181,7 @@ export class Reference {
         if (qualifierType instanceof StructTy || qualifierType instanceof MessageTy) {
             const node = index.elementByName(IndexKey.Primitives, "AnyStruct")
             if (node) {
-                const structPrimitiveTy = new PrimitiveTy("AnyStruct", node)
+                const structPrimitiveTy = new PrimitiveTy("AnyStruct", node, null)
                 if (!this.processType(qualifier, structPrimitiveTy, proc, state)) return false
             }
         }

server/src/types/BaseTy.ts

@@ -47,7 +47,31 @@ export class StructTy extends FieldsOwnerTy<Struct> {}
 
 export class MessageTy extends FieldsOwnerTy<Message> {}
 
-export class PrimitiveTy extends BaseTy<Primitive> {}
+export class PrimitiveTy extends BaseTy<Primitive> {
+    public constructor(
+        name: string,
+        anchor: Primitive | null,
+        public tlb: string | null,
+    ) {
+        super(name, anchor)
+    }
+
+    public override name(): string {
+        if (this.tlb) {
+            return `${this._name} as ${this.tlb}`
+        }
+
+        return this._name
+    }
+
+    public override qualifiedName(): string {
+        if (this.tlb) {
+            return `${this._name} as ${this.tlb}`
+        }
+
+        return this._name
+    }
+}
 
 export class PlaceholderTy extends BaseTy<NamedNode> {}