Add extended block-break syntax

This is a redo of #60367 taking into account various feedback on that
PR. In particular, it seemed like people strongly disliked the `break
break` syntax for two primary reasons:

1. It scales poorly to multiple loops `break break break break`
2. It introduced footguns if extra loops are introduced between the
   loop and the break.

Instead, the consensus seemed to be that labeled break should be
the only facility available. Thus, this implements a proper labeled
break facility that looks as follows:

```
@Label name for i = 1:10
  for j = 1:10
    break name (i, j)
  end
end # evaluate to `(1,1)
```

The idea is to re-use the `@label` macro for now, but possibly promote
this to syntax in a future version if it gains widespread use. Note
that parser changes are still required, since the `break` syntax is
currently an error. However, compat.jl could provide `@goto break name
val`, which parses fine.

`continue` is extended with label support as well:
```
@Label outer while true
  for i = 1:10
    a[i] && continue outer
  end
  [...]
end
```

However, the feature is not restricted to loops. A particular use
case is to replace cleanup blocks written like

```
cond1 && @goto error
cond2 && @goto error

return true

@Label error
error("foo")
```

by a labeled begin/end block:
```
@Label error begin
    cond1 && break error
    cond2 && break error
    return true
end
error("foo")
```

This doesn't save much typing work, but it makes this kind of
pattern much more structured, e.g. for code-folding in IDEs.

A similar pattern replaces the `for-then` construction originally
proposed:

```
result = @Label result begin
  for x in arr
    pred(x) && break result x
  end
  default
end
```

For anonymous blocks, use `@label _ begin ... end` with `break _`:

```
result = @Label _ begin
  for x in arr
    pred(x) && break _ x
  end
  default
end
```

I've taken the liberty of converting some base code for testing and
to give an idea of what the syntax looks like in practice, but didn't
go through particularly comprehensively. These changes should
be considered extended usage examples.

Largely written by Claude.

Author: Keno

JuliaLowering/src/JuliaLowering.jl

@@ -16,6 +16,7 @@ using .JuliaSyntax: highlight, Kind, @KSet_str, is_leaf, children, numchildren,
     head, kind, flags, has_flags, filename, first_byte, last_byte, byte_range,
     sourcefile, source_location, span, sourcetext, is_literal, is_infix_op_call,
     is_postfix_op_call, @isexpr, SyntaxHead, is_syntactic_operator,
+    is_contextual_keyword,
     SyntaxGraph, SyntaxTree, SyntaxList, NodeId, SourceRef, SourceAttrType,
     ensure_attributes, ensure_attributes!, delete_attributes, new_id!, hasattr,
     setattr, setattr!, syntax_graph, is_compatible_graph,

JuliaLowering/src/desugaring.jl

@@ -4449,10 +4449,40 @@ function expand_forms_2(ctx::DesugaringContext, ex::SyntaxTree, docs=nothing)
     elseif k == K"="
         expand_assignment(ctx, ex)
     elseif k == K"break"
-        numchildren(ex) > 0 ? ex :
+        nc = numchildren(ex)
+        if nc == 0
             @ast ctx ex [K"break" "loop_exit"::K"symbolic_label"]
+        else
+            @chk nc <= 2 (ex, "Too many arguments to break")
+            label = ex[1]
+            label_kind = kind(label)
+            # Convert Symbol (from Expr conversion) to symbolic_label
+            if label_kind == K"Symbol"
+                label = @ast ctx label label.name_val::K"symbolic_label"
+            elseif !(label_kind == K"Identifier" || label_kind == K"symbolic_label" ||
+                     is_contextual_keyword(label_kind))
+                throw(LoweringError(label, "Invalid break label: expected identifier"))
+            end
+            if nc == 2
+                @ast ctx ex [K"break" label expand_forms_2(ctx, ex[2])]
+            else
+                @ast ctx ex [K"break" label]
+            end
+        end
     elseif k == K"continue"
-        @ast ctx ex [K"break" "loop_cont"::K"symbolic_label"]
+        nc = numchildren(ex)
+        if nc == 0
+            @ast ctx ex [K"break" "loop_cont"::K"symbolic_label"]
+        else
+            @chk nc == 1 (ex, "Too many arguments to continue")
+            label = ex[1]
+            label_kind = kind(label)
+            if !(label_kind == K"Identifier" || label_kind == K"Placeholder" ||
+                 label_kind == K"Symbol" || is_contextual_keyword(label_kind))
+                throw(LoweringError(label, "Invalid continue label: expected identifier"))
+            end
+            @ast ctx ex [K"break" string(label.name_val, "#cont")::K"symbolic_label"]
+        end
     elseif k == K"comparison"
         expand_forms_2(ctx, expand_compare_chain(ctx, ex))
     elseif k == K"doc"
@@ -4613,6 +4643,11 @@ function expand_forms_2(ctx::DesugaringContext, ex::SyntaxTree, docs=nothing)
         ]
     elseif k == K"inert" || k == K"inert_syntaxtree"
         ex
+    elseif k == K"symbolic_block"
+        # @label name body -> (symbolic_block name expanded_body)
+        # The @label macro inserts the continue block for loops, so we just expand the body
+        @chk numchildren(ex) == 2
+        @ast ctx ex [K"symbolic_block" ex[1] expand_forms_2(ctx, ex[2])]
     elseif k == K"gc_preserve"
         s = ssavar(ctx, ex)
         r = ssavar(ctx, ex)

JuliaLowering/src/kinds.jl

@@ -41,6 +41,8 @@ function _register_kinds()
             "symbolic_label"
             # Goto named label
             "symbolic_goto"
+            # Labeled block for `@label name expr` (block break)
+            "symbolic_block"
             # Internal initializer for struct types, for inner constructors/functions
             "new"
             "splatnew"

JuliaLowering/src/linear_ir.jl

@@ -29,10 +29,11 @@ struct JumpTarget{Attrs}
     label::SyntaxTree{Attrs}
     handler_token_stack::SyntaxList{Attrs, Vector{NodeId}}
     catch_token_stack::SyntaxList{Attrs, Vector{NodeId}}
+    result_var::Union{SyntaxTree{Attrs}, Nothing}  # for symbolic_block valued breaks
 end
 
-function JumpTarget(label::SyntaxTree{Attrs}, ctx) where {Attrs}
-    JumpTarget{Attrs}(label, copy(ctx.handler_token_stack), copy(ctx.catch_token_stack))
+function JumpTarget(label::SyntaxTree{Attrs}, ctx, result_var=nothing) where {Attrs}
+    JumpTarget{Attrs}(label, copy(ctx.handler_token_stack), copy(ctx.catch_token_stack), result_var)
 end
 
 struct JumpOrigin{Attrs}
@@ -79,6 +80,7 @@ struct LinearIRContext{Attrs} <: AbstractLoweringContext
     finally_handlers::Vector{FinallyHandler{Attrs}}
     symbolic_jump_targets::Dict{String,JumpTarget{Attrs}}
     symbolic_jump_origins::Vector{JumpOrigin{Attrs}}
+    symbolic_block_labels::Set{String}  # labels that are symbolic blocks (not allowed as @goto targets)
     meta::Dict{Symbol, Any}
     mod::Module
 end
@@ -91,7 +93,7 @@ function LinearIRContext(ctx, is_toplevel_thunk, lambda_bindings, return_type)
                     is_toplevel_thunk, lambda_bindings, Dict{IdTag,IdTag}(), rett,
                     Dict{String,JumpTarget{Attrs}}(), SyntaxList(ctx), SyntaxList(ctx),
                     Vector{FinallyHandler{Attrs}}(), Dict{String,JumpTarget{Attrs}}(),
-                    Vector{JumpOrigin{Attrs}}(), Dict{Symbol, Any}(), ctx.mod)
+                    Vector{JumpOrigin{Attrs}}(), Set{String}(), Dict{Symbol, Any}(), ctx.mod)
 end
 
 function current_lambda_bindings(ctx::LinearIRContext)
@@ -309,6 +311,14 @@ function emit_break(ctx, ex)
         ty = name == "loop_exit" ? "break" : "continue"
         throw(LoweringError(ex, "$ty must be used inside a `while` or `for` loop"))
     end
+    # Handle valued break (break name val)
+    if numchildren(ex) >= 2
+        if isnothing(target.result_var)
+            throw(LoweringError(ex, "break with value not allowed for label `$name`"))
+        end
+        val = compile(ctx, ex[2], true, false)
+        emit_assignment(ctx, ex, target.result_var, val)
+    end
     if !isempty(ctx.finally_handlers)
         handler = last(ctx.finally_handlers)
         if length(target.handler_token_stack) < length(handler.target.handler_token_stack)
@@ -683,7 +693,9 @@ function compile(ctx::LinearIRContext, ex, needs_value, in_tail_pos)
         end_label = make_label(ctx, ex)
         name = ex[1].name_val
         outer_target = get(ctx.break_targets, name, nothing)
-        ctx.break_targets[name] = JumpTarget(end_label, ctx)
+        # Inherit result_var from outer symbolicblock if present
+        outer_result_var = isnothing(outer_target) ? nothing : outer_target.result_var
+        ctx.break_targets[name] = JumpTarget(end_label, ctx, outer_result_var)
         compile(ctx, ex[2], false, false)
         if isnothing(outer_target)
             delete!(ctx.break_targets, name)
@@ -694,12 +706,44 @@ function compile(ctx::LinearIRContext, ex, needs_value, in_tail_pos)
         if needs_value
             compile(ctx, nothing_(ctx, ex), needs_value, in_tail_pos)
         end
+    elseif k == K"symbolic_block"
+        name = ex[1].name_val
+        if haskey(ctx.symbolic_jump_targets, name) || name in ctx.symbolic_block_labels
+            throw(LoweringError(ex, "Label `$name` defined multiple times"))
+        end
+        push!(ctx.symbolic_block_labels, name)
+        end_label = make_label(ctx, ex)
+        result_var = if needs_value || in_tail_pos
+            rv = new_local_binding(ctx, ex, "$(name)_result")
+            emit_assignment(ctx, ex, rv, nothing_(ctx, ex))
+            rv
+        else
+            nothing
+        end
+        outer_target = get(ctx.break_targets, name, nothing)
+        ctx.break_targets[name] = JumpTarget(end_label, ctx, result_var)
+        body_val = compile(ctx, ex[2], !isnothing(result_var), false)
+        if !isnothing(result_var) && !isnothing(body_val)
+            emit_assignment(ctx, ex, result_var, body_val)
+        end
+        if isnothing(outer_target)
+            delete!(ctx.break_targets, name)
+        else
+            ctx.break_targets[name] = outer_target
+        end
+        emit(ctx, end_label)
+        if in_tail_pos
+            emit_return(ctx, ex, result_var)
+            nothing
+        else
+            result_var
+        end
     elseif k == K"break"
         emit_break(ctx, ex)
     elseif k == K"symbolic_label"
         label = emit_label(ctx, ex)
         name = ex.name_val
-        if haskey(ctx.symbolic_jump_targets, name)
+        if haskey(ctx.symbolic_jump_targets, name) || name in ctx.symbolic_block_labels
             throw(LoweringError(ex, "Label `$name` defined multiple times"))
         end
         push!(ctx.symbolic_jump_targets, name=>JumpTarget(label, ctx))
@@ -950,6 +994,10 @@ function compile_body(ctx::LinearIRContext, ex)
         name = origin.goto.name_val
         target = get(ctx.symbolic_jump_targets, name, nothing)
         if isnothing(target)
+            # Check if it's a symbolic block label
+            if name in ctx.symbolic_block_labels
+                throw(LoweringError(origin.goto, "cannot use @goto to jump to @label block `$name`"))
+            end
             throw(LoweringError(origin.goto, "label `$name` referenced but not defined"))
         end
         i = origin.index
@@ -1172,7 +1220,7 @@ loops, etc) to gotos and exception handling to enter/leave. We also convert
                            Vector{FinallyHandler{Attrs}}(),
                            Dict{String, JumpTarget{Attrs}}(),
                            Vector{JumpOrigin{Attrs}}(),
-                           Dict{Symbol, Any}(), ctx.mod)
+                           Set{String}(), Dict{Symbol, Any}(), ctx.mod)
     res = compile_lambda(_ctx, reparent(_ctx, ex))
     _ctx, res
 end

JuliaLowering/src/scope_analysis.jl

@@ -220,6 +220,12 @@ function _find_scope_decls!(ctx, scope, ex)
             k === K"constdecl" && numchildren(ex) == 2)
             _find_scope_decls!(ctx, scope, ex[2])
         end
+    elseif k === K"symbolic_block"
+        # Only recurse into the body (second child), not the label name (first child)
+        _find_scope_decls!(ctx, scope, ex[2])
+    elseif k === K"break" && numchildren(ex) >= 2
+        # For break with value, only recurse into the value expression (second child), not the label
+        _find_scope_decls!(ctx, scope, ex[2])
     elseif needs_resolution(ex) && !(k === K"scope_block" || k === K"lambda")
         for e in children(ex)
             _find_scope_decls!(ctx, scope, e)
@@ -343,6 +349,10 @@ function _resolve_scopes(ctx, ex::SyntaxTree,
         ex
     elseif k == K"softscope"
         newleaf(ctx, ex, K"TOMBSTONE")
+    elseif k == K"break" && numchildren(ex) >= 2
+        # For break with value (break label value), process the value expression but not the label
+        # This must come BEFORE !needs_resolution check since K"break" is in is_quoted
+        @ast ctx ex [K"break" ex[1] _resolve_scopes(ctx, ex[2], scope)]
     elseif !needs_resolution(ex)
         ex
     elseif k == K"local"
@@ -507,6 +517,9 @@ function _resolve_scopes(ctx, ex::SyntaxTree,
         @assert numchildren(ex) === 2
         assignment_kind = bk == :global ? K"constdecl" : K"="
         @ast ctx ex _resolve_scopes(ctx, [assignment_kind ex[1] ex[2]], scope)
+    elseif k == K"symbolic_block"
+        # Only recurse into the body (second child), not the label name (first child)
+        @ast ctx ex [K"symbolic_block" ex[1] _resolve_scopes(ctx, ex[2], scope)]
     else
         mapchildren(e->_resolve_scopes(ctx, e, scope), ctx, ex)
     end
@@ -600,6 +613,11 @@ function analyze_variables!(ctx, ex)
         @assert b.kind === :global || b.is_ssa || haskey(ctx.lambda_bindings.locals_capt, b.id)
     elseif k == K"Identifier"
         @assert false
+    elseif k == K"break" && numchildren(ex) >= 2
+        # For break with value, only analyze the value expression (second child), not the label
+        # This must come BEFORE !needs_resolution check since K"break" is in is_quoted
+        analyze_variables!(ctx, ex[2])
+        return
     elseif !needs_resolution(ex)
         return
     elseif k == K"static_eval"
@@ -676,6 +694,9 @@ function analyze_variables!(ctx, ex)
             ctx.graph, ctx.bindings, ctx.mod, ctx.scopes, lambda_bindings,
             ctx.method_def_stack, ctx.closure_bindings)
         foreach(e->analyze_variables!(ctx2, e), ex[3:end]) # body & return type
+    elseif k == K"symbolic_block"
+        # Only analyze the body (second child), not the label name (first child)
+        analyze_variables!(ctx, ex[2])
     else
         foreach(e->analyze_variables!(ctx, e), children(ex))
     end

JuliaLowering/src/syntax_macros.jl

@@ -49,6 +49,35 @@ function Base.var"@label"(__context__::MacroContext, ex)
     @ast __context__ ex ex=>K"symbolic_label"
 end
 
+function Base.var"@label"(__context__::MacroContext, name, body)
+    # Handle `@label _ body` (anonymous) or `@label name body` (named)
+    k = kind(name)
+    if k == K"Identifier"
+        # `@label _ body` or `@label name body` - plain identifier
+    elseif is_contextual_keyword(k)
+        # Contextual keyword used as label name (e.g., `@label outer body`)
+    else
+        throw(MacroExpansionError(name, "Expected identifier for block label"))
+    end
+    # If body is a syntactic loop, wrap its body in a continue block
+    # This allows `continue name` to work by breaking to `name#cont`
+    body_kind = kind(body)
+    if body_kind == K"for" || body_kind == K"while"
+        cont_name = string(name.name_val, "#cont")
+        loop_body = body[2]
+        wrapped_body = @ast __context__ loop_body [K"symbolic_block"
+            cont_name::K"Identifier"
+            loop_body
+        ]
+        if body_kind == K"for"
+            body = @ast __context__ body [K"for" body[1] wrapped_body]
+        else  # while
+            body = @ast __context__ body [K"while" body[1] wrapped_body]
+        end
+    end
+    @ast __context__ __context__.macrocall [K"symbolic_block" name body]
+end
+
 function Base.var"@goto"(__context__::MacroContext, ex)
     @chk kind(ex) == K"Identifier"
     @ast __context__ ex ex=>K"symbolic_goto"

JuliaSyntax/src/julia/parser.jl

@@ -2058,15 +2058,60 @@ function parse_resword(ps::ParseState)
             parse_eq(ps)
         end
         emit(ps, mark, K"return")
-    elseif word in KSet"break continue"
-        # break     ==>  (break)
-        # continue  ==>  (continue)
+    elseif word == K"continue"
+        # continue         ==>  (continue)
+        # continue _       ==>  (continue _)        [1.14+]
+        # continue label   ==>  (continue label)    [1.14+]
         bump(ps, TRIVIA_FLAG)
-        emit(ps, mark, word)
         k = peek(ps)
-        if !(k in KSet"NewlineWs ; ) : EndMarker" || (k == K"end" && !ps.end_symbol))
-            recover(is_closer_or_newline, ps, TRIVIA_FLAG,
-                    error="unexpected token after $(untokenize(word))")
+        if k in KSet"NewlineWs ; ) EndMarker" || (k == K"end" && !ps.end_symbol)
+            # continue with no arguments
+            emit(ps, mark, K"continue")
+        elseif ps.range_colon_enabled && k == K":"
+            # Ternary case: `cond ? continue : x`
+            emit(ps, mark, K"continue")
+        elseif k == K"Identifier" || is_contextual_keyword(k)
+            # continue label - plain identifier or contextual keyword as label
+            bump(ps)
+            emit(ps, mark, K"continue")
+            min_supported_version(v"1.14", ps, mark, "labeled `continue`")
+        else
+            # Error: unexpected token after continue
+            emit(ps, mark, K"continue")
+        end
+    elseif word == K"break"
+        # break            ==>  (break)
+        # break _          ==>  (break _)               [1.14+]
+        # break _ val      ==>  (break _ val)           [1.14+]
+        # break label      ==>  (break label)           [1.14+]
+        # break label val  ==>  (break label val)       [1.14+]
+        bump(ps, TRIVIA_FLAG)
+        function parse_break_value(ps, mark)
+            k2 = peek(ps)
+            if k2 in KSet"NewlineWs ; ) : EndMarker" || (k2 == K"end" && !ps.end_symbol)
+                # break label
+                emit(ps, mark, K"break")
+            else
+                # break label value
+                parse_eq(ps)
+                emit(ps, mark, K"break")
+            end
+            min_supported_version(v"1.14", ps, mark, "labeled `break`")
+        end
+        k = peek(ps)
+        if k in KSet"NewlineWs ; ) EndMarker" || (k == K"end" && !ps.end_symbol)
+            # break with no arguments
+            emit(ps, mark, K"break")
+        elseif ps.range_colon_enabled && k == K":"
+            # Ternary case: `cond ? break : x`
+            emit(ps, mark, K"break")
+        elseif k == K"Identifier" || is_contextual_keyword(k)
+            # break label [value] - plain identifier or contextual keyword as label
+            bump(ps)
+            parse_break_value(ps, mark)
+        else
+            # Error: unexpected token after break
+            emit(ps, mark, K"break")
         end
     elseif word in KSet"module baremodule"
         # module A end  ==> (module A (block))

JuliaSyntax/test/parser.jl

@@ -551,6 +551,13 @@ tests = [
         # break/continue
         "break"    => "(break)"
         "continue" => "(continue)"
+        # break/continue with labels (plain identifiers only)
+        "break _"  => "(break _)"
+        "break _ x" => "(break _ x)"
+        "break label" => "(break label)"
+        "break label x" => "(break label x)"
+        "continue _" => "(continue _)"
+        "continue label" => "(continue label)"
         # module/baremodule
         "module A end"      =>  "(module A (block))"
         "baremodule A end"  =>  "(module-bare A (block))"

NEWS.md

@@ -11,6 +11,9 @@ New language features
   - `ᵅ` (U+U+1D45), `ᵋ` (U+1D4B), `ᶲ` (U+1DB2), `˱` (U+02F1), `˲` (U+02F2), and `ₔ` (U+2094) can now also be used as
     operator suffixes, accessible as `\^alpha`, `\^epsilon`, `\^ltphi`, `\_<`, `\_>`, and `\_schwa` at the REPL
     ([#60285]).
+  - The `@label` macro can now create labeled blocks that can be exited early with `break name [value]`. Use
+    `@label name expr` for named blocks or `@label _ expr` for anonymous blocks. The `continue` statement also
+    supports labels with `continue name` to continue a labeled loop ([#60481]).
 
 Language changes
 ----------------