Add support for block arguments in methods (#21)

* Add support for block arguments in methods

* Fix regression in block methods requiring parens even without args

Author: mgomes

examples/blocks/yield_patterns.vibe

@@ -0,0 +1,42 @@
+# vibe: 0.2
+
+def times(n)
+  i = 0
+  while i < n
+    yield(i)
+    i = i + 1
+  end
+end
+
+def with_retry(max_attempts, delay_seconds)
+  attempt = 0
+  while attempt < max_attempts
+    result = yield(attempt)
+    if result
+      return result
+    end
+    attempt = attempt + 1
+  end
+  nil
+end
+
+def benchmark
+  start = Time.now
+  result = yield
+  elapsed = Time.now - start
+  { result: result, elapsed: elapsed }
+end
+
+def tap(value)
+  yield(value)
+  value
+end
+
+def transform_keys(hash)
+  result = {}
+  hash.keys.each do |key|
+    new_key = yield(key)
+    result[new_key] = hash[key]
+  end
+  result
+end

tests/blocks/error_cases.vibe

@@ -0,0 +1,19 @@
+def each_without_block
+  [1, 2, 3].each
+end
+
+def map_without_block
+  [1, 2, 3].map
+end
+
+def reduce_empty_without_init
+  [].reduce do |acc, x|
+    acc + x
+  end
+end
+
+def reduce_empty_with_init
+  [].reduce(10) do |acc, x|
+    acc + x
+  end
+end

tests/complex/advanced_blocks.vibe

@@ -0,0 +1,39 @@
+def call_with_three
+  yield(1, 2, 3)
+end
+
+def nested_sum(arr)
+  total = 0
+  arr.each do |x|
+    arr.each do |y|
+      total = total + yield(x, y)
+    end
+  end
+  total
+end
+
+def yield_one
+  yield(7)
+end
+
+def run
+  captured = []
+  call_with_three do |a, b|
+    captured = [a, b]
+    a + b
+  end
+
+  nested = nested_sum([1, 2, 3]) do |x, y|
+    x * y
+  end
+
+  defaulted = yield_one do |a, b|
+    if b == nil
+      a
+    else
+      a + b
+    end
+  end
+
+  { captured: captured, nested: nested, defaulted: defaulted }
+end

tests/complex/with_blocks.vibe

@@ -0,0 +1,52 @@
+class Collection
+  def initialize(items)
+    @items = items
+  end
+
+  def each
+    @items.each do |item|
+      yield(item)
+    end
+  end
+
+  def map_items
+    result = []
+    @items.each do |item|
+      result = result.push(yield(item))
+    end
+    result
+  end
+
+  def find
+    result = nil
+    done = false
+    @items.each do |item|
+      if done == false
+        if yield(item)
+          result = item
+          done = true
+        end
+      end
+    end
+    result
+  end
+end
+
+def run
+  coll = Collection.new([1, 2, 3, 4, 5])
+
+  sum = 0
+  coll.each do |x|
+    sum = sum + x
+  end
+
+  doubled = coll.map_items do |x|
+    x * 2
+  end
+
+  first_even = coll.find do |x|
+    x % 2 == 0
+  end
+
+  { sum: sum, doubled: doubled, first_even: first_even }
+end

tests/complex/yield_basics.vibe

@@ -0,0 +1,29 @@
+def twice
+  yield
+  yield
+end
+
+def with_value(val)
+  yield(val)
+end
+
+def transform(a, b)
+  yield(a) + yield(b)
+end
+
+def run
+  count = 0
+  twice do
+    count = count + 1
+  end
+
+  doubled = with_value(21) do |x|
+    x * 2
+  end
+
+  sum = transform(3, 4) do |n|
+    n * 10
+  end
+
+  { count: count, doubled: doubled, sum: sum }
+end

vibes/ast.go

@@ -259,6 +259,14 @@ type BlockLiteral struct {
 func (b *BlockLiteral) exprNode()     {}
 func (b *BlockLiteral) Pos() Position { return b.position }
 
+type YieldExpr struct {
+	Args     []Expression
+	position Position
+}
+
+func (y *YieldExpr) exprNode()     {}
+func (y *YieldExpr) Pos() Position { return y.position }
+
 type PropertyDecl struct {
 	Names    []string
 	Kind     string // property/getter/setter

vibes/execution.go

@@ -263,7 +263,7 @@ func (exec *Execution) assign(target Expression, value Value, env *Env) error {
 				if fn.Private && !exec.isCurrentReceiver(obj) {
 					return exec.errorAt(t.Pos(), "private method %s", setterName)
 				}
-				_, err := exec.callFunction(fn, obj, []Value{value}, nil, t.Pos())
+				_, err := exec.callFunction(fn, obj, []Value{value}, nil, NewNil(), t.Pos())
 				return err
 			}
 			if _, hasGetter := obj.Instance().Class.Methods[t.Property]; hasGetter {
@@ -278,7 +278,7 @@ func (exec *Execution) assign(target Expression, value Value, env *Env) error {
 				if fn.Private && !exec.isCurrentReceiver(obj) {
 					return exec.errorAt(t.Pos(), "private method %s", setterName)
 				}
-				_, err := exec.callFunction(fn, obj, []Value{value}, nil, t.Pos())
+				_, err := exec.callFunction(fn, obj, []Value{value}, nil, NewNil(), t.Pos())
 				return err
 			}
 			if _, hasGetter := cl.ClassMethods[t.Property]; hasGetter {
@@ -531,6 +531,8 @@ func (exec *Execution) evalExpressionWithAuto(expr Expression, env *Env, autoCal
 		return exec.evalCallExpr(e, env)
 	case *BlockLiteral:
 		return exec.evalBlockLiteral(e, env)
+	case *YieldExpr:
+		return exec.evalYield(e, env)
 	default:
 		return NewNil(), exec.errorAt(expr.Pos(), "unsupported expression")
 	}
@@ -556,10 +558,7 @@ func (exec *Execution) invokeCallable(callee Value, receiver Value, args []Value
 	switch callee.Kind() {
 	case KindFunction:
 		fn := callee.Function()
-		if block.Kind() != KindNil {
-			return NewNil(), exec.errorAt(pos, "script functions do not accept blocks")
-		}
-		return exec.callFunction(fn, receiver, args, kwargs, pos)
+		return exec.callFunction(fn, receiver, args, kwargs, block, pos)
 	case KindBuiltin:
 		result, err := callee.Builtin().Fn(exec, receiver, args, kwargs, block)
 		if err != nil {
@@ -571,11 +570,12 @@ func (exec *Execution) invokeCallable(callee Value, receiver Value, args []Value
 	}
 }
 
-func (exec *Execution) callFunction(fn *ScriptFunction, receiver Value, args []Value, kwargs map[string]Value, pos Position) (Value, error) {
+func (exec *Execution) callFunction(fn *ScriptFunction, receiver Value, args []Value, kwargs map[string]Value, block Value, pos Position) (Value, error) {
 	callEnv := newEnv(fn.Env)
 	if receiver.Kind() != KindNil {
 		callEnv.Define("self", receiver)
 	}
+	callEnv.Define("__block__", block)
 	if err := exec.bindFunctionArgs(fn, callEnv, args, kwargs, pos); err != nil {
 		return NewNil(), err
 	}
@@ -729,6 +729,22 @@ func (exec *Execution) callBlock(block Value, args []Value) (Value, error) {
 	return val, nil
 }
 
+func (exec *Execution) evalYield(expr *YieldExpr, env *Env) (Value, error) {
+	block, ok := env.Get("__block__")
+	if !ok || block.Kind() == KindNil {
+		return NewNil(), exec.errorAt(expr.Pos(), "no block given")
+	}
+	var args []Value
+	for _, arg := range expr.Args {
+		val, err := exec.evalExpression(arg, env)
+		if err != nil {
+			return NewNil(), err
+		}
+		args = append(args, val)
+	}
+	return exec.callBlock(block, args)
+}
+
 func (exec *Execution) evalRangeExpr(expr *RangeExpr, env *Env) (Value, error) {
 	startVal, err := exec.evalExpression(expr.Start, env)
 	if err != nil {
@@ -829,13 +845,10 @@ func (exec *Execution) getMember(obj Value, property string, pos Position) (Valu
 		cl := obj.Class()
 		if property == "new" {
 			return NewAutoBuiltin(cl.Name+".new", func(exec *Execution, receiver Value, args []Value, kwargs map[string]Value, block Value) (Value, error) {
-				if block.Kind() != KindNil {
-					return NewNil(), fmt.Errorf("script functions do not accept blocks")
-				}
 				inst := &Instance{Class: cl, Ivars: make(map[string]Value)}
 				instVal := NewInstance(inst)
 				if initFn, ok := cl.Methods["initialize"]; ok {
-					if _, err := exec.callFunction(initFn, instVal, args, kwargs, pos); err != nil {
+					if _, err := exec.callFunction(initFn, instVal, args, kwargs, block, pos); err != nil {
 						return NewNil(), err
 					}
 				}
@@ -847,10 +860,7 @@ func (exec *Execution) getMember(obj Value, property string, pos Position) (Valu
 				return NewNil(), exec.errorAt(pos, "private method %s", property)
 			}
 			return NewAutoBuiltin(cl.Name+"."+property, func(exec *Execution, receiver Value, args []Value, kwargs map[string]Value, block Value) (Value, error) {
-				if block.Kind() != KindNil {
-					return NewNil(), fmt.Errorf("script functions do not accept blocks")
-				}
-				return exec.callFunction(fn, obj, args, kwargs, pos)
+				return exec.callFunction(fn, obj, args, kwargs, block, pos)
 			}), nil
 		}
 		if val, ok := cl.ClassVars[property]; ok {
@@ -867,10 +877,7 @@ func (exec *Execution) getMember(obj Value, property string, pos Position) (Valu
 				return NewNil(), exec.errorAt(pos, "private method %s", property)
 			}
 			return NewAutoBuiltin(inst.Class.Name+"#"+property, func(exec *Execution, receiver Value, args []Value, kwargs map[string]Value, block Value) (Value, error) {
-				if block.Kind() != KindNil {
-					return NewNil(), fmt.Errorf("script functions do not accept blocks")
-				}
-				return exec.callFunction(fn, obj, args, kwargs, pos)
+				return exec.callFunction(fn, obj, args, kwargs, block, pos)
 			}), nil
 		}
 		if val, ok := inst.Ivars[property]; ok {
@@ -1149,7 +1156,7 @@ func arrayMember(array Value, property string) (Value, error) {
 			return NewInt(int64(len(receiver.Array()))), nil
 		}), nil
 	case "each":
-		return NewBuiltin("array.each", func(exec *Execution, receiver Value, args []Value, kwargs map[string]Value, block Value) (Value, error) {
+		return NewAutoBuiltin("array.each", func(exec *Execution, receiver Value, args []Value, kwargs map[string]Value, block Value) (Value, error) {
 			if block.Block() == nil {
 				return NewNil(), fmt.Errorf("array.each requires a block")
 			}
@@ -1161,7 +1168,7 @@ func arrayMember(array Value, property string) (Value, error) {
 			return receiver, nil
 		}), nil
 	case "map":
-		return NewBuiltin("array.map", func(exec *Execution, receiver Value, args []Value, kwargs map[string]Value, block Value) (Value, error) {
+		return NewAutoBuiltin("array.map", func(exec *Execution, receiver Value, args []Value, kwargs map[string]Value, block Value) (Value, error) {
 			if block.Block() == nil {
 				return NewNil(), fmt.Errorf("array.map requires a block")
 			}
@@ -1177,7 +1184,7 @@ func arrayMember(array Value, property string) (Value, error) {
 			return NewArray(result), nil
 		}), nil
 	case "select":
-		return NewBuiltin("array.select", func(exec *Execution, receiver Value, args []Value, kwargs map[string]Value, block Value) (Value, error) {
+		return NewAutoBuiltin("array.select", func(exec *Execution, receiver Value, args []Value, kwargs map[string]Value, block Value) (Value, error) {
 			if block.Block() == nil {
 				return NewNil(), fmt.Errorf("array.select requires a block")
 			}
@@ -1195,7 +1202,7 @@ func arrayMember(array Value, property string) (Value, error) {
 			return NewArray(out), nil
 		}), nil
 	case "reduce":
-		return NewBuiltin("array.reduce", func(exec *Execution, receiver Value, args []Value, kwargs map[string]Value, block Value) (Value, error) {
+		return NewAutoBuiltin("array.reduce", func(exec *Execution, receiver Value, args []Value, kwargs map[string]Value, block Value) (Value, error) {
 			if block.Block() == nil {
 				return NewNil(), fmt.Errorf("array.reduce requires a block")
 			}