gitnexus 1.4.0 → 1.4.5

package/dist/core/ingestion/type-extractors/go.js

@@ -1,4 +1,4 @@
-import { extractSimpleTypeName, extractVarName } from './shared.js';
+import { extractSimpleTypeName, extractVarName, extractElementTypeFromString, extractGenericTypeArgs, resolveIterableElementType, methodToTypeArgPosition } from './shared.js';
 const DECLARATION_NODE_TYPES = new Set([
     'var_declaration',
     'var_spec',
@@ -57,7 +57,56 @@ const extractGoShortVarDeclaration = (node, env) => {
     // Pair each LHS name with its corresponding RHS value
     const count = Math.min(lhsNodes.length, rhsNodes.length);
     for (let i = 0; i < count; i++) {
-        const valueNode = rhsNodes[i];
+        let valueNode = rhsNodes[i];
+        // Unwrap &User{} — unary_expression (address-of) wrapping composite_literal
+        if (valueNode.type === 'unary_expression' && valueNode.firstNamedChild?.type === 'composite_literal') {
+            valueNode = valueNode.firstNamedChild;
+        }
+        // Go built-in new(User) — call_expression with 'new' callee and type argument
+        // Go built-in make([]User, 0) / make(map[string]User) — extract element/value type
+        if (valueNode.type === 'call_expression') {
+            const funcNode = valueNode.childForFieldName('function');
+            if (funcNode?.text === 'new') {
+                const args = valueNode.childForFieldName('arguments');
+                if (args?.firstNamedChild) {
+                    const typeName = extractSimpleTypeName(args.firstNamedChild);
+                    const varName = extractVarName(lhsNodes[i]);
+                    if (varName && typeName)
+                        env.set(varName, typeName);
+                }
+            }
+            else if (funcNode?.text === 'make') {
+                const args = valueNode.childForFieldName('arguments');
+                const firstArg = args?.firstNamedChild;
+                if (firstArg) {
+                    let innerType = null;
+                    if (firstArg.type === 'slice_type') {
+                        innerType = firstArg.childForFieldName('element');
+                    }
+                    else if (firstArg.type === 'map_type') {
+                        innerType = firstArg.childForFieldName('value');
+                    }
+                    if (innerType) {
+                        const typeName = extractSimpleTypeName(innerType);
+                        const varName = extractVarName(lhsNodes[i]);
+                        if (varName && typeName)
+                            env.set(varName, typeName);
+                    }
+                }
+            }
+            continue;
+        }
+        // Go type assertion: user := iface.(User) — type_assertion_expression with 'type' field
+        if (valueNode.type === 'type_assertion_expression') {
+            const typeNode = valueNode.childForFieldName('type');
+            if (typeNode) {
+                const typeName = extractSimpleTypeName(typeNode);
+                const varName = extractVarName(lhsNodes[i]);
+                if (varName && typeName)
+                    env.set(varName, typeName);
+            }
+            continue;
+        }
         if (valueNode.type !== 'composite_literal')
             continue;
         const typeNode = valueNode.childForFieldName('type');
@@ -98,8 +147,290 @@ const extractParameter = (node, env) => {
     if (varName && typeName)
         env.set(varName, typeName);
 };
+/** Go: user := NewUser(...) — infer type from single-assignment call expression */
+const scanConstructorBinding = (node) => {
+    if (node.type !== 'short_var_declaration')
+        return undefined;
+    const left = node.childForFieldName('left');
+    const right = node.childForFieldName('right');
+    if (!left || !right)
+        return undefined;
+    const leftIds = left.type === 'expression_list' ? left.namedChildren : [left];
+    const rightExprs = right.type === 'expression_list' ? right.namedChildren : [right];
+    // Multi-return: user, err := NewUser() — bind first var when second is err/ok/_
+    if (leftIds.length === 2 && rightExprs.length === 1) {
+        const secondVar = leftIds[1];
+        const isErrorOrDiscard = secondVar.text === '_' ||
+            secondVar.text === 'err' ||
+            secondVar.text === 'ok' ||
+            secondVar.text === 'error';
+        if (isErrorOrDiscard && leftIds[0].type === 'identifier') {
+            if (rightExprs[0].type !== 'call_expression')
+                return undefined;
+            const func = rightExprs[0].childForFieldName('function');
+            if (!func)
+                return undefined;
+            if (func.text === 'new' || func.text === 'make')
+                return undefined;
+            const calleeName = extractSimpleTypeName(func);
+            if (!calleeName)
+                return undefined;
+            return { varName: leftIds[0].text, calleeName };
+        }
+    }
+    // Single assignment only
+    if (leftIds.length !== 1 || leftIds[0].type !== 'identifier')
+        return undefined;
+    if (rightExprs.length !== 1 || rightExprs[0].type !== 'call_expression')
+        return undefined;
+    const func = rightExprs[0].childForFieldName('function');
+    if (!func)
+        return undefined;
+    // Skip new() and make() — already handled by extractDeclaration
+    if (func.text === 'new' || func.text === 'make')
+        return undefined;
+    const calleeName = extractSimpleTypeName(func);
+    if (!calleeName)
+        return undefined;
+    return { varName: leftIds[0].text, calleeName };
+};
+const FOR_LOOP_NODE_TYPES = new Set([
+    'for_statement',
+]);
+/** Go function/method node types that carry a parameter list. */
+const GO_FUNCTION_NODE_TYPES = new Set([
+    'function_declaration', 'method_declaration', 'func_literal',
+]);
+/**
+ * Extract element type from a Go type annotation AST node.
+ * Handles:
+ *   slice_type "[]User"  →  element field → type_identifier "User"
+ *   array_type "[10]User" →  element field → type_identifier "User"
+ * Falls back to text-based extraction via extractElementTypeFromString.
+ */
+const extractGoElementTypeFromTypeNode = (typeNode, pos = 'last') => {
+    // slice_type: []User — element field is the element type
+    if (typeNode.type === 'slice_type' || typeNode.type === 'array_type') {
+        const elemNode = typeNode.childForFieldName('element');
+        if (elemNode)
+            return extractSimpleTypeName(elemNode);
+    }
+    // map_type: map[string]User — value field is the element type (for range, second var gets value)
+    if (typeNode.type === 'map_type') {
+        const valueNode = typeNode.childForFieldName('value');
+        if (valueNode)
+            return extractSimpleTypeName(valueNode);
+    }
+    // channel_type: chan User — the type argument is the element type
+    if (typeNode.type === 'channel_type') {
+        const valueNode = typeNode.childForFieldName('value') ?? typeNode.lastNamedChild;
+        if (valueNode)
+            return extractSimpleTypeName(valueNode);
+    }
+    // generic_type: Go 1.18+ generics (e.g., MySlice[User], Cache[string, User])
+    // Use position-aware arg selection: 'first' for keys, 'last' for values.
+    if (typeNode.type === 'generic_type') {
+        const args = extractGenericTypeArgs(typeNode);
+        if (args.length >= 1)
+            return pos === 'first' ? args[0] : args[args.length - 1];
+    }
+    // Fallback: text-based extraction ([]User → User, User[] → User)
+    return extractElementTypeFromString(typeNode.text, pos);
+};
+/** Check if a Go type node represents a channel type. Used to determine
+ *  whether single-var range yields the element (channels) vs index (slices/maps). */
+const isChannelType = (iterableName, scopeEnv, declarationTypeNodes, scope) => {
+    if (declarationTypeNodes && scope) {
+        const typeNode = declarationTypeNodes.get(`${scope}\0${iterableName}`);
+        if (typeNode)
+            return typeNode.type === 'channel_type';
+    }
+    const t = scopeEnv.get(iterableName);
+    return !!t && t.startsWith('chan ');
+};
+/**
+ * Walk up the AST from a for-statement to find the enclosing function declaration,
+ * then search its parameters for one named `iterableName`.
+ * Returns the element type extracted from its type annotation, or undefined.
+ *
+ * Go parameter_declaration has:
+ *   name field: identifier (the parameter name)
+ *   type field: the type node (slice_type for []User)
+ */
+const findGoParamElementType = (iterableName, startNode, pos = 'last') => {
+    let current = startNode.parent;
+    while (current) {
+        if (GO_FUNCTION_NODE_TYPES.has(current.type)) {
+            const paramsNode = current.childForFieldName('parameters');
+            if (paramsNode) {
+                for (let i = 0; i < paramsNode.namedChildCount; i++) {
+                    const paramDecl = paramsNode.namedChild(i);
+                    if (!paramDecl || paramDecl.type !== 'parameter_declaration')
+                        continue;
+                    // parameter_declaration: name type — name field is the identifier
+                    const nameNode = paramDecl.childForFieldName('name');
+                    if (nameNode?.text === iterableName) {
+                        const typeNode = paramDecl.childForFieldName('type');
+                        if (typeNode)
+                            return extractGoElementTypeFromTypeNode(typeNode, pos);
+                    }
+                }
+            }
+            break;
+        }
+        current = current.parent;
+    }
+    return undefined;
+};
+/**
+ * Go: for _, user := range users where users has a known slice type.
+ *
+ * Go uses a single `for_statement` node for all for-loop forms. We detect
+ * range-based loops by looking for a `range_clause` child node. C-style for
+ * loops (with `for_clause`) and infinite loops (no clause) are ignored.
+ *
+ * Tier 1c: resolves the element type via three strategies in priority order:
+ *   1. declarationTypeNodes — raw type annotation AST node
+ *   2. scopeEnv string — extractElementTypeFromString on the stored type
+ *   3. AST walk — walks up to the enclosing function's parameters to read []User directly
+ * For `_, user := range users`, the loop variable is the second identifier in
+ * the `left` expression_list (index is discarded, value is the element).
+ */
+const extractForLoopBinding = (node, scopeEnv, declarationTypeNodes, scope) => {
+    if (node.type !== 'for_statement')
+        return;
+    // Find the range_clause child — this distinguishes range loops from other for forms.
+    let rangeClause = null;
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (child?.type === 'range_clause') {
+            rangeClause = child;
+            break;
+        }
+    }
+    if (!rangeClause)
+        return;
+    // The iterable is the `right` field of the range_clause.
+    const rightNode = rangeClause.childForFieldName('right');
+    let iterableName;
+    if (rightNode?.type === 'identifier') {
+        iterableName = rightNode.text;
+    }
+    else if (rightNode?.type === 'selector_expression') {
+        const field = rightNode.childForFieldName('field');
+        if (field)
+            iterableName = field.text;
+    }
+    if (!iterableName)
+        return;
+    const containerTypeName = scopeEnv.get(iterableName);
+    const typeArgPos = methodToTypeArgPosition(undefined, containerTypeName);
+    const elementType = resolveIterableElementType(iterableName, node, scopeEnv, declarationTypeNodes, scope, extractGoElementTypeFromTypeNode, findGoParamElementType, typeArgPos);
+    if (!elementType)
+        return;
+    // The loop variable(s) are in the `left` field.
+    // Go range semantics:
+    //   Slice/Array/String: single-var → INDEX (int); two-var → (index, element)
+    //   Map:                single-var → KEY; two-var → (key, value)
+    //   Channel:            single-var → ELEMENT (channels have no index)
+    const leftNode = rangeClause.childForFieldName('left');
+    if (!leftNode)
+        return;
+    let loopVarNode = null;
+    if (leftNode.type === 'expression_list') {
+        if (leftNode.namedChildCount >= 2) {
+            // Two-var form: `_, user` or `i, user` — second variable gets element/value type
+            loopVarNode = leftNode.namedChild(1);
+        }
+        else {
+            // Single-var in expression_list — yields INDEX for slices/maps, ELEMENT for channels
+            if (isChannelType(iterableName, scopeEnv, declarationTypeNodes, scope)) {
+                loopVarNode = leftNode.namedChild(0);
+            }
+            else {
+                return; // index-only range on slice/map — skip
+            }
+        }
+    }
+    else {
+        // Plain identifier (single-var form without expression_list)
+        if (isChannelType(iterableName, scopeEnv, declarationTypeNodes, scope)) {
+            loopVarNode = leftNode;
+        }
+        else {
+            return; // index-only range on slice/map — skip
+        }
+    }
+    if (!loopVarNode)
+        return;
+    // Skip the blank identifier `_`
+    if (loopVarNode.text === '_')
+        return;
+    const loopVarName = extractVarName(loopVarNode);
+    if (loopVarName)
+        scopeEnv.set(loopVarName, elementType);
+};
+/** Go: alias := u (short_var_declaration) or var b = u (var_spec) */
+const extractPendingAssignment = (node, scopeEnv) => {
+    if (node.type === 'short_var_declaration') {
+        const left = node.childForFieldName('left');
+        const right = node.childForFieldName('right');
+        if (!left || !right)
+            return undefined;
+        const lhsNode = left.type === 'expression_list' ? left.firstNamedChild : left;
+        const rhsNode = right.type === 'expression_list' ? right.firstNamedChild : right;
+        if (!lhsNode || !rhsNode)
+            return undefined;
+        if (lhsNode.type !== 'identifier')
+            return undefined;
+        const lhs = lhsNode.text;
+        if (scopeEnv.has(lhs))
+            return undefined;
+        if (rhsNode.type === 'identifier')
+            return { lhs, rhs: rhsNode.text };
+        return undefined;
+    }
+    if (node.type === 'var_spec' || node.type === 'var_declaration') {
+        // var_declaration contains var_spec children; var_spec has name + expression_list value
+        const specs = [];
+        if (node.type === 'var_declaration') {
+            for (let i = 0; i < node.namedChildCount; i++) {
+                const c = node.namedChild(i);
+                if (c?.type === 'var_spec')
+                    specs.push(c);
+            }
+        }
+        else {
+            specs.push(node);
+        }
+        for (const spec of specs) {
+            const nameNode = spec.childForFieldName('name');
+            if (!nameNode || nameNode.type !== 'identifier')
+                continue;
+            const lhs = nameNode.text;
+            if (scopeEnv.has(lhs))
+                continue;
+            // Check if the last named child is a bare identifier (no type annotation between name and value)
+            let exprList = null;
+            for (let i = 0; i < spec.childCount; i++) {
+                if (spec.child(i)?.type === 'expression_list') {
+                    exprList = spec.child(i);
+                    break;
+                }
+            }
+            const rhsNode = exprList?.firstNamedChild;
+            if (rhsNode?.type === 'identifier')
+                return { lhs, rhs: rhsNode.text };
+        }
+    }
+    return undefined;
+};
 export const typeConfig = {
     declarationNodeTypes: DECLARATION_NODE_TYPES,
+    forLoopNodeTypes: FOR_LOOP_NODE_TYPES,
     extractDeclaration,
     extractParameter,
+    scanConstructorBinding,
+    extractForLoopBinding,
+    extractPendingAssignment,
 };

package/dist/core/ingestion/type-extractors/index.d.ts

@@ -16,6 +16,7 @@ export declare const typeConfigs: {
     c: LanguageTypeConfig;
     cpp: LanguageTypeConfig;
     php: LanguageTypeConfig;
+    ruby: LanguageTypeConfig;
 };
-export type { LanguageTypeConfig, TypeBindingExtractor, ParameterExtractor } from './types.js';
-export { TYPED_PARAMETER_TYPES, extractSimpleTypeName, extractVarName, findChildByType } from './shared.js';
+export type { LanguageTypeConfig, TypeBindingExtractor, ParameterExtractor, ConstructorBindingScanner, ForLoopExtractor, PendingAssignmentExtractor, PatternBindingExtractor, } from './types.js';
+export { TYPED_PARAMETER_TYPES, extractSimpleTypeName, extractGenericTypeArgs, extractVarName, findChildByType, extractRubyConstructorAssignment } from './shared.js';

package/dist/core/ingestion/type-extractors/index.js

@@ -12,6 +12,7 @@ import { typeConfig as pythonConfig } from './python.js';
 import { typeConfig as swiftConfig } from './swift.js';
 import { typeConfig as cCppConfig } from './c-cpp.js';
 import { typeConfig as phpConfig } from './php.js';
+import { typeConfig as rubyConfig } from './ruby.js';
 export const typeConfigs = {
     [SupportedLanguages.JavaScript]: typescriptConfig,
     [SupportedLanguages.TypeScript]: typescriptConfig,
@@ -25,5 +26,6 @@ export const typeConfigs = {
     [SupportedLanguages.C]: cCppConfig,
     [SupportedLanguages.CPlusPlus]: cCppConfig,
     [SupportedLanguages.PHP]: phpConfig,
+    [SupportedLanguages.Ruby]: rubyConfig,
 };
-export { TYPED_PARAMETER_TYPES, extractSimpleTypeName, extractVarName, findChildByType } from './shared.js';
+export { TYPED_PARAMETER_TYPES, extractSimpleTypeName, extractGenericTypeArgs, extractVarName, findChildByType, extractRubyConstructorAssignment } from './shared.js';