gitnexus 1.6.5 → 1.6.6-rc.2

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

@@ -0,0 +1,308 @@
+/**
+ * Extract C++ template constraint expressions for SFINAE-aware overload
+ * narrowing (issue #1579). Recognizes 3 AST shapes:
+ *
+ *   F1 — unqualified non-type template param default:
+ *        `template<class T, enable_if_t<P, int> = 0> void f(T);`
+ *   F2 — `std::`-qualified variant (canonical ticket form):
+ *        `template<class T, std::enable_if_t<P, int> = 0> void f(T);`
+ *   F4 — C++20 leading requires-clause:
+ *        `template<class T> requires P void f(T);`
+ *
+ * Deferred (return `{kind:'unknown'}`):
+ *   F3 — void-default `typename = enable_if_t<P>` (cppref labels this
+ *        `/* WRONG *\/` because adjacent overloads collapse to redeclarations)
+ *   F5 — trailing requires (`void f(T) requires P;`)
+ *   `requires_expression` blocks (`requires { typename T::U; }`)
+ *   `decltype(...)`, fold-expressions, user-defined `_v` aliases.
+ *
+ * The output payload is opaque to shared code — only
+ * `constraint-filter.ts` consumes it. See ISO `[temp.constr.normal]` /
+ * `<https://en.cppreference.com/w/cpp/language/constraints>` for the
+ * normalization the Kleene 3-valued evaluator implements.
+ */
+/**
+ * Walk a `template_declaration` AST node and extract its constraint
+ * payload. Caller is responsible for passing the OUTER `template_declaration`
+ * — for class-member template functions, that means the enclosing
+ * template_declaration of the class OR of the method, whichever
+ * directly precedes the function definition.
+ *
+ * Returns `undefined` when the template_declaration declares no
+ * constraints worth tracking (no enable_if default, no requires clause).
+ * Returns a payload whose `expr.kind === 'unknown'` when constraints are
+ * present but the extractor cannot model them — monotonicity guarantees
+ * the filter keeps the candidate in that case.
+ */
+export function extractCppTemplateConstraints(templateDecl, funcDeclarator) {
+    const paramList = childOfType(templateDecl, 'template_parameter_list');
+    if (paramList === null)
+        return undefined;
+    const templateParams = [];
+    const exprs = [];
+    for (let i = 0; i < paramList.namedChildCount; i++) {
+        const param = paramList.namedChild(i);
+        if (param === null)
+            continue;
+        if (param.type === 'type_parameter_declaration' ||
+            param.type === 'optional_type_parameter_declaration' ||
+            param.type === 'variadic_type_parameter_declaration') {
+            const id = firstDescendantOfType(param, 'type_identifier');
+            if (id !== null)
+                templateParams.push(id.text);
+            continue;
+        }
+        // Non-type parameter — F1 / F2 default-value carries the enable_if
+        // predicate. Shape: `optional_parameter_declaration` with field
+        // `default_value`, whose value is a `template_type` named
+        // `enable_if_t` (F1) or a qualified version (F2).
+        if (param.type === 'optional_parameter_declaration') {
+            const defaultVal = param.childForFieldName('default_value');
+            const typeNode = param.childForFieldName('type');
+            const candidate = extractEnableIfPredicate(typeNode);
+            if (candidate !== undefined) {
+                exprs.push(candidate);
+            }
+            else if (defaultVal !== null) {
+                // Default-value-as-predicate not yet supported. Bail conservatively.
+                exprs.push({ kind: 'unknown' });
+            }
+        }
+    }
+    // F4 — C++20 leading `requires` clause. Tree-sitter-cpp exposes it as a
+    // `requires_clause` child of `template_declaration` (sibling of the
+    // template_parameter_list).
+    const requiresClause = childOfType(templateDecl, 'requires_clause');
+    if (requiresClause !== null) {
+        const parsed = parseRequiresClause(requiresClause);
+        if (parsed !== undefined)
+            exprs.push(parsed);
+    }
+    if (templateParams.length === 0 && exprs.length === 0)
+        return undefined;
+    const paramArgIndex = buildParamArgIndex(templateParams, funcDeclarator);
+    const expr = exprs.length === 0
+        ? { kind: 'unknown' }
+        : exprs.length === 1
+            ? exprs[0]
+            : { kind: 'and', children: exprs };
+    return { templateParams, paramArgIndex, expr };
+}
+/**
+ * Inspect a non-type template parameter's declared type to see whether
+ * it's `enable_if_t<P, T>` (F1) or `std::enable_if_t<P, T>` (F2). When
+ * matched, extract the predicate `P` and return it as a `ConstraintExpr`.
+ *
+ * Returns undefined when the parameter's type is not enable_if (so the
+ * caller can decide whether to bail or ignore).
+ */
+function extractEnableIfPredicate(typeNode) {
+    if (typeNode === null)
+        return undefined;
+    // Unwrap a type_descriptor wrapper (when present).
+    let t = typeNode;
+    if (t.type === 'type_descriptor') {
+        t = t.childForFieldName('type') ?? firstDescendantOfType(t, 'template_type');
+    }
+    // F2 shape: tree-sitter-cpp models `std::enable_if_t<...>` as
+    // `qualified_identifier` whose `name` field is the `template_type`.
+    // F1 shape (unqualified `enable_if_t<...>`) is `template_type` directly.
+    if (t !== null && t.type === 'qualified_identifier') {
+        const inner = t.childForFieldName('name') ?? firstDescendantOfType(t, 'template_type');
+        if (inner !== null && inner.type === 'template_type') {
+            t = inner;
+        }
+    }
+    if (t === null || t.type !== 'template_type')
+        return undefined;
+    const nameNode = t.childForFieldName('name');
+    if (nameNode === null)
+        return undefined;
+    const tail = stripQualifiedPrefix(nameNode.text);
+    if (tail !== 'enable_if_t' && tail !== 'enable_if')
+        return undefined;
+    // Predicate is the first template argument of enable_if_t.
+    const argList = t.childForFieldName('arguments') ?? childOfType(t, 'template_argument_list');
+    if (argList === null)
+        return { kind: 'unknown' };
+    for (let i = 0; i < argList.namedChildCount; i++) {
+        const arg = argList.namedChild(i);
+        if (arg === null)
+            continue;
+        if (arg.type !== 'type_descriptor')
+            continue;
+        const inner = arg.childForFieldName('type') ?? arg.namedChild(0);
+        if (inner === null)
+            continue;
+        return parseAtomicOrBoolean(inner);
+    }
+    return { kind: 'unknown' };
+}
+/** Parse a requires-clause body. The body is a binary or unary expression
+ *  over atomic predicates (variable templates like `is_integral_v<T>`). */
+function parseRequiresClause(requiresClause) {
+    // tree-sitter-cpp exposes the expression as a named child or via a
+    // `constraint` field. Probe both.
+    let expr = requiresClause.childForFieldName('constraint');
+    if (expr === null) {
+        for (let i = 0; i < requiresClause.namedChildCount; i++) {
+            const c = requiresClause.namedChild(i);
+            if (c === null)
+                continue;
+            // Skip the `requires` keyword token.
+            if (c.type === 'requires')
+                continue;
+            expr = c;
+            break;
+        }
+    }
+    if (expr === null)
+        return undefined;
+    return parseAtomicOrBoolean(expr);
+}
+/**
+ * Recursively parse a constraint sub-expression. Recognizes:
+ *   - `template_type` / `template_function` named `<predicate>_v` → atomic
+ *   - binary_expression with `&&` / `||` → conjunction / disjunction
+ *   - unary_expression with `!` → negation
+ *   - parenthesized_expression → unwrap
+ *   - anything else → `{kind:'unknown'}` (monotonicity-safe)
+ *
+ * `requires_expression` blocks intentionally fall through to 'unknown'
+ * — they need substitution semantics we don't model in V1.
+ */
+function parseAtomicOrBoolean(node) {
+    // Unwrap parentheses.
+    if (node.type === 'parenthesized_expression') {
+        const inner = node.namedChild(0);
+        return inner === null ? { kind: 'unknown' } : parseAtomicOrBoolean(inner);
+    }
+    // Boolean composition.
+    if (node.type === 'binary_expression') {
+        const left = node.childForFieldName('left');
+        const right = node.childForFieldName('right');
+        const opNode = node.childForFieldName('operator');
+        if (left !== null && right !== null && opNode !== null) {
+            const op = opNode.text;
+            const l = parseAtomicOrBoolean(left);
+            const r = parseAtomicOrBoolean(right);
+            if (op === '&&')
+                return { kind: 'and', children: [l, r] };
+            if (op === '||')
+                return { kind: 'or', children: [l, r] };
+        }
+        return { kind: 'unknown' };
+    }
+    if (node.type === 'unary_expression') {
+        const opNode = node.childForFieldName('operator') ?? node.namedChild(0);
+        const arg = node.childForFieldName('argument') ?? node.namedChild(1) ?? node.namedChild(0);
+        if (opNode !== null && opNode.text === '!' && arg !== null && arg !== opNode) {
+            return { kind: 'not', child: parseAtomicOrBoolean(arg) };
+        }
+        return { kind: 'unknown' };
+    }
+    // Atomic predicate — `template_type` is the typical shape for variable
+    // templates like `is_integral_v<T>`. Some grammar variants surface it as
+    // `template_function` or via a `qualified_identifier` wrapper.
+    if (node.type === 'template_type' || node.type === 'template_function') {
+        return parseAtomicTemplate(node);
+    }
+    if (node.type === 'qualified_identifier') {
+        // `std::is_integral_v<T>` shape (without template_type wrapping).
+        const inner = node.childForFieldName('name');
+        if (inner !== null && (inner.type === 'template_type' || inner.type === 'template_function')) {
+            return parseAtomicTemplate(inner);
+        }
+        return { kind: 'unknown' };
+    }
+    // `requires { typename T::U; }` blocks and decltype: out of V1 scope.
+    return { kind: 'unknown' };
+}
+function parseAtomicTemplate(t) {
+    const nameNode = t.childForFieldName('name');
+    if (nameNode === null)
+        return { kind: 'unknown' };
+    const name = stripQualifiedPrefix(nameNode.text);
+    const argList = t.childForFieldName('arguments') ?? childOfType(t, 'template_argument_list');
+    const args = [];
+    if (argList !== null) {
+        for (let i = 0; i < argList.namedChildCount; i++) {
+            const arg = argList.namedChild(i);
+            if (arg === null)
+                continue;
+            if (arg.type !== 'type_descriptor')
+                continue;
+            const inner = arg.childForFieldName('type') ?? arg.namedChild(0);
+            if (inner === null)
+                continue;
+            // For Tier-A predicates the args are bare template-parameter names
+            // (`T`, `U`). Anything more elaborate is bailed via 'unknown' at the
+            // top level if needed; here we just record the textual identifier.
+            const id = inner.type === 'type_identifier' ? inner : firstDescendantOfType(inner, 'type_identifier');
+            args.push(id !== null ? id.text : inner.text);
+        }
+    }
+    return { kind: 'atomic', name, args };
+}
+/** Build a `paramName → call-site argument index` map by scanning the
+ *  function's parameter list for parameters typed by each template param. */
+function buildParamArgIndex(templateParams, funcDeclarator) {
+    const out = {};
+    if (funcDeclarator === null || templateParams.length === 0)
+        return out;
+    const paramList = funcDeclarator.childForFieldName('parameters');
+    if (paramList === null)
+        return out;
+    let argIdx = 0;
+    for (let i = 0; i < paramList.childCount; i++) {
+        const p = paramList.child(i);
+        if (p === null)
+            continue;
+        if (p.type !== 'parameter_declaration' &&
+            p.type !== 'optional_parameter_declaration' &&
+            p.type !== 'variadic_parameter_declaration') {
+            continue;
+        }
+        const typeNode = p.childForFieldName('type');
+        if (typeNode !== null) {
+            const tname = bareTypeIdentifier(typeNode);
+            if (tname !== null && templateParams.includes(tname) && !(tname in out)) {
+                out[tname] = argIdx;
+            }
+        }
+        argIdx++;
+    }
+    return out;
+}
+function bareTypeIdentifier(typeNode) {
+    if (typeNode.type === 'type_identifier')
+        return typeNode.text;
+    // Allow `T const`, `T&`, `T*` shapes — the inner type_identifier still wins.
+    const id = firstDescendantOfType(typeNode, 'type_identifier');
+    return id !== null ? id.text : null;
+}
+function stripQualifiedPrefix(text) {
+    const idx = text.lastIndexOf('::');
+    return idx >= 0 ? text.slice(idx + 2) : text;
+}
+function childOfType(node, type) {
+    for (let i = 0; i < node.childCount; i++) {
+        const c = node.child(i);
+        if (c !== null && c.type === type)
+            return c;
+    }
+    return null;
+}
+function firstDescendantOfType(node, type) {
+    if (node.type === type)
+        return node;
+    for (let i = 0; i < node.childCount; i++) {
+        const c = node.child(i);
+        if (c === null)
+            continue;
+        const hit = firstDescendantOfType(c, type);
+        if (hit !== null)
+            return hit;
+    }
+    return null;
+}

package/dist/core/ingestion/languages/cpp/constraint-filter.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Kleene 3-valued evaluator + curated 4-predicate registry +
+ * `cppConstraintCompatibility` hook export for SFINAE / `requires`-clause
+ * filtering (issue #1579).
+ *
+ * Semantics:
+ *   - `'incompatible'` → predicate provably fails for these argumentTypes
+ *     (ISO `[temp.constr.atomic]` "not satisfied")
+ *   - `'compatible'`   → predicate provably holds
+ *   - `'unknown'`      → cannot decide (missing arg-type info, predicate
+ *     not in registry, AST shape bailed during extraction). The shared
+ *     filter keeps the candidate on `'unknown'` — monotonicity guarantee.
+ *
+ * Kleene rules (extension of ISO's 2-valued short-circuit conjunction in
+ * `<https://en.cppreference.com/w/cpp/language/constraints>`):
+ *   AND: incompatible if any child incompatible; compatible iff all
+ *        children compatible; otherwise unknown.
+ *   OR:  compatible if any child compatible; incompatible iff all
+ *        children incompatible; otherwise unknown.
+ *   NOT: flip compatible↔incompatible; pass through unknown.
+ */
+import type { ArityVerdict, Callsite, ConstraintContext, SymbolDefinition } from '../../../../_shared/index.js';
+import type { ConstraintExpr, CppConstraintPayload } from './constraint-extractor.js';
+/** Public surface — registered as `ScopeResolver.constraintCompatibility`. */
+export declare function cppConstraintCompatibility(_callsite: Callsite, def: SymbolDefinition, ctx: ConstraintContext): ArityVerdict;
+/** Exposed for unit tests — lets `cpp-constraint.test.ts` assert
+ *  `expect(getRegistrySize()).toBe(4)` without exporting the Map itself. */
+export declare function getRegistrySize(): number;
+/** Exposed for unit tests covering the Kleene 3-valued truth table
+ *  directly, without an AST round-trip. */
+export declare function evaluateForTest(expr: ConstraintExpr, payload: CppConstraintPayload, ctx: ConstraintContext): ArityVerdict;

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

@@ -0,0 +1,135 @@
+/**
+ * Kleene 3-valued evaluator + curated 4-predicate registry +
+ * `cppConstraintCompatibility` hook export for SFINAE / `requires`-clause
+ * filtering (issue #1579).
+ *
+ * Semantics:
+ *   - `'incompatible'` → predicate provably fails for these argumentTypes
+ *     (ISO `[temp.constr.atomic]` "not satisfied")
+ *   - `'compatible'`   → predicate provably holds
+ *   - `'unknown'`      → cannot decide (missing arg-type info, predicate
+ *     not in registry, AST shape bailed during extraction). The shared
+ *     filter keeps the candidate on `'unknown'` — monotonicity guarantee.
+ *
+ * Kleene rules (extension of ISO's 2-valued short-circuit conjunction in
+ * `<https://en.cppreference.com/w/cpp/language/constraints>`):
+ *   AND: incompatible if any child incompatible; compatible iff all
+ *        children compatible; otherwise unknown.
+ *   OR:  compatible if any child compatible; incompatible iff all
+ *        children incompatible; otherwise unknown.
+ *   NOT: flip compatible↔incompatible; pass through unknown.
+ */
+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.
+ */
+// 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>`
+// and `is_integral_v<char>` must both yield `true`. We keep the `TypeClass`
+// enum precise (separate `'bool'` / `'char'` buckets) so that
+// `is_same_v<bool, int>` still resolves to `'incompatible'`; the integral-
+// family widening lives here in the predicate evaluators instead.
+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_arithmetic_v',
+        (cls) => verdictFromBool(isIntegralClass(cls[0]) || cls[0] === 'floating', cls),
+    ],
+    // 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')
+                return 'unknown';
+            return cls[0] === cls[1] ? 'compatible' : 'incompatible';
+        },
+    ],
+]);
+function verdictFromBool(predicate, cls) {
+    if (cls[0] === 'unknown')
+        return 'unknown';
+    return predicate ? 'compatible' : 'incompatible';
+}
+/** 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);
+}
+function evaluate(expr, payload, ctx) {
+    switch (expr.kind) {
+        case 'unknown':
+            return 'unknown';
+        case 'atomic': {
+            const evaluator = REGISTRY.get(expr.name);
+            if (evaluator === undefined)
+                return 'unknown';
+            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 evaluator(classes);
+        }
+        case 'and': {
+            let result = 'compatible';
+            for (const child of expr.children) {
+                const v = evaluate(child, payload, ctx);
+                if (v === 'incompatible')
+                    return 'incompatible';
+                if (v === 'unknown')
+                    result = 'unknown';
+            }
+            return result;
+        }
+        case 'or': {
+            let result = 'incompatible';
+            for (const child of expr.children) {
+                const v = evaluate(child, payload, ctx);
+                if (v === 'compatible')
+                    return 'compatible';
+                if (v === 'unknown')
+                    result = 'unknown';
+            }
+            return result;
+        }
+        case 'not': {
+            const v = evaluate(expr.child, payload, ctx);
+            if (v === 'compatible')
+                return 'incompatible';
+            if (v === 'incompatible')
+                return 'compatible';
+            return 'unknown';
+        }
+    }
+}
+/** Exposed for unit tests — lets `cpp-constraint.test.ts` assert
+ *  `expect(getRegistrySize()).toBe(4)` without exporting the Map itself. */
+export function getRegistrySize() {
+    return REGISTRY.size;
+}
+/** Exposed for unit tests covering the Kleene 3-valued truth table
+ *  directly, without an AST round-trip. */
+export function evaluateForTest(expr, payload, ctx) {
+    return evaluate(expr, payload, ctx);
+}

package/dist/core/ingestion/languages/cpp/scope-resolver.js

@@ -13,6 +13,7 @@ import { populateCppDependentBases, clearCppDependentBases, isCppDependentBaseMe
 import { populateCppAssociatedNamespaces, clearCppAdlState, pickCppAdlCandidates } from './adl.js';
 import { clearCppInlineNamespaces, populateCppInlineNamespaceScopes, resolveCppQualifiedNamespaceMember, } from './inline-namespaces.js';
 import { populateCppRangeBindings } from './range-bindings.js';
+import { cppConstraintCompatibility } from './constraint-filter.js';
 /**
  * C++ `ScopeResolver` registered in `SCOPE_RESOLVERS` and consumed by
  * the generic `runScopeResolution` orchestrator (RFC #909 Ring 3).
@@ -58,6 +59,11 @@ export const cppScopeResolver = {
     // Adapter: cppArityCompatibility predates ScopeResolver and uses
     // (def, callsite). ScopeResolver contract is (callsite, def).
     arityCompatibility: (callsite, def) => cppArityCompatibility(def, callsite),
+    // SFINAE / `requires`-clause aware overload filter (issue #1579).
+    // Drops candidates whose template constraints (`enable_if_t<P, T>`,
+    // C++20 `requires P`) provably fail at the call site. Three-valued —
+    // `'unknown'` keeps the candidate, preserving "degrade not lie".
+    constraintCompatibility: cppConstraintCompatibility,
     buildMro: (graph, parsedFiles, nodeLookup) => buildMro(graph, parsedFiles, nodeLookup, defaultLinearize),
     populateOwners: (parsed) => {
         populateClassOwnedMembers(parsed);

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

@@ -0,0 +1,26 @@
+/**
+ * Coarse-grained type classifier for C++ constraint evaluation
+ * (`<https://en.cppreference.com/w/cpp/types/is_integral>`,
+ *  `<https://en.cppreference.com/w/cpp/types/is_floating_point>`).
+ *
+ * Maps a normalized type token (as produced by `normalizeCppParamType` /
+ * 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").
+ */
+export type TypeClass = 'integral' | 'floating' | 'bool' | 'char' | 'string' | 'null' | 'class' | '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.
+ */
+export declare function classifyType(token: string): TypeClass;

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

@@ -0,0 +1,49 @@
+/**
+ * Coarse-grained type classifier for C++ constraint evaluation
+ * (`<https://en.cppreference.com/w/cpp/types/is_integral>`,
+ *  `<https://en.cppreference.com/w/cpp/types/is_floating_point>`).
+ *
+ * Maps a normalized type token (as produced by `normalizeCppParamType` /
+ * 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").
+ */
+/**
+ * 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.
+ */
+export function classifyType(token) {
+    if (token.length === 0)
+        return 'unknown';
+    switch (token) {
+        case 'int':
+            return 'integral';
+        case 'double':
+        case 'float':
+            return 'floating';
+        case 'bool':
+            return 'bool';
+        case 'char':
+            return 'char';
+        case 'string':
+            return 'string';
+        case 'null':
+            return 'null';
+        default:
+            // After normalization, anything that isn't a recognized primitive
+            // is assumed to be a class-like type. The Tier-A predicate registry
+            // doesn't introspect class types — `is_integral_v` etc. simply
+            // returns `false` for `'class'`, matching ISO behavior.
+            return 'class';
+    }
+}

package/dist/core/ingestion/model/symbol-table.d.ts

@@ -33,7 +33,7 @@
  * import from `./model/` here, you are going the wrong way — move the
  * logic up the dependency chain instead.
  */
-import type { NodeLabel, SymbolDefinition } from '../../../_shared/index.js';
+import type { NodeLabel, ParameterTypeClass, SymbolDefinition } from '../../../_shared/index.js';
 /**
  * Class-like NodeLabels — used for qualifiedName fallback inside
  * `SymbolTable.add()` and (via import into `model/registration-table.ts`)
@@ -97,6 +97,7 @@ export interface AddMetadata {
     parameterCount?: number;
     requiredParameterCount?: number;
     parameterTypes?: string[];
+    parameterTypeClasses?: ParameterTypeClass[];
     returnType?: string;
     declaredType?: string;
     templateArguments?: string[];

package/dist/core/ingestion/model/symbol-table.js

@@ -128,6 +128,9 @@ export const createSymbolTable = () => {
             ...(metadata?.parameterTypes !== undefined
                 ? { parameterTypes: metadata.parameterTypes }
                 : {}),
+            ...(metadata?.parameterTypeClasses !== undefined
+                ? { parameterTypeClasses: metadata.parameterTypeClasses }
+                : {}),
             ...(metadata?.returnType !== undefined ? { returnType: metadata.returnType } : {}),
             ...(metadata?.declaredType !== undefined ? { declaredType: metadata.declaredType } : {}),
             ...(metadata?.templateArguments !== undefined