Let a class declaration be for a type rather than of one

[matt-edmondson]

A generated reflection table has to be reachable from the type it describes, and C++ does that by specialising a template on it:

template <>
struct Describe<holo::components::RigidBody>
{
    static constexpr ComponentInfo info{ /* ... */ };
};

The AST could already say everything such a table contains — namespace-scope inline constexpr arrays of braced lists, designated initialisers, nested lists one per line — and could not say the declaration that anchors them. That made the whole artefact unreachable from the thing it is about.

The alternative was naming. A DescribeRigidBody beside RigidBody works, and it is exactly what a lookup by type exists to avoid: every consumer has to spell the convention for itself, and nothing checks that it got it right.

The change

ClassDeclaration gains SpecialisationArguments, an ordered list that is empty on an ordinary declaration:

ClassDeclaration describe = new("Describe")
{
    Kind = TypeDeclarationKind.Struct,
    SpecialisationArguments = { new TypeReference("holo::components::RigidBody") },
};

Empty is what makes this safe to add. IsSpecialisation is false for every type this library has ever emitted, so nothing moves.

Why the arguments are types and not text

This is the one place it departs from CompileTimeAssertion's precedent. An assertion's condition is opaque to everything but the compiler, so carrying it as a string costs nothing. A specialisation argument is a type — the AST already knows how to be one, and the comma in Result<Handle, Error> belongs to that type rather than separating two arguments. Text would have to guess; a list does not, and there's a test for exactly that case.

One generator honours it, three say what it was

Language	Output
C++	template <> then struct Describe<holo::components::RigidBody>
C#	// specialised for holo::components::RigidBody above an ordinary struct Describe
Python	# specialised for holo::components::RigidBody
JavaScript	// specialised for holo::components::RigidBody

A generated file that quietly drops what it was for looks like one that still means it. That is now the second node with this shape, and the reason is the same both times.

Tests

Seven, and the one that matters as much as the positive cases is Cpp_WritesAnOrdinaryDeclarationWithNone — a declaration with no arguments still writes no template. Unconditional would have broken every type this library emits. Also covered: argument order, a nested generic argument kept whole, the comment in all three other languages, YAML round-trip (nested argument included), clone independence, and that an ordinary declaration serialises no key at all.

Full suite: 503 passed.

🤖 Generated with Claude Code

https://claude.ai/code/session_01UGHDsYaaTQdzVR4XBR6miu

---

Generated by Claude Code

[sonarqubecloud]

Quality Gate passed

Issues
1 New issue
0 Accepted issues

Measures
0 Security Hotspots
100.0% Coverage on New Code
0.0% Duplication on New Code

See analysis details on SonarQube Cloud