Aggregate codegen errors and lower Julia throws (#248)

This changes codegen to collect independent errors instead of stopping at the first one. Failed values are replaced with poison values so compilation can continue, while follow-on errors caused by those values are suppressed. The final error reports the useful root causes in source order.

It also handles Julia throw calls directly. Throws that are unavoidable become compile-time diagnostics, while throws in conditional control flow become runtime Tile IR assertions. Static exception messages are preserved when possible, and exception objects are removed before Tile IR codegen.

Co-authored-by: Claude Fable 5 <noreply@anthropic.com>

Author: maleadt

src/bytecode/types.jl

@@ -148,12 +148,12 @@ F8E4M3FN(table::TypeTable) = simple_type!(table, SimpleType.F8E4M3FN)
 F8E5M2(table::TypeTable) = simple_type!(table, SimpleType.F8E5M2)
 function F8E8M0FNU(table::TypeTable)
     table.version >= v"13.2" ||
-        throw(ArgumentError("Float8_E8M0FNU requires Tile IR bytecode v13.2+, got v$(table.version)"))
+        throw(IRError("Float8_E8M0FNU requires Tile IR bytecode v13.2+, got v$(table.version)"))
     simple_type!(table, SimpleType.F8E8M0FNU)
 end
 function F4E2M1FN(table::TypeTable)
     table.version >= v"13.3" ||
-        throw(ArgumentError("Float4_E2M1FN requires Tile IR bytecode v13.3+, got v$(table.version)"))
+        throw(IRError("Float4_E2M1FN requires Tile IR bytecode v13.3+, got v$(table.version)"))
     simple_type!(table, SimpleType.F4E2M1FN)
 end
 Token(table::TypeTable) = simple_type!(table, SimpleType.Token)
@@ -242,7 +242,7 @@ function julia_to_tile_dtype!(table::TypeTable, ::Type{T}) where T
         elem_dtype = lookup_dtype!(table, eltype(T))
         pointer_type!(table, elem_dtype)
     else
-        error("Unsupported Julia type for Tile IR: $T")
+        throw(IRError("Unsupported Julia type for Tile IR: $T"))
     end
 end
 

src/compiler/codegen/control_flow.jl

@@ -23,10 +23,44 @@ function emit_block!(ctx::CGCtx, block::Block; skip_terminator::Bool=false)
                     ctx.debug_emitter, ctx.sci, inst.ssa_idx; linkage_name=ln)
             end
             s = inst[:stmt]
-            if s isa ControlFlowOp
-                emit_control_flow_op!(ctx, s, value_type(inst), inst.ssa_idx)
-            else
-                emit_statement!(ctx, s, inst.ssa_idx, value_type(inst))
+            # Per-statement diagnostic boundary: an `IRError` from anywhere in
+            # this statement's emission is recorded (with its kernel-side stack)
+            # and the result poisoned, so emission continues and one compile can
+            # report every problem. See compiler/codegen/errors.jl.
+            ctx.current_ssa_idx = inst.ssa_idx
+            ctx.touched_poison = false
+            try
+                if s isa ControlFlowOp
+                    emit_control_flow_op!(ctx, s, value_type(inst), inst.ssa_idx)
+                else
+                    emit_statement!(ctx, s, inst.ssa_idx, value_type(inst))
+                end
+                # A successful statement that read a poisoned input still
+                # yields a poison-derived value: taint it so failures further
+                # down the dataflow chain are suppressed as cascades even when
+                # intermediate statements emit fine.
+                if ctx.touched_poison || reads_poison(ctx, s)
+                    push!(ctx.poisoned, inst.ssa_idx)
+                end
+            catch e
+                if !(e isa IRError)
+                    # Anything else escaping emission is a compiler bug, not a
+                    # kernel diagnostic: abort immediately (the context may be
+                    # inconsistent), but point the report at the offending
+                    # kernel statement and ask for an issue.
+                    e isa Union{InternalCompilerError, InterruptException} && rethrow()
+                    throw(InternalCompilerError(source_location(ctx.sci, inst.ssa_idx),
+                                                CapturedException(e, catch_backtrace())))
+                end
+                ctx.current_ssa_idx = inst.ssa_idx
+                # Suppress errors derived purely from an already-poisoned input;
+                # keep only root causes. The static operand check backs up the
+                # dynamic flag for emitters that throw before reading arguments.
+                if !(ctx.touched_poison || reads_poison(ctx, s))
+                    record_error!(ctx, e.msg)
+                end
+                push!(ctx.poisoned, inst.ssa_idx)
+                ctx.values[inst.ssa_idx] = poison_value(ctx)
             end
         end
         if !skip_terminator && terminator(block) !== nothing
@@ -62,17 +96,24 @@ function emit_if_op!(ctx::CGCtx, op::IfOp, @nospecialize(parent_result_type), ss
     cond_tv === nothing && throw(IRError("Cannot resolve condition for IfOp"))
 
     # Determine result types from parent_result_type (token_order_pass! already
-    # updated the type to include any token carries via inst[:type] = …)
+    # updated the type to include any token carries via inst[:type] = …).
+    #
+    # A non-representable result (typically `Any`/`Union{}` left when inference
+    # could not pin a branch's tile down) is recorded but does NOT abort: we
+    # substitute a poison type and still emit both regions, so the root cause
+    # inside the branch (e.g. a non-constant tile shape) surfaces too. The IfOp
+    # result is then marked poison to suppress the cascade at its consumers,
+    # and the carry diagnostic itself is dropped again if the regions surface
+    # errors of their own (prune_derived_errors! below).
     result_types = TypeId[]
+    result_poisoned = false
+    carry_mark = length(ctx.errors)
     if parent_result_type !== Nothing
-        if parent_result_type <: Tuple
-            for T in parent_result_type.parameters
-                push!(result_types, tile_type_for_julia!(ctx, T))
-            end
-        else
-            push!(result_types, tile_type_for_julia!(ctx, parent_result_type))
-        end
+        Ts = parent_result_type <: Tuple ? collect(parent_result_type.parameters) :
+                                            Any[parent_result_type]
+        result_types, result_poisoned = collect_result_types!(ctx, Ts; context="`if`/`else` result")
     end
+    carry_errors = carry_mark+1:length(ctx.errors)
 
     then_body = function(_)
         saved = copy(ctx.block_args)
@@ -87,8 +128,10 @@ function emit_if_op!(ctx::CGCtx, op::IfOp, @nospecialize(parent_result_type), ss
         empty!(ctx.block_args); merge!(ctx.block_args, saved)
     end
     results = encode_IfOp!(then_body, else_body, cb, result_types, cond_tv.v)
+    prune_derived_errors!(ctx, carry_errors)
 
     ctx.values[ssa_idx] = CGVal(results, parent_result_type)
+    result_poisoned && push!(ctx.poisoned, ssa_idx)
 end
 
 #=============================================================================
@@ -120,9 +163,14 @@ function emit_for_op!(ctx::CGCtx, op::ForOp, @nospecialize(parent_result_type),
         push!(init_values, tv.v)
     end
 
-    # Build result types uniformly from block args
+    # Build result types uniformly from block args. A non-representable carry
+    # (typically `Any`/`Union{}`) is recorded but does not abort: poison it and
+    # still emit the body so the root cause inside the loop surfaces too.
     n_carries = length(body_blk.args)
-    result_types = TypeId[tile_type_for_julia!(ctx, arg.type) for arg in body_blk.args]
+    carry_mark = length(ctx.errors)
+    result_types, result_poisoned =
+        collect_result_types!(ctx, (arg.type for arg in body_blk.args); context="loop carry")
+    carry_errors = carry_mark+1:length(ctx.errors)
 
     body_builder = function(block_args)
         saved = copy(ctx.block_args)
@@ -144,8 +192,10 @@ function emit_for_op!(ctx::CGCtx, op::ForOp, @nospecialize(parent_result_type),
     end
     results = encode_ForOp!(body_builder, cb, result_types, iv_type,
                              lower_tv.v, upper_tv.v, step_tv.v, init_values)
+    prune_derived_errors!(ctx, carry_errors)
 
     ctx.values[ssa_idx] = CGVal(results, parent_result_type)
+    result_poisoned && push!(ctx.poisoned, ssa_idx)
 end
 
 #=============================================================================
@@ -164,7 +214,10 @@ function emit_loop_op!(ctx::CGCtx, op::LoopOp, @nospecialize(parent_result_type)
     end
 
     n_carries = length(body_blk.args)
-    result_types = TypeId[tile_type_for_julia!(ctx, arg.type) for arg in body_blk.args]
+    carry_mark = length(ctx.errors)
+    result_types, result_poisoned =
+        collect_result_types!(ctx, (arg.type for arg in body_blk.args); context="loop carry")
+    carry_errors = carry_mark+1:length(ctx.errors)
 
     body_builder = function(block_args)
         saved = copy(ctx.block_args)
@@ -186,8 +239,10 @@ function emit_loop_op!(ctx::CGCtx, op::LoopOp, @nospecialize(parent_result_type)
         empty!(ctx.block_args); merge!(ctx.block_args, saved)
     end
     results = encode_LoopOp!(body_builder, cb, result_types, init_values)
+    prune_derived_errors!(ctx, carry_errors)
 
     ctx.values[ssa_idx] = CGVal(results, parent_result_type)
+    result_poisoned && push!(ctx.poisoned, ssa_idx)
 end
 
 #=============================================================================
@@ -212,7 +267,10 @@ function emit_while_op!(ctx::CGCtx, op::WhileOp, @nospecialize(parent_result_typ
     end
 
     n_carries = length(before_blk.args)
-    result_types = TypeId[tile_type_for_julia!(ctx, arg.type) for arg in before_blk.args]
+    carry_mark = length(ctx.errors)
+    result_types, result_poisoned =
+        collect_result_types!(ctx, (arg.type for arg in before_blk.args); context="loop carry")
+    carry_errors = carry_mark+1:length(ctx.errors)
 
     body_builder = function(block_args)
         saved = copy(ctx.block_args)
@@ -299,8 +357,10 @@ function emit_while_op!(ctx::CGCtx, op::WhileOp, @nospecialize(parent_result_typ
         empty!(ctx.block_args); merge!(ctx.block_args, saved)
     end
     results = encode_LoopOp!(body_builder, cb, result_types, init_values)
+    prune_derived_errors!(ctx, carry_errors)
 
     ctx.values[ssa_idx] = CGVal(results, parent_result_type)
+    result_poisoned && push!(ctx.poisoned, ssa_idx)
 end
 
 #=============================================================================