fix(tolk/inspections): add NeedNotNullUnwrapping inspection (#72)

Fixes #50

Author: i582

package.json

@@ -434,7 +434,8 @@
                                 "deprecated-symbol-usage",
                                 "unused-import",
                                 "struct-initialization",
-                                "cannot-reassign"
+                                "cannot-reassign",
+                                "need-not-null-unwrapping"
                             ]
                         },
                         "default": [

server/src/e2e/tolk/testcases/inspections/NeedNotNullUnwrappingInspection.test

@@ -0,0 +1,96 @@
+========================================================================
+Simple nullable builtin type
+========================================================================
+fun int.someMethod(self) {}
+
+fun main(value: int?) {
+    value.someMethod();
+}
+------------------------------------------------------------------------
+3 0:8 to 0:18 Method 'someMethod' is never used (tolk)
+0 3:10 to 3:20 Cannot call method `someMethod` on nullable type `int?`, you need to unwrap it with `!` or explicitly check for `value != null` (tolk)
+
+========================================================================
+Simple nullable builtin type, fixed
+========================================================================
+fun int.someMethod(self) {}
+
+fun main(value: int?) {
+    value!.someMethod();
+}
+------------------------------------------------------------------------
+no issues
+
+========================================================================
+Simple nullable builtin type, fixed 2
+========================================================================
+fun int.someMethod(self) {}
+
+fun main(value: int?) {
+    if (value == null) {
+        return
+    }
+    value.someMethod();
+}
+------------------------------------------------------------------------
+no issues
+
+========================================================================
+Simple nullable builtin type, fixed 3
+========================================================================
+fun int.someMethod(self) {}
+
+fun main(value: int?) {
+    if (value != null) {
+        value.someMethod();
+    }
+}
+------------------------------------------------------------------------
+no issues
+
+========================================================================
+Tensor nullable builtin type
+========================================================================
+fun (int, slice).someMethod(self) {}
+
+fun main(value: (int, slice)?) {
+    value.someMethod();
+}
+------------------------------------------------------------------------
+3 0:17 to 0:27 Method 'someMethod' is never used (tolk)
+0 3:10 to 3:20 Cannot call method `someMethod` on nullable type `(int, slice)?`, you need to unwrap it with `!` or explicitly check for `value != null` (tolk)
+
+========================================================================
+Simple nullable builtin type without methods
+========================================================================
+fun main(value: int?) {
+    value.someMethod();
+}
+------------------------------------------------------------------------
+no issues
+
+========================================================================
+Simple nullable builtin type with several methods
+========================================================================
+fun (int, slice).someMethod(self) {}
+fun T.someMethod(self) {}
+
+fun main(value: int?) {
+    value.someMethod();
+}
+------------------------------------------------------------------------
+3 0:17 to 0:27 Method 'someMethod' is never used (tolk)
+
+========================================================================
+Simple nullable builtin type with complex qualifier
+========================================================================
+fun int.someMethod(self) {}
+
+fun getData(): int? { return null }
+
+fun main() {
+    getData().someMethod();
+}
+------------------------------------------------------------------------
+3 0:8 to 0:18 Method 'someMethod' is never used (tolk)
+0 5:14 to 5:24 Cannot call method `someMethod` on nullable type `int?`, you need to unwrap it with `!` or explicitly check for `getData() != null` (tolk)

server/src/languages/tolk/inspections/Inspection.ts

@@ -13,6 +13,7 @@ export const InspectionIds = {
     STRUCT_INITIALIZATION: "struct-initialization",
     TYPE_COMPATIBILITY: "type-compatibility",
     CANNOT_REASSIGN: "cannot-reassign",
+    NEED_NOT_NULL_UNWRAPPING: "need-not-null-unwrapping",
 } as const
 
 export type InspectionId = (typeof InspectionIds)[keyof typeof InspectionIds]

server/src/languages/tolk/inspections/NeedNotNullUnwrappingInspection.ts

@@ -0,0 +1,76 @@
+//  SPDX-License-Identifier: MIT
+//  Copyright © 2025 TON Core
+import * as lsp from "vscode-languageserver"
+import type {TolkFile} from "@server/languages/tolk/psi/TolkFile"
+import {asLspPosition, asLspRange} from "@server/utils/position"
+import {RecursiveVisitor} from "@server/visitor/visitor"
+import {Inspection, InspectionIds} from "./Inspection"
+import {inferenceOf, methodCandidates} from "@server/languages/tolk/type-inference"
+import {CallLike} from "@server/languages/tolk/psi/TolkNode"
+import {Ty, UnknownTy, UnionTy} from "@server/languages/tolk/types/ty"
+import {Node as SyntaxNode} from "web-tree-sitter"
+import {FileDiff} from "@server/utils/FileDiff"
+
+export class NeedNotNullUnwrappingInspection implements Inspection {
+    public readonly id: "need-not-null-unwrapping" = InspectionIds.NEED_NOT_NULL_UNWRAPPING
+
+    public inspect(file: TolkFile): lsp.Diagnostic[] {
+        if (file.fromStdlib) return []
+        const diagnostics: lsp.Diagnostic[] = []
+
+        RecursiveVisitor.visit(file.rootNode, node => {
+            if (node.type !== "function_call") return true
+            const call = new CallLike(node, file)
+            const calleeName = call.calleeName()
+            if (!calleeName) return true
+
+            const inference = inferenceOf(node, file)
+            if (!inference) return true
+
+            const resolved = inference.resolve(calleeName)
+            if (resolved) return true // already resolved, all okay
+
+            const qualifier = call.calleeQualifier()
+            if (!qualifier) return true // simple call like `foo()`
+
+            const qualifierType = inference.typeOf(qualifier)
+            if (!qualifierType) return true
+
+            if (qualifierType instanceof UnionTy && qualifierType.asNullable()) {
+                // try to find methods for unwrapped T?
+                const asNullable =
+                    qualifierType.asNullable() ??
+                    ([UnknownTy.UNKNOWN as Ty, UnknownTy.UNKNOWN as Ty] as const)
+                const innerTy = asNullable[0]
+
+                const methods = methodCandidates(inference.ctx, innerTy, calleeName.text)
+                if (methods.length === 0) return true // no options for this type
+
+                diagnostics.push({
+                    severity: lsp.DiagnosticSeverity.Error,
+                    range: asLspRange(calleeName),
+                    message: `Cannot call method \`${calleeName.text}\` on nullable type \`${qualifierType.name()}\`, you need to unwrap it with \`!\` or explicitly check for \`${qualifier.text} != null\``,
+                    source: "tolk",
+                    data: this.unwrapWithNotNull(file, qualifier),
+                })
+            }
+
+            return true
+        })
+
+        return diagnostics
+    }
+
+    private unwrapWithNotNull(file: TolkFile, qualifier: SyntaxNode): undefined | lsp.CodeAction {
+        const diff = FileDiff.forFile(file.uri)
+
+        diff.appendTo(asLspPosition(qualifier.endPosition), "!")
+
+        const edit = diff.toWorkspaceEdit()
+        return {
+            edit,
+            title: `Unwrap with \`!\` (unsafe)`,
+            isPreferred: true,
+        }
+    }
+}

server/src/languages/tolk/inspections/index.ts

@@ -11,6 +11,7 @@ import {TypeCompatibilityInspection} from "@server/languages/tolk/inspections/Ty
 import {CannotReassignInspection} from "@server/languages/tolk/inspections/CannotReassignInspection"
 import {UnusedTopLevelDeclarationInspection} from "@server/languages/tolk/inspections/UnusedTopLevelDeclarationInspection"
 import {UnusedTypeParameterInspection} from "@server/languages/tolk/inspections/UnusedTypeParameterInspection"
+import {NeedNotNullUnwrappingInspection} from "@server/languages/tolk/inspections/NeedNotNullUnwrappingInspection"
 
 export async function runTolkInspections(
     uri: string,
@@ -27,6 +28,7 @@ export async function runTolkInspections(
         new StructInitializationInspection(),
         new TypeCompatibilityInspection(),
         new CannotReassignInspection(),
+        new NeedNotNullUnwrappingInspection(),
     ]
 
     const settings = await getDocumentSettings(uri)

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

@@ -363,6 +363,15 @@ class InferenceWalker {
 
     public constructor(public ctx: InferenceContext) {}
 
+    public static methodCandidates(
+        ctx: InferenceContext,
+        qualifierTy: Ty,
+        searchName: string,
+    ): MethodBase[] {
+        const walker = new InferenceWalker(ctx)
+        return walker.methodCandidates(qualifierTy, searchName)
+    }
+
     public inferConstant(constant: Constant, flow: FlowContext): FlowContext {
         const expression = constant.value()?.node
         if (!expression) return flow
@@ -2659,3 +2668,11 @@ export function functionTypeOf(func: FunctionBase): FuncTy | null {
     }
     return null
 }
+
+export function methodCandidates(
+    ctx: InferenceContext,
+    qualifierTy: Ty,
+    searchName: string,
+): MethodBase[] {
+    return InferenceWalker.methodCandidates(ctx, qualifierTy, searchName)
+}