cgraphx 2.0.1 → 2.0.3

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

@@ -0,0 +1,311 @@
+"use strict";
+/**
+ * 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractCppTemplateConstraints = extractCppTemplateConstraints;
+/**
+ * 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.
+ */
+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/code/engine/core/ingestion/languages/cpp/constraint-filter.js

@@ -0,0 +1,210 @@
+"use strict";
+/**
+ * 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cppConstraintCompatibility = cppConstraintCompatibility;
+exports.getRegistrySize = getRegistrySize;
+exports.evaluateForTest = evaluateForTest;
+const type_classifier_js_1 = require("./type-classifier.js");
+/**
+ * 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>`
+// 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_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',
+        (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,
+        }),
+    ],
+    [
+        'is_same_v',
+        (args) => {
+            if (args.length < 2 || args[0].typeClass === 'unknown' || args[1].typeClass === 'unknown') {
+                return 'unknown';
+            }
+            return args[0].typeClass === args[1].typeClass ? 'compatible' : 'incompatible';
+        },
+    ],
+]);
+function unaryVerdict(args, predicate) {
+    const arg = args[0];
+    if (arg === undefined || arg.typeClass === 'unknown')
+        return 'unknown';
+    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' : (0, type_classifier_js_1.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`. */
+function cppConstraintCompatibility(_callsite, def, ctx) {
+    const payload = def.templateConstraints;
+    if (payload === undefined)
+        return 'unknown';
+    return evaluate(payload.expr, payload, ctx, def);
+}
+function evaluate(expr, payload, ctx, def) {
+    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 { 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, def);
+                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, def);
+                if (v === 'compatible')
+                    return 'compatible';
+                if (v === 'unknown')
+                    result = 'unknown';
+            }
+            return result;
+        }
+        case 'not': {
+            const v = evaluate(expr.child, payload, ctx, def);
+            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. */
+function getRegistrySize() {
+    return REGISTRY.size;
+}
+/** Exposed for unit tests covering the Kleene 3-valued truth table
+ *  directly, without an AST round-trip. */
+function evaluateForTest(expr, payload, ctx) {
+    return evaluate(expr, payload, ctx);
+}

package/dist/core/code/engine/core/ingestion/languages/cpp/conversion-rank.js

@@ -0,0 +1,163 @@
+"use strict";
+/**
+ * C++ conversion-rank scoring for overload resolution (#1578, #1637).
+ *
+ * Operates on normalized type strings (output of `normalizeCppParamType`
+ * in `arity-metadata.ts`) plus optional shape sidecars from #1630.
+ * Normalization intentionally collapses cv/ref/pointer spelling for stable
+ * graph IDs, so pointer/nullptr rules must consult `ParameterTypeClass`.
+ *
+ * Post-normalization ranking:
+ *   - rank 0: exact (same normalized type)
+ *   - rank 1: integral promotion (char -> int, bool -> int)
+ *   - rank 2: standard conversion (arithmetic, nullptr -> T*, T* -> bool,
+ *             T* -> void*)
+ *   - rank 3: nullptr -> bool (kept worse than nullptr -> T*)
+ *   - rank 4: user-defined conversion (one-step, conservative)
+ *   - rank 5: ellipsis conversion (worst viable)
+ *   - Infinity: mismatch (string -> int, user types, unsupported shapes)
+ *
+ * This function is intentionally C++-specific. Other languages may define
+ * their own `ConversionRankFn` in the future.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CPP_CONVERSION_ONLY_ARG_TYPE_PREFIXES = exports.CPP_BRACED_INIT_TYPE_PREFIX = void 0;
+exports.cppConversionRank = cppConversionRank;
+const arity_metadata_js_1 = require("./arity-metadata.js");
+const user_defined_conversions_js_1 = require("./user-defined-conversions.js");
+/** Set of normalized arithmetic types that support implicit conversion. */
+const ARITHMETIC = new Set(['int', 'double', 'char', 'bool']);
+/** Integral promotion targets: char -> int and bool -> int are rank 1. */
+const INTEGRAL_PROMOTION = new Map([
+    ['char', 'int'],
+    ['bool', 'int'],
+]);
+exports.CPP_BRACED_INIT_TYPE_PREFIX = 'braced-init:';
+exports.CPP_CONVERSION_ONLY_ARG_TYPE_PREFIXES = [exports.CPP_BRACED_INIT_TYPE_PREFIX];
+const BRACED_INIT_CONTAINER_TYPES = new Set([
+    'array',
+    'deque',
+    'list',
+    'set',
+    'std::array',
+    'std::deque',
+    'std::list',
+    'std::set',
+    'std::unordered_set',
+    'std::vector',
+    'unordered_set',
+    'vector',
+]);
+/**
+ * Return the conversion rank from `argType` to `paramType`.
+ *
+ * @returns 0 for exact match, 1 for integral promotion, 2 for standard
+ *          conversion, 3 for nullptr -> bool, 4 for user-defined conversion,
+ *          5 for ellipsis, Infinity
+ *          for mismatch.
+ */
+function cppConversionRank(argType, paramType, argTypeClass, paramTypeClass) {
+    const bracedInitType = parseBracedInitArgType(argType);
+    if (bracedInitType !== undefined) {
+        if (bracedInitType.elementType === 'unknown')
+            return Infinity;
+        if (bracedInitType.elementCount === 1) {
+            const scalarRank = cppConversionRank(bracedInitType.elementType, paramType, undefined, paramTypeClass);
+            if (isFinite(scalarRank))
+                return scalarRank;
+        }
+        return bracedInitConversionRank(paramType, bracedInitType, paramTypeClass);
+    }
+    if (argType === paramType) {
+        return exactShapeCompatible(argTypeClass, paramTypeClass) ? 0 : Infinity;
+    }
+    if (paramType === '...')
+        return 5;
+    if (INTEGRAL_PROMOTION.get(argType) === paramType)
+        return 1;
+    if (ARITHMETIC.has(argType) && ARITHMETIC.has(paramType))
+        return 2;
+    if (argType === 'null' && isPointer(paramTypeClass))
+        return 2;
+    if (argType === 'null' && paramType === 'bool')
+        return 3;
+    if (isPointer(argTypeClass) && paramType === 'bool')
+        return 2;
+    if (isPointer(argTypeClass) && isPointer(paramTypeClass) && paramType === 'void')
+        return 2;
+    if ((0, user_defined_conversions_js_1.hasCppUserDefinedConversion)(argType, paramType))
+        return 4;
+    return Infinity;
+}
+function parseBracedInitArgType(argType) {
+    if (!argType.startsWith(exports.CPP_BRACED_INIT_TYPE_PREFIX))
+        return undefined;
+    const payload = argType.slice(exports.CPP_BRACED_INIT_TYPE_PREFIX.length);
+    if (payload === '')
+        return undefined;
+    const separator = payload.lastIndexOf(':');
+    if (separator > 0) {
+        const countText = payload.slice(separator + 1);
+        if (/^\d+$/.test(countText)) {
+            return {
+                elementType: payload.slice(0, separator),
+                elementCount: Number(countText),
+            };
+        }
+    }
+    return { elementType: payload };
+}
+function bracedInitConversionRank(paramType, argType, paramTypeClass) {
+    const targetBase = bracedInitTargetBase(paramType);
+    if (targetBase === 'initializer_list' || targetBase === 'std::initializer_list') {
+        return bracedInitValueTypeMatches(paramType, argType, paramTypeClass) ? 0 : Infinity;
+    }
+    if (BRACED_INIT_CONTAINER_TYPES.has(targetBase)) {
+        return bracedInitValueTypeMatches(paramType, argType, paramTypeClass) ? 4 : Infinity;
+    }
+    return Infinity;
+}
+function bracedInitValueTypeMatches(paramType, argType, paramTypeClass) {
+    const valueType = bracedInitTargetValueType(paramType, paramTypeClass);
+    if (valueType === undefined)
+        return false;
+    return isFinite(cppConversionRank(argType.elementType, valueType));
+}
+function bracedInitTargetValueType(paramType, paramTypeClass) {
+    return firstTemplateArgument(paramType) ?? paramTypeClass?.templateArguments?.[0];
+}
+function firstTemplateArgument(rawType) {
+    const start = rawType.indexOf('<');
+    if (start < 0)
+        return undefined;
+    let depth = 0;
+    for (let i = start + 1; i < rawType.length; i++) {
+        const ch = rawType[i];
+        if (ch === '<') {
+            depth++;
+        }
+        else if (ch === '>') {
+            if (depth === 0)
+                return bracedInitTargetBase(rawType.slice(start + 1, i));
+            depth--;
+        }
+        else if (ch === ',' && depth === 0) {
+            return bracedInitTargetBase(rawType.slice(start + 1, i));
+        }
+    }
+    return undefined;
+}
+function bracedInitTargetBase(paramType) {
+    return (0, arity_metadata_js_1.normalizeCppParamType)(paramType);
+}
+function isPointer(typeClass) {
+    return typeClass?.indirection === 'pointer' && typeClass.pointerDepth > 0;
+}
+function exactShapeCompatible(argTypeClass, paramTypeClass) {
+    if (argTypeClass === undefined || paramTypeClass === undefined)
+        return true;
+    if (argTypeClass.indirection === 'unknown' || paramTypeClass.indirection === 'unknown') {
+        return true;
+    }
+    return isPointer(argTypeClass) === isPointer(paramTypeClass);
+}