[Compiler] Compile boolean operators

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.InstructionJumpIfTrue:
+		ins.Target = newTarget
+		(*g.target)[offset] = ins
+
 	case opcode.InstructionJumpIfNil:
 		ins.Target = newTarget
 		(*g.target)[offset] = ins

bbq/compiler/compiler.go

@@ -262,6 +262,12 @@ func (c *Compiler[_]) emitUndefinedJumpIfFalse() int {
 	return offset
 }
 
+func (c *Compiler[_]) emitUndefinedJumpIfTrue() int {
+	offset := c.codeGen.Offset()
+	c.codeGen.Emit(opcode.InstructionJumpIfTrue{Target: math.MaxUint16})
+	return offset
+}
+
 func (c *Compiler[_]) emitUndefinedJumpIfNil() int {
 	offset := c.codeGen.Offset()
 	c.codeGen.Emit(opcode.InstructionJumpIfNil{Target: math.MaxUint16})
@@ -1282,6 +1288,44 @@ func (c *Compiler[_]) VisitBinaryExpression(expression *ast.BinaryExpression) (_
 		// End
 		c.patchJump(thenJump)
 
+	case ast.OperationOr:
+		// TODO: optimize chains of ors / ands
+
+		leftTrueJump := c.emitUndefinedJumpIfTrue()
+
+		c.compileExpression(expression.Right)
+		rightFalseJump := c.emitUndefinedJumpIfFalse()
+
+		// Left or right is true
+		c.patchJump(leftTrueJump)
+		c.codeGen.Emit(opcode.InstructionTrue{})
+		trueJump := c.emitUndefinedJump()
+
+		// Left and right are false
+		c.patchJump(rightFalseJump)
+		c.codeGen.Emit(opcode.InstructionFalse{})
+
+		c.patchJump(trueJump)
+
+	case ast.OperationAnd:
+		// TODO: optimize chains of ors / ands
+
+		leftFalseJump := c.emitUndefinedJumpIfFalse()
+
+		c.compileExpression(expression.Right)
+		rightFalseJump := c.emitUndefinedJumpIfFalse()
+
+		// Left and right are true
+		c.codeGen.Emit(opcode.InstructionTrue{})
+		trueJump := c.emitUndefinedJump()
+
+		// Left or right is false
+		c.patchJump(leftFalseJump)
+		c.patchJump(rightFalseJump)
+		c.codeGen.Emit(opcode.InstructionFalse{})
+
+		c.patchJump(trueJump)
+
 	default:
 		c.compileExpression(expression.Right)
 
@@ -1296,10 +1340,12 @@ func (c *Compiler[_]) VisitBinaryExpression(expression *ast.BinaryExpression) (_
 			c.codeGen.Emit(opcode.InstructionDivide{})
 		case ast.OperationMod:
 			c.codeGen.Emit(opcode.InstructionMod{})
+
 		case ast.OperationEqual:
 			c.codeGen.Emit(opcode.InstructionEqual{})
 		case ast.OperationNotEqual:
 			c.codeGen.Emit(opcode.InstructionNotEqual{})
+
 		case ast.OperationLess:
 			c.codeGen.Emit(opcode.InstructionLess{})
 		case ast.OperationLessEqual:

bbq/compiler/compiler_test.go

@@ -3637,3 +3637,117 @@ func TestCompileConditional(t *testing.T) {
 		program.Constants,
 	)
 }
+
+func TestCompileOr(t *testing.T) {
+
+	t.Parallel()
+
+	checker, err := ParseAndCheck(t, `
+      fun test(x: Bool, y: Bool): Bool {
+          return x || y
+      }
+    `)
+	require.NoError(t, err)
+
+	comp := compiler.NewInstructionCompiler(checker)
+	program := comp.Compile()
+
+	const parameterCount = 2
+
+	const (
+		// xIndex is the index of the parameter `x`, which is the first parameter
+		xIndex = iota
+		// yIndex is the index of the parameter `y`, which is the second parameter
+		yIndex
+	)
+
+	// resultIndex is the index of the $result variable
+	const resultIndex = parameterCount
+
+	require.Len(t, program.Functions, 1)
+
+	functions := comp.ExportFunctions()
+	require.Equal(t, len(program.Functions), len(functions))
+
+	assert.Equal(t,
+		[]opcode.Instruction{
+			// return x || y
+			opcode.InstructionGetLocal{LocalIndex: xIndex},
+			opcode.InstructionJumpIfTrue{Target: 4},
+
+			opcode.InstructionGetLocal{LocalIndex: yIndex},
+			opcode.InstructionJumpIfFalse{Target: 6},
+
+			opcode.InstructionTrue{},
+			opcode.InstructionJump{Target: 7},
+
+			opcode.InstructionFalse{},
+
+			// assign to temp $result
+			opcode.InstructionTransfer{TypeIndex: 0},
+			opcode.InstructionSetLocal{LocalIndex: resultIndex},
+
+			// return $result
+			opcode.InstructionGetLocal{LocalIndex: resultIndex},
+			opcode.InstructionReturnValue{},
+		},
+		functions[0].Code,
+	)
+}
+
+func TestCompileAnd(t *testing.T) {
+
+	t.Parallel()
+
+	checker, err := ParseAndCheck(t, `
+      fun test(x: Bool, y: Bool): Bool {
+          return x && y
+      }
+    `)
+	require.NoError(t, err)
+
+	comp := compiler.NewInstructionCompiler(checker)
+	program := comp.Compile()
+
+	const parameterCount = 2
+
+	const (
+		// xIndex is the index of the parameter `x`, which is the first parameter
+		xIndex = iota
+		// yIndex is the index of the parameter `y`, which is the second parameter
+		yIndex
+	)
+
+	// resultIndex is the index of the $result variable
+	const resultIndex = parameterCount
+
+	require.Len(t, program.Functions, 1)
+
+	functions := comp.ExportFunctions()
+	require.Equal(t, len(program.Functions), len(functions))
+
+	assert.Equal(t,
+		[]opcode.Instruction{
+			// return x && y
+			opcode.InstructionGetLocal{LocalIndex: xIndex},
+			opcode.InstructionJumpIfFalse{Target: 6},
+
+			opcode.InstructionGetLocal{LocalIndex: yIndex},
+			opcode.InstructionJumpIfFalse{Target: 6},
+
+			opcode.InstructionTrue{},
+			opcode.InstructionJump{Target: 7},
+
+			opcode.InstructionFalse{},
+
+			// assign to temp $result
+			opcode.InstructionTransfer{TypeIndex: 0},
+			opcode.InstructionSetLocal{LocalIndex: resultIndex},
+
+			// return $result
+			opcode.InstructionGetLocal{LocalIndex: resultIndex},
+			opcode.InstructionReturnValue{},
+		},
+		functions[0].Code,
+	)
+}

bbq/opcode/instructions.yml

@@ -400,6 +400,19 @@
       - name: "value"
         type: "value"
 
+- name: "jumpIfTrue"
+  description:
+    Pops a value off the stack. If it is `true`, jumps to the target instruction.
+  operands:
+    - name: "target"
+      type: "index"
+  controlEffects:
+    - jump: "target"
+  valueEffects:
+    pop:
+      - name: "value"
+        type: "value"
+
 - name: "jumpIfNil"
   description:
     Pops a value off the stack. If it is `nil`, jumps to the target instruction.

bbq/opcode/opcode.go

@@ -31,12 +31,12 @@ const (
 	ReturnValue
 	Jump
 	JumpIfFalse
+	JumpIfTrue
 	JumpIfNil
 	_
 	_
 	_
 	_
-	_
 
 	// Int operations