feat(completion/resolving/documentation): add support for fromCell and fromSlice methods on structs and messages

server/src/TypeInferer.ts

@@ -44,7 +44,12 @@ export class TypeInferer {
         if (node.node.type === "type_identifier") {
             const resolved = Reference.resolve(new NamedNode(node.node, node.file))
             if (resolved === null) {
-                if (node.node.text === "K" || node.node.text === "V") {
+                if (
+                    node.node.text === "K" ||
+                    node.node.text === "V" ||
+                    node.node.text === "S" ||
+                    node.node.text === "M"
+                ) {
                     return new PlaceholderTy(node.node.text, new NamedNode(node.node, node.file))
                 }
                 return null
@@ -224,12 +229,23 @@ export class TypeInferer {
             const resolved = Reference.resolve(element)
             if (resolved === null) return null
             if (!(resolved instanceof Fun)) return null
+            const calledName = resolved.name()
 
             const returnType = resolved.returnType()
             if (returnType === null) return null
             const type = this.inferTypeMaybeOption(returnType.node, returnType)
             if (!type) return null
 
+            const qualifier = node.node.childForFieldName("object")
+
+            // Handle `Struct.fromCell()` calls
+            if (
+                qualifier &&
+                (calledName.startsWith("AnyStruct_") || calledName.startsWith("AnyMessage_"))
+            ) {
+                return new Expression(qualifier, node.file).type()
+            }
+
             // following code is completely garbage, we need to replace it with actual generics
             if (
                 type instanceof PlaceholderTy ||

server/src/completion/ReferenceCompletionProcessor.ts

@@ -11,6 +11,7 @@ import {
 } from "@server/completion/WeightedCompletionItem"
 import {StructTy} from "@server/types/BaseTy"
 import {tactCodeBlock} from "@server/documentation/documentation"
+import {trimPrefix} from "@server/utils/strings"
 
 export class ReferenceCompletionProcessor implements ScopeProcessor {
     public constructor(private readonly ctx: CompletionContext) {}
@@ -58,7 +59,7 @@ export class ReferenceCompletionProcessor implements ScopeProcessor {
         if (!(node instanceof NamedNode)) return true
 
         const prefix = state.get("prefix") ?? ""
-        const name = node.name()
+        const name = trimPrefix(trimPrefix(node.name(), "AnyMessage_"), "AnyStruct_")
         if (name.endsWith("DummyIdentifier") || name === "AnyStruct" || name === "AnyMessage") {
             return true
         }

server/src/documentation/documentation.ts

@@ -44,8 +44,10 @@ export function generateDocFor(node: NamedNode): string | null {
             const func = new Fun(astNode, node.file)
             const doc = extractCommentsDoc(node)
 
+            const name = trimPrefix(trimPrefix(node.name(), "AnyMessage_"), "AnyStruct_")
+
             return defaultResult(
-                `${func.modifiers()}fun ${node.name()}${func.signaturePresentation()}`,
+                `${func.modifiers()}fun ${name}${func.signaturePresentation()}`,
                 doc,
             )
         }

server/src/e2e/suite/testcases/completion/fromCell.test

@@ -0,0 +1,45 @@
+========================================================================
+fromCell/fromSlice for Struct
+========================================================================
+primitive Int;
+
+fun AnyStruct_fromCell(cell: Cell): S {}
+fun AnyStruct_fromSlice(slice: Slice): S {}
+
+struct Foo {}
+
+fun test() {
+    Foo.<caret>;
+}
+------------------------------------------------------------------------
+2  fromCell(cell: Cell): S
+2  fromSlice(slice: Slice): S
+14 call  Use as function argument
+14 do  Create do-until loop
+14 if  Create if statement
+14 let  Create variable
+14 not  Negate expression
+14 repeat  Create repeat loop
+
+========================================================================
+fromCell/fromSlice for message
+========================================================================
+primitive Int;
+
+fun AnyMessage_fromCell(cell: Cell): M {}
+fun AnyMessage_fromSlice(slice: Slice): M {}
+
+message Foo {}
+
+fun test() {
+    Foo.<caret>;
+}
+------------------------------------------------------------------------
+2  fromCell(cell: Cell): M
+2  fromSlice(slice: Slice): M
+14 call  Use as function argument
+14 do  Create do-until loop
+14 if  Create if statement
+14 let  Create variable
+14 not  Negate expression
+14 repeat  Create repeat loop

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

@@ -0,0 +1,35 @@
+========================================================================
+fromCell/fromSlice for Struct
+========================================================================
+primitive Int;
+
+fun AnyStruct_fromCell(cell: Cell): S {}
+fun AnyStruct_fromSlice(slice: Slice): S {}
+
+struct Foo {}
+
+fun test() {
+    Foo.<caret>fromCell();
+}
+------------------------------------------------------------------------
+```tact
+fun fromCell(cell: Cell): S
+```
+
+========================================================================
+fromCell/fromSlice for message
+========================================================================
+primitive Int;
+
+fun AnyMessage_fromCell(cell: Cell): M {}
+fun AnyMessage_fromSlice(slice: Slice): M {}
+
+message Foo {}
+
+fun test() {
+    Foo.<caret>fromSlice();
+}
+------------------------------------------------------------------------
+```tact
+fun fromSlice(slice: Slice): M
+```

server/src/e2e/suite/testcases/resolve/fromCell.test

@@ -0,0 +1,31 @@
+========================================================================
+fromCell/fromSlice for Struct
+========================================================================
+primitive Int;
+
+fun AnyStruct_fromCell(cell: Cell): S {}
+fun AnyStruct_fromSlice(slice: Slice): S {}
+
+struct Foo {}
+
+fun test() {
+    Foo.<caret>fromCell();
+}
+------------------------------------------------------------------------
+8:8 -> 2:4 resolved
+
+========================================================================
+fromCell/fromSlice for message
+========================================================================
+primitive Int;
+
+fun AnyMessage_fromCell(cell: Cell): M {}
+fun AnyMessage_fromSlice(slice: Slice): M {}
+
+message Foo {}
+
+fun test() {
+    Foo.<caret>fromSlice();
+}
+------------------------------------------------------------------------
+8:8 -> 3:4 resolved

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

@@ -0,0 +1,33 @@
+========================================================================
+fromCell/fromSlice for Struct
+========================================================================
+primitive Int;
+
+fun AnyStruct_fromCell(cell: Cell): S {}
+fun AnyStruct_fromSlice(slice: Slice): S {}
+
+struct Foo {}
+
+fun test() {
+    let f = Foo.<caret>;
+    //  ^! Foo
+}
+------------------------------------------------------------------------
+ok
+
+========================================================================
+fromCell/fromSlice for message
+========================================================================
+primitive Int;
+
+fun AnyMessage_fromCell(cell: Cell): M {}
+fun AnyMessage_fromSlice(slice: Slice): M {}
+
+message Foo {}
+
+fun test() {
+    let f = Foo.<caret>;
+    //  ^! Foo
+}
+------------------------------------------------------------------------
+ok

server/src/psi/Reference.ts

@@ -179,6 +179,36 @@ export class Reference {
         if (qualifierType === null) return true
 
         if (qualifierType instanceof StructTy || qualifierType instanceof MessageTy) {
+            if (qualifier.node.type === "identifier") {
+                const resolved = Reference.resolve(new NamedNode(qualifier.node, qualifier.file))
+                if (resolved instanceof Struct || resolved instanceof Message) {
+                    // found `Foo.fromCell` case
+                    const prefix = resolved instanceof Struct ? "AnyStruct_" : "AnyMessage_"
+
+                    const fromCellName = prefix + "fromCell"
+                    const fromCell = index.elementByName(IndexKey.Funs, fromCellName)
+                    if (fromCell) {
+                        const newState = state.withValue(
+                            "search-name",
+                            prefix + this.element.name(),
+                        )
+                        if (!proc.execute(fromCell, newState)) return false
+                    }
+
+                    const fromSliceName = prefix + "fromSlice"
+                    const fromSlice = index.elementByName(IndexKey.Funs, fromSliceName)
+                    if (fromSlice) {
+                        const newState = state.withValue(
+                            "search-name",
+                            prefix + this.element.name(),
+                        )
+                        if (!proc.execute(fromSlice, newState)) return false
+                    }
+
+                    return true
+                }
+            }
+
             const nodeStruct = index.elementByName(IndexKey.Primitives, "AnyStruct")
             if (nodeStruct) {
                 const structPrimitiveTy = new PrimitiveTy("AnyStruct", nodeStruct, null)
@@ -418,6 +448,13 @@ export class Reference {
                 public execute(node: Node, state: ResolveState): boolean {
                     if (!(node instanceof Fun)) return true
                     if (node.withSelf()) return true // don't add methods to unqualified completion
+                    if (
+                        node.name().startsWith("AnyStruct_") ||
+                        node.name().startsWith("AnyMessage_")
+                    ) {
+                        // this functions in fact static methods
+                        return true
+                    }
                     return proc.execute(node, state)
                 }
             })()

stubs/stubs.tact

@@ -131,6 +131,12 @@ primitive AnyStruct;
 /// Pseudo-type that represents any Message.
 primitive AnyMessage;
 
+fun AnyStruct_fromCell(cell: Cell): S {}
+fun AnyStruct_fromSlice(slice: Slice): S {}
+
+fun AnyMessage_fromCell(cell: Cell): M {}
+fun AnyMessage_fromSlice(slice: Slice): M {}
+
 /// Extension function for any Struct.
 ///
 /// Converts the Struct to a `Cell` and returns it.