Supported C++ Feature Matrix

cppbolt implements a defined, correctness-oriented subset of C++17. Every supported feature is covered by automated corpus tests and pinned by cryptographic golden hashes. Features outside the subset are either explicitly rejected with clear diagnostics or tracked as planned future extensions.

The baseline test status is tracked in tests/PASSING.txt. Run the test runner to verify status locally:

cargo run --bin cppbolt-testrunner -- target/release/cppbolt-cli

Feature Matrix

Known Limitations & Design Rules

1. Language Semantics & Edge Cases

• Copy Elision: Prvalue initialization is elided as guaranteed by C++17 (T x = T(1);). However, return of named local variables requires running the copy constructor.
• Null Pointer Constants & Pointer Conversions:
  • Integer literal zeroes (0, 0u) and nullptr (std::nullptr_t, decltype(nullptr)) qualify as null pointer constants. Zero-valued variables, non-zero integers, and false are rejected.
  • Qualification conversions require every subsequent indirection level to be const when adding const to an intermediate level (int** converts to const int* const*, but not const int**).
  • Object pointers convert implicitly to void*; converting void* to a typed pointer requires static_cast<T*>.
• String Literal Semantics: String literals have type const char[N] with a null terminator (sizeof("hello") == 6). They decay to const char* for call arguments and pointer assignments, and cannot bind to char*.
• Multiple and Virtual Inheritance: Explicitly rejected at parse time:
  • Second base specifier yields: multiple inheritance is not supported
  • virtual base specifier yields: virtual inheritance is not supported
• Operator Overloading Boundaries: User-defined operator overloads for arithmetic, relational, bitwise, assignment, subscript [], smart-pointer ->, dereference *(), functor (), postfix ++/--, and conversion operators operator T() are supported. Method ref-qualifier overloading with const-lvalue references (const &) is explicitly rejected with const overloading is not supported.
• Chained operator-> & Cycle Detection: In accordance with C++17, member access via -> recursively resolves through chained operator->() overloads returning class objects or references until a raw struct pointer is reached. Cycle detection prevents compile-time recursion loops (circular operator-> delegation on '<class>'), and recursion depth is budgeted to 128 hops.
• C++17 Lambda Expressions: Lambdas desugar into anonymous closure structs (__lambda_N) holding captured state as either by-value copies or references. The synthesized operator() is const-qualified unless marked mutable, enforcing immutability on by-value captures. Return types can be explicitly annotated with trailing return syntax (-> T) or automatically deduced from return statements. Captureless lambdas ([]) synthesize a static __invoke trampoline enabling implicit conversion to standard C function pointers (R (*)(P...)), including as return statement targets and via unary + decay (+[](){}). Default captures (=, &) must strictly appear first in the capture list, and free-variable discovery traverses RangeFor, StructuredBinding, and nested Lambda/New constructs.
• List Initialization & Aggregates: Braced initializer lists ({...}) work across variable declarations, namespace-scope (global) variables, constructor member initializers (: member{val}), returns, call arguments, assignments, typed temporaries (Type{args...}.member()), and heap allocations (new T{...}, new T[n]{...}).
  • Direct-list initialization allows selecting explicit constructors; copy-list initialization rejects them. Empty braces ({}) value-initialize scalars and enums to zero, clear aggregate fields, or call default constructors.
  • Under C++17 aggregate rules, classes qualify as aggregates when they have no user-declared constructors, no private or protected non-static data members, no virtual functions, and no virtual or private base classes. Public non-virtual bases initialize as initial subobjects, either with nested braces (Derived{{base_args}, derived_args}) or flattened across the outer list.
  • Narrowing conversion checks follow C++17 [dcl.init.list] p7, rejecting conversions from floating-point to integer, double to float (unless an exact constant literal), and between integer types with sign changes or smaller ranges. Compile-time constant expressions, including negative integer literals, are accepted when the value fits the destination type.
  • Single-object new T{...} direct-initializes the heap object. Array new T[n]{...} initializes explicit elements and runs a WebAssembly loop to value-initialize omitted trailing elements up to n.
  • Initializer-list constructors taking std::initializer_list<T> receive a frame-backed pointer-and-size view. The backing array stays live through the full expression; elements of local initializer-list variables are destroyed at scope exit.
  • Multiple viable initializer-list constructors are ranked by element conversions: exact matches beat integral promotions, which beat other standard conversions. A narrowing candidate is discarded, and its diagnostic is reported only when no viable candidate remains. Empty braces use the initializer-list constructor when the class has no default constructor.
  • Nested brace lists such as std::vector<std::vector<int>> v{{1, 2}, {3, 4}} are resolved against the chosen element type after constructor selection.
  • Namespace-scope lists and braced containers are initialized before main runs. The backing array of a namespace-scope std::initializer_list is placed in main's frame, which outlives every use of the list.
• Extended Casts (reinterpret_cast): Supports C++17 reinterpret_cast<T>(expr) between pointer types, pointer and integer types (matching the 32-bit ILP32 pointer width), and reference types (reinterpret_cast<T&>(v)). Does not invoke user-defined conversion operators or constructors. Scalar floating-point reinterpretations by value are rejected; bit patterns of floats can be inspected via pointer or reference reinterpretation (e.g. *reinterpret_cast<uint32_t*>(&f)).
• Template Core:
  • Class templates and function templates support type parameters (template <typename T>). Non-type parameters, template template parameters, variadic templates, and explicit specializations (template <>) are rejected with explicit diagnostics.
  • Instantiation follows a single-phase lookup model (ADR 0010). The parser preserves template declarations in the AST (TemplateDecl), and semantic analysis resolves names and types during concrete specialization.
  • Type resolution recursively unwraps pointers, references, const qualifiers, and arrays, generating concrete struct layouts before calculating member access offsets.
  • Non-template structs compute layouts after resolving template fields, giving fields valid offsets and sizes. Non-template functions accept and return template instance types.
  • Class template member methods instantiate lazily on first call, address-of reference, or operator overload lookup (operator[], unary operators). Unused member methods are neither typechecked nor emitted into WebAssembly.
  • Non-virtual class template destructors instantiate eagerly alongside virtual methods so synthesized cleanup logic can drop values on scope exit. Dynamically instantiated template classes containing fields with non-trivial destructors synthesize cleanup methods and copy operations.
  • Function template overload resolution deduces type arguments from values, references, const references, top-level const pointers, and template instance arguments. Candidate registration tracks overloads sharing identical parameter counts by signature. Explicit template arguments (func<int>(val), func<Inner<int>>(val)) override deduction and parse nested template types. Default argument expressions fill omitted trailing parameters for both free and member template functions. Exact non-template function overloads take precedence over template specializations.
  • Out-of-class method definitions match class template and concrete struct declarations by parameter types and const qualification, including across multi-part namespace paths (Outer::Inner::Class::Class()).
  • Member template parameters shadow outer class template parameters with identical names during class instantiation.
  • Expression calls on struct instances dispatch to operator() only when an explicit call operator or member template operator() exists.
  • Nested class declarations inside class templates clone and specialize on outer template instantiation, generating qualified types (such as Container<int>::Node), computing distinct field layouts, and registering member methods.
  • Nested class type specifiers (Outer::Inner) enforce access control during type resolution. Private nested types can only be referenced from within the enclosing class, its member methods, or template specializations parameterized with the nested type. Referencing private nested types externally triggers a compile diagnostic (tests/negative/nested_type_private_access.cpp). Nested class short names remain scoped to the outer struct and do not pollute the global namespace (tests/negative/nested_class_unqualified_leak.cpp).
  • Chained dependent type aliases resolve iteratively to a fixed point during template specialization, supporting arbitrary alias chains without fixed loop bounds (tests/templates_operators/template_nested_alias_chain.cpp). Member type aliases in the std namespace are restricted to templates actually defined within std.
  • Dependent member type specifiers require the typename prefix (typename Container<T>::iterator). Unqualified typename or non-type usage is rejected at parse time.
  • Instantiation recursion is limited to 500 levels (template instantiation depth exceeded (limit: 500)).

2. Nesting Limits per Construct

To protect WebAssembly engine shadow stacks from exhaustion when compiling deep programs in Web Workers, the compiler enforces per-construct nesting budgets (src/depth.rs). One construct cannot exhaust the budget of another:

These limits are verified by tests/nesting.rs and tests/wasm_stack_safety.rs.

Wide left-associative expressions (sums of 20,000 terms), string concatenations (4,000 terms), and else-if chains (5,000 branches) are flattened iteratively and do not consume recursion depth.

3. Printf Runtime Specifications

The embedded printf engine (src/runtime/format.rs) supports:

• Specifiers: %d, %i, %u, %o, %x, %X, %c, %s, %e, %E, %f, %g, %G.
• Modifiers: h, hh, l, ll, and z.
• Flags: 0 (zero-pad), - (left-align), + (sign), (space sign), # (alternate form).
• Dynamic precision: .* is supported. (Dynamic width * is not implemented).
• Unsupported conversions: %p and %n.
• NaN and Infinities: Zero padding falls back to spaces; sign of NaN is implementation-defined.