Fixed #420: use next to return from a captured block. return is d…

…isallowed in that case

spec/compiler/codegen/block_spec.cr

@@ -1280,4 +1280,36 @@ describe "Code gen: block" do
       $x
       )).to_i.should eq(1)
   end
+
+  it "returns from proc literal" do
+    run(%(
+      foo = ->{
+        if 1 == 1
+          return 10
+        end
+
+        20
+      }
+
+      foo.call
+      )).to_i.should eq(10)
+  end
+
+  it "does next from captured block" do
+    run(%(
+      def foo(&block : -> T)
+        block
+      end
+
+      f = foo do
+        if 1 == 1
+          next 10
+        end
+
+        next 20
+      end
+
+      f.call
+      )).to_i.should eq(10)
+  end
 end

spec/compiler/type_inference/block_spec.cr

@@ -975,4 +975,80 @@ describe "Block inference" do
       yielder { 1 }
       )) { int32.metaclass }
   end
+
+  it "returns from proc literal" do
+    assert_type(%(
+      foo = ->{
+        if 1 == 1
+          return 1
+        end
+
+        1.5
+      }
+
+      foo.call
+      )) { union_of int32, float64 }
+  end
+
+  it "errors if returns from captured block" do
+    assert_error %(
+      def foo(&block)
+        block
+      end
+
+      def bar
+        foo do
+          return
+        end
+      end
+
+      bar
+      ),
+      "can't return from captured block, use next"
+  end
+
+  it "errors if breaks from captured block" do
+    assert_error %(
+      def foo(&block)
+        block
+      end
+
+      def bar
+        foo do
+          break
+        end
+      end
+
+      bar
+      ),
+      "can't break from captured block"
+  end
+
+  it "errors if doing next in proc literal" do
+    assert_error %(
+      foo = ->{
+        next
+      }
+      foo.call
+      ),
+      "Invalid next"
+  end
+
+  it "does next from captured block" do
+    assert_type(%(
+      def foo(&block : -> T)
+        block
+      end
+
+      f = foo do
+        if 1 == 1
+          next 1
+        end
+
+        next 1.5
+      end
+
+      f.call
+      )) { union_of int32, float64 }
+  end
 end

src/compiler/crystal/codegen/codegen.cr

@@ -429,6 +429,12 @@ module Crystal
     def visit(node : Return)
       node_type = accept_control_expression(node)
 
+      codegen_return_node(node, node_type)
+
+      false
+    end
+
+    def codegen_return_node(node, node_type)
       old_last = @last
 
       execute_ensures_until(node.target as Def)
@@ -440,8 +446,6 @@ module Crystal
       else
         codegen_return node_type
       end
-
-      false
     end
 
     def codegen_return(type : NoReturnType | Nil)
@@ -655,7 +659,9 @@ module Crystal
         execute_ensures_until(node.target as While)
         br while_block
       else
-        node.raise "Bug: unknown exit for next"
+        # The only possibility is that we are in a captured block,
+        # so this is the same as a return
+        codegen_return_node(node, node_type)
       end
 
       false

src/compiler/crystal/semantic/ast.cr

@@ -251,6 +251,9 @@ module Crystal
     property :block_nest
     @block_nest = 0
 
+    property? :captured_block
+    @captured_block = false
+
     def macro_owner=(@macro_owner)
     end
 

src/compiler/crystal/semantic/call.cr

@@ -702,7 +702,10 @@ class Crystal::Call
             raise "wrong number of block arguments (#{block.args.size} for #{fun_args.size})"
           end
 
-          fun_literal = FunLiteral.new(Def.new("->", fun_args, block.body))
+          a_def = Def.new("->", fun_args, block.body)
+          a_def.captured_block = true
+
+          fun_literal = FunLiteral.new(a_def)
           fun_literal.force_void = true unless block_arg_restriction_output
           fun_literal.accept parent_visitor
         end

src/compiler/crystal/semantic/type_visitor.cr

@@ -1232,13 +1232,16 @@ module Crystal
     end
 
     def visit(node : Return)
-      node.raise "can't return from top level" unless @typed_def
+      typed_def = @typed_def || node.raise("can't return from top level")
+
+      if typed_def.captured_block?
+        node.raise "can't return from captured block, use next"
+      end
 
       node.exp.try &.accept self
 
-      node.target = @typed_def
+      node.target = typed_def
 
-      typed_def = @typed_def.not_nil!
       typed_def.bind_to(node.exp || mod.nil_var)
       @unreachable = true
 
@@ -1723,6 +1726,10 @@ module Crystal
         break_vars = (target_while.break_vars ||= [] of MetaVars)
         break_vars.push @vars.dup
       else
+        if @typed_def.try &.captured_block?
+          node.raise "can't break from captured block"
+        end
+
         node.raise "Invalid break"
       end
 
@@ -1742,7 +1749,13 @@ module Crystal
 
         bind_vars @vars, @while_vars
       else
-        node.raise "Invalid next"
+        typed_def = @typed_def
+        if typed_def && typed_def.captured_block?
+          node.target = typed_def
+          typed_def.bind_to(node.exp || mod.nil_var)
+        else
+          node.raise "Invalid next"
+        end
       end
 
       @unreachable = true