gitnexus 1.4.0 → 1.4.1

package/dist/core/ingestion/symbol-resolver.js

@@ -1,83 +0,0 @@
-/**
- * Symbol Resolver
- *
- * Import-filtered candidate narrowing for bare identifier resolution.
- * NOT FQN resolution — does not parse qualifiers (ns::Bar, com.foo.Bar).
- *
- * Shared between heritage-processor.ts and call-processor.ts.
- */
-import { isFileInPackageDir } from './import-processor.js';
-import { walkBindingChain } from './named-binding-extraction.js';
-/**
- * Resolve a bare identifier to its best-matching definition using import context.
- *
- * Resolution tiers (highest confidence first):
- * 1. Same file (lookupExactFull — authoritative)
- * 2. Import-scoped (lookupFuzzy filtered by importMap — acceptable)
- * 3. Unique global (lookupFuzzy with exactly 1 match — acceptable fallback)
- *
- * If multiple global candidates remain after filtering, returns null.
- * A wrong edge is worse than no edge.
- */
-export const resolveSymbol = (name, currentFilePath, symbolTable, importMap, packageMap, namedImportMap) => {
-    return resolveSymbolInternal(name, currentFilePath, symbolTable, importMap, packageMap, namedImportMap)?.definition ?? null;
-};
-/** Internal resolver preserving tier metadata for logging and test assertions. */
-export const resolveSymbolInternal = (name, currentFilePath, symbolTable, importMap, packageMap, namedImportMap) => {
-    // Tier 1: Same file — authoritative match
-    const localDef = symbolTable.lookupExactFull(currentFilePath, name);
-    if (localDef)
-        return { definition: localDef, tier: 'same-file', candidateCount: 1 };
-    // Get all global definitions for subsequent tiers
-    const allDefs = symbolTable.lookupFuzzy(name);
-    // Tier 2a-named: Check named bindings BEFORE the empty-allDefs early return,
-    // because aliased imports (import { User as U }) mean lookupFuzzy('U') returns
-    // empty but we can resolve via the exported name.
-    if (namedImportMap) {
-        const result = resolveNamedBindingChain(name, currentFilePath, symbolTable, namedImportMap, allDefs);
-        if (result)
-            return result;
-    }
-    if (allDefs.length === 0)
-        return null;
-    // Tier 2a: Import-scoped — check if any definition is in a file imported by currentFile
-    const importedFiles = importMap.get(currentFilePath);
-    if (importedFiles) {
-        for (const def of allDefs) {
-            if (importedFiles.has(def.filePath)) {
-                return { definition: def, tier: 'import-scoped', candidateCount: allDefs.length };
-            }
-        }
-    }
-    // Tier 2b: Package-scoped — check if any definition is in a package/namespace dir imported by currentFile
-    // Used for Go packages and C# namespace imports to avoid ImportMap expansion bloat
-    const importedPackages = packageMap?.get(currentFilePath);
-    if (importedPackages) {
-        for (const def of allDefs) {
-            for (const dirSuffix of importedPackages) {
-                if (isFileInPackageDir(def.filePath, dirSuffix)) {
-                    return { definition: def, tier: 'import-scoped', candidateCount: allDefs.length };
-                }
-            }
-        }
-    }
-    // Tier 3: Unique global — ONLY if exactly one candidate exists
-    // Ambiguous global matches are refused. A wrong edge is worse than no edge.
-    if (allDefs.length === 1) {
-        return { definition: allDefs[0], tier: 'unique-global', candidateCount: 1 };
-    }
-    // Ambiguous: multiple global candidates, no import or same-file match → refuse
-    return null;
-};
-/**
- * Follow re-export chains through NamedImportMap.
- * Delegates chain-walking to the shared walkBindingChain utility, then
- * applies symbol-resolver semantics: exactly one match required.
- */
-const resolveNamedBindingChain = (name, currentFilePath, symbolTable, namedImportMap, allDefs) => {
-    const defs = walkBindingChain(name, currentFilePath, symbolTable, namedImportMap, allDefs);
-    if (defs?.length === 1) {
-        return { definition: defs[0], tier: 'import-scoped', candidateCount: defs.length };
-    }
-    return null;
-};

package/dist/core/ingestion/type-env.d.ts

@@ -1,27 +0,0 @@
-import type { SyntaxNode } from './utils.js';
-import { SupportedLanguages } from '../../config/supported-languages.js';
-/**
- * Per-file scoped type environment: maps (scope, variableName) → typeName.
- * Scope-aware: variables inside functions are keyed by function name,
- * file-level variables use the '' (empty string) scope.
- *
- * Design constraints:
- * - Explicit-only: only type annotations, never inferred types
- * - Scope-aware: function-local variables don't collide across functions
- * - Conservative: complex/generic types extract the base name only
- * - Per-file: built once, used for receiver resolution, then discarded
- */
-export type TypeEnv = Map<string, Map<string, string>>;
-/**
- * Look up a variable's type in the TypeEnv, trying the call's enclosing
- * function scope first, then falling back to file-level scope.
- */
-export declare const lookupTypeEnv: (env: TypeEnv, varName: string, callNode: SyntaxNode) => string | undefined;
-/**
- * Build a scoped TypeEnv from a tree-sitter AST for a given language.
- * Walks the tree tracking enclosing function scopes, so that variables
- * inside different functions don't collide.
- */
-export declare const buildTypeEnv: (tree: {
-    rootNode: SyntaxNode;
-}, language: SupportedLanguages) => TypeEnv;

package/dist/core/ingestion/type-env.js

@@ -1,86 +0,0 @@
-import { FUNCTION_NODE_TYPES, extractFunctionName } from './utils.js';
-import { typeConfigs, TYPED_PARAMETER_TYPES } from './type-extractors/index.js';
-/** File-level scope key */
-const FILE_SCOPE = '';
-/**
- * Look up a variable's type in the TypeEnv, trying the call's enclosing
- * function scope first, then falling back to file-level scope.
- */
-export const lookupTypeEnv = (env, varName, callNode) => {
-    // Determine the enclosing function scope for the call
-    const scopeKey = findEnclosingScopeKey(callNode);
-    // Try function-local scope first
-    if (scopeKey) {
-        const scopeEnv = env.get(scopeKey);
-        if (scopeEnv) {
-            const result = scopeEnv.get(varName);
-            if (result)
-                return result;
-        }
-    }
-    // Fall back to file-level scope
-    const fileEnv = env.get(FILE_SCOPE);
-    return fileEnv?.get(varName);
-};
-/** Find the enclosing function name for scope lookup. */
-const findEnclosingScopeKey = (node) => {
-    let current = node.parent;
-    while (current) {
-        if (FUNCTION_NODE_TYPES.has(current.type)) {
-            const { funcName } = extractFunctionName(current);
-            if (funcName)
-                return `${funcName}@${current.startIndex}`;
-        }
-        current = current.parent;
-    }
-    return undefined;
-};
-/**
- * Build a scoped TypeEnv from a tree-sitter AST for a given language.
- * Walks the tree tracking enclosing function scopes, so that variables
- * inside different functions don't collide.
- */
-export const buildTypeEnv = (tree, language) => {
-    const env = new Map();
-    walkForTypes(tree.rootNode, language, env, FILE_SCOPE);
-    return env;
-};
-const walkForTypes = (node, language, env, currentScope) => {
-    // Detect scope boundaries (function/method definitions)
-    let scope = currentScope;
-    if (FUNCTION_NODE_TYPES.has(node.type)) {
-        const { funcName } = extractFunctionName(node);
-        if (funcName)
-            scope = `${funcName}@${node.startIndex}`;
-    }
-    // Get or create the sub-map for this scope
-    if (!env.has(scope))
-        env.set(scope, new Map());
-    const scopeEnv = env.get(scope);
-    // Check if this node provides type information
-    extractTypeBinding(node, language, scopeEnv);
-    // Recurse into children
-    for (let i = 0; i < node.childCount; i++) {
-        const child = node.child(i);
-        if (child)
-            walkForTypes(child, language, env, scope);
-    }
-};
-/**
- * Try to extract a (variableName → typeName) binding from a single AST node.
- * Delegates to per-language type configurations.
- */
-const extractTypeBinding = (node, language, env) => {
-    // === PARAMETERS (most languages) ===
-    // This guard eliminates 90%+ of calls before any language dispatch.
-    if (TYPED_PARAMETER_TYPES.has(node.type)) {
-        const config = typeConfigs[language];
-        config.extractParameter(node, env);
-        return;
-    }
-    // === Per-language declaration extraction ===
-    const config = typeConfigs[language];
-    if (config.declarationNodeTypes.has(node.type)) {
-        config.extractDeclaration(node, env);
-    }
-};

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

@@ -1,2 +0,0 @@
-import type { LanguageTypeConfig } from './types.js';
-export declare const typeConfig: LanguageTypeConfig;

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

@@ -1,60 +0,0 @@
-import { extractSimpleTypeName, extractVarName } from './shared.js';
-const DECLARATION_NODE_TYPES = new Set([
-    'declaration',
-]);
-/** C++: Type x = ...; Type* x; Type& x; */
-const extractDeclaration = (node, env) => {
-    const typeNode = node.childForFieldName('type');
-    if (!typeNode)
-        return;
-    const typeName = extractSimpleTypeName(typeNode);
-    if (!typeName)
-        return;
-    const declarator = node.childForFieldName('declarator');
-    if (!declarator)
-        return;
-    // init_declarator: Type x = value
-    const nameNode = declarator.type === 'init_declarator'
-        ? declarator.childForFieldName('declarator')
-        : declarator;
-    if (!nameNode)
-        return;
-    // Handle pointer/reference declarators
-    const finalName = nameNode.type === 'pointer_declarator' || nameNode.type === 'reference_declarator'
-        ? nameNode.firstNamedChild
-        : nameNode;
-    if (!finalName)
-        return;
-    const varName = extractVarName(finalName);
-    if (varName)
-        env.set(varName, typeName);
-};
-/** C/C++: parameter_declaration → type declarator */
-const extractParameter = (node, env) => {
-    let nameNode = null;
-    let typeNode = null;
-    if (node.type === 'parameter_declaration') {
-        typeNode = node.childForFieldName('type');
-        const declarator = node.childForFieldName('declarator');
-        if (declarator) {
-            nameNode = declarator.type === 'pointer_declarator' || declarator.type === 'reference_declarator'
-                ? declarator.firstNamedChild
-                : declarator;
-        }
-    }
-    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);
-};
-export const typeConfig = {
-    declarationNodeTypes: DECLARATION_NODE_TYPES,
-    extractDeclaration,
-    extractParameter,
-};

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

@@ -1,2 +0,0 @@
-import type { LanguageTypeConfig } from './types.js';
-export declare const typeConfig: LanguageTypeConfig;

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

@@ -1,89 +0,0 @@
-import { extractSimpleTypeName, extractVarName, findChildByType } from './shared.js';
-const DECLARATION_NODE_TYPES = new Set([
-    'local_declaration_statement',
-    'variable_declaration',
-    'field_declaration',
-]);
-/** C#: Type x = ...; var x = new Type(); */
-const extractDeclaration = (node, env) => {
-    // 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()
-        // C# tree-sitter puts object_creation_expression as direct child of variable_declarator
-        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);
-};
-export const typeConfig = {
-    declarationNodeTypes: DECLARATION_NODE_TYPES,
-    extractDeclaration,
-    extractParameter,
-};

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

@@ -1,2 +0,0 @@
-import type { LanguageTypeConfig } from './types.js';
-export declare const typeConfig: LanguageTypeConfig;

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

@@ -1,105 +0,0 @@
-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) => {
-    // Go 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++) {
-        const valueNode = rhsNodes[i];
-        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);
-};
-export const typeConfig = {
-    declarationNodeTypes: DECLARATION_NODE_TYPES,
-    extractDeclaration,
-    extractParameter,
-};

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

@@ -1,21 +0,0 @@
-/**
- * Per-language type extraction configurations.
- * Assembled here 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;
-};
-export type { LanguageTypeConfig, TypeBindingExtractor, ParameterExtractor } from './types.js';
-export { TYPED_PARAMETER_TYPES, extractSimpleTypeName, extractVarName, findChildByType } from './shared.js';

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

@@ -1,29 +0,0 @@
-/**
- * Per-language type extraction configurations.
- * Assembled here 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';
-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,
-};
-export { TYPED_PARAMETER_TYPES, extractSimpleTypeName, extractVarName, findChildByType } from './shared.js';

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

@@ -1,3 +0,0 @@
-import type { LanguageTypeConfig } from './types.js';
-export declare const javaTypeConfig: LanguageTypeConfig;
-export declare const kotlinTypeConfig: LanguageTypeConfig;

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

@@ -1,121 +0,0 @@
-import { extractSimpleTypeName, extractVarName, findChildByType } from './shared.js';
-// ── Java ──────────────────────────────────────────────────────────────────
-const JAVA_DECLARATION_NODE_TYPES = new Set([
-    'local_variable_declaration',
-    'field_declaration',
-]);
-/** Java: Type x = ...; Type x; */
-const extractJavaDeclaration = (node, env) => {
-    const typeNode = node.childForFieldName('type');
-    if (!typeNode)
-        return;
-    const typeName = extractSimpleTypeName(typeNode);
-    if (!typeName)
-        return;
-    // Find variable_declarator children
-    for (let i = 0; i < node.namedChildCount; i++) {
-        const child = node.namedChild(i);
-        if (child?.type !== 'variable_declarator')
-            continue;
-        const nameNode = child.childForFieldName('name');
-        if (nameNode) {
-            const varName = extractVarName(nameNode);
-            if (varName)
-                env.set(varName, typeName);
-        }
-    }
-};
-/** Java: formal_parameter → type name */
-const extractJavaParameter = (node, env) => {
-    let nameNode = null;
-    let typeNode = null;
-    if (node.type === 'formal_parameter') {
-        typeNode = node.childForFieldName('type');
-        nameNode = node.childForFieldName('name');
-    }
-    else {
-        // Generic fallback
-        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);
-};
-export const javaTypeConfig = {
-    declarationNodeTypes: JAVA_DECLARATION_NODE_TYPES,
-    extractDeclaration: extractJavaDeclaration,
-    extractParameter: extractJavaParameter,
-};
-// ── Kotlin ────────────────────────────────────────────────────────────────
-const KOTLIN_DECLARATION_NODE_TYPES = new Set([
-    'property_declaration',
-    'variable_declaration',
-]);
-/** Kotlin: val x: Foo = ... */
-const extractKotlinDeclaration = (node, env) => {
-    if (node.type === 'property_declaration') {
-        // Kotlin property_declaration: name/type are inside a variable_declaration child
-        const varDecl = findChildByType(node, 'variable_declaration');
-        if (varDecl) {
-            const nameNode = findChildByType(varDecl, 'simple_identifier');
-            const typeNode = findChildByType(varDecl, 'user_type');
-            if (!nameNode || !typeNode)
-                return;
-            const varName = extractVarName(nameNode);
-            const typeName = extractSimpleTypeName(typeNode);
-            if (varName && typeName)
-                env.set(varName, typeName);
-            return;
-        }
-        // Fallback: try direct fields
-        const nameNode = node.childForFieldName('name')
-            ?? findChildByType(node, 'simple_identifier');
-        const typeNode = node.childForFieldName('type')
-            ?? findChildByType(node, 'user_type');
-        if (!nameNode || !typeNode)
-            return;
-        const varName = extractVarName(nameNode);
-        const typeName = extractSimpleTypeName(typeNode);
-        if (varName && typeName)
-            env.set(varName, typeName);
-    }
-    else if (node.type === 'variable_declaration') {
-        // variable_declaration directly inside functions
-        const nameNode = findChildByType(node, 'simple_identifier');
-        const typeNode = findChildByType(node, 'user_type');
-        if (nameNode && typeNode) {
-            const varName = extractVarName(nameNode);
-            const typeName = extractSimpleTypeName(typeNode);
-            if (varName && typeName)
-                env.set(varName, typeName);
-        }
-    }
-};
-/** Kotlin: formal_parameter → type name */
-const extractKotlinParameter = (node, env) => {
-    let nameNode = null;
-    let typeNode = null;
-    if (node.type === 'formal_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);
-};
-export const kotlinTypeConfig = {
-    declarationNodeTypes: KOTLIN_DECLARATION_NODE_TYPES,
-    extractDeclaration: extractKotlinDeclaration,
-    extractParameter: extractKotlinParameter,
-};

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

@@ -1,2 +0,0 @@
-import type { LanguageTypeConfig } from './types.js';
-export declare const typeConfig: LanguageTypeConfig;