Random lowering bugfixes (#24)

* Random lowering bugfixes

- `init` not provided for possibly-empty `sum()`s in desugaring causing failures
     for empty ctors, empty tuple destruct
- linearize: break_block type error
- missing desugaring when if-condition is a block
- undef var `ex` in expand_arrow_arglist

Co-authored-by: Claire Foster <[email protected]>

Author: mlechu

src/desugaring.jl

@@ -414,7 +414,7 @@ function expand_tuple_destruct(ctx, ex)
     end
 
     if kind(rhs) == K"tuple"
-        num_splat = sum(kind(rh) == K"..." for rh in children(rhs))
+        num_splat = sum(kind(rh) == K"..." for rh in children(rhs); init=0)
         if num_splat == 0 && (numchildren(lhs) - num_slurp) > numchildren(rhs)
             throw(LoweringError(ex, "More variables on left hand side than right hand in tuple assignment"))
         end
@@ -1402,7 +1402,7 @@ function expand_condition(ctx, ex)
     if isblock
         # Special handling so that the rules for `&&` and `||` can be applied
         # to the last statement of a block
-        @ast ctx ex [K"block" ex[1:end-1]... test]
+        @ast ctx ex [K"block" map(e->expand_forms_2(ctx,e), ex[1:end-1])... test]
     else
         test
     end
@@ -2112,7 +2112,7 @@ end
 
 # Separate decls and assignments (which require re-expansion)
 # local x, (y=2), z ==> local x; local z; y = 2
-function expand_decls(ctx, ex, is_const=false)
+function expand_decls(ctx, ex)
     declkind = kind(ex)
     @assert declkind in KSet"local global"
     declmeta = get(ex, :meta, nothing)
@@ -2124,7 +2124,7 @@ function expand_decls(ctx, ex, is_const=false)
             @chk numchildren(binding) == 2
             lhs = strip_decls!(ctx, stmts, declkind, declmeta, binding[1])
             push!(stmts, expand_assignment(ctx, @ast ctx binding [kb lhs binding[2]]))
-        elseif is_sym_decl(binding) && !is_const
+        elseif is_sym_decl(binding)
             strip_decls!(ctx, stmts, declkind, declmeta, binding)
         else
             throw(LoweringError(ex, "invalid syntax in variable declaration"))
@@ -3085,7 +3085,7 @@ function expand_arrow_arglist(ctx, arglist, arrowname)
     if k == K"where"
         @ast ctx arglist [K"where"
             expand_arrow_arglist(ctx, arglist[1], arrowname)
-            argslist[2]
+            arglist[2]
         ]
     else
         # The arglist can sometimes be parsed as a block, or something else, and
@@ -3094,13 +3094,12 @@ function expand_arrow_arglist(ctx, arglist, arrowname)
         if k == K"block"
             @chk numchildren(arglist) == 2
             arglist = @ast ctx arglist [K"tuple"
-                ex[1]
-                [K"parameters" ex[2]]
+                arglist[1]
+                [K"parameters" arglist[2]]
             ]
         elseif k != K"tuple"
-            # `x::Int -> body`
             arglist = @ast ctx arglist [K"tuple"
-                ex[1]
+                arglist[1]
             ]
         end
         @ast ctx arglist [K"call"
@@ -3665,7 +3664,7 @@ function _rewrite_ctor_new_calls(ctx, ex, struct_name, global_struct_name, ctor_
     full_struct_type = if kind(ex[1]) == K"curly"
         # new{A,B}(...)
         new_type_params = ex[1][2:end]
-        n_type_splat = sum(kind(t) == K"..." for t in new_type_params)
+        n_type_splat = sum(kind(t) == K"..." for t in new_type_params; init=0)
         n_type_nonsplat = length(new_type_params) - n_type_splat
         if n_type_splat == 0 && n_type_nonsplat < length(struct_typevars)
             throw(LoweringError(ex[1], "too few type parameters specified in `new{...}`"))
@@ -3685,7 +3684,7 @@ function _rewrite_ctor_new_calls(ctx, ex, struct_name, global_struct_name, ctor_
         end
     end
     new_args = ex[2:end]
-    n_splat = sum(kind(t) == K"..." for t in new_args)
+    n_splat = sum(kind(t) == K"..." for t in new_args; init=0)
     n_nonsplat = length(new_args) - n_splat
     n_fields = length(field_types)
     function throw_n_fields_error(desc)

src/linear_ir.jl

@@ -703,7 +703,7 @@ function compile(ctx::LinearIRContext, ex, needs_value, in_tail_pos)
         if isnothing(outer_target)
             delete!(ctx.break_targets, name)
         else
-            ctx.break_targets = outer_target
+            ctx.break_targets[name] = outer_target
         end
         emit(ctx, end_label)
         if needs_value

test/branching.jl

@@ -221,6 +221,15 @@ end
 """) === 3
 
 end
+#-------------------------------------------------------------------------------
+# Block condition
+@test JuliaLowering.include_string(test_mod, """
+let a = true
+    if begin; x = 2; a; end
+        x
+    end
+end
+""") === 2
 
 #-------------------------------------------------------------------------------
 @testset "`&&` and `||` chains" begin

test/destructuring_ir.jl

@@ -280,6 +280,22 @@ end
 8   (call core.tuple %₁ %₂ %₃)
 9   (return %₈)
 
+########################################
+# Error: Destructuring with tuple elimination and too few RHS elements
+(x,) = ()
+#---------------------
+LoweringError:
+(x,) = ()
+└───────┘ ── More variables on left hand side than right hand in tuple assignment
+
+########################################
+# Error: Destructuring with tuple elimination, slurping, and too few RHS elements
+(x,y,ys...) = (1,)
+#---------------------
+LoweringError:
+(x,y,ys...) = (1,)
+└────────────────┘ ── More variables on left hand side than right hand in tuple assignment
+
 ########################################
 # Destructuring with tuple elimination but not in value position never creates
 # the tuple

test/functions.jl

@@ -56,6 +56,31 @@ end
 2^4
 """) == 16
 
+#-------------------------------------------------------------------------------
+# Arrow syntax
+@test JuliaLowering.include_string(test_mod, """
+let
+    f = ((x::T, y::T) where T) -> x + y
+    f(1, 2)
+end
+""") === 3
+
+@test JuliaLowering.include_string(test_mod, """
+let
+    f = ((x::T; y=2) where T) -> x + y
+    f(1)
+end
+""") === 3
+
+# Passes desugaring, but T is detected as unused and throws an error.
+# Is it clear whether this should be `f(x::T) where T` or `f(x::T where T)`?
+@test_broken JuliaLowering.include_string(test_mod, """
+let
+    f = ((x::T) where T) -> x
+    f(1)
+end
+""") === 1
+
 #-------------------------------------------------------------------------------
 # Function definitions
 @test JuliaLowering.include_string(test_mod, """

test/loops.jl

@@ -95,6 +95,19 @@ let
     a
 end
 """) == [1, 2]
+# Break from inner nested loop
+@test JuliaLowering.include_string(test_mod, """
+let
+    a = []
+    for i in 1:2
+       for j in 3:4
+           push!(a, (i, j))
+           j == 6 && break
+       end
+    end
+    a
+end
+""") == [(1, 3), (1, 4), (2, 3), (2, 4)]
 
 # continue
 @test JuliaLowering.include_string(test_mod, """

test/typedefs_ir.jl

@@ -409,6 +409,52 @@ end
 34  latestworld
 35  (return core.nothing)
 
+########################################
+# Empty struct with empty ctor
+struct X
+    X() = new()
+end
+#---------------------
+1   (global TestMod.X)
+2   latestworld
+3   (call core.svec)
+4   (call core.svec)
+5   (call core.svec)
+6   (call core._structtype TestMod :X %₃ %₄ %₅ false 0)
+7   (= slot₁/X %₆)
+8   (call core._setsuper! %₆ core.Any)
+9   (call core.isdefinedglobal TestMod :X false)
+10  (gotoifnot %₉ label₁₄)
+11  TestMod.X
+12  (= slot₂/if_val (call core._equiv_typedef %₁₁ %₆))
+13  (goto label₁₅)
+14  (= slot₂/if_val false)
+15  slot₂/if_val
+16  (gotoifnot %₁₅ label₂₀)
+17  TestMod.X
+18  (= slot₃/if_val %₁₇)
+19  (goto label₂₁)
+20  (= slot₃/if_val false)
+21  slot₃/if_val
+22  (gotoifnot %₁₅ label₂₃)
+23  (call core.svec)
+24  (call core._typebody! %₂₁ %₆ %₂₃)
+25  (constdecl TestMod.X %₂₄)
+26  latestworld
+27  TestMod.X
+28  (call core.apply_type core.Type %₂₇)
+29  (call core.svec %₂₈)
+30  (call core.svec)
+31  SourceLocation::2:5
+32  (call core.svec %₂₉ %₃₀ %₃₁)
+33  --- method core.nothing %₃₂
+    slots: [slot₁/#ctor-self#]
+    1   slot₁/#ctor-self#
+    2   (new %₁)
+    3   (return %₂)
+34  latestworld
+35  (return core.nothing)
+
 ########################################
 # Basic struct
 struct X