cgraphx 2.0.2 → 2.0.3

package/dist/core/code/engine/core/ingestion/languages/go/query.js

@@ -0,0 +1,298 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getGoParser = getGoParser;
+exports.getGoScopeQuery = getGoScopeQuery;
+const tree_sitter_1 = __importDefault(require("tree-sitter"));
+const node_module_1 = require("node:module");
+// 懒加载(spec §7/§13):tree-sitter-go 移至 devDependencies,生产 --omit=dev 不装。
+// 首次用到时按需 require + 缓存;失败 → null,该语言降级为结构层收录,不阻断 analyze。
+const _require = (0, node_module_1.createRequire)(__filename);
+let _goGrammar;
+const loadGoGrammar = () => {
+    if (_goGrammar !== undefined)
+        return _goGrammar;
+    try {
+        _goGrammar = _require('tree-sitter-go');
+    }
+    catch {
+        _goGrammar = null;
+    }
+    return _goGrammar;
+};
+const GO_SCOPE_QUERY = `
+;; Scopes
+(source_file) @scope.module
+;; One Class scope per DECLARED TYPE, not per declaration (#2837).
+;;
+;; Capturing the type_declaration made a grouped declaration
+;;   type (
+;;     Decoy       struct { ... }
+;;     PickService struct { ... }
+;;   )
+;; a SINGLE Class scope owning every struct in the block. Downstream that scope
+;; can name only one owner -- buildWorkspaceResolutionIndex keeps the first
+;; class-like def it finds -- so the block's structs lost their field type
+;; bindings, typeOfMemberOnClass found no scope, the compound-receiver fold
+;; declined, and every s.field.Method() site in the file emitted nothing at
+;; all. Silent, per-file, and independent of file size: exactly the split
+;; reported in #2837 that #2829's global fixes could not explain. Measured on
+;; the go-grouped-type-decl fixture: EVERY struct in a grouped block lost its
+;; edges, the first one included, and grouped interface blocks produced no
+;; IMPLEMENTS edges at all.
+;;
+;; type_spec is the node Go's own grammar gives one declared type, so one
+;; capture per type_spec is the granularity the rest of the pipeline already
+;; assumes. A plain single-type declaration is unaffected in count -- only its
+;; scope range narrows, from the type keyword to the name.
+;;
+;; NOTE: this string is a JS template literal. Backticks are a syntax error.
+(type_declaration
+  (type_spec
+    type: [(struct_type) (interface_type)]) @scope.class)
+(function_declaration) @scope.function
+(method_declaration) @scope.function
+(func_literal) @scope.function
+(block) @scope.block
+(if_statement) @scope.block
+(for_statement) @scope.block
+(select_statement) @scope.block
+(expression_switch_statement) @scope.block
+(type_switch_statement) @scope.block
+(expression_case) @scope.block
+(default_case) @scope.block
+(type_case) @scope.block
+(communication_case) @scope.block
+
+;; Declarations — struct
+;;
+;; Anchored on the type_spec, in lockstep with @scope.class above (#2837). Both
+;; captures MUST name the same node: the def node and the class-scope node are
+;; paired by range, so anchoring the def on the enclosing type_declaration while
+;; the scope sits on the type_spec leaves the def strictly larger than its own
+;; scope and NOTHING is owned -- measured as every Go field-receiver edge in the
+;; fixture disappearing, plain declarations included. Keeping both on
+;; type_declaration is the original bug: a grouped block gave both structs the
+;; same capture node, so one silently displaced the other.
+(type_declaration
+  (type_spec name: (type_identifier) @declaration.name
+    type: (struct_type)) @declaration.struct)
+
+;; Declarations — interface
+;; Same lockstep requirement as @declaration.struct above (#2837).
+(type_declaration
+  (type_spec name: (type_identifier) @declaration.name
+    type: (interface_type)) @declaration.interface)
+
+;; Declarations — function
+(function_declaration
+  name: (identifier) @declaration.name) @declaration.function
+
+;; Declarations — closure bindings (\`var f = func(){}\`, \`f := func(){}\`).
+;; The \`@declaration.function\` anchor sits on the INNER func_literal so its
+;; range aligns with the \`(func_literal) @scope.function\` scope above —
+;; without that alignment pass2AttachDeclarations owns the def by the module
+;; scope and calls inside the closure lose caller attribution. Mirrors the
+;; TypeScript \`const f = () => {}\` patterns (#2687).
+(var_declaration
+  (var_spec
+    name: (identifier) @declaration.name
+    value: (expression_list (func_literal) @declaration.function)))
+(var_declaration
+  (var_spec_list
+    (var_spec
+      name: (identifier) @declaration.name
+      value: (expression_list (func_literal) @declaration.function))))
+(short_var_declaration
+  left: (expression_list (identifier) @declaration.name)
+  right: (expression_list (func_literal) @declaration.function))
+
+;; Declarations — method
+(method_declaration
+  name: (field_identifier) @declaration.name) @declaration.method
+
+;; Declarations — interface methods
+(method_elem
+  name: (field_identifier) @declaration.name) @declaration.method
+
+;; Declarations — struct fields
+(struct_type
+  (field_declaration_list
+    (field_declaration
+      name: (field_identifier) @declaration.name
+      type: (_) @declaration.field-type))) @declaration.field
+
+;; Declarations — variables
+(var_declaration
+  (var_spec
+    (identifier) @declaration.name)) @declaration.variable
+(var_declaration
+  (var_spec_list
+    (var_spec
+      (identifier) @declaration.name))) @declaration.variable
+
+(const_declaration
+  (const_spec
+    (identifier) @declaration.name)) @declaration.const
+
+(short_var_declaration
+  left: (expression_list (identifier) @declaration.name)) @declaration.variable
+
+;; Imports
+(import_spec) @import.statement
+
+;; Type bindings — parameter annotations
+(function_declaration
+  name: (identifier) @_fn_name
+  parameters: (parameter_list
+    (parameter_declaration
+      name: (identifier) @type-binding.name
+      type: [(type_identifier) (qualified_type) (pointer_type) (slice_type) (map_type) (channel_type) (array_type) (function_type) (interface_type) (generic_type)] @type-binding.type))) @type-binding.parameter
+
+(method_declaration
+  name: (field_identifier) @_fn_name
+  parameters: (parameter_list
+    (parameter_declaration
+      name: (identifier) @type-binding.name
+      type: [(type_identifier) (qualified_type) (pointer_type) (slice_type) (map_type) (channel_type) (array_type) (function_type) (interface_type) (generic_type)] @type-binding.type))) @type-binding.parameter
+
+;; Type bindings — constructor-inferred (:= T{})
+(short_var_declaration
+  left: (expression_list (identifier) @type-binding.name)
+  right: (expression_list
+    (composite_literal
+      type: [(type_identifier) (qualified_type) (generic_type)] @type-binding.type))) @type-binding.constructor
+
+;; Type bindings — pointer constructor (:= &T{})
+(short_var_declaration
+  left: (expression_list (identifier) @type-binding.name)
+  right: (expression_list
+    (unary_expression
+      "&"
+      operand: (composite_literal
+        type: [(type_identifier) (qualified_type) (generic_type)] @type-binding.type)))) @type-binding.constructor
+
+;; Type bindings — type assertion (:= s.(T))
+(short_var_declaration
+  left: (expression_list (identifier) @type-binding.name)
+  right: (expression_list
+    (type_assertion_expression
+      type: (_) @type-binding.type))) @type-binding.assertion
+
+(var_declaration
+  (var_spec
+    name: (identifier) @type-binding.name
+    value: (expression_list
+      (type_assertion_expression
+        type: (_) @type-binding.type)))) @type-binding.assertion
+
+;; Type bindings — explicit var type
+(var_declaration
+  (var_spec
+    name: (identifier) @type-binding.name
+    type: (_) @type-binding.type)) @type-binding.assignment
+
+;; Type bindings — call-return inference (:= Func(args))
+(short_var_declaration
+  left: (expression_list (identifier) @type-binding.name)
+  right: (expression_list (call_expression
+    function: (identifier) @type-binding.type))) @type-binding.call-return
+
+;; Type bindings — call-return inference qualified (:= pkg.Func(args))
+(short_var_declaration
+  left: (expression_list (identifier) @type-binding.name)
+  right: (expression_list (call_expression
+    function: (selector_expression
+      field: (field_identifier) @type-binding.type)))) @type-binding.call-return
+
+;; Type bindings — return type annotation (func Foo() *Type)
+(function_declaration
+  name: (identifier) @type-binding.name
+  result: (_) @type-binding.type) @type-binding.return
+
+;; Type bindings — method return type (func (r *T) Method() *Type)
+(method_declaration
+  name: (field_identifier) @type-binding.name
+  result: (_) @type-binding.type) @type-binding.return
+
+;; Type bindings — variable alias (y := x)
+(short_var_declaration
+  left: (expression_list (identifier) @type-binding.name)
+  right: (expression_list (identifier) @type-binding.type)) @type-binding.alias
+
+;; Type bindings — variable alias var form (var x = y)
+(var_declaration
+  (var_spec
+    name: (identifier) @type-binding.name
+    value: (expression_list (identifier) @type-binding.type))) @type-binding.alias
+
+;; Type bindings — call-return var form (var x = Func())
+(var_declaration
+  (var_spec
+    name: (identifier) @type-binding.name
+    value: (expression_list (call_expression
+      function: (identifier) @type-binding.type)))) @type-binding.call-return
+
+;; References — free calls
+(call_expression
+  function: (identifier) @reference.name) @reference.call.free
+
+;; References — member calls
+(call_expression
+  function: (selector_expression
+    operand: (_) @reference.receiver
+    field: (field_identifier) @reference.name)) @reference.call.member
+
+;; References — constructor calls (T{})
+(composite_literal
+  type: [(type_identifier) (qualified_type) (generic_type)] @reference.name) @reference.call.constructor
+
+;; References — field reads
+(selector_expression
+  operand: (_) @reference.receiver
+  field: (field_identifier) @reference.name) @reference.read
+
+;; References — field writes (assignment)
+(assignment_statement
+  left: (expression_list
+    (selector_expression
+      operand: (_) @reference.receiver
+      field: (field_identifier) @reference.name))) @reference.write
+
+;; References — field writes (inc: obj.Field++)
+(inc_statement
+  (selector_expression
+    operand: (_) @reference.receiver
+    field: (field_identifier) @reference.name)) @reference.write
+
+;; References — field writes (dec: obj.Field--)
+(dec_statement
+  (selector_expression
+    operand: (_) @reference.receiver
+    field: (field_identifier) @reference.name)) @reference.write
+`;
+let _parser = null;
+let _query = null;
+function getGoParser() {
+    if (_parser === null) {
+        const grammar = loadGoGrammar();
+        if (grammar === null) {
+            throw new Error('tree-sitter-go grammar unavailable — install it (devDependency) or the language degrades to structure-layer capture.');
+        }
+        _parser = new tree_sitter_1.default();
+        _parser.setLanguage(grammar);
+    }
+    return _parser;
+}
+function getGoScopeQuery() {
+    if (_query === null) {
+        const grammar = loadGoGrammar();
+        if (grammar === null) {
+            throw new Error('tree-sitter-go grammar unavailable — install it (devDependency) or the language degrades to structure-layer capture.');
+        }
+        _query = new tree_sitter_1.default.Query(grammar, GO_SCOPE_QUERY);
+    }
+    return _query;
+}

package/dist/core/code/engine/core/ingestion/languages/go/range-binding.js

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.populateGoRangeBindings = populateGoRangeBindings;
+const query_js_1 = require("./query.js");
+const constants_js_1 = require("../../constants.js");
+const safe_parse_js_1 = require("../../../tree-sitter/safe-parse.js");
+const logger_js_1 = require("../../../logger.js");
+function populateGoRangeBindings(parsedFiles, _indexes, ctx) {
+    const parser = (0, query_js_1.getGoParser)();
+    for (const parsed of parsedFiles) {
+        const sourceText = ctx.fileContents.get(parsed.filePath);
+        if (sourceText === undefined)
+            continue;
+        const cachedTree = ctx.treeCache?.get(parsed.filePath);
+        let tree;
+        if (cachedTree !== undefined) {
+            tree = cachedTree;
+        }
+        else {
+            try {
+                tree = (0, safe_parse_js_1.parseSourceSafe)(parser, sourceText, undefined, {
+                    bufferSize: (0, constants_js_1.getTreeSitterBufferSize)(sourceText),
+                });
+            }
+            catch (err) {
+                if (err instanceof safe_parse_js_1.ParseTimeoutError) {
+                    logger_js_1.logger.warn({ file: parsed.filePath }, 'go range-binding: parse timed out, skipping file');
+                    continue;
+                }
+                throw err;
+            }
+        }
+        const moduleScope = parsed.scopes.find((s) => s.kind === 'Module');
+        if (moduleScope === undefined)
+            continue;
+        const scopeMap = new Map(parsed.scopes.map((s) => [s.id, s]));
+        for (const rangeNode of tree.rootNode.descendantsOfType('for_statement')) {
+            const rangeClause = rangeNode.namedChildren.find((c) => c.type === 'range_clause');
+            if (rangeClause === undefined)
+                continue;
+            const left = rangeClause.namedChildren.find((c) => c.type === 'expression_list');
+            if (left === undefined)
+                continue;
+            const rangeExpr = rangeClause.namedChildren.find((c, idx) => c.type !== 'expression_list' && idx > rangeClause.namedChildren.indexOf(left));
+            if (rangeExpr === undefined)
+                continue;
+            // Identify the value variable (skip the `_` discard if present)
+            const idents = left.namedChildren.filter((c) => c.type === 'identifier');
+            let valueVar = null;
+            if (idents.length >= 2) {
+                valueVar = idents[1].text; // for _, v := range ...
+            }
+            else if (idents.length === 1) {
+                valueVar = idents[0].text; // for v := range ...
+            }
+            if (valueVar === null || valueVar === '_')
+                continue;
+            // Resolve range expression type
+            let elementType = null;
+            const functionScope = findEnclosingFunctionScope(rangeNode, scopeMap);
+            if (rangeExpr.type === 'identifier') {
+                const binding = functionScope?.typeBindings.get(rangeExpr.text) ??
+                    moduleScope.typeBindings.get(rangeExpr.text);
+                if (binding !== null && binding !== undefined) {
+                    elementType = extractElementType(binding);
+                }
+            }
+            else if (rangeExpr.type === 'call_expression') {
+                const fnNode = rangeExpr.childForFieldName('function');
+                if (fnNode !== null) {
+                    const fnName = fnNode.type === 'selector_expression'
+                        ? fnNode.childForFieldName('field')?.text
+                        : fnNode.text;
+                    if (fnName !== undefined) {
+                        const binding = moduleScope.typeBindings.get(fnName);
+                        if (binding !== null && binding !== undefined) {
+                            elementType = extractElementType(binding);
+                        }
+                    }
+                }
+            }
+            if (elementType !== null && valueVar !== null) {
+                // Inject type binding for the range variable onto the enclosing function scope
+                const targetScope = functionScope ?? moduleScope;
+                const mutable = targetScope.typeBindings;
+                mutable.set(valueVar, {
+                    rawName: elementType,
+                    declaredAtScope: targetScope.id,
+                    source: 'annotation',
+                });
+            }
+        }
+    }
+}
+function extractElementType(binding) {
+    const raw = binding.rawName;
+    const mapMatch = raw.match(/^map\[[^\]]+\]\s*(.+)$/);
+    if (mapMatch)
+        return mapMatch[1].trim();
+    if (raw.startsWith('[]'))
+        return raw.slice(2).trim();
+    const arrMatch = raw.match(/^\[\d+\](.+)$/);
+    if (arrMatch)
+        return arrMatch[1].trim();
+    return raw;
+}
+function findEnclosingFunctionScope(node, scopeMap) {
+    const tsNode = node;
+    // Walk up the AST to find the enclosing function or method declaration.
+    let current = tsNode;
+    while (current !== null) {
+        if (current.type === 'function_declaration' || current.type === 'method_declaration') {
+            // Match by source position: the scope whose range starts at the
+            // same line/column as the tree-sitter node.
+            for (const scope of scopeMap.values()) {
+                if (scope.kind === 'Function' &&
+                    scope.range.startLine === current.startPosition.row + 1 &&
+                    scope.range.startCol === current.startPosition.column) {
+                    return scope;
+                }
+            }
+            break;
+        }
+        current = current.parent ?? null;
+    }
+    return null;
+}

package/dist/core/code/engine/core/ingestion/languages/go/receiver-binding.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.synthesizeGoReceiverBinding = synthesizeGoReceiverBinding;
+const ast_helpers_js_1 = require("../../utils/ast-helpers.js");
+function synthesizeGoReceiverBinding(fnNode) {
+    if (fnNode.type !== 'method_declaration')
+        return null;
+    const receiver = fnNode.childForFieldName('receiver');
+    if (receiver === null)
+        return null;
+    const param = receiver.namedChildren.find((c) => c.type === 'parameter_declaration');
+    if (param === undefined)
+        return null;
+    const nameNode = param.childForFieldName('name');
+    const typeNode = param.childForFieldName('type');
+    if (nameNode === null || typeNode === null)
+        return null;
+    const typeName = typeNode.text;
+    return {
+        '@type-binding.self': (0, ast_helpers_js_1.syntheticCapture)('@type-binding.self', fnNode, nameNode.text),
+        '@type-binding.name': (0, ast_helpers_js_1.syntheticCapture)('@type-binding.name', nameNode, nameNode.text),
+        '@type-binding.type': (0, ast_helpers_js_1.syntheticCapture)('@type-binding.type', typeNode, typeName),
+    };
+}

package/dist/core/code/engine/core/ingestion/languages/go/scope-resolver.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.goScopeResolver = void 0;
+const index_js_1 = require("../../../../../shared/index.js");
+const mro_js_1 = require("../../scope-resolution/passes/mro.js");
+const method_owners_js_1 = require("./method-owners.js");
+const language_config_js_1 = require("../../language-config.js");
+const go_js_1 = require("../go.js");
+const index_js_2 = require("./index.js");
+const interface_impls_js_1 = require("./interface-impls.js");
+const range_binding_js_1 = require("./range-binding.js");
+const expand_wildcards_js_1 = require("./expand-wildcards.js");
+const interpret_js_1 = require("./interpret.js");
+/** Slice `[]T` and array `[N]T` / `[...]T` → the element spelling. Hoisted —
+ *  a literal inside the hook would mint a fresh RegExp per folded subscript. */
+const GO_SLICE_ELEMENT_RE = /^\[[^\]]*\]\s*(.+)$/;
+exports.goScopeResolver = {
+    language: index_js_1.SupportedLanguages.Go,
+    languageProvider: go_js_1.goProvider,
+    importEdgeReason: 'go-scope: import',
+    loadResolutionConfig: (repoPath) => (0, language_config_js_1.loadGoModulePath)(repoPath),
+    resolveImportTarget: (targetRaw, fromFile, allFilePaths, resolutionConfig) => (0, index_js_2.resolveGoImportTarget)(targetRaw, fromFile, allFilePaths, resolutionConfig),
+    expandsWildcardTo: (targetModuleScope, parsedFiles) => (0, expand_wildcards_js_1.expandGoWildcardNames)(targetModuleScope, parsedFiles),
+    mergeBindings: (existing, incoming, scopeId) => (0, index_js_2.goMergeBindings)(existing, incoming, scopeId),
+    arityCompatibility: (callsite, def) => (0, index_js_2.goArityCompatibility)(def, callsite),
+    // Only `*` — a pointer leaves the method set reachable by selector unchanged,
+    // so `*Host` and `Host` name the same class for receiver typing. `[]` and
+    // `map[…]` are deliberately NOT stripped here: they are containers whose
+    // member set differs from the element's, and unwrapping them belongs to the
+    // index step that consumed a subscript. (Field bindings never reach this
+    // anyway — `normalizeGoTypeName` already strips them at capture. The one
+    // binding that arrives decorated is the receiver self-binding, kept raw on
+    // purpose for `method-owners.ts`.)
+    stripTypePreservingDecoration: (typeName) => typeName.startsWith('*') ? typeName.slice(1).trim() : undefined,
+    // The subscript counterpart of the stripper above, and the reason the two are
+    // separate hooks: `*` is safe to strip at any class lookup, `[]` / `map[K]`
+    // only where the source actually indexed. Answers the `index` route only —
+    // Go has no property-style collection view.
+    //
+    // Reads the AS-WRITTEN spelling (`[]*User`), not the capture-normalized name:
+    // `normalizeGoTypeName` already collapsed that to `User`, which is exactly the
+    // ambiguity that made an unanswered index step fold onto the container. The
+    // element is returned STILL DECORATED (`*User`) — the index step looks it up
+    // through `stripTypePreservingDecoration` above, so the pointer resolves.
+    elementTypeOf: (containerType, via) => {
+        if (via.kind !== 'index')
+            return undefined;
+        const t = containerType.trim();
+        // `map[K]V` — a subscript yields V. Literally the same matcher
+        // `normalizeGoTypeName` uses, so the two cannot disagree on what a map
+        // spelling is.
+        const mapValue = (0, interpret_js_1.goMapValueType)(t);
+        if (mapValue !== undefined)
+            return mapValue;
+        // Slice `[]T` and array `[N]T` / `[...]T`.
+        const sliceMatch = GO_SLICE_ELEMENT_RE.exec(t);
+        if (sliceMatch !== null)
+            return sliceMatch[1].trim();
+        return undefined;
+    },
+    buildMro: (graph, parsedFiles, nodeLookup) => (0, mro_js_1.buildMro)(graph, parsedFiles, nodeLookup, mro_js_1.defaultLinearize),
+    populateOwners: (parsed) => (0, method_owners_js_1.populateGoOwners)(parsed),
+    populateWorkspaceOwners: (parsedFiles, ctx) => (0, method_owners_js_1.populateGoWorkspaceOwners)(parsedFiles, ctx),
+    isSuperReceiver: () => false,
+    fieldFallbackOnMethodLookup: false,
+    hoistTypeBindingsToModule: true,
+    propagatesReturnTypesAcrossImports: true,
+    allowGlobalFreeCallFallback: true,
+    populateNamespaceSiblings: index_js_2.populateGoPackageSiblings,
+    mirrorNamespaceTypeBindings: index_js_2.mirrorGoNamespaceTypeBindings,
+    // Go has structural interfaces: implementations are inferred by signature,
+    // then fed into generic MRO/interface-dispatch.
+    detectInterfaceImplementations: interface_impls_js_1.detectGoInterfaceImplementations,
+    populateRangeBindings: range_binding_js_1.populateGoRangeBindings,
+};

package/dist/core/code/engine/core/ingestion/languages/go/simple-hooks.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.goBindingScopeFor = goBindingScopeFor;
+exports.goImportOwningScope = goImportOwningScope;
+exports.goReceiverBinding = goReceiverBinding;
+function goBindingScopeFor(decl, innermost, _tree) {
+    // Keep receiver and parameter typeBindings in the function scope
+    // (prevent auto-hoist to Module). Parameters are local variables:
+    // hoisting `repo Repository` from one function to module scope can
+    // pollute another function's local receiver resolution.
+    if (decl['@type-binding.self'] !== undefined || decl['@type-binding.parameter'] !== undefined) {
+        return innermost.id;
+    }
+    return null; // default auto-hoist for other bindings
+}
+function goImportOwningScope(_imp, _innermost, _tree) {
+    return null;
+}
+function goReceiverBinding(functionScope) {
+    if (functionScope.kind !== 'Function')
+        return null;
+    for (const binding of functionScope.typeBindings.values()) {
+        if (binding.source === 'self')
+            return normalizeGoSelfTypeRef(binding);
+    }
+    return null;
+}
+function normalizeGoSelfTypeRef(binding) {
+    const rawName = binding.rawName.replace(/^\*+/, '').trim();
+    return rawName === binding.rawName ? binding : { ...binding, rawName };
+}