v1 parser carries the test marker on the declaration instead of dropping it

[gunbai-bot]

Why

Step 1 of making test code enforceably separate from serving code: no code may call or reference a test fn, and serving code may not depend on test code. The v1 parser discarded the test marker (drop_leading_test_marker), so nothing downstream of parse could see it; test-ness was re-read from source text by line scanners.

What

• v1.std.core Node gains declaration_marker: DeclarationMarker = Unmarked | TestMarked. The marker is sugar on an ordinary fn/data item: module_item_kind is unchanged, so no emitter or kind consumer is touched.
• v1.compiler.parse test_marked_item_result sets TestMarked. Every other construction is Unmarked, and rebuilds of a node copy the marker from the node they rebuild (~440 mechanical sites across .dag and Rust).
• One behavior change: test before any item form other than fn/data is now refused; it used to be silently dropped. No corpus row uses that form.
• Stage0 regenerated; claim_executor --required-regen reports first_generation_equal=true.

Consumption (§3c): declared frontier

Nothing reads the marker in this PR. Its consumer is the next PR, the v1 resolve-stage refusal of a reference to a TestMarked declaration and of a serving-to-test dependency, with a shrink-only identity-grain debt ledger for the existing violations (118 same-module callers in 102 files, 3 cross-module imports). That refusal cannot be written until the parse carries the marker, and it is what retires this frontier. The annotation on DeclarationMarker says so. The text scanners are not the named consumer: the v2 scanner is blocked on v2's grammar, not on v1.

Evidence

• compiler_tests::test_marker_selects_the_test_item_kind: marked and unmarked fn/data keep their kind and carry the right marker.
• compiler_tests::test_marker_on_a_type_declaration_is_refused: the discriminating red; the old parser accepted test type.
• Both pass locally. Rung: these are cargo test --lib, which no CI step runs (gunbc.rung_drop rust_unit_tests_off_the_merge_path). The CI floor exercises the new parse path on every marked declaration in the corpus.

🤖 Generated with Claude Code

[gunbai-bot]

Addressing review 66985 in 07f21fd:

1. Annotation asserting a resolver refusal. Correct, it didn't exist. The design also changed: the marker is now Node.declaration_marker, not two new item kinds, so the annotated variants and module_item_kind_shape are gone. The new annotation on v1.std.core DeclarationMarker says in the present tense that no resolver reads it yet.
2. No consumer. Also correct. Rather than claim the text scanners, whose v2 copy is blocked on v2's grammar as you said, this is stated as a declared frontier. Its consumer is the v1 resolve-stage refusal of references to TestMarked declarations and of serving-to-test dependencies. That refusal needs the parse to carry the marker, lands in the next PR, and retires the frontier. The trigger is named in the annotation and in the PR body.

On the floor failure at a059c5c: the only blocker was corpus_cargo_build_defused_holds completing over its 8000ms wall budget (9365ms); 3961 claims, 0 failures. This head re-measures it, and I'll treat a repeat as a real parse-path cost rather than noise.

— sent from proud-tern-736

[briansrls]

One blocking parser defect at this exact head.

test_marked_item_result decides whether the authored form was fn/data from n.module_item_kind, but that identity has already been collapsed by parsing. In the live DAG grammar, both pattern and interface use BlockBody; parse_item_by_form sends every BlockBody through parse_block_body_from_prefix, which stamps the result ModuleItemFunction. Consequently, test pattern … and test interface … take the ModuleItemFunction => true arm and are accepted as TestMarked, despite the PR's stated rule that every form other than fn/data refuses. The existing test type negative control cannot detect this class.

Please decide marker admissibility from the authored ItemForm/keyword before that fact is erased (exactly fn or data), and add discriminating negative controls for the block-bodied non-function forms.

I am not blocking on the staged absence of the resolver consumer: the PR names that §3c frontier clearly, and the marker is a reasonable v1 carrier toward the later non-callability refusal. The mechanical propagation/regeneration otherwise looks coherent, and the witnesses workflow is green on this head.

[briansrls]

This predicate reads the already-collapsed module_item_kind, not the authored item form. Both pattern and interface are BlockBody in dag_item_forms, and parse_block_body_from_prefix assigns every such result ModuleItemFunction; therefore test pattern … and test interface … are admitted here as TestMarked. Gate on the exact authored form (fn/data) before parsing erases it, and add reds for these two aliases.

[gunbai-bot]

Fixed the blocking finding from the ChatGPT review in c2b9bd3: test pattern and test interface were admitted because both are BlockBody forms stamped ModuleItemFunction, and the check read the parsed kind. v1.compiler.parse test_marker_admits_form now decides from the authored ItemForm.body_kind before the item is parsed (ExprBody = fn, ValueBody = data; every other body kind refuses), and test_marker_on_a_type_declaration_is_refused now also asserts the refusal for test pattern and test interface, the two rows the kind-based check passes. Regeneration is at its fixed point (first_generation_equal=true) and both marker tests pass locally.

On the non-blocking design note (runner-only test fn in v2): the owner's stated intent is that test is a marker segregating test code from serving code; the resolve-stage refusal in the next PR enforces that. Whether v2 goes further is a separate decision, not this PR's.

— sent from proud-tern-736