fix: an @inline marked kernel registered a probe nothing could ever set

[sotashimozono]

The question was whether @experimental itself has settled. The churn says yes — src/mark.jl has
not been touched since #13, across the fourteen commits since, while everything around it moved. So
I put the question to a sweep of 25 definition forms instead of to the git log, and the sweep found
one hole, in the class this package exists to close.

The finding

@experimental "kernel unverified" @inline f(x) = x     # mark outside
@inline @experimental "kernel unverified" g(x) = x     # mark inside

f(1); g(1)
entered(M)   # → [:g]

Both are marked. Both register a probe, so both count toward "observable marked definitions".
Only one can ever be entered. With the mark outside:

what asked	what it said
entered	not entered, no matter what ran
@entered / record	a clean run through unvalidated code
unverified	reported forever

Six macros affected: @inline, @noinline, @propagate_inbounds, @assume_effects,
@constprop, @nospecializeinfer. An @inline kernel is exactly the small numeric body this
package is aimed at.

Cause: two halves of one feature, written to different assumptions

_subject (src/mark.jl) was right — those six are in _ANNOTATING_MACROS, the wrapper is rebuilt
around the definition, instrumentable is passed through, and the comment says "an @inline
marked kernel is exactly the kind that has to be observable".

_instrument (src/detect.jl) began (def.head === :function || def.head === :(=)) || return nothing and handed back nothing for the :macrocall it was given. The probe was dropped; the
flag was registered anyway.

It now recurses through the wrapper and rebuilds it around the instrumented body.

Two documents that described the defect rather than the design

The docstring table read `Base.@kwdef`, `@inline`, `@noinline` and the other pass-through macros | no — which is what the code did, not what the code was for. Split into two rows, each
saying why: the annotating six are observed; @generated (its body returns an expression) and
Base.@kwdef (it wraps a struct) are not.

The test was named "@inline and the mark compose in both orders" and asserted
Set([:f, :g]) == names marked — satisfied by a mark that can never fire. The two orders did not
compose the same way and the assertion was structurally unable to see it. It now asserts the
observation, and a second testset pins the split a careless fix would break: instrumenting every
macrocall would put a probe inside @generated's returned expression.

Three refusals that no test touched

Measured by grepping test/ for their message text — zero hits each:

refused	now pinned on
a wrapping macro this cannot read	the name of the macro, and @experimental "why" the_name
begin f(x)=x; g(x)=x end	the word block and the alternative — half-marking two definitions is the silence this package removes
a bare Sub.g	Sub.g, WHICH method, and Sub.g(:: — the form that works, spelled with their own name

Incidental: a macro that throws while expanding a module body run through include_string comes
back wrapped in LoadError twice, so the usual single .error leaves a LoadError that reads
exactly like the failure it hides.

186 behaviours, 1210 assertions, green.

🤖 Generated with Claude Code

[github-actions]

📚 Docs preview: https://codes.sota-shimozono.com/ExperimentalAPI.jl/previews/PR28/

(updates on each push to this PR)

[codecov]

Codecov Report

✅ All modified and coverable lines are covered by tests.

📢 Thoughts on this report? Let us know!