gitnexus 1.4.7 → 1.4.9

package/dist/core/ingestion/type-extractors/c-cpp.d.ts

@@ -1,2 +1,7 @@
+import type { SyntaxNode } from '../utils/ast-helpers.js';
 import type { LanguageTypeConfig } from './types.js';
+/** Extract the first type name from a template_argument_list child.
+ *  Unwraps type_descriptor wrappers common in tree-sitter-cpp ASTs.
+ *  Returns undefined if no template arguments or no type found. */
+export declare const extractFirstTemplateTypeArg: (parentNode: SyntaxNode) => string | undefined;
 export declare const typeConfig: LanguageTypeConfig;

package/dist/core/ingestion/type-extractors/c-cpp.js

@@ -2,6 +2,28 @@ import { extractSimpleTypeName, extractVarName, resolveIterableElementType, meth
 const DECLARATION_NODE_TYPES = new Set([
     'declaration',
 ]);
+/** Smart pointer factory function names that create a typed object. */
+const SMART_PTR_FACTORIES = new Set([
+    'make_shared', 'make_unique', 'make_shared_for_overwrite',
+]);
+/** Smart pointer wrapper type names. When the declared type is a smart pointer,
+ *  the inner template type is extracted for virtual dispatch comparison. */
+const SMART_PTR_WRAPPERS = new Set(['shared_ptr', 'unique_ptr', 'weak_ptr']);
+/** Extract the first type name from a template_argument_list child.
+ *  Unwraps type_descriptor wrappers common in tree-sitter-cpp ASTs.
+ *  Returns undefined if no template arguments or no type found. */
+export const extractFirstTemplateTypeArg = (parentNode) => {
+    const templateArgs = parentNode.children.find((c) => c.type === 'template_argument_list');
+    if (!templateArgs?.firstNamedChild)
+        return undefined;
+    let argNode = templateArgs.firstNamedChild;
+    if (argNode.type === 'type_descriptor') {
+        const inner = argNode.childForFieldName('type');
+        if (inner)
+            argNode = inner;
+    }
+    return extractSimpleTypeName(argNode) ?? undefined;
+};
 /** C++: Type x = ...; Type* x; Type& x; */
 const extractDeclaration = (node, env) => {
     const typeNode = node.childForFieldName('type');
@@ -89,6 +111,29 @@ const extractInitializer = (node, env, classNames) => {
             if (text && classNames.has(text))
                 env.set(varName, text);
         }
+        else {
+            // auto x = std::make_shared<Dog>() — smart pointer factory via template_function.
+            // AST: call_expression > function: qualified_identifier > template_function
+            //   or: call_expression > function: template_function (unqualified)
+            const templateFunc = func.type === 'template_function'
+                ? func
+                : (func.type === 'qualified_identifier' || func.type === 'scoped_identifier')
+                    ? func.namedChildren.find((c) => c.type === 'template_function') ?? null
+                    : null;
+            if (templateFunc) {
+                const nameNode = templateFunc.firstNamedChild;
+                if (nameNode) {
+                    const funcName = (nameNode.type === 'qualified_identifier' || nameNode.type === 'scoped_identifier')
+                        ? nameNode.lastNamedChild?.text ?? ''
+                        : nameNode.text;
+                    if (SMART_PTR_FACTORIES.has(funcName)) {
+                        const typeName = extractFirstTemplateTypeArg(templateFunc);
+                        if (typeName)
+                            env.set(varName, typeName);
+                    }
+                }
+            }
+        }
         return;
     }
     // auto x = User{} — compound_literal_expression (brace initialization)
@@ -398,6 +443,77 @@ const extractForLoopBinding = (node, { scopeEnv, declarationTypeNodes, scope })
     if (elementType)
         scopeEnv.set(varName, elementType);
 };
+/** Infer the type of a literal AST node for C++ overload disambiguation. */
+const inferLiteralType = (node) => {
+    switch (node.type) {
+        case 'number_literal': {
+            const t = node.text;
+            // Float suffixes
+            if (t.endsWith('f') || t.endsWith('F'))
+                return 'float';
+            if (t.includes('.') || t.includes('e') || t.includes('E'))
+                return 'double';
+            // Long suffix
+            if (t.endsWith('L') || t.endsWith('l') || t.endsWith('LL') || t.endsWith('ll'))
+                return 'long';
+            return 'int';
+        }
+        case 'string_literal':
+        case 'raw_string_literal':
+        case 'concatenated_string':
+            return 'string';
+        case 'char_literal':
+            return 'char';
+        case 'true':
+        case 'false':
+            return 'bool';
+        case 'null':
+        case 'nullptr':
+            return 'null';
+        default:
+            return undefined;
+    }
+};
+/** C++: detect constructor type from smart pointer factory calls (make_shared<Dog>()).
+ *  Extracts the template type argument as the constructor type for virtual dispatch. */
+const detectCppConstructorType = (node, classNames) => {
+    // Navigate to the initializer value in the declaration
+    const declarator = node.childForFieldName('declarator');
+    const initDecl = declarator?.type === 'init_declarator' ? declarator : undefined;
+    if (!initDecl)
+        return undefined;
+    const value = initDecl.childForFieldName('value');
+    if (!value || value.type !== 'call_expression')
+        return undefined;
+    // Check for template_function pattern: make_shared<Dog>()
+    const func = value.childForFieldName('function');
+    if (!func || func.type !== 'template_function')
+        return undefined;
+    // Extract function name (possibly qualified: std::make_shared)
+    const nameNode = func.firstNamedChild;
+    if (!nameNode)
+        return undefined;
+    let funcName;
+    if (nameNode.type === 'qualified_identifier' || nameNode.type === 'scoped_identifier') {
+        funcName = nameNode.lastNamedChild?.text ?? '';
+    }
+    else {
+        funcName = nameNode.text;
+    }
+    if (!SMART_PTR_FACTORIES.has(funcName))
+        return undefined;
+    // Extract template type argument
+    return extractFirstTemplateTypeArg(func);
+};
+/** Unwrap a C++ smart pointer declared type to its inner template type.
+ *  E.g., shared_ptr<Animal> → Animal. Returns the original name if not a smart pointer. */
+const unwrapCppDeclaredType = (declaredType, typeNode) => {
+    if (!SMART_PTR_WRAPPERS.has(declaredType))
+        return declaredType;
+    if (typeNode.type !== 'template_type')
+        return declaredType;
+    return extractFirstTemplateTypeArg(typeNode) ?? declaredType;
+};
 export const typeConfig = {
     declarationNodeTypes: DECLARATION_NODE_TYPES,
     forLoopNodeTypes: FOR_LOOP_NODE_TYPES,
@@ -407,4 +523,7 @@ export const typeConfig = {
     scanConstructorBinding,
     extractForLoopBinding,
     extractPendingAssignment,
+    inferLiteralType,
+    detectConstructorType: detectCppConstructorType,
+    unwrapDeclaredType: unwrapCppDeclaredType,
 };

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

@@ -1,4 +1,5 @@
-import { extractSimpleTypeName, extractVarName, findChildByType, unwrapAwait, resolveIterableElementType, methodToTypeArgPosition, extractElementTypeFromString } from './shared.js';
+import { findChild } from '../utils/ast-helpers.js';
+import { extractSimpleTypeName, extractVarName, unwrapAwait, resolveIterableElementType, methodToTypeArgPosition, extractElementTypeFromString } from './shared.js';
 /** Known container property accessors that operate on the container itself (e.g., dict.Keys, dict.Values) */
 const KNOWN_CONTAINER_PROPS = new Set(['Keys', 'Values']);
 const DECLARATION_NODE_TYPES = new Set([
@@ -43,8 +44,8 @@ const extractDeclaration = (node, env) => {
         // 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;
+            const initializer = findChild(declarators[0], 'object_creation_expression')
+                ?? findChild(declarators[0], 'equals_value_clause')?.firstNamedChild;
             if (initializer?.type === 'object_creation_expression') {
                 const ctorType = initializer.childForFieldName('type');
                 if (ctorType)
@@ -159,7 +160,7 @@ const extractCSharpElementTypeFromTypeNode = (typeNode, pos = 'last', depth = 0)
     // generic_name: List<User>, IEnumerable<User>, Dictionary<string, User>
     // C# uses generic_name (not generic_type)
     if (typeNode.type === 'generic_name') {
-        const argList = findChildByType(typeNode, 'type_argument_list');
+        const argList = findChild(typeNode, 'type_argument_list');
         if (argList && argList.namedChildCount >= 1) {
             if (pos === 'first') {
                 const firstArg = argList.namedChild(0);
@@ -307,21 +308,89 @@ const extractForLoopBinding = (node, { scopeEnv, declarationTypeNodes, scope, re
  * declaration_pattern, or when the type/name cannot be extracted.
  * No scopeEnv lookup is needed — the pattern explicitly declares the new variable's type.
  */
-const extractPatternBinding = (node) => {
+/**
+ * Find the if-body (consequence) block for a C# null-check.
+ * Walks up from the expression to find the enclosing if_statement,
+ * then returns its first block child (the truthy branch body).
+ */
+const findCSharpIfConsequenceBlock = (expr) => {
+    let current = expr.parent;
+    while (current) {
+        if (current.type === 'if_statement') {
+            // C# if_statement consequence is the 'consequence' field or first block child
+            const consequence = current.childForFieldName('consequence');
+            if (consequence)
+                return consequence;
+            for (let i = 0; i < current.childCount; i++) {
+                const child = current.child(i);
+                if (child?.type === 'block')
+                    return child;
+            }
+            return undefined;
+        }
+        if (current.type === 'block' || current.type === 'method_declaration'
+            || current.type === 'constructor_declaration' || current.type === 'local_function_statement'
+            || current.type === 'lambda_expression')
+            return undefined;
+        current = current.parent;
+    }
+    return undefined;
+};
+/** Check if a C# declaration type node represents a nullable type.
+ *  Checks for nullable_type AST node or '?' in the type text (e.g., User?). */
+const isCSharpNullableDecl = (declTypeNode) => {
+    if (declTypeNode.type === 'nullable_type')
+        return true;
+    return declTypeNode.text.includes('?');
+};
+const extractPatternBinding = (node, scopeEnv, declarationTypeNodes, scope) => {
     // is_pattern_expression: `obj is User user` — has a declaration_pattern child
+    // Also handles `x is not null` for null-check narrowing
     if (node.type === 'is_pattern_expression') {
         const pattern = node.childForFieldName('pattern');
-        if (pattern?.type !== 'declaration_pattern' && pattern?.type !== 'recursive_pattern')
+        if (!pattern)
             return undefined;
-        const typeNode = pattern.childForFieldName('type');
-        const nameNode = pattern.childForFieldName('name');
-        if (!typeNode || !nameNode)
-            return undefined;
-        const typeName = extractSimpleTypeName(typeNode);
-        const varName = extractVarName(nameNode);
-        if (!typeName || !varName)
-            return undefined;
-        return { varName, typeName };
+        // Standard type pattern: `obj is User user`
+        if (pattern.type === 'declaration_pattern' || pattern.type === 'recursive_pattern') {
+            const typeNode = pattern.childForFieldName('type');
+            const nameNode = pattern.childForFieldName('name');
+            if (!typeNode || !nameNode)
+                return undefined;
+            const typeName = extractSimpleTypeName(typeNode);
+            const varName = extractVarName(nameNode);
+            if (!typeName || !varName)
+                return undefined;
+            return { varName, typeName };
+        }
+        // Null-check: `x is not null` — negated_pattern > constant_pattern > null_literal
+        if (pattern.type === 'negated_pattern') {
+            const inner = pattern.firstNamedChild;
+            if (inner?.type === 'constant_pattern') {
+                const literal = inner.firstNamedChild ?? inner.firstChild;
+                if (literal?.type === 'null_literal' || literal?.text === 'null') {
+                    const expr = node.childForFieldName('expression');
+                    if (!expr || expr.type !== 'identifier')
+                        return undefined;
+                    const varName = expr.text;
+                    const resolvedType = scopeEnv.get(varName);
+                    if (!resolvedType)
+                        return undefined;
+                    // Verify the original declaration was nullable
+                    const declTypeNode = declarationTypeNodes.get(`${scope}\0${varName}`);
+                    if (!declTypeNode || !isCSharpNullableDecl(declTypeNode))
+                        return undefined;
+                    const ifBody = findCSharpIfConsequenceBlock(node);
+                    if (!ifBody)
+                        return undefined;
+                    return {
+                        varName,
+                        typeName: resolvedType,
+                        narrowingRange: { startIndex: ifBody.startIndex, endIndex: ifBody.endIndex },
+                    };
+                }
+            }
+        }
+        return undefined;
     }
     // declaration_pattern / recursive_pattern: standalone in switch statements and switch expressions
     // `case User u:` or `User u =>` or `User { Name: "Alice" } u =>`
@@ -337,6 +406,41 @@ const extractPatternBinding = (node) => {
             return undefined;
         return { varName, typeName };
     }
+    // Null-check: `x != null` — binary_expression with != operator
+    if (node.type === 'binary_expression') {
+        const op = node.children.find(c => !c.isNamed && c.text === '!=');
+        if (!op)
+            return undefined;
+        const left = node.namedChild(0);
+        const right = node.namedChild(1);
+        if (!left || !right)
+            return undefined;
+        let varNode;
+        if (left.type === 'identifier' && (right.type === 'null_literal' || right.text === 'null')) {
+            varNode = left;
+        }
+        else if (right.type === 'identifier' && (left.type === 'null_literal' || left.text === 'null')) {
+            varNode = right;
+        }
+        if (!varNode)
+            return undefined;
+        const varName = varNode.text;
+        const resolvedType = scopeEnv.get(varName);
+        if (!resolvedType)
+            return undefined;
+        // Verify the original declaration was nullable
+        const declTypeNode = declarationTypeNodes.get(`${scope}\0${varName}`);
+        if (!declTypeNode || !isCSharpNullableDecl(declTypeNode))
+            return undefined;
+        const ifBody = findCSharpIfConsequenceBlock(node);
+        if (!ifBody)
+            return undefined;
+        return {
+            varName,
+            typeName: resolvedType,
+            narrowingRange: { startIndex: ifBody.startIndex, endIndex: ifBody.endIndex },
+        };
+    }
     return undefined;
 };
 /** C#: var alias = u → variable_declarator with name + equals_value_clause.
@@ -410,14 +514,43 @@ const extractPendingAssignment = (node, scopeEnv) => {
     }
     return undefined;
 };
+/** Infer the type of a literal AST node for C# overload disambiguation. */
+const inferLiteralType = (node) => {
+    switch (node.type) {
+        case 'integer_literal':
+            if (node.text.endsWith('L') || node.text.endsWith('l'))
+                return 'long';
+            return 'int';
+        case 'real_literal':
+            if (node.text.endsWith('f') || node.text.endsWith('F'))
+                return 'float';
+            if (node.text.endsWith('m') || node.text.endsWith('M'))
+                return 'decimal';
+            return 'double';
+        case 'string_literal':
+        case 'verbatim_string_literal':
+        case 'raw_string_literal':
+        case 'interpolated_string_expression':
+            return 'string';
+        case 'character_literal':
+            return 'char';
+        case 'boolean_literal':
+            return 'bool';
+        case 'null_literal':
+            return 'null';
+        default:
+            return undefined;
+    }
+};
 export const typeConfig = {
     declarationNodeTypes: DECLARATION_NODE_TYPES,
     forLoopNodeTypes: FOR_LOOP_NODE_TYPES,
-    patternBindingNodeTypes: new Set(['is_pattern_expression', 'declaration_pattern', 'recursive_pattern']),
+    patternBindingNodeTypes: new Set(['is_pattern_expression', 'declaration_pattern', 'recursive_pattern', 'binary_expression']),
     extractDeclaration,
     extractParameter,
     scanConstructorBinding,
     extractForLoopBinding,
     extractPendingAssignment,
     extractPatternBinding,
+    inferLiteralType,
 };

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

@@ -0,0 +1,15 @@
+/**
+ * Dart type extractor — full implementation following type-resolution-system.md.
+ *
+ * Tier 0: Explicit type annotations (User user = ...)
+ * Tier 0b: For-loop element types (for (var u in users))
+ * Tier 1: Constructor/initializer inference (var user = User())
+ * Tier 2: Assignment chain propagation (copy, fieldAccess, callResult, methodCallResult)
+ *
+ * Handles tree-sitter-dart's flat sibling AST structure:
+ * identifier + selector + selector (not nested call_expression).
+ *
+ * Credit: Type resolution approach adapted from @xFlaviews' PR #83.
+ */
+import type { LanguageTypeConfig } from './types.js';
+export declare const typeConfig: LanguageTypeConfig;