compile if-let statements, add JumpIfNil instruction

bbq/compiler/codegen.go

@@ -82,6 +82,10 @@ func (g *InstructionCodeGen) PatchJump(offset int, newTarget uint16) {
 		ins.Target = newTarget
 		(*g.target)[offset] = ins
 
+	case opcode.InstructionJumpIfNil:
+		ins.Target = newTarget
+		(*g.target)[offset] = ins
+
 	default:
 		panic(errors.NewUnreachableError())
 	}

bbq/compiler/compiler.go

@@ -250,6 +250,12 @@ func (c *Compiler[_]) emitUndefinedJumpIfFalse() int {
 	return offset
 }
 
+func (c *Compiler[_]) emitUndefinedJumpIfNil() int {
+	offset := c.codeGen.Offset()
+	c.codeGen.Emit(opcode.InstructionJumpIfNil{Target: math.MaxUint16})
+	return offset
+}
+
 func (c *Compiler[_]) patchJump(opcodeOffset int) {
 	count := c.codeGen.Offset()
 	if count == 0 {
@@ -570,14 +576,33 @@ func (c *Compiler[_]) VisitContinueStatement(_ *ast.ContinueStatement) (_ struct
 
 func (c *Compiler[_]) VisitIfStatement(statement *ast.IfStatement) (_ struct{}) {
 	// TODO: scope
+	var elseJump int
 	switch test := statement.Test.(type) {
 	case ast.Expression:
 		c.compileExpression(test)
+		elseJump = c.emitUndefinedJumpIfFalse()
+
+	case *ast.VariableDeclaration:
+		// TODO: second value
+		c.compileExpression(test.Value)
+
+		tempIndex := c.currentFunction.generateLocalIndex()
+		c.codeGen.Emit(opcode.InstructionSetLocal{LocalIndex: tempIndex})
+
+		c.codeGen.Emit(opcode.InstructionGetLocal{LocalIndex: tempIndex})
+		elseJump = c.emitUndefinedJumpIfNil()
+
+		c.codeGen.Emit(opcode.InstructionGetLocal{LocalIndex: tempIndex})
+		c.codeGen.Emit(opcode.InstructionUnwrap{})
+		varDeclTypes := c.ExtendedElaboration.VariableDeclarationTypes(test)
+		c.emitTransfer(varDeclTypes.TargetType)
+		local := c.currentFunction.declareLocal(test.Identifier.Identifier)
+		c.codeGen.Emit(opcode.InstructionSetLocal{LocalIndex: local.index})
+
 	default:
-		// TODO:
 		panic(errors.NewUnreachableError())
 	}
-	elseJump := c.emitUndefinedJumpIfFalse()
+
 	c.compileBlock(statement.Then)
 	elseBlock := statement.Else
 	if elseBlock != nil {
@@ -588,6 +613,7 @@ func (c *Compiler[_]) VisitIfStatement(statement *ast.IfStatement) (_ struct{})
 	} else {
 		c.patchJump(elseJump)
 	}
+
 	return
 }
 

bbq/compiler/compiler_test.go

@@ -21,6 +21,7 @@ package compiler
 import (
 	"testing"
 
+	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
 	"github.com/onflow/cadence/bbq"
@@ -457,3 +458,64 @@ func TestCompileDictionary(t *testing.T) {
 		program.Constants,
 	)
 }
+
+func TestCompileIfLet(t *testing.T) {
+
+	t.Parallel()
+
+	checker, err := ParseAndCheck(t, `
+      fun test(x: Int?): Int {
+          if let y = x {
+             return y
+          } else {
+             return 2
+          }
+      }
+    `)
+	require.NoError(t, err)
+
+	compiler := NewInstructionCompiler(checker)
+	program := compiler.Compile()
+
+	require.Len(t, program.Functions, 1)
+
+	assert.Equal(t,
+		[]opcode.Instruction{
+			// let y = x
+			opcode.InstructionGetLocal{LocalIndex: 0x0},
+			opcode.InstructionSetLocal{LocalIndex: 0x1},
+
+			// if
+			opcode.InstructionGetLocal{LocalIndex: 0x1},
+			opcode.InstructionJumpIfNil{Target: 11},
+
+			// let y = x
+			opcode.InstructionGetLocal{LocalIndex: 0x1},
+			opcode.InstructionUnwrap{},
+			opcode.InstructionTransfer{TypeIndex: 0x0},
+			opcode.InstructionSetLocal{LocalIndex: 0x2},
+
+			// then { return y }
+			opcode.InstructionGetLocal{LocalIndex: 0x2},
+			opcode.InstructionReturnValue{},
+			opcode.InstructionJump{Target: 13},
+
+			// else { return 2 }
+			opcode.InstructionGetConstant{ConstantIndex: 0x0},
+			opcode.InstructionReturnValue{},
+
+			opcode.InstructionReturn{},
+		},
+		compiler.ExportFunctions()[0].Code,
+	)
+
+	assert.Equal(t,
+		[]*bbq.Constant{
+			{
+				Data: []byte{0x2},
+				Kind: constantkind.Int,
+			},
+		},
+		program.Constants,
+	)
+}

bbq/compiler/function.go

@@ -43,12 +43,17 @@ func newFunction[E any](name string, parameterCount uint16, isCompositeFunction
 	}
 }
 
+func (f *function[E]) generateLocalIndex() uint16 {
+	index := f.localCount
+	f.localCount++
+	return index
+}
+
 func (f *function[E]) declareLocal(name string) *local {
 	if f.localCount == math.MaxUint16 {
 		panic(errors.NewDefaultUserError("invalid local declaration"))
 	}
-	index := f.localCount
-	f.localCount++
+	index := f.generateLocalIndex()
 	local := &local{index: index}
 	f.locals.Set(name, local)
 	return local

bbq/opcode/instructions.yml

@@ -334,6 +334,22 @@
       type: "index"
   controlEffects:
     - jump: "target"
+  valueEffects:
+    pop:
+      - name: "value"
+        type: "value"
+
+- name: "jumpIfNil"
+  description: Jumps to the given instruction, if the top value on the stack is `nil`.
+  operands:
+    - name: "target"
+      type: "index"
+  controlEffects:
+    - jump: "target"
+  valueEffects:
+    pop:
+      - name: "value"
+        type: "value"
 
 - name: "return"
   description: Returns from the current function, without a value.

bbq/opcode/opcode.go

@@ -31,7 +31,7 @@ const (
 	ReturnValue
 	Jump
 	JumpIfFalse
-	_
+	JumpIfNil
 	_
 	_
 	_

bbq/vm/test/vm_test.go

@@ -3184,3 +3184,51 @@ func TestFunctionPostConditions(t *testing.T) {
 		assert.Equal(t, []string{"A", "D", "F", "E", "C", "B"}, logs)
 	})
 }
+
+func TestIfLet(t *testing.T) {
+
+	t.Parallel()
+
+	t.Run("some", func(t *testing.T) {
+
+		t.Parallel()
+
+		result, err := compileAndInvoke(t, `
+			  fun main(x: Int?): Int {
+                  if let y = x {
+                     return y
+                  } else {
+                     return 2
+                  }
+              }
+            `,
+			"main",
+			vm.NewSomeValueNonCopying(
+				vm.NewIntValue(1),
+			),
+		)
+		require.NoError(t, err)
+		assert.Equal(t, vm.NewIntValue(1), result)
+	})
+
+	t.Run("nil", func(t *testing.T) {
+
+		t.Parallel()
+
+		result, err := compileAndInvoke(t, `
+            fun main(x: Int?): Int {
+                  if let y = x {
+                     return y
+                  } else {
+                     return 2
+                  }
+              }
+            `,
+			"main",
+			vm.NilValue{},
+		)
+
+		require.NoError(t, err)
+		assert.Equal(t, vm.NewIntValue(2), result)
+	})
+}

bbq/vm/vm.go

@@ -344,6 +344,13 @@ func opJumpIfFalse(vm *VM, ins opcode.InstructionJumpIfFalse) {
 	}
 }
 
+func opJumpIfNil(vm *VM, ins opcode.InstructionJumpIfNil) {
+	_, ok := vm.pop().(NilValue)
+	if ok {
+		vm.ip = ins.Target
+	}
+}
+
 func opBinaryIntAdd(vm *VM) {
 	left, right := vm.peekPop()
 	leftNumber := left.(IntValue)
@@ -698,6 +705,8 @@ func (vm *VM) run() {
 			opJump(vm, ins)
 		case opcode.InstructionJumpIfFalse:
 			opJumpIfFalse(vm, ins)
+		case opcode.InstructionJumpIfNil:
+			opJumpIfNil(vm, ins)
 		case opcode.InstructionIntAdd:
 			opBinaryIntAdd(vm)
 		case opcode.InstructionIntSubtract: