pi-lens 3.8.65 → 3.8.67

package/dist/clients/dispatch/facts/function-facts.js

@@ -1,4 +1,4 @@
-import { ts } from "../../deps/typescript.js";
+import { extractFactsFromTree, firstChildOfType, walk, } from "./tree-sitter-facts.js";
 const BOUNDARY_PREFIXES = [
     "fetch",
     "fs.",
@@ -9,139 +9,177 @@ const BOUNDARY_PREFIXES = [
     "req.",
     "res.",
 ];
+const FUNCTION_TYPES = new Set([
+    "function_declaration",
+    "method_definition",
+    "function_expression",
+    "arrow_function",
+]);
+// Decision points for McCabe complexity (matches the old ts.SyntaxKind set).
+const COMPLEXITY_TYPES = new Set([
+    "if_statement",
+    "for_statement",
+    "for_in_statement", // for…of and for…in both parse to for_in_statement
+    "while_statement",
+    "do_statement",
+    "switch_case", // `case` only — `default` (switch_default) is not counted
+    "catch_clause",
+    "ternary_expression",
+]);
+// Control structures that increase nesting depth (matches the old set).
+const NESTING_TYPES = new Set([
+    "if_statement",
+    "for_statement",
+    "for_in_statement",
+    "while_statement",
+    "do_statement",
+    "switch_statement",
+    "try_statement",
+]);
+const LOGICAL_OPERATORS = new Set(["&&", "||", "??"]);
+/** Named children excluding comments — i.e. the "real" statements/args/expressions. */
+function namedChildren(node) {
+    return (node.children ?? []).filter((c) => c && c.isNamed && c.type !== "comment");
+}
+/** First named, non-comment child (e.g. a return statement's returned expression). */
+function firstNamedChild(node) {
+    return namedChildren(node)[0];
+}
+function getBody(node) {
+    // Only block-bodied functions get a summary (expression-bodied arrows have no
+    // statement_block — matching the old `!ts.isBlock(body)` skip).
+    return firstChildOfType(node, "statement_block");
+}
+function getParameters(node) {
+    const fp = firstChildOfType(node, "formal_parameters");
+    if (!fp)
+        return [];
+    return (fp.children ?? []).filter((c) => c &&
+        (c.type === "required_parameter" ||
+            c.type === "optional_parameter" ||
+            c.type === "rest_pattern"));
+}
+function parameterName(param) {
+    return firstNamedChild(param)?.text ?? "";
+}
 function getFunctionName(node) {
-    if (ts.isFunctionDeclaration(node)) {
-        return node.name?.text ?? "<anonymous>";
+    if (node.type === "function_declaration") {
+        return firstChildOfType(node, "identifier")?.text ?? "<anonymous>";
     }
-    if (ts.isMethodDeclaration(node)) {
-        if (ts.isIdentifier(node.name))
-            return node.name.text;
-        return node.name.getText();
+    if (node.type === "method_definition") {
+        // The name is the child just before formal_parameters (property_identifier /
+        // private / computed / string / number); skip async/get/set modifiers.
+        const kids = node.children ?? [];
+        const paramsIdx = kids.findIndex((c) => c?.type === "formal_parameters");
+        for (let i = paramsIdx - 1; i >= 0; i -= 1) {
+            const t = kids[i]?.type;
+            if (t === "property_identifier" ||
+                t === "private_property_identifier" ||
+                t === "computed_property_name" ||
+                t === "string" ||
+                t === "number") {
+                return kids[i].text;
+            }
+        }
+        return "<anonymous>";
     }
-    if (ts.isArrowFunction(node) || ts.isFunctionExpression(node)) {
+    if (node.type === "arrow_function" || node.type === "function_expression") {
+        // Name comes from the binding site (like the old parent-based lookup):
+        // `const f = () => …` / `{ prop: () => … }`.
         const parent = node.parent;
-        if (ts.isVariableDeclaration(parent) && ts.isIdentifier(parent.name)) {
-            return parent.name.text;
+        if (parent?.type === "variable_declarator") {
+            const id = firstChildOfType(parent, "identifier");
+            if (id)
+                return id.text;
         }
-        if (ts.isPropertyAssignment(parent)) {
-            return parent.name.getText();
+        else if (parent?.type === "pair") {
+            const key = (parent.children ?? [])[0];
+            if (key)
+                return key.text;
         }
         return "<anonymous>";
     }
     return "<unknown>";
 }
 function isCallPassThrough(stmt, paramNames) {
-    if (!ts.isReturnStatement(stmt) || !stmt.expression)
+    if (stmt.type !== "return_statement")
         return { pass: false };
-    const expr = stmt.expression;
-    if (!ts.isCallExpression(expr))
+    const expr = firstNamedChild(stmt);
+    if (!expr || expr.type !== "call_expression")
         return { pass: false };
-    const args = expr.arguments.map((a) => a.getText());
+    const argsNode = firstChildOfType(expr, "arguments");
+    const args = argsNode ? namedChildren(argsNode).map((a) => a.text) : [];
     if (args.length !== paramNames.length)
         return { pass: false };
     for (let i = 0; i < args.length; i += 1) {
         if (args[i] !== paramNames[i])
             return { pass: false };
     }
-    return { pass: true, target: expr.expression.getText() };
+    return { pass: true, target: (expr.children ?? [])[0]?.text };
 }
 function calcCyclomaticComplexity(body) {
     let cc = 1;
-    const walk = (node) => {
-        switch (node.kind) {
-            case ts.SyntaxKind.IfStatement:
-            case ts.SyntaxKind.ForStatement:
-            case ts.SyntaxKind.ForInStatement:
-            case ts.SyntaxKind.ForOfStatement:
-            case ts.SyntaxKind.WhileStatement:
-            case ts.SyntaxKind.DoStatement:
-            case ts.SyntaxKind.CaseClause:
-            case ts.SyntaxKind.CatchClause:
-            case ts.SyntaxKind.ConditionalExpression:
+    walk(body, (node) => {
+        if (COMPLEXITY_TYPES.has(node.type)) {
+            cc++;
+        }
+        else if (node.type === "binary_expression") {
+            if ((node.children ?? []).some((c) => LOGICAL_OPERATORS.has(c?.type))) {
                 cc++;
-                break;
-            case ts.SyntaxKind.BinaryExpression: {
-                const op = node.operatorToken.kind;
-                if (op === ts.SyntaxKind.AmpersandAmpersandToken ||
-                    op === ts.SyntaxKind.BarBarToken ||
-                    op === ts.SyntaxKind.QuestionQuestionToken)
-                    cc++;
-                break;
             }
         }
-        ts.forEachChild(node, walk);
-    };
-    walk(body);
+    });
     return cc;
 }
 function calcMaxNestingDepth(body) {
     let maxDepth = 0;
-    const isNestingNode = (node) => {
-        switch (node.kind) {
-            case ts.SyntaxKind.IfStatement:
-            case ts.SyntaxKind.ForStatement:
-            case ts.SyntaxKind.ForInStatement:
-            case ts.SyntaxKind.ForOfStatement:
-            case ts.SyntaxKind.WhileStatement:
-            case ts.SyntaxKind.DoStatement:
-            case ts.SyntaxKind.SwitchStatement:
-            case ts.SyntaxKind.TryStatement:
-                return true;
-            default:
-                return false;
-        }
-    };
-    const walk = (node, depth) => {
+    const walkDepth = (node, depth) => {
         if (depth > maxDepth)
             maxDepth = depth;
-        const next = isNestingNode(node) ? depth + 1 : depth;
-        ts.forEachChild(node, (child) => walk(child, next));
+        const next = NESTING_TYPES.has(node.type) ? depth + 1 : depth;
+        for (const child of node.children ?? []) {
+            if (child)
+                walkDepth(child, next);
+        }
     };
-    ts.forEachChild(body, (child) => walk(child, 0));
+    // Start at the body's children at depth 0 (the body block itself isn't counted).
+    for (const child of body.children ?? []) {
+        if (child)
+            walkDepth(child, 0);
+    }
     return maxDepth;
 }
 function collectOutgoingCalls(body) {
     const calls = new Set();
-    const walk = (node) => {
-        if (ts.isCallExpression(node)) {
-            const callee = node.expression.getText();
+    walk(body, (node) => {
+        if (node.type === "call_expression") {
+            const callee = (node.children ?? [])[0]?.text ?? "";
             if (callee.length < 80)
                 calls.add(callee);
         }
-        ts.forEachChild(node, walk);
-    };
-    walk(body);
+    });
     return [...calls];
 }
 function hasAwaitInNode(node) {
     let found = false;
-    const walk = (n) => {
-        if (found)
-            return;
-        if (ts.isAwaitExpression(n)) {
+    walk(node, (n) => {
+        if (n.type === "await_expression")
             found = true;
-            return;
-        }
-        ts.forEachChild(n, walk);
-    };
-    walk(node);
+    });
     return found;
 }
 function hasReturnAwaitCall(node) {
     let found = false;
-    const walk = (n) => {
-        if (found)
+    walk(node, (n) => {
+        if (n.type !== "return_statement")
             return;
-        if (ts.isReturnStatement(n) &&
-            n.expression &&
-            ts.isAwaitExpression(n.expression) &&
-            ts.isCallExpression(n.expression.expression)) {
-            found = true;
+        const ret = firstNamedChild(n);
+        if (ret?.type !== "await_expression")
             return;
-        }
-        ts.forEachChild(n, walk);
-    };
-    walk(node);
+        const awaited = firstNamedChild(ret);
+        if (awaited?.type === "call_expression")
+            found = true;
+    });
     return found;
 }
 export const functionFactProvider = {
@@ -151,54 +189,45 @@ export const functionFactProvider = {
     appliesTo(ctx) {
         return /\.tsx?$/.test(ctx.filePath);
     },
-    run(ctx, store) {
-        const content = store.getFileFact(ctx.filePath, "file.content");
-        if (!content) {
-            store.setFileFact(ctx.filePath, "file.functionSummaries", []);
-            return;
-        }
-        const sourceFile = ts.createSourceFile(ctx.filePath, content, ts.ScriptTarget.Latest, true, ts.ScriptKind.TSX);
-        const summaries = [];
-        const addSummary = (node) => {
-            const body = node.body;
-            if (!body || !ts.isBlock(body))
-                return;
-            const lc = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile));
-            const paramNames = node.parameters.map((p) => p.name.getText(sourceFile));
-            const statementCount = body.statements.length;
-            const passThrough = statementCount === 1
-                ? isCallPassThrough(body.statements[0], paramNames)
-                : { pass: false };
-            const target = passThrough.target ?? "";
-            const lowerTarget = target.toLowerCase();
-            const isBoundaryWrapper = BOUNDARY_PREFIXES.some((prefix) => lowerTarget.startsWith(prefix));
-            summaries.push({
-                name: getFunctionName(node),
-                line: lc.line + 1,
-                column: lc.character + 1,
-                isAsync: !!node.modifiers?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword),
-                hasAwait: hasAwaitInNode(body),
-                hasReturnAwaitCall: hasReturnAwaitCall(body),
-                statementCount,
-                parameterCount: node.parameters.length,
-                isPassThroughWrapper: passThrough.pass,
-                passThroughTarget: passThrough.target,
-                isBoundaryWrapper,
-                cyclomaticComplexity: calcCyclomaticComplexity(body),
-                maxNestingDepth: calcMaxNestingDepth(body),
-                outgoingCalls: collectOutgoingCalls(body),
+    async run(ctx, store) {
+        await extractFactsFromTree(ctx, store, { "file.functionSummaries": [] }, (root) => {
+            const summaries = [];
+            const addSummary = (node) => {
+                const body = getBody(node);
+                if (!body)
+                    return;
+                const params = getParameters(node);
+                const paramNames = params.map(parameterName);
+                const statements = namedChildren(body);
+                const statementCount = statements.length;
+                const passThrough = statementCount === 1
+                    ? isCallPassThrough(statements[0], paramNames)
+                    : { pass: false };
+                const target = passThrough.target ?? "";
+                const lowerTarget = target.toLowerCase();
+                const isBoundaryWrapper = BOUNDARY_PREFIXES.some((prefix) => lowerTarget.startsWith(prefix));
+                summaries.push({
+                    name: getFunctionName(node),
+                    line: node.startPosition.row + 1,
+                    column: node.startPosition.column + 1,
+                    isAsync: Boolean(firstChildOfType(node, "async")),
+                    hasAwait: hasAwaitInNode(body),
+                    hasReturnAwaitCall: hasReturnAwaitCall(body),
+                    statementCount,
+                    parameterCount: params.length,
+                    isPassThroughWrapper: passThrough.pass,
+                    passThroughTarget: passThrough.target,
+                    isBoundaryWrapper,
+                    cyclomaticComplexity: calcCyclomaticComplexity(body),
+                    maxNestingDepth: calcMaxNestingDepth(body),
+                    outgoingCalls: collectOutgoingCalls(body),
+                });
+            };
+            walk(root, (node) => {
+                if (FUNCTION_TYPES.has(node.type))
+                    addSummary(node);
             });
-        };
-        const visit = (node) => {
-            if (ts.isFunctionDeclaration(node) ||
-                ts.isMethodDeclaration(node) ||
-                ts.isFunctionExpression(node) ||
-                ts.isArrowFunction(node)) {
-                addSummary(node);
-            }
-            ts.forEachChild(node, visit);
-        };
-        visit(sourceFile);
-        store.setFileFact(ctx.filePath, "file.functionSummaries", summaries);
+            return { "file.functionSummaries": summaries };
+        });
     },
 };