Mixed registries: virtual parameters in different registries

[jll63]

(Written by Claude Code, on behalf of @jll63.)

A method's virtual parameters may now carry different registries, which lets a multi-method dispatch on classes that use different RTTI systems, e.g. a hierarchy with a custom RTTI next to one with standard RTTI:

BOOST_OPENMETHOD(
    render, (virtual_<const Node&, node_registry>, virtual_<const Format&>),
    std::string, default_registry);

Rules

• Each virtual parameter dispatches in the registry it carries (spelled, or by class affinity), or in the method's when it carries none. Its traits, v-table pointer and type ids come from that registry.
• Parameters that carry different registries still require the method to name one ("carry conflicting registries"). The named registry may be any registry.
• The parameter's registry must be initialized before the method's, and the method's again whenever the parameter's is re-initialized. Otherwise the new parameter_registry_not_initialized error is raised: by initialize(), and by a call under runtime_checks. Two registries that each hold a method with a parameter in the other therefore cannot both be initialized.
• Registries that use deferred_static_rtti mix with those that don't, in either direction: each parameter's type ids are resolved when its own registry resolves them.

How it works

Type ids never cross registries: two registries may give the same id to different classes, or use incomparable ids. The method registers one foreign_parameter_info per foreign parameter with that parameter's registry. That registry's initialize():

1. maps the ids through its own class map, raising missing_class / missing_base itself;
2. reserves a slot in its v-tables and leaves the entries empty;
3. publishes the cone of the parameter's class by position, with each class's entry address.

The method's registry builds proxy classes from the cone and writes the entries in its noexcept commit. The dispatch code is unchanged, and a foreign parameter may be in any position, including the first. A generation counter detects re-initialization.

Module copies share a slot. When modules share a registry, each may hold its own copy of a method, and each registers its own record. The parameter's registry groups them by the address of the method registry's state, the method's type id, and the parameter's position. It cannot compare the method's ids itself - they belong to another rtti policy - so the method template supplies a comparator built from its own registry's rtti::type_index.

Deferral is per parameter. The method's own ids and those of its native parameters follow the method registry's deferral, as before. A foreign parameter whose registry does not defer gets its ids at construction; one whose registry does gets them in that registry's initialize(), through function pointers the templates supply, since that registry knows neither the method's type nor the overriders'. No registry calls another's rtti during static construction.

trace() shows the handshake from both ends. The parameter's registry prints the overrider classes it resolved and what it publishes; the method's registry prints what it received, names the cone classes foreign#k, and lists the entries it writes back into the other registry's v-tables. The addresses match between the two.

Tests and docs

• test_mixed_registries.cpp uses three registries with different RTTI, two of which deliberately assign the same ids to unrelated classes. It covers a foreign first, second and only parameter, next, the bad-call errors, re-initialization, and (copies_share_the_slot) two module copies of a method sharing one slot.
• test_mixed_registries_affinity.cpp replaces the five compile-fail tests that expected "registry mismatch", which is now legal.
• test_mixed_registries_deferred.cpp mixes deferred and non-deferred registries both ways. Its ids are assigned at the start of the test, so an id read during static construction is 0 and dispatch fails.
• New section Mixing registries in registries_and_policies.adoc, with example mixed_registries.cpp: an expression tree with custom RTTI, rendered through standard-RTTI output formats, and evaluated by a method of the node registry itself. Reference comments are updated.

Verified locally. Headers (0470caf): GCC 13 CMake with -Werror (196/196), GCC 16 with C++26 reflection + shared libs + -Werror (202/202), b2 with -Wall -Wextra -Werror (125 tests), MSVC v18 /W4 /WX on the three mixed-registry tests. Example and docs (a84fc9f): GCC 13 CMake only; the Antora render predates the value section.

Notes

• Also fixes an ambiguous validate_overrider_parameter specialization when an overrider's const virtual_ptr<C>& parameter is exactly the method's. This predates the change.
• Interop: virtual_<const std::any&, S> in a method of another registry now dispatches in S (a manual probe works). No test covers it yet, and the other interop headers were not tried. This changes the behaviour described in interop: a registry spelled on an any virtual parameter is never validated against the method's #123: the spelled registry is now honoured rather than ignored.

🤖 Generated with Claude Code

https://claude.ai/code/session_011Eo4q4cYTx457W7oaunqsQ

[cppalliance-bot]

An automated preview of the documentation is available at https://126.openmethod.prtest3.cppalliance.org/libs/openmethod/doc/html/index.html

If more commits are pushed to the pull request, the docs will rebuild at the same URL.

2026-09-26 19:19:55 UTC

[codecov]

Codecov Report

❌ Patch coverage is 88.59649% with 39 lines in your changes missing coverage. Please review.
✅ Project coverage is 92.03%. Comparing base (f093df7) to head (45c404b).
⚠️ Report is 1 commits behind head on develop.

Files with missing lines	Patch %	Lines
include/boost/openmethod/initialize.hpp	86.03%	14 Missing and 23 partials ⚠️
include/boost/openmethod/core.hpp	97.26%	2 Missing ⚠️

Additional details and impacted files

@@             Coverage Diff             @@
##           develop     #126      +/-   ##
===========================================
- Coverage    92.34%   92.03%   -0.31%     
===========================================
  Files           27       27              
  Lines         2234     2524     +290     
  Branches       679      801     +122     
===========================================
+ Hits          2063     2323     +260     
- Misses         112      123      +11     
- Partials        59       78      +19     

Files with missing lines	Coverage Δ
...oost/openmethod/policies/default_error_handler.hpp	100.00% <ø> (ø)
include/boost/openmethod/preamble.hpp	80.30% <100.00%> (+1.73%)	⬆️
include/boost/openmethod/core.hpp	92.96% <97.26%> (+1.15%)	⬆️
include/boost/openmethod/initialize.hpp	91.95% <86.03%> (-1.03%)	⬇️

... and 2 files with indirect coverage changes

---

Continue to review full report in Codecov by Harness.

Legend - Click here to learn more
Δ = absolute <relative> (impact), ø = not affected, ? = missing data
Powered by Codecov. Last update 108fd89...45c404b. Read the comment docs.

🚀 New features to boost your workflow:

• ❄️ Test Analytics: Detect flaky tests, report on failures, and find test suite problems.