gitnexus 1.6.6-rc.98 → 1.6.6

package/dist/core/ingestion/call-routing.d.ts

@@ -7,8 +7,8 @@
  * call-processor so that the classification logic lives in one place.
  *
  * Heritage (mixins: include/extend/prepend) was previously routed here
- * but is now handled by heritageExtractor.extractFromCall before the
- * call router runs.  The router still returns 'skip' for these calls.
+ * but is now emitted by the scope-resolution pipeline. The router still
+ * returns 'skip' for these calls so they don't become spurious call edges.
  *
  * NOTE: This file is intentionally duplicated in gitnexus-web/ because the
  * two packages have separate build targets (Node native vs WASM/browser).
@@ -19,9 +19,10 @@ import type { SyntaxNode } from './utils/ast-helpers.js';
 export type CallRoutingResult = RubyCallRouting | null;
 /**
  * Per-language call router.
- * IMPORTANT: Call-routed imports bypass preprocessImportPath(), so any router that
- * returns an importPath MUST validate it independently (length cap, control-char
- * rejection). See routeRubyCall for the reference implementation.
+ * IMPORTANT: Call-routed imports are NOT sanitized by the standard import-path
+ * cleaner, so any router that returns an importPath MUST validate it
+ * independently (length cap, control-char rejection). See routeRubyCall for the
+ * reference implementation.
  */
 export type CallRouter = (calledName: string, callNode: SyntaxNode) => CallRoutingResult;
 export type RubyCallRouting = {

package/dist/core/ingestion/call-routing.js

@@ -7,8 +7,8 @@
  * call-processor so that the classification logic lives in one place.
  *
  * Heritage (mixins: include/extend/prepend) was previously routed here
- * but is now handled by heritageExtractor.extractFromCall before the
- * call router runs.  The router still returns 'skip' for these calls.
+ * but is now emitted by the scope-resolution pipeline. The router still
+ * returns 'skip' for these calls so they don't become spurious call edges.
  *
  * NOTE: This file is intentionally duplicated in gitnexus-web/ because the
  * two packages have separate build targets (Node native vs WASM/browser).
@@ -44,10 +44,10 @@ export function routeRubyCall(calledName, callNode) {
         }
         return { kind: 'import', importPath, isRelative };
     }
-    // ── include / extend / prepend — heritage (now handled by heritageExtractor) ─
-    // Call-based heritage is intercepted by heritageExtractor.extractFromCall
-    // before the call router runs.  Return SKIP_RESULT so these calls don't
-    // fall through to normal call processing.
+    // ── include / extend / prepend — heritage (emitted by scope-resolution) ─
+    // Call-based heritage (Ruby mixins) is emitted by the scope-resolution
+    // pipeline. Return SKIP_RESULT so these calls don't fall through to normal
+    // call processing and become spurious call edges.
     if (calledName === 'include' || calledName === 'extend' || calledName === 'prepend') {
         return SKIP_RESULT;
     }

package/dist/core/ingestion/call-types.d.ts

@@ -58,78 +58,3 @@ export interface CallExtractionConfig {
      */
     typeAsReceiverHeuristic?: boolean;
 }
-/**
- * DAG stage 3 output: call record with receiver type and source discriminant.
- *
- * `receiverTypeName` is resolved via TypeEnv → constructor-map → class-as-receiver →
- * mixed-chain, or synthesized by `inferImplicitReceiver`. `receiverSource` tags
- * which path won and drives MRO strategy selection in stage 4.
- *
- * Invariants:
- * - `receiverSource` MUST match how `receiverTypeName` was resolved; every
- *   discriminant must have a live reader and writer.
- * - `hint` is opaque to shared stages; only the same provider's `selectDispatch` reads it.
- *
- * @see language-provider.ts § inferImplicitReceiver, selectDispatch
- */
-export interface ReceiverEnriched {
-    readonly calledName: string;
-    readonly callForm: 'free' | 'member' | 'constructor' | undefined;
-    readonly receiverName: string | undefined;
-    readonly receiverTypeName: string | undefined;
-    readonly receiverSource: 'none' | 'typed-binding' | 'constructor-map' | 'class-as-receiver' | 'mixed-chain' | 'implicit-self';
-    /** Free-form hint from the provider hook; opaque to shared stages. */
-    readonly hint?: string;
-}
-/**
- * Provider hook output for `LanguageProvider.inferImplicitReceiver` (DAG stage 3).
- *
- * Overlay applied to `ReceiverEnriched` when an implicit receiver is synthesized.
- * Ruby example: bare `serialize` inside `Account#call_serialize` →
- * `{ callForm: 'member', receiverName: 'self', receiverTypeName: 'Account',
- *   receiverSource: 'implicit-self', hint: 'instance' }`
- *
- * Invariants:
- * - `receiverSource` is always `'implicit-self'` — the only variant this type produces.
- * - `callForm` is always `'member'` — the rewrite converts bare-call to method invocation.
- * - `hint` is opaque to shared stages; consumed by the same language's `selectDispatch`.
- */
-export interface ImplicitReceiverOverride {
-    readonly callForm: 'free' | 'member' | 'constructor';
-    readonly receiverName: string;
-    readonly receiverTypeName: string;
-    readonly receiverSource: Extract<ReceiverEnriched['receiverSource'], 'implicit-self'>;
-    /** Free-form language tag (e.g. Ruby sets 'singleton' for `def self.foo`
-     *  method bodies). Consumed by the same language's `selectDispatch` hook. */
-    readonly hint?: string;
-}
-/**
- * DAG stage 4 output: dispatch strategy for resolving the target method.
- *
- * Encodes which resolver branch to try first and an optional fallback.
- * Stage 5 delegates to `resolveMemberCall`, `resolveFreeCall`, or
- * `resolveStaticCall` based on `primary`.
- *
- * - `primary`: `'owner-scoped'` = MRO walk, `'free'` = arity-tiered global lookup,
- *   `'constructor'` = type instantiation.
- * - `fallback`: Only `'free-arity-narrowed'` exists; used by Ruby implicit-self
- *   to degrade to arity-tiered free lookup when the MRO walk misses.
- * - `ancestryView`: Ruby `'ruby-mixin'` only. `'singleton'` walks extend providers
- *   only; a miss NEVER falls through to file-scoped lookup (enforced in
- *   resolveCallTarget). `'instance'` is the default.
- *
- * Common patterns:
- *   - `{primary: 'constructor'}` — constructor call
- *   - `{primary: 'owner-scoped'}` — member call with known type
- *   - `{primary: 'owner-scoped', fallback: 'free-arity-narrowed', ancestryView: 'instance'}` — Ruby implicit-self
- *   - `{primary: 'owner-scoped', ancestryView: 'singleton'}` — Ruby class-method call
- *
- * @see language-provider.ts § selectDispatch
- * @see call-processor.ts § defaultDispatchDecision, resolveCallTarget
- */
-export interface DispatchDecision {
-    readonly primary: 'owner-scoped' | 'free' | 'constructor';
-    readonly fallback?: 'free-arity-narrowed';
-    readonly ancestryView?: 'instance' | 'singleton';
-    readonly hint?: string;
-}

package/dist/core/ingestion/class-extractors/configs/c-cpp.js

@@ -29,7 +29,32 @@ export const cClassConfig = {
 export const cppClassConfig = {
     language: SupportedLanguages.CPlusPlus,
     typeDeclarationNodes: ['class_specifier', 'struct_specifier', 'enum_specifier'],
-    ancestorScopeNodeTypes: ['namespace_definition', 'class_specifier', 'struct_specifier'],
+    // #1995: `union_specifier` is included so a type nested in a NAMED union
+    // (`union U1 { struct Inner {...} }`) qualifies as `U1.Inner`. Anonymous unions
+    // have no `name` child → extractScopeSegmentsFromNode returns [] → they correctly
+    // contribute nothing (members inject into the enclosing scope). C uses the
+    // separate cClassConfig (no qualifiedNodeId), so it is intentionally untouched.
+    ancestorScopeNodeTypes: [
+        'namespace_definition',
+        'class_specifier',
+        'struct_specifier',
+        'union_specifier',
+    ],
+    // #1978: key nested-type nodes by their fully-qualified path (Outer.Inner) so
+    // same-tail nested types in one TU stay distinct instead of silently merging.
+    qualifiedNodeId: true,
+    // #1995: anonymous namespaces have no `name` child, so the generic scope walker
+    // drops them (empty segment) and two `namespace { struct Inner {} }` blocks in one
+    // TU collapse onto a single `Inner` node. Give each anonymous namespace_definition
+    // a deterministic per-block discriminator (its start byte — stable across the
+    // sequential and worker full-file parses) so the nested types stay distinct.
+    // Returning `undefined` for every other scope — named namespaces (incl. `inline
+    // namespace`), classes, structs, named unions — falls through to the default
+    // name-based extraction, leaving them unchanged. Anonymous UNIONS are not matched
+    // here (members inject into the enclosing scope), so they keep yielding [].
+    extractScopeSegments: (node) => node.type === 'namespace_definition' && !node.childForFieldName?.('name')
+        ? [`@anon${node.startIndex}`]
+        : undefined,
     extractName: (node) => {
         const nameNode = node.childForFieldName?.('name');
         if (!nameNode)

package/dist/core/ingestion/class-extractors/configs/ruby.js

@@ -4,4 +4,7 @@ export const rubyClassConfig = {
     language: SupportedLanguages.Ruby,
     typeDeclarationNodes: ['class'],
     ancestorScopeNodeTypes: ['module', 'class'],
+    // #1978: key nested-type nodes by their fully-qualified path (Outer.Inner) so
+    // same-tail classes nested under different modules stay distinct.
+    qualifiedNodeId: true,
 };

package/dist/core/ingestion/class-extractors/generic.js

@@ -1,3 +1,4 @@
+import { splitQualifiedName } from '../utils/qualified-name.js';
 const DEFAULT_SCOPE_NAME_NODE_TYPES = new Set([
     'nested_namespace_specifier',
     'scoped_identifier',
@@ -45,17 +46,6 @@ const CLASS_LIKE_LABELS = new Set([
     'Enum',
     'Record',
 ]);
-const normalizeQualifiedName = (value) => value
-    .replace(/\s+/g, '')
-    .replace(/^::/, '')
-    .replace(/::/g, '.')
-    .replace(/\\/g, '.')
-    .replace(/\.+/g, '.')
-    .replace(/^\.+|\.+$/g, '');
-const splitQualifiedName = (value) => {
-    const normalized = normalizeQualifiedName(value);
-    return normalized ? normalized.split('.').filter(Boolean) : [];
-};
 const extractScopeSegmentsFromNode = (scopeNode, scopeNameNodeTypes) => {
     const nameNode = scopeNode.childForFieldName?.('name') ??
         scopeNode.namedChildren?.find((child) => scopeNameNodeTypes.has(child.type));
@@ -126,6 +116,7 @@ export function createClassExtractor(config) {
     };
     return {
         language: config.language,
+        qualifiedNodeId: config.qualifiedNodeId ?? false,
         isTypeDeclaration(node) {
             return typeDeclarationSet.has(node.type);
         },
@@ -133,6 +124,13 @@ export function createClassExtractor(config) {
         extractQualifiedName(node, simpleName) {
             return extract(node, { name: simpleName })?.qualifiedName ?? null;
         },
+        // #1991: qualify a non-typeDeclaration scope node (e.g. a Ruby `module` → Trait)
+        // by the same ancestor-scope walk the node-id path uses, so two same-tail nested
+        // mixin modules stay distinct. extract()/extractQualifiedName cannot be reused —
+        // they bail on non-typeDeclarations (a module is not in typeDeclarationNodes).
+        qualifyScopeName(node, simpleName) {
+            return buildQualifiedName(node, simpleName);
+        },
         shouldSkipClassCapture(context) {
             return config.shouldSkipClassCapture?.(context) ?? false;
         },

package/dist/core/ingestion/class-types.d.ts

@@ -21,12 +21,27 @@ export interface ClassCaptureContext {
  */
 export interface ClassExtractor {
     language: SupportedLanguages;
+    /**
+     * When true, this language's nested-type graph nodes are keyed by their
+     * fully-qualified path (e.g. `Class:file:Outer.Inner`) instead of the simple
+     * tail name, so same-tail nested types in one file stay distinct (#1978).
+     * Surfaced from `ClassExtractionConfig.qualifiedNodeId`.
+     */
+    readonly qualifiedNodeId: boolean;
     isTypeDeclaration(node: SyntaxNode): boolean;
     extract(node: SyntaxNode, fallback?: {
         name?: string;
         type?: NodeLabel | null;
     }): ExtractedClassSymbol | null;
     extractQualifiedName(node: SyntaxNode, simpleName: string): string | null;
+    /**
+     * #1991: qualify a scope-defining node that maps to a class-like registry label
+     * (e.g. a Ruby `module` → Trait) but is NOT a typeDeclaration, so it cannot go
+     * through extract()/extractQualifiedName (which bail on non-typeDeclarations).
+     * Walks the same ancestor scopes as the node-id path. Optional — only providers
+     * that materialize such nodes implement it.
+     */
+    qualifyScopeName?(node: SyntaxNode, simpleName: string): string;
     shouldSkipClassCapture?(context: ClassCaptureContext & {
         nodeLabel: ClassLikeNodeLabel;
     }): boolean;
@@ -37,6 +52,14 @@ export interface ClassExtractionConfig {
     typeDeclarationNodes: string[];
     fileScopeNodeTypes?: string[];
     ancestorScopeNodeTypes?: string[];
+    /**
+     * Opt-in (#1978): key this language's nested-type graph nodes (and their
+     * member-owner edges) by the fully-qualified path instead of the simple tail
+     * name, so same-tail nested types in one file stop colliding. Default false.
+     * Requires `ancestorScopeNodeTypes` to be set so `buildQualifiedName` can walk
+     * the scope chain.
+     */
+    qualifiedNodeId?: boolean;
     scopeNameNodeTypes?: string[];
     extractName?: (node: SyntaxNode) => string | undefined;
     extractType?: (node: SyntaxNode) => ClassLikeNodeLabel | undefined;

package/dist/core/ingestion/cobol/cobol-preprocessor.d.ts

@@ -187,6 +187,17 @@ export interface CobolRegexResults {
         line: number;
         caller: string | null;
     }>;
+    arithmeticOps: Array<{
+        verb: 'COMPUTE' | 'ADD' | 'SUBTRACT' | 'MULTIPLY' | 'DIVIDE';
+        /** Target variable (written to) */
+        target: string;
+        /** Source operand variables (read from) */
+        sources: string[];
+        line: number;
+        caller: string | null;
+        /** For ADD/SUBTRACT/MULTIPLY/DIVIDE with GIVING: the GIVING target */
+        givingTarget?: string;
+    }>;
 }
 /**
  * Normalize COBOL source for regex-based extraction.