gitnexus 1.6.6-rc.12 → 1.6.6-rc.13

package/dist/_shared/scope-resolution/reference-site.d.ts

@@ -20,6 +20,7 @@
  * resolution step that reads this record and produces a `Reference`
  * (defined in `./types.ts`).
  */
+import type { ParameterTypeClass } from './symbol-definition.js';
 import type { Range, ScopeId } from './types.js';
 /**
  * What kind of usage this reference represents — the graph-edge kind
@@ -71,5 +72,12 @@ export interface ReferenceSite {
      * (C#: `42` → `'int'`, `"alice"` → `'string'`).
      */
     readonly argumentTypes?: readonly string[];
+    /**
+     * Optional per-argument type-shape sidecar for languages that need
+     * cv/ref/pointer distinctions during constraint filtering. This is
+     * intentionally separate from `argumentTypes`, which stays normalized
+     * for existing overload narrowing and conversion-rank logic.
+     */
+    readonly argumentTypeClasses?: readonly ParameterTypeClass[];
 }
 //# sourceMappingURL=reference-site.d.ts.map

package/dist/_shared/scope-resolution/reference-site.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"reference-site.d.ts","sourceRoot":"","sources":["../../src/scope-resolution/reference-site.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAEjD;;;;;;GAMG;AACH,MAAM,MAAM,aAAa,GACrB,MAAM,GACN,MAAM,GACN,OAAO,GACP,gBAAgB,GAChB,UAAU,GACV,YAAY,CAAC;AAEjB;;;;;;;;;GASG;AACH,MAAM,MAAM,QAAQ,GAAG,MAAM,GAAG,QAAQ,GAAG,aAAa,GAAG,OAAO,CAAC;AAEnE,MAAM,WAAW,aAAa;IAC5B,uEAAuE;IACvE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,2CAA2C;IAC3C,QAAQ,CAAC,OAAO,EAAE,KAAK,CAAC;IACxB;;;;OAIG;IACH,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC;IAC7B,kCAAkC;IAClC,QAAQ,CAAC,QAAQ,CAAC,EAAE,QAAQ,CAAC;IAC7B;;;OAGG;IACH,QAAQ,CAAC,gBAAgB,CAAC,EAAE;QAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;IACtD,8EAA8E;IAC9E,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB;;;;;;OAMG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CAC5C"}
+{"version":3,"file":"reference-site.d.ts","sourceRoot":"","sources":["../../src/scope-resolution/reference-site.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AACjE,OAAO,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAEjD;;;;;;GAMG;AACH,MAAM,MAAM,aAAa,GACrB,MAAM,GACN,MAAM,GACN,OAAO,GACP,gBAAgB,GAChB,UAAU,GACV,YAAY,CAAC;AAEjB;;;;;;;;;GASG;AACH,MAAM,MAAM,QAAQ,GAAG,MAAM,GAAG,QAAQ,GAAG,aAAa,GAAG,OAAO,CAAC;AAEnE,MAAM,WAAW,aAAa;IAC5B,uEAAuE;IACvE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,2CAA2C;IAC3C,QAAQ,CAAC,OAAO,EAAE,KAAK,CAAC;IACxB;;;;OAIG;IACH,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC;IAC7B,kCAAkC;IAClC,QAAQ,CAAC,QAAQ,CAAC,EAAE,QAAQ,CAAC;IAC7B;;;OAGG;IACH,QAAQ,CAAC,gBAAgB,CAAC,EAAE;QAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;IACtD,8EAA8E;IAC9E,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB;;;;;;OAMG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3C;;;;;OAKG;IACH,QAAQ,CAAC,mBAAmB,CAAC,EAAE,SAAS,kBAAkB,EAAE,CAAC;CAC9D"}

package/dist/_shared/scope-resolution/registries/context.d.ts

@@ -12,7 +12,7 @@
  * reaches into the CLI package.
  */
 import type { NodeLabel } from '../../graph/types.js';
-import type { SymbolDefinition } from '../symbol-definition.js';
+import type { ParameterTypeClass, SymbolDefinition } from '../symbol-definition.js';
 import type { Callsite, DefId } from '../types.js';
 import type { DefIndex } from '../def-index.js';
 import type { QualifiedNameIndex } from '../qualified-name-index.js';
@@ -54,6 +54,13 @@ export interface ConstraintContext {
      * `narrowOverloadCandidates`' `argTypes` parameter.
      */
     readonly argumentTypes?: readonly string[];
+    /**
+     * Optional shape-preserving sidecar aligned with `argumentTypes`.
+     * Unknown or unsupported slots should be omitted by producers or
+     * marked with `indirection: 'unknown'`; consumers must preserve the
+     * monotonic fallback and return 'unknown' instead of guessing.
+     */
+    readonly argumentTypeClasses?: readonly ParameterTypeClass[];
 }
 /**
  * Per-owner membership view plugged into `LookupParams.ownerScopedContributor`.

package/dist/_shared/scope-resolution/registries/context.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../../src/scope-resolution/registries/context.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AACtD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAChE,OAAO,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AACnD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AACrE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AACjE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AAIvE,MAAM,WAAW,iBAAiB;IAChC;;;;OAIG;IACH,kBAAkB,CAAC,CAAC,QAAQ,EAAE,QAAQ,EAAE,GAAG,EAAE,gBAAgB,GAAG,YAAY,CAAC;IAE7E;;;;;;;;;;OAUG;IACH,uBAAuB,CAAC,CACtB,QAAQ,EAAE,QAAQ,EAClB,GAAG,EAAE,gBAAgB,EACrB,GAAG,EAAE,iBAAiB,GACrB,YAAY,CAAC;CACjB;AAED,MAAM,MAAM,YAAY,GAAG,YAAY,GAAG,SAAS,GAAG,cAAc,CAAC;AAErE;;;;;;GAMG;AACH,MAAM,WAAW,iBAAiB;IAChC;;;;OAIG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CAC5C;AAID;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,sBAAsB;IACrC,sEAAsE;IACtE,QAAQ,CAAC,UAAU,EAAE,KAAK,CAAC;IAC3B;;;;OAIG;IACH,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,gBAAgB,EAAE,CAAC;CACnD;AAED;;;;;;;GAOG;AACH,MAAM,MAAM,yBAAyB,GAAG,CACtC,UAAU,EAAE,KAAK,EACjB,UAAU,EAAE,MAAM,KACf,SAAS,gBAAgB,EAAE,CAAC;AAIjC,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,MAAM,EAAE,SAAS,CAAC;IAC3B,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IACxB,QAAQ,CAAC,cAAc,EAAE,kBAAkB,CAAC;IAC5C,QAAQ,CAAC,YAAY,EAAE,gBAAgB,CAAC;IACxC,QAAQ,CAAC,mBAAmB,EAAE,yBAAyB,CAAC;IACxD;;;OAGG;IACH,QAAQ,CAAC,cAAc,CAAC,EAAE,mBAAmB,CAAC;IAC9C,QAAQ,CAAC,SAAS,EAAE,iBAAiB,CAAC;CACvC;AAOD,eAAO,MAAM,WAAW,EAAE,SAAS,SAAS,EAc1C,CAAC;AAEH,eAAO,MAAM,YAAY,EAAE,SAAS,SAAS,EAI3C,CAAC;AAEH,eAAO,MAAM,WAAW,EAAE,SAAS,SAAS,EAK1C,CAAC"}
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../../src/scope-resolution/registries/context.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AACtD,OAAO,KAAK,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AACpF,OAAO,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AACnD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AACrE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AACjE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AAIvE,MAAM,WAAW,iBAAiB;IAChC;;;;OAIG;IACH,kBAAkB,CAAC,CAAC,QAAQ,EAAE,QAAQ,EAAE,GAAG,EAAE,gBAAgB,GAAG,YAAY,CAAC;IAE7E;;;;;;;;;;OAUG;IACH,uBAAuB,CAAC,CACtB,QAAQ,EAAE,QAAQ,EAClB,GAAG,EAAE,gBAAgB,EACrB,GAAG,EAAE,iBAAiB,GACrB,YAAY,CAAC;CACjB;AAED,MAAM,MAAM,YAAY,GAAG,YAAY,GAAG,SAAS,GAAG,cAAc,CAAC;AAErE;;;;;;GAMG;AACH,MAAM,WAAW,iBAAiB;IAChC;;;;OAIG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3C;;;;;OAKG;IACH,QAAQ,CAAC,mBAAmB,CAAC,EAAE,SAAS,kBAAkB,EAAE,CAAC;CAC9D;AAID;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,sBAAsB;IACrC,sEAAsE;IACtE,QAAQ,CAAC,UAAU,EAAE,KAAK,CAAC;IAC3B;;;;OAIG;IACH,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,gBAAgB,EAAE,CAAC;CACnD;AAED;;;;;;;GAOG;AACH,MAAM,MAAM,yBAAyB,GAAG,CACtC,UAAU,EAAE,KAAK,EACjB,UAAU,EAAE,MAAM,KACf,SAAS,gBAAgB,EAAE,CAAC;AAIjC,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,MAAM,EAAE,SAAS,CAAC;IAC3B,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IACxB,QAAQ,CAAC,cAAc,EAAE,kBAAkB,CAAC;IAC5C,QAAQ,CAAC,YAAY,EAAE,gBAAgB,CAAC;IACxC,QAAQ,CAAC,mBAAmB,EAAE,yBAAyB,CAAC;IACxD;;;OAGG;IACH,QAAQ,CAAC,cAAc,CAAC,EAAE,mBAAmB,CAAC;IAC9C,QAAQ,CAAC,SAAS,EAAE,iBAAiB,CAAC;CACvC;AAOD,eAAO,MAAM,WAAW,EAAE,SAAS,SAAS,EAc1C,CAAC;AAEH,eAAO,MAAM,YAAY,EAAE,SAAS,SAAS,EAI3C,CAAC;AAEH,eAAO,MAAM,WAAW,EAAE,SAAS,SAAS,EAK1C,CAAC"}

package/dist/_shared/scope-resolution/registries/context.js.map

@@ -1 +1 @@
-{"version":3,"file":"context.js","sourceRoot":"","sources":["../../../src/scope-resolution/registries/context.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAgHH,8EAA8E;AAC9E,EAAE;AACF,0EAA0E;AAC1E,6DAA6D;AAE7D,MAAM,CAAC,MAAM,WAAW,GAAyB,MAAM,CAAC,MAAM,CAAC;IAC7D,OAAO;IACP,WAAW;IACX,MAAM;IACN,QAAQ;IACR,OAAO;IACP,OAAO;IACP,WAAW;IACX,SAAS;IACT,QAAQ;IACR,UAAU;IACV,YAAY;IACZ,UAAU;IACV,WAAW;CACZ,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,YAAY,GAAyB,MAAM,CAAC,MAAM,CAAC;IAC9D,QAAQ;IACR,UAAU;IACV,aAAa;CACd,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,WAAW,GAAyB,MAAM,CAAC,MAAM,CAAC;IAC7D,UAAU;IACV,UAAU;IACV,OAAO;IACP,QAAQ;CACT,CAAC,CAAC"}
+{"version":3,"file":"context.js","sourceRoot":"","sources":["../../../src/scope-resolution/registries/context.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAuHH,8EAA8E;AAC9E,EAAE;AACF,0EAA0E;AAC1E,6DAA6D;AAE7D,MAAM,CAAC,MAAM,WAAW,GAAyB,MAAM,CAAC,MAAM,CAAC;IAC7D,OAAO;IACP,WAAW;IACX,MAAM;IACN,QAAQ;IACR,OAAO;IACP,OAAO;IACP,WAAW;IACX,SAAS;IACT,QAAQ;IACR,UAAU;IACV,YAAY;IACZ,UAAU;IACV,WAAW;CACZ,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,YAAY,GAAyB,MAAM,CAAC,MAAM,CAAC;IAC9D,QAAQ;IACR,UAAU;IACV,aAAa;CACd,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,WAAW,GAAyB,MAAM,CAAC,MAAM,CAAC;IAC7D,UAAU;IACV,UAAU;IACV,OAAO;IACP,QAAQ;CACT,CAAC,CAAC"}

package/dist/core/ingestion/languages/cpp/captures.js

@@ -3,7 +3,7 @@ import { getCppParser, getCppScopeQuery } from './query.js';
 import { getTreeSitterBufferSize } from '../../constants.js';
 import { parseSourceSafe } from '../../../tree-sitter/safe-parse.js';
 import { splitCppInclude, splitCppUsingDecl } from './import-decomposer.js';
-import { computeCppDeclarationArity, computeCppCallArity } from './arity-metadata.js';
+import { classifyCppParameterType, computeCppDeclarationArity, computeCppCallArity, } from './arity-metadata.js';
 import { markCppAnonymousNamespaceRange, markFileLocal } from './file-local-linkage.js';
 import { markCppDependentBase } from './two-phase-lookup.js';
 import { markCppAdlSiteArgs, markCppAdlSiteNoAdl } from './adl.js';
@@ -159,6 +159,10 @@ export function emitCppScopeCaptures(sourceText, filePath, cachedTree) {
                 if (argTypes !== undefined && argTypes.length > 0) {
                     grouped['@reference.parameter-types'] = syntheticCapture('@reference.parameter-types', cNode, JSON.stringify(argTypes));
                 }
+                const argTypeClasses = inferCppCallArgTypeClasses(cNode);
+                if (argTypeClasses !== undefined && argTypeClasses.length > 0) {
+                    grouped['@reference.parameter-type-classes'] = syntheticCapture('@reference.parameter-type-classes', cNode, JSON.stringify(argTypeClasses));
+                }
             }
         }
         // ── Inline namespace detection ──────────────────────────────────
@@ -612,6 +616,36 @@ function inferCppCallArgTypes(node) {
     }
     return types.length > 0 ? types : undefined;
 }
+function inferCppCallArgTypeClasses(node) {
+    const argList = node.childForFieldName('arguments');
+    if (argList === null)
+        return undefined;
+    const classes = [];
+    for (let i = 0; i < argList.childCount; i++) {
+        const child = argList.child(i);
+        if (child === null)
+            continue;
+        if (child.type === ',' || child.type === '(' || child.type === ')')
+            continue;
+        const litType = inferCppLiteralType(child);
+        if (litType !== '') {
+            classes.push(valueTypeClass(litType));
+        }
+        else if (child.type === 'identifier') {
+            classes.push(lookupDeclaredTypeClassForIdentifier(child));
+        }
+        else {
+            classes.push(unknownTypeClass('unknown'));
+        }
+    }
+    return classes.length > 0 ? classes : undefined;
+}
+function valueTypeClass(base) {
+    return { base, cv: 'none', indirection: 'value', pointerDepth: 0 };
+}
+function unknownTypeClass(base) {
+    return { base, cv: 'unknown', indirection: 'unknown', pointerDepth: 0 };
+}
 /**
  * Infer the canonical type name of a C++ literal AST node.
  * Returns empty string for non-literal / unknown nodes.
@@ -674,6 +708,9 @@ function lookupDeclaredTypeForIdentifier(identNode) {
     }
     if (scope === null)
         return '';
+    const paramType = lookupFunctionParameterType(scope, varName);
+    if (paramType !== '')
+        return paramType;
     // Scan declarations in the scope for a matching variable name
     for (let i = 0; i < scope.childCount; i++) {
         const stmt = scope.child(i);
@@ -689,18 +726,113 @@ function lookupDeclaredTypeForIdentifier(identNode) {
         const declarator = stmt.childForFieldName('declarator');
         if (declarator === null)
             continue;
-        if (declarator.type === 'init_declarator') {
-            const nameChild = declarator.childForFieldName('declarator');
-            if (nameChild !== null && nameChild.text === varName) {
-                return normalizeCppTypeText(typeNode.text);
-            }
-        }
-        else if (declarator.text === varName) {
+        const nameChild = declaredNameNode(declarator);
+        if (nameChild !== null && extractDeclaratorLeafName(nameChild) === varName) {
             return normalizeCppTypeText(typeNode.text);
         }
     }
     return '';
 }
+function lookupDeclaredTypeClassForIdentifier(identNode) {
+    const varName = identNode.text;
+    let scope = identNode.parent;
+    while (scope !== null &&
+        scope.type !== 'compound_statement' &&
+        scope.type !== 'translation_unit') {
+        scope = scope.parent;
+    }
+    if (scope === null)
+        return unknownTypeClass('unknown');
+    const paramTypeClass = lookupFunctionParameterTypeClass(scope, varName, identNode);
+    if (paramTypeClass !== undefined)
+        return paramTypeClass;
+    for (let i = 0; i < scope.childCount; i++) {
+        const stmt = scope.child(i);
+        if (stmt === null || stmt.type !== 'declaration')
+            continue;
+        const typeNode = stmt.childForFieldName('type');
+        if (typeNode === null)
+            continue;
+        if (typeNode.type === 'placeholder_type_specifier')
+            continue;
+        const declarator = stmt.childForFieldName('declarator');
+        if (declarator === null)
+            continue;
+        const nameChild = declaredNameNode(declarator);
+        if (nameChild === null || extractDeclaratorLeafName(nameChild) !== varName)
+            continue;
+        const typeClass = classifyCppParameterType(typeNode.text, nameChild.text, stmt.text.replace(/;\s*$/, ''));
+        if (isKnownEnumName(identNode, typeClass.base)) {
+            return { ...typeClass, base: `enum:${typeClass.base}` };
+        }
+        return typeClass;
+    }
+    return unknownTypeClass('unknown');
+}
+function lookupFunctionParameterType(scope, varName) {
+    const param = findEnclosingFunctionParameter(scope, varName);
+    if (param === null)
+        return '';
+    const typeNode = param.childForFieldName('type');
+    if (typeNode === null)
+        return '';
+    return normalizeCppTypeText(typeNode.text);
+}
+function lookupFunctionParameterTypeClass(scope, varName, identNode) {
+    const param = findEnclosingFunctionParameter(scope, varName);
+    if (param === null)
+        return undefined;
+    const typeNode = param.childForFieldName('type');
+    if (typeNode === null)
+        return undefined;
+    const declarator = param.childForFieldName('declarator');
+    if (declarator === null)
+        return undefined;
+    const typeClass = classifyCppParameterType(typeNode.text, declarator.text, param.text);
+    if (isKnownEnumName(identNode, typeClass.base)) {
+        return { ...typeClass, base: `enum:${typeClass.base}` };
+    }
+    return typeClass;
+}
+function findEnclosingFunctionParameter(scope, varName) {
+    let node = scope.parent;
+    while (node !== null) {
+        if (node.type === 'function_definition' || node.type === 'function_declarator') {
+            const fnDecl = node.type === 'function_declarator'
+                ? node
+                : findFirstDescendantOfType(node, 'function_declarator');
+            const params = fnDecl?.childForFieldName('parameters') ?? null;
+            if (params !== null) {
+                for (let i = 0; i < params.namedChildCount; i++) {
+                    const param = params.namedChild(i);
+                    if (param === null || param.type !== 'parameter_declaration')
+                        continue;
+                    const declarator = param.childForFieldName('declarator');
+                    if (declarator !== null && extractDeclaratorLeafName(declarator) === varName) {
+                        return param;
+                    }
+                }
+            }
+            return null;
+        }
+        node = node.parent;
+    }
+    return null;
+}
+function declaredNameNode(declarator) {
+    if (declarator.type !== 'init_declarator')
+        return declarator;
+    for (let i = 0; i < declarator.namedChildCount; i++) {
+        const child = declarator.namedChild(i);
+        if (child === null)
+            continue;
+        if (child.type === 'identifier')
+            return child;
+        if (child.type.endsWith('_declarator'))
+            return child;
+    }
+    return declarator.childForFieldName('declarator');
+}
 /** Normalize a type-specifier text for argument type matching.
  *  Strips qualifiers (const, volatile), namespace prefixes (std::),
  *  and pointer/reference markers. */
@@ -711,6 +843,28 @@ function normalizeCppTypeText(text) {
     t = t.replace(/[*&]/g, '').trim();
     return t;
 }
+function isKnownEnumName(node, typeName) {
+    if (typeName === '' || typeName === 'unknown')
+        return false;
+    let root = node;
+    while (root.parent !== null)
+        root = root.parent;
+    const stack = [root];
+    while (stack.length > 0) {
+        const cur = stack.pop();
+        if (cur.type === 'enum_specifier') {
+            const name = cur.childForFieldName('name');
+            if (name?.text === typeName)
+                return true;
+        }
+        for (let i = 0; i < cur.childCount; i++) {
+            const child = cur.child(i);
+            if (child !== null)
+                stack.push(child);
+        }
+    }
+    return false;
+}
 /**
  * Detect whether a `namespace_definition` AST node is inline.
  * Tree-sitter-cpp exposes the `inline` keyword as an anonymous child
@@ -1166,7 +1320,9 @@ function extractDeclaratorLeafName(node) {
         // Common wrapper nodes — follow the 'declarator' field when present.
         const next = cur.childForFieldName('declarator') ??
             // parenthesized_declarator: single named child
-            (cur.type === 'parenthesized_declarator' ? cur.namedChild(0) : null);
+            (cur.type === 'parenthesized_declarator' || cur.type.endsWith('_declarator')
+                ? cur.namedChild(0)
+                : null);
         if (next === null)
             return null;
         cur = next;

package/dist/core/ingestion/languages/cpp/constraint-filter.js

@@ -21,13 +21,9 @@
  */
 import { classifyType } from './type-classifier.js';
 /**
- * Curated Tier-A predicate registry — the four canonical
- * `<type_traits>` variable templates whose truth tables are closed-form
- * over our coarse `TypeClass` enum.
- *
- * Deferred predicates that need a cv/ref/pointer sidecar on
- * `normalizeCppParamType` (today the normalizer strips those markers
- * before storage) live in #1579 as one-line follow-up adds.
+ * Curated Tier-A predicate registry. Predicates that depend on pointer,
+ * reference, or cv shape consult `ConstraintContext.argumentTypeClasses`.
+ * Missing or unsupported shape returns 'unknown' to preserve monotonicity.
  */
 // ISO `<type_traits>` treats `bool`, `char`, and the signed/unsigned char
 // variants as integral types (§21.3.4 Table 48), so `is_integral_v<bool>`
@@ -39,40 +35,117 @@ function isIntegralClass(c) {
     return c === 'integral' || c === 'bool' || c === 'char';
 }
 const REGISTRY = new Map([
-    ['is_integral_v', (cls) => verdictFromBool(isIntegralClass(cls[0]), cls)],
-    ['is_floating_point_v', (cls) => verdictFromBool(cls[0] === 'floating', cls)],
+    [
+        'is_void_v',
+        (args) => unaryVerdict(args, (arg) => isPlainValue(arg) && arg.typeClass === 'void'),
+    ],
+    [
+        'is_integral_v',
+        (args) => unaryVerdict(args, (arg) => isPlainValue(arg) && isIntegralClass(arg.typeClass)),
+    ],
+    [
+        'is_floating_point_v',
+        (args) => unaryVerdict(args, (arg) => isPlainValue(arg) && arg.typeClass === 'floating'),
+    ],
     [
         'is_arithmetic_v',
-        (cls) => verdictFromBool(isIntegralClass(cls[0]) || cls[0] === 'floating', cls),
+        (args) => unaryVerdict(args, (arg) => isPlainValue(arg) && (isIntegralClass(arg.typeClass) || arg.typeClass === 'floating')),
+    ],
+    [
+        'is_enum_v',
+        (args) => unaryVerdict(args, (arg) => isPlainValue(arg) && arg.typeClass === 'enum'),
+    ],
+    [
+        'is_class_v',
+        (args) => unaryVerdict(args, (arg) => isPlainValue(arg) && arg.typeClass === 'class'),
+    ],
+    [
+        'is_pointer_v',
+        (args) => unaryShapeVerdict(args, (shape) => shape.indirection === 'pointer' && shape.pointerDepth > 0),
+    ],
+    [
+        'is_reference_v',
+        (args) => unaryShapeVerdict(args, (shape) => shape.indirection === 'lvalue-ref' || shape.indirection === 'rvalue-ref'),
+    ],
+    [
+        'is_const_v',
+        (args) => unaryShapeVerdict(args, (shape) => shape.cv === 'const' || shape.cv === 'const volatile', {
+            requireTopLevelCv: true,
+        }),
+    ],
+    [
+        'is_volatile_v',
+        (args) => unaryShapeVerdict(args, (shape) => shape.cv === 'volatile' || shape.cv === 'const volatile', {
+            requireTopLevelCv: true,
+        }),
     ],
-    // NOTE: cv-qualifiers are stripped by `normalizeCppParamType` before the
-    // type token reaches `classifyType`, so `is_same_v<const T, T>` returns
-    // `'compatible'` instead of the ISO-correct `false`. Tracked under the
-    // cv-sidecar refactor in #1579's "Out of scope" list; until that lands
-    // this approximation matches the common `is_same_v<T, ConcreteType>`
-    // dispatch idiom and silently degrades on cv-distinct compares.
     [
         'is_same_v',
-        (cls) => {
-            if (cls.length < 2 || cls[0] === 'unknown' || cls[1] === 'unknown')
+        (args) => {
+            if (args.length < 2 || args[0].typeClass === 'unknown' || args[1].typeClass === 'unknown') {
                 return 'unknown';
-            return cls[0] === cls[1] ? 'compatible' : 'incompatible';
+            }
+            return args[0].typeClass === args[1].typeClass ? 'compatible' : 'incompatible';
         },
     ],
 ]);
-function verdictFromBool(predicate, cls) {
-    if (cls[0] === 'unknown')
+function unaryVerdict(args, predicate) {
+    const arg = args[0];
+    if (arg === undefined || arg.typeClass === 'unknown')
         return 'unknown';
-    return predicate ? 'compatible' : 'incompatible';
+    return predicate(arg) ? 'compatible' : 'incompatible';
+}
+function unaryShapeVerdict(args, predicate, options = {}) {
+    const arg = args[0];
+    if (arg === undefined || arg.typeClass === 'unknown')
+        return 'unknown';
+    const shape = arg.shape;
+    if (shape === undefined || shape.indirection === 'unknown' || shape.cv === 'unknown') {
+        return 'unknown';
+    }
+    if (options.requireTopLevelCv === true && shape.indirection === 'pointer') {
+        return 'unknown';
+    }
+    return predicate(shape) ? 'compatible' : 'incompatible';
+}
+function isPlainValue(arg) {
+    const shape = arg.shape;
+    if (shape === undefined)
+        return true;
+    return shape.indirection === 'value';
+}
+function classifyConstraintArg(token, shape) {
+    if (shape !== undefined && shape.base.startsWith('enum:')) {
+        return { typeClass: 'enum', shape };
+    }
+    const typeClass = token === undefined || token === '' ? 'unknown' : classifyType(token);
+    return { typeClass, ...(shape !== undefined ? { shape } : {}) };
+}
+function tokenForArg(ctx, argIdx) {
+    const shape = ctx.argumentTypeClasses?.[argIdx];
+    if (shape?.base.startsWith('enum:'))
+        return shape.base;
+    return ctx.argumentTypes?.[argIdx];
+}
+function shapeForTemplateParam(ctx, paramName, argIdx, def) {
+    const argShape = ctx.argumentTypeClasses?.[argIdx];
+    if (argShape === undefined)
+        return undefined;
+    const paramShape = def?.parameterTypeClasses?.[argIdx];
+    if (paramShape === undefined)
+        return argShape;
+    if (paramShape.base === paramName && paramShape.indirection === 'value')
+        return argShape;
+    return undefined;
 }
 /** Public surface — registered as `ScopeResolver.constraintCompatibility`. */
 export function cppConstraintCompatibility(_callsite, def, ctx) {
     const payload = def.templateConstraints;
     if (payload === undefined)
         return 'unknown';
-    return evaluate(payload.expr, payload, ctx);
+    return evaluate(payload.expr, payload, ctx, def);
 }
-function evaluate(expr, payload, ctx) {
+function evaluate(expr, payload, ctx, def) {
     switch (expr.kind) {
         case 'unknown':
             return 'unknown';
@@ -83,18 +156,15 @@ function evaluate(expr, payload, ctx) {
             const classes = expr.args.map((paramName) => {
                 const argIdx = payload.paramArgIndex[paramName];
                 if (argIdx === undefined)
-                    return 'unknown';
-                const token = ctx.argumentTypes?.[argIdx];
-                if (token === undefined || token === '')
-                    return 'unknown';
-                return classifyType(token);
+                    return { typeClass: 'unknown' };
+                return classifyConstraintArg(tokenForArg(ctx, argIdx), shapeForTemplateParam(ctx, paramName, argIdx, def));
             });
             return evaluator(classes);
         }
         case 'and': {
             let result = 'compatible';
             for (const child of expr.children) {
-                const v = evaluate(child, payload, ctx);
+                const v = evaluate(child, payload, ctx, def);
                 if (v === 'incompatible')
                     return 'incompatible';
                 if (v === 'unknown')
@@ -105,7 +175,7 @@ function evaluate(expr, payload, ctx) {
         case 'or': {
             let result = 'incompatible';
             for (const child of expr.children) {
-                const v = evaluate(child, payload, ctx);
+                const v = evaluate(child, payload, ctx, def);
                 if (v === 'compatible')
                     return 'compatible';
                 if (v === 'unknown')
@@ -114,7 +184,7 @@ function evaluate(expr, payload, ctx) {
             return result;
         }
         case 'not': {
-            const v = evaluate(expr.child, payload, ctx);
+            const v = evaluate(expr.child, payload, ctx, def);
             if (v === 'compatible')
                 return 'incompatible';
             if (v === 'incompatible')

package/dist/core/ingestion/languages/cpp/type-classifier.d.ts

@@ -7,20 +7,20 @@
  * the call-site inference in `captures.ts`) to one of the categories
  * the `<type_traits>` predicate registry uses for SFINAE filtering.
  *
- * Intentionally coarse: cv / pointer / reference qualifiers are stripped
- * upstream by `normalizeCppParamType`. Tier-A predicates
- * (`is_integral_v`, `is_floating_point_v`, `is_arithmetic_v`, `is_same_v`)
- * are insensitive to those modifiers per ISO `<type_traits>` semantics
- * ("including any cv-qualified variants").
+ * `argumentTypes` remain normalized for overload narrowing, while
+ * constraint predicates that need cv/ref/pointer shape read the parallel
+ * `argumentTypeClasses` sidecar. Unknown shapes must stay unknown rather
+ * than being guessed as incompatible.
  */
-export type TypeClass = 'integral' | 'floating' | 'bool' | 'char' | 'string' | 'null' | 'class' | 'unknown';
+export type TypeClass = 'integral' | 'floating' | 'bool' | 'char' | 'string' | 'null' | 'void' | 'enum' | 'class' | 'pointer' | 'reference' | 'unknown';
 /**
  * Classify a normalized C++ type token. The mapping mirrors the literal-
  * inference table in `captures.ts:inferCppLiteralType` plus the std::
  * normalization in `arity-metadata.ts:normalizeCppParamType`.
  *
- * Caller note: token must already be normalized (no `const`, no `&` / `*`,
- * no `std::` prefix). Tokens passed via `ConstraintContext.argumentTypes`
- * coming from `inferCppCallArgTypes` satisfy this.
+ * Caller note: token should be normalized for overload matching. Enum
+ * tokens produced by the C++ adapter use the internal `enum:<Name>`
+ * prefix so `is_enum_v` does not have to guess that every user token is
+ * class-like.
  */
 export declare function classifyType(token: string): TypeClass;

package/dist/core/ingestion/languages/cpp/type-classifier.js

@@ -7,25 +7,29 @@
  * the call-site inference in `captures.ts`) to one of the categories
  * the `<type_traits>` predicate registry uses for SFINAE filtering.
  *
- * Intentionally coarse: cv / pointer / reference qualifiers are stripped
- * upstream by `normalizeCppParamType`. Tier-A predicates
- * (`is_integral_v`, `is_floating_point_v`, `is_arithmetic_v`, `is_same_v`)
- * are insensitive to those modifiers per ISO `<type_traits>` semantics
- * ("including any cv-qualified variants").
+ * `argumentTypes` remain normalized for overload narrowing, while
+ * constraint predicates that need cv/ref/pointer shape read the parallel
+ * `argumentTypeClasses` sidecar. Unknown shapes must stay unknown rather
+ * than being guessed as incompatible.
  */
 /**
  * Classify a normalized C++ type token. The mapping mirrors the literal-
  * inference table in `captures.ts:inferCppLiteralType` plus the std::
  * normalization in `arity-metadata.ts:normalizeCppParamType`.
  *
- * Caller note: token must already be normalized (no `const`, no `&` / `*`,
- * no `std::` prefix). Tokens passed via `ConstraintContext.argumentTypes`
- * coming from `inferCppCallArgTypes` satisfy this.
+ * Caller note: token should be normalized for overload matching. Enum
+ * tokens produced by the C++ adapter use the internal `enum:<Name>`
+ * prefix so `is_enum_v` does not have to guess that every user token is
+ * class-like.
  */
 export function classifyType(token) {
     if (token.length === 0)
         return 'unknown';
+    if (token.startsWith('enum:'))
+        return 'enum';
     switch (token) {
+        case 'void':
+            return 'void';
         case 'int':
             return 'integral';
         case 'double':

package/dist/core/ingestion/scope-extractor.js

@@ -692,6 +692,7 @@ function pass5CollectReferences(matches, positionIndex, filePath, referenceSites
         const explicitReceiver = extractExplicitReceiver(match);
         const arity = extractArity(match);
         const argumentTypes = extractArgumentTypes(match);
+        const argumentTypeClasses = parseJsonParameterTypeClassesCapture(match['@reference.parameter-type-classes']);
         const site = {
             name: nameCap.text,
             atRange: anchor.range,
@@ -701,6 +702,7 @@ function pass5CollectReferences(matches, positionIndex, filePath, referenceSites
             ...(explicitReceiver !== undefined ? { explicitReceiver } : {}),
             ...(arity !== undefined ? { arity } : {}),
             ...(argumentTypes !== undefined ? { argumentTypes } : {}),
+            ...(argumentTypeClasses !== undefined ? { argumentTypeClasses } : {}),
         };
         referenceSites.push(site);
     }
@@ -806,9 +808,11 @@ const KNOWN_SUB_TAGS = new Set([
     '@reference.receiver',
     '@reference.arity',
     '@reference.parameter-types',
+    '@reference.parameter-type-classes',
     '@declaration.parameter-count',
     '@declaration.required-parameter-count',
     '@declaration.parameter-types',
+    '@declaration.parameter-type-classes',
     '@declaration.template-constraints',
 ]);
 /**

package/dist/core/ingestion/scope-resolution/passes/free-call-fallback.d.ts

@@ -70,6 +70,7 @@ export declare function pickImplicitThisOverload(site: {
     readonly name: string;
     readonly arity?: number;
     readonly argumentTypes?: readonly string[];
+    readonly argumentTypeClasses?: readonly import('../../../../_shared/index.js').ParameterTypeClass[];
 }, scopes: ScopeResolutionIndexes, workspaceIndex: WorkspaceResolutionIndex, model: SemanticModel, hookCtx?: {
     readonly conversionRankFn?: ConversionRankFn;
     readonly constraintCompatibility?: ScopeResolver['constraintCompatibility'];

package/dist/core/ingestion/scope-resolution/passes/free-call-fallback.js

@@ -72,6 +72,7 @@ export function emitFreeCallFallback(graph, scopes, parsedFiles, nodeLookup, _re
                         const allCallables = findAllCallableBindingsInScope(site.inScope, site.name, scopes);
                         if (allCallables.length > 1) {
                             const narrowed = narrowOverloadCandidates(allCallables, site.arity, site.argumentTypes, {
+                                argumentTypeClasses: site.argumentTypeClasses,
                                 conversionRankFn: options.conversionRankFn,
                                 constraintCompatibility: options.constraintCompatibility,
                             });
@@ -126,6 +127,7 @@ export function emitFreeCallFallback(graph, scopes, parsedFiles, nodeLookup, _re
                         }
                         else {
                             const narrowed = narrowOverloadCandidates(ordinary, site.arity, site.argumentTypes, {
+                                argumentTypeClasses: site.argumentTypeClasses,
                                 conversionRankFn: options.conversionRankFn,
                                 constraintCompatibility: options.constraintCompatibility,
                             });
@@ -164,6 +166,7 @@ export function emitFreeCallFallback(graph, scopes, parsedFiles, nodeLookup, _re
                         push(ordinary);
                         push(adl);
                         const narrowed = narrowOverloadCandidates(merged, site.arity, site.argumentTypes, {
+                            argumentTypeClasses: site.argumentTypeClasses,
                             conversionRankFn: options.conversionRankFn,
                             constraintCompatibility: options.constraintCompatibility,
                         });
@@ -427,6 +430,7 @@ export function pickImplicitThisOverload(site, scopes, workspaceIndex, model, ho
     // disambiguating signal) leaves the call unresolved rather than
     // routing to an arbitrary first overload by registration order.
     const candidates = narrowOverloadCandidates(overloads, site.arity, site.argumentTypes, {
+        argumentTypeClasses: site.argumentTypeClasses,
         conversionRankFn: hookCtx?.conversionRankFn,
         constraintCompatibility: hookCtx?.constraintCompatibility,
     });

package/dist/core/ingestion/scope-resolution/passes/overload-narrowing.d.ts

@@ -59,6 +59,8 @@ export type ConversionRankFn = (argType: string, paramType: string) => number;
  * undefined preserves the legacy arity + exact-type behavior.
  */
 export interface OverloadNarrowingHookCtx {
+    /** Shape-preserving per-argument sidecar aligned with `argTypes`. */
+    readonly argumentTypeClasses?: ConstraintContext['argumentTypeClasses'];
     /** Conversion-rank scoring fallback (step 4b). Engages when the
      *  exact-type filter rejects every candidate. */
     readonly conversionRankFn?: ConversionRankFn;

package/dist/core/ingestion/scope-resolution/passes/overload-narrowing.js

@@ -118,7 +118,14 @@ export function narrowOverloadCandidates(overloads, argCount, argTypes, hookCtx)
     // than emitting a wrong edge.
     if (hookCtx?.constraintCompatibility !== undefined && argCount !== undefined) {
         const callsite = { arity: argCount };
-        const ctx = argTypes !== undefined ? { argumentTypes: argTypes } : {};
+        const ctx = argTypes !== undefined
+            ? {
+                argumentTypes: argTypes,
+                ...(hookCtx.argumentTypeClasses !== undefined
+                    ? { argumentTypeClasses: hookCtx.argumentTypeClasses }
+                    : {}),
+            }
+            : {};
         result = result.filter((def) => {
             if (def.templateConstraints === undefined)
                 return true;

package/dist/core/ingestion/scope-resolution/passes/receiver-bound-calls.js

@@ -250,6 +250,7 @@ export function emitReceiverBoundCalls(graph, scopes, parsedFiles, nodeLookup, h
                         const methodOverloads = model.methods.lookupAllByOwner(ownerId, memberName);
                         if (methodOverloads.length > 0) {
                             const narrowed = narrowOverloadCandidates(methodOverloads, site.arity, site.argumentTypes, {
+                                argumentTypeClasses: site.argumentTypeClasses,
                                 conversionRankFn: provider.conversionRankFn,
                                 constraintCompatibility: provider.constraintCompatibility,
                             });
@@ -532,6 +533,7 @@ function pickOverload(ownerId, memberName, site, model, provider) {
     if (overloads.length === 1)
         return overloads[0];
     const candidates = narrowOverloadCandidates(overloads, site.arity, site.argumentTypes, {
+        argumentTypeClasses: site.argumentTypeClasses,
         conversionRankFn: provider.conversionRankFn,
         constraintCompatibility: provider.constraintCompatibility,
     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitnexus",
-  "version": "1.6.6-rc.12",
+  "version": "1.6.6-rc.13",
   "description": "Graph-powered code intelligence for AI agents. Index any codebase, query via MCP or CLI.",
   "author": "Abhigyan Patwari",
   "license": "PolyForm-Noncommercial-1.0.0",