@zuvia-software-solutions/code-mapper 1.4.0

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

@@ -0,0 +1,224 @@
+// code-mapper/src/core/ingestion/type-extractors/csharp.ts
+/** @file csharp.ts
+ *  @description Type extraction for C# (typed declarations, var inference, pattern matching) */
+import { extractSimpleTypeName, extractVarName, findChildByType, unwrapAwait } from './shared.js';
+const DECLARATION_NODE_TYPES = new Set([
+    'local_declaration_statement',
+    'variable_declaration',
+    'field_declaration',
+    'is_pattern_expression',
+]);
+// C#: Type x = ...; var x = new Type(); obj is Type x
+const extractDeclaration = (node, env) => {
+    // C# pattern matching: `obj is User user` -> is_pattern_expression > declaration_pattern
+    if (node.type === 'is_pattern_expression') {
+        const pattern = node.childForFieldName('pattern');
+        if (pattern?.type === 'declaration_pattern') {
+            const typeNode = pattern.childForFieldName('type');
+            const nameNode = pattern.childForFieldName('name');
+            if (typeNode && nameNode) {
+                const typeName = extractSimpleTypeName(typeNode);
+                const varName = extractVarName(nameNode);
+                if (typeName && varName)
+                    env.set(varName, typeName);
+            }
+        }
+        return;
+    }
+    // C# tree-sitter: local_declaration_statement > variable_declaration > ...
+    // Recursively descend through wrapper nodes
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (!child)
+            continue;
+        if (child.type === 'variable_declaration' || child.type === 'local_declaration_statement') {
+            extractDeclaration(child, env);
+            return;
+        }
+    }
+    // At variable_declaration level: first child is type, rest are variable_declarators
+    let typeNode = null;
+    const declarators = [];
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (!child)
+            continue;
+        if (!typeNode && child.type !== 'variable_declarator' && child.type !== 'equals_value_clause') {
+            // First non-declarator child is the type (identifier, implicit_type, generic_name, etc.)
+            typeNode = child;
+        }
+        if (child.type === 'variable_declarator') {
+            declarators.push(child);
+        }
+    }
+    if (!typeNode || declarators.length === 0)
+        return;
+    // Handle 'var x = new Foo()' -- infer from object_creation_expression
+    let typeName;
+    if (typeNode.type === 'implicit_type' && typeNode.text === 'var') {
+        // Try to infer from initializer: var x = new Foo()
+        // tree-sitter-c-sharp may put object_creation_expression as direct child
+        // or inside equals_value_clause depending on grammar version
+        if (declarators.length === 1) {
+            const initializer = findChildByType(declarators[0], 'object_creation_expression')
+                ?? findChildByType(declarators[0], 'equals_value_clause')?.firstNamedChild;
+            if (initializer?.type === 'object_creation_expression') {
+                const ctorType = initializer.childForFieldName('type');
+                if (ctorType)
+                    typeName = extractSimpleTypeName(ctorType);
+            }
+        }
+    }
+    else {
+        typeName = extractSimpleTypeName(typeNode);
+    }
+    if (!typeName)
+        return;
+    for (const decl of declarators) {
+        const nameNode = decl.childForFieldName('name') ?? decl.firstNamedChild;
+        if (nameNode) {
+            const varName = extractVarName(nameNode);
+            if (varName)
+                env.set(varName, typeName);
+        }
+    }
+};
+// C#: parameter -> type name
+const extractParameter = (node, env) => {
+    let nameNode = null;
+    let typeNode = null;
+    if (node.type === 'parameter') {
+        typeNode = node.childForFieldName('type');
+        nameNode = node.childForFieldName('name');
+    }
+    else {
+        nameNode = node.childForFieldName('name') ?? node.childForFieldName('pattern');
+        typeNode = node.childForFieldName('type');
+    }
+    if (!nameNode || !typeNode)
+        return;
+    const varName = extractVarName(nameNode);
+    const typeName = extractSimpleTypeName(typeNode);
+    if (varName && typeName)
+        env.set(varName, typeName);
+};
+// C#: var x = SomeFactory(...) -> bind x to SomeFactory (constructor-like call)
+const scanConstructorBinding = (node) => {
+    if (node.type !== 'variable_declaration')
+        return undefined;
+    // Find type and declarator children by iterating (C# grammar doesn't expose 'type' as a named field)
+    let typeNode = null;
+    let declarator = null;
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (!child)
+            continue;
+        if (child.type === 'variable_declarator') {
+            if (!declarator)
+                declarator = child;
+        }
+        else if (!typeNode) {
+            typeNode = child;
+        }
+    }
+    // Only handle implicit_type (var) -- explicit types handled by extractDeclaration
+    if (!typeNode || typeNode.type !== 'implicit_type')
+        return undefined;
+    if (!declarator)
+        return undefined;
+    const nameNode = declarator.childForFieldName('name') ?? declarator.firstNamedChild;
+    if (!nameNode || nameNode.type !== 'identifier')
+        return undefined;
+    // Find the initializer value: either inside equals_value_clause or as a direct child
+    // (tree-sitter-c-sharp puts invocation_expression directly inside variable_declarator)
+    let value = null;
+    for (let i = 0; i < declarator.namedChildCount; i++) {
+        const child = declarator.namedChild(i);
+        if (!child)
+            continue;
+        if (child.type === 'equals_value_clause') {
+            value = child.firstNamedChild;
+            break;
+        }
+        if (child.type === 'invocation_expression' || child.type === 'object_creation_expression' || child.type === 'await_expression') {
+            value = child;
+            break;
+        }
+    }
+    if (!value)
+        return undefined;
+    // Unwrap await: `var user = await svc.GetUserAsync()` -> await_expression wraps invocation_expression
+    value = unwrapAwait(value);
+    if (!value)
+        return undefined;
+    // Skip object_creation_expression (new User()) -- handled by extractInitializer
+    if (value.type === 'object_creation_expression')
+        return undefined;
+    if (value.type !== 'invocation_expression')
+        return undefined;
+    const func = value.firstNamedChild;
+    if (!func)
+        return undefined;
+    const calleeName = extractSimpleTypeName(func);
+    if (!calleeName)
+        return undefined;
+    return { varName: nameNode.text, calleeName };
+};
+const FOR_LOOP_NODE_TYPES = new Set([
+    'foreach_statement',
+]);
+// C#: foreach (User user in users) -- extract loop variable binding
+const extractForLoopBinding = (node, scopeEnv) => {
+    const typeNode = node.childForFieldName('type');
+    // The loop variable name is in the 'left' field in tree-sitter-c-sharp
+    const nameNode = node.childForFieldName('left');
+    if (!typeNode || !nameNode)
+        return;
+    // Skip 'var' -- type would need to be inferred from the collection element type
+    if (typeNode.type === 'implicit_type' && typeNode.text === 'var')
+        return;
+    const typeName = extractSimpleTypeName(typeNode);
+    const varName = extractVarName(nameNode);
+    if (typeName && varName)
+        scopeEnv.set(varName, typeName);
+};
+// C#: var alias = u -> variable_declarator with name + equals_value_clause
+// Only local_declaration_statement and variable_declaration contain variable_declarator
+// children; is_pattern_expression and field_declaration never do -- skip them early
+const extractPendingAssignment = (node, scopeEnv) => {
+    if (node.type === 'is_pattern_expression' || node.type === 'field_declaration')
+        return undefined;
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (!child || child.type !== 'variable_declarator')
+            continue;
+        const nameNode = child.childForFieldName('name');
+        if (!nameNode)
+            continue;
+        const lhs = nameNode.text;
+        if (scopeEnv.has(lhs))
+            continue;
+        // C# wraps value in equals_value_clause; fall back to last named child
+        let evc = null;
+        for (let j = 0; j < child.childCount; j++) {
+            if (child.child(j)?.type === 'equals_value_clause') {
+                evc = child.child(j);
+                break;
+            }
+        }
+        const valueNode = evc?.firstNamedChild ?? child.namedChild(child.namedChildCount - 1);
+        if (valueNode && valueNode !== nameNode && (valueNode.type === 'identifier' || valueNode.type === 'simple_identifier')) {
+            return { lhs, rhs: valueNode.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/go.d.ts

@@ -0,0 +1,4 @@
+/** @file go.ts
+ *  @description Type extraction for Go (var declarations, short var declarations, composite literals) */
+import type { LanguageTypeConfig } from './types.js';
+export declare const typeConfig: LanguageTypeConfig;

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

@@ -0,0 +1,261 @@
+// code-mapper/src/core/ingestion/type-extractors/go.ts
+/** @file go.ts
+ *  @description Type extraction for Go (var declarations, short var declarations, composite literals) */
+import { extractSimpleTypeName, extractVarName } from './shared.js';
+const DECLARATION_NODE_TYPES = new Set([
+    'var_declaration',
+    'var_spec',
+    'short_var_declaration',
+]);
+// Go: var x Foo
+const extractGoVarDeclaration = (node, env) => {
+    // var_declaration contains var_spec children
+    if (node.type === 'var_declaration') {
+        for (let i = 0; i < node.namedChildCount; i++) {
+            const spec = node.namedChild(i);
+            if (spec?.type === 'var_spec')
+                extractGoVarDeclaration(spec, env);
+        }
+        return;
+    }
+    // var_spec: name type [= value]
+    const nameNode = node.childForFieldName('name');
+    const typeNode = node.childForFieldName('type');
+    if (!nameNode || !typeNode)
+        return;
+    const varName = extractVarName(nameNode);
+    const typeName = extractSimpleTypeName(typeNode);
+    if (varName && typeName)
+        env.set(varName, typeName);
+};
+// Go: x := Foo{...} -- infer type from composite literal (handles multi-assignment)
+const extractGoShortVarDeclaration = (node, env) => {
+    const left = node.childForFieldName('left');
+    const right = node.childForFieldName('right');
+    if (!left || !right)
+        return;
+    // Collect LHS names and RHS values (may be expression_lists for multi-assignment)
+    const lhsNodes = [];
+    const rhsNodes = [];
+    if (left.type === 'expression_list') {
+        for (let i = 0; i < left.namedChildCount; i++) {
+            const c = left.namedChild(i);
+            if (c)
+                lhsNodes.push(c);
+        }
+    }
+    else {
+        lhsNodes.push(left);
+    }
+    if (right.type === 'expression_list') {
+        for (let i = 0; i < right.namedChildCount; i++) {
+            const c = right.namedChild(i);
+            if (c)
+                rhsNodes.push(c);
+        }
+    }
+    else {
+        rhsNodes.push(right);
+    }
+    // Pair each LHS name with its corresponding RHS value
+    const count = Math.min(lhsNodes.length, rhsNodes.length);
+    for (let i = 0; i < count; 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');
+        if (!typeNode)
+            continue;
+        const typeName = extractSimpleTypeName(typeNode);
+        if (!typeName)
+            continue;
+        const varName = extractVarName(lhsNodes[i]);
+        if (varName)
+            env.set(varName, typeName);
+    }
+};
+const extractDeclaration = (node, env) => {
+    if (node.type === 'var_declaration' || node.type === 'var_spec') {
+        extractGoVarDeclaration(node, env);
+    }
+    else if (node.type === 'short_var_declaration') {
+        extractGoShortVarDeclaration(node, env);
+    }
+};
+// Go: parameter -> name type
+const extractParameter = (node, env) => {
+    let nameNode = null;
+    let typeNode = null;
+    if (node.type === 'parameter') {
+        nameNode = node.childForFieldName('name');
+        typeNode = node.childForFieldName('type');
+    }
+    else {
+        nameNode = node.childForFieldName('name') ?? node.childForFieldName('pattern');
+        typeNode = node.childForFieldName('type');
+    }
+    if (!nameNode || !typeNode)
+        return;
+    const varName = extractVarName(nameNode);
+    const typeName = extractSimpleTypeName(typeNode);
+    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 };
+};
+// 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,
+    extractDeclaration,
+    extractParameter,
+    scanConstructorBinding,
+    extractPendingAssignment,
+};

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

@@ -0,0 +1,20 @@
+/** @file index.ts
+ *  @description Per-language type extraction configs assembled into a dispatch map keyed by SupportedLanguages */
+import type { LanguageTypeConfig } from './types.js';
+export declare const typeConfigs: {
+    javascript: LanguageTypeConfig;
+    typescript: LanguageTypeConfig;
+    java: LanguageTypeConfig;
+    kotlin: LanguageTypeConfig;
+    csharp: LanguageTypeConfig;
+    go: LanguageTypeConfig;
+    rust: LanguageTypeConfig;
+    python: LanguageTypeConfig;
+    swift: LanguageTypeConfig;
+    c: LanguageTypeConfig;
+    cpp: LanguageTypeConfig;
+    php: LanguageTypeConfig;
+    ruby: LanguageTypeConfig;
+};
+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

@@ -0,0 +1,30 @@
+// code-mapper/src/core/ingestion/type-extractors/index.ts
+/** @file index.ts
+ *  @description Per-language type extraction configs assembled into a dispatch map keyed by SupportedLanguages */
+import { SupportedLanguages } from '../../../config/supported-languages.js';
+import { typeConfig as typescriptConfig } from './typescript.js';
+import { javaTypeConfig, kotlinTypeConfig } from './jvm.js';
+import { typeConfig as csharpConfig } from './csharp.js';
+import { typeConfig as goConfig } from './go.js';
+import { typeConfig as rustConfig } from './rust.js';
+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,
+    [SupportedLanguages.Java]: javaTypeConfig,
+    [SupportedLanguages.Kotlin]: kotlinTypeConfig,
+    [SupportedLanguages.CSharp]: csharpConfig,
+    [SupportedLanguages.Go]: goConfig,
+    [SupportedLanguages.Rust]: rustConfig,
+    [SupportedLanguages.Python]: pythonConfig,
+    [SupportedLanguages.Swift]: swiftConfig,
+    [SupportedLanguages.C]: cCppConfig,
+    [SupportedLanguages.CPlusPlus]: cCppConfig,
+    [SupportedLanguages.PHP]: phpConfig,
+    [SupportedLanguages.Ruby]: rubyConfig,
+};
+export { TYPED_PARAMETER_TYPES, extractSimpleTypeName, extractGenericTypeArgs, extractVarName, findChildByType, extractRubyConstructorAssignment } from './shared.js';

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

@@ -0,0 +1,5 @@
+/** @file jvm.ts
+ *  @description Type extraction for Java and Kotlin */
+import type { LanguageTypeConfig } from './types.js';
+export declare const javaTypeConfig: LanguageTypeConfig;
+export declare const kotlinTypeConfig: LanguageTypeConfig;