medvednikov · 2026-07-07T10:02:04Z

What changed

Reject standalone value-producing $embed_file(...) expressions, including parenthesized forms, parenthesized if/match result forms, selectors rooted in $embed_file(...), and discarded field selections after embed-producing or {}/lock fallbacks, with the existing expression evaluated but not used parser diagnostic instead of letting discarded embedded data reach later stages.
Reject discarded final expressions that contain $embed_file(...) under value-only wrappers such as infix expressions, containers, casts, selectors, string interpolations, attached or {} fallbacks, lock bodies, and nested value-result branches, instead of only checking expressions rooted directly at $embed_file(...).
Preserve $embed_file(...) values when they are actually consumed as final values of if/match expression branches, used or {} fallbacks, single-expression unsafe { ... } results, and value-producing lock/rlock expressions.
Propagate used single-expression unsafe {} result context to nested value-producing if/match expressions and or {} fallbacks inside that unsafe block.
Keep the exemptions scoped to the result-producing body itself, so ordinary nested blocks, statement-only branches, unused parenthesized statements, unused or {} handlers, unused unsafe statements, unused lock statements, discarded selector-only postfix chains, newline-separated pseudo-calls, and non-final nested branch statements still reject discarded $embed_file(...) values.
Preserve used fallback/result values through trailing comments, parenthesized call arguments, postfix receiver calls, comma-separated branch results, nested if/match results consumed by outer operators, parenthesized nested if/match results consumed by postfix calls, and unused call statements whose receiver is a parenthesized branch value.
Preserve parenthesized lock/rlock result values used as postfix call receivers, e.g. (rlock s { ... }).to_string().
Skip condition-side or {} blocks, braced literals, braced literals passed as call arguments, called anonymous function bodies, nested branch expressions, unsafe {} blocks, and lock/rlock bodies while locating the real body of nested if/match result expressions.
Route leading script $dbg; through generated main, including when it appears inside an initial comptime $if or $match branch, while still rejecting debugger statements outside functions in non-script contexts.
Added regression fixtures for the standalone $embed_file diagnostics, valid branch/or/unsafe/lock result values, nested condition lookahead cases, nested value constructs inside used unsafe results, condition literal argument delimiters, parenthesized unused branch expressions, selectors rooted in embeds, discarded field selections after embed fallbacks, wrapped selector fallbacks, wrapped lock selectors, parenthesized lock postfix calls, parenthesized nested branch postfix calls, unused parenthesized branch receiver calls, newline-separated selector/call lookalikes, infix expressions and string interpolations hiding discarded embeds, and leading script debugger wrapping.

Root cause

The parser previously allowed direct $... expression statements too broadly, so a discarded $embed_file(...) could survive parsing and fail later. The new diagnostic needs to distinguish real value-result contexts from any arbitrary following }. The parser now tracks the exact scopes where a final expression value is consumed, including if/match branches, used or {} handlers, used single-expression unsafe {} bodies, and used lock/rlock bodies. Nested scopes only inherit that state when their expression is the actual result expression.

expr_no_value() reparses parenthesized contents with p.expr(0), so expecting_value alone is not reliable inside an unused parenthesized statement. Value-use detection now also respects the current parenthesized-used state and detects postfix receiver calls after the closing parenthesis, while still preserving real consumed contexts such as call arguments. Selector statements remain generally allowed, but selectors whose receiver contains discarded embedded data are rejected unless the selector value is actually consumed.

Postfix handling for embed-producing or {}/lock/unsafe results must distinguish selector-only chains from call chains. A plain .path still discards the value, while .to_string() or .field.method() consumes the value as a call receiver; the parser now only suppresses the inner embed diagnostic for postfix chains that reach a same-line call, matching expr_with_left() call parsing. The same postfix-call continuation logic is used when deciding whether a parenthesized nested if/match expression is the current branch result or the receiver of an otherwise allowed call statement.

Discarded expression detection needs to look through all value-producing wrappers that can hide an embed, not just the root node. String interpolations store their payload expressions and dynamic format expressions separately, so the embed search now descends into StringInterLiteral.exprs, fwidth_exprs, and precision_exprs. It also descends into call/selector receiver and argument subexpressions plus attached or {} blocks, so a consumed fallback cannot disappear inside a larger discarded wrapper. Lock bodies are scanned directly during parsing rather than relying on checker-populated LockExpr.is_expr.

A used single-expression unsafe {} body is itself a value-result scope. Without including that scope in the shared value-result helper, nested if/match expressions and or {} fallbacks inside the unsafe body were parsed as statement-only even though their value becomes the unsafe expression result.

Condition lookahead for nested if/match result expressions must skip braced constructs that belong to the condition, including braced literals used as call arguments and lock/rlock result bodies. Otherwise those condition-side braces are mistaken for the nested branch body and valid final $embed_file(...) branch values are parsed as statement-only. Parenthesized lock results also need postfix-call handling through closing parentheses, because a closing ) before .to_string() still means the value is consumed as a receiver.

The checker also accepted top-level ast.DebuggerStmt, which let cgen emit debugger code outside a function. Script parsing now wraps leading script debugger statements, including initial comptime branches containing them, into the synthetic main before checking.

Fixes #27681.
Fixes #27682.

Validation

Latest follow-up:

./v -g -keepc -o ./vnew cmd/v
./vnew -check vlib/v/tests/debugger_reserved_arg_name_test.v
Direct compile check: temporary script starting with $if linux { #include <stdint.h>; $dbg } $else { #include <stdint.h>; $dbg } compiled with ./vnew -o ... main.v.
Direct compile check: temporary script starting with $match @OS { 'linux' { #include <stdint.h>; $dbg } $else { #include <stdint.h>; $dbg } } compiled with ./vnew -o ... main.v.
git diff --check -- vlib/v/parser/parser.v vlib/v/tests/debugger_reserved_arg_name_test.v
git diff --cached --check
Attempted ./vnew fmt -w vlib/v/parser/parser.v vlib/v/tests/debugger_reserved_arg_name_test.v, but compiling cmd/tools/vfmt.v currently fails on existing vlib/v/parser/fn.v enum inference errors.
Not run for latest follow-up: V test runner, per skip-tests request.

Earlier checks on this PR included targeted compiler-error fixtures, embed-file tests, debugger tests, repeated formatting, rebuilds, and staged diff checks. Broad ./vnew -silent test vlib/v/ was started earlier and then stopped/skipped per request.

Navigation Menu

Uh oh!

Uh oh!

fix standalone comptime diagnostics - #27683