[Compiler] Compile and execute emit statement

bbq/compiler/compiler.go

@@ -634,9 +634,15 @@ func (c *Compiler[_]) VisitForStatement(_ *ast.ForStatement) (_ struct{}) {
 	panic(errors.NewUnreachableError())
 }
 
-func (c *Compiler[_]) VisitEmitStatement(_ *ast.EmitStatement) (_ struct{}) {
-	// TODO
-	panic(errors.NewUnreachableError())
+func (c *Compiler[_]) VisitEmitStatement(statement *ast.EmitStatement) (_ struct{}) {
+	c.compileExpression(statement.InvocationExpression)
+	eventType := c.ExtendedElaboration.EmitStatementEventType(statement)
+	typeIndex := c.getOrAddType(eventType)
+	c.codeGen.Emit(opcode.InstructionEmitEvent{
+		TypeIndex: typeIndex,
+	})
+
+	return
 }
 
 func (c *Compiler[_]) VisitSwitchStatement(statement *ast.SwitchStatement) (_ struct{}) {

bbq/compiler/compiler_test.go

@@ -654,3 +654,44 @@ func TestCompileSwitch(t *testing.T) {
 		program.Constants,
 	)
 }
+
+func TestCompileEmit(t *testing.T) {
+
+	t.Parallel()
+
+	checker, err := ParseAndCheck(t, `
+      event Inc(val: Int)
+
+      fun test(x: Int) {
+          emit Inc(val: x)
+      }
+    `)
+	require.NoError(t, err)
+
+	compiler := NewInstructionCompiler(checker)
+	program := compiler.Compile()
+
+	require.Len(t, program.Functions, 2)
+
+	var testFunction *bbq.Function[opcode.Instruction]
+	for _, f := range compiler.ExportFunctions() {
+		if f.Name == "test" {
+			testFunction = f
+		}
+	}
+	require.NotNil(t, testFunction)
+
+	assert.Equal(t,
+		[]opcode.Instruction{
+			opcode.InstructionGetLocal{LocalIndex: 0},
+			opcode.InstructionTransfer{TypeIndex: 0},
+			opcode.InstructionGetGlobal{GlobalIndex: 1},
+			opcode.InstructionInvoke{},
+			opcode.InstructionEmitEvent{TypeIndex: 1},
+			opcode.InstructionReturn{},
+		},
+		testFunction.Code,
+	)
+
+	assert.Empty(t, program.Constants)
+}

bbq/compiler/extended_elaboration.go

@@ -230,6 +230,10 @@ func (e *ExtendedElaboration) CastingExpressionTypes(expression *ast.CastingExpr
 	return e.elaboration.CastingExpressionTypes(expression)
 }
 
+func (e *ExtendedElaboration) EmitStatementEventType(statement *ast.EmitStatement) *sema.CompositeType {
+	return e.elaboration.EmitStatementEventType(statement)
+}
+
 func (e *ExtendedElaboration) ResultVariableType(enclosingBlock ast.Element) (typ sema.Type, exist bool) {
 	if e.resultVariableTypes != nil {
 		types, ok := e.resultVariableTypes[enclosingBlock]

bbq/opcode/instructions.yml

@@ -572,3 +572,16 @@
     push:
       - name: "result"
         type: "bool"
+
+# Other
+
+- name: "emitEvent"
+  description:
+    Pops an event off the stack and then emits it.
+  operands:
+    - name: "typeIndex"
+      type: "index"
+  valueEffects:
+    pop:
+      - name: "event"
+        type: "value"

bbq/opcode/opcode.go

@@ -142,4 +142,10 @@ const (
 	_
 	_
 	_
+	_
+	_
+	_
+
+	// Other
+	EmitEvent
 )

bbq/vm/config.go

@@ -27,6 +27,12 @@ import (
 	"github.com/onflow/cadence/test_utils/common_utils"
 )
 
+// OnEventEmittedFunc is a function that is triggered when an event is emitted by the program.
+type OnEventEmittedFunc func(
+	event *CompositeValue,
+	eventType *interpreter.CompositeStaticType,
+) error
+
 type Config struct {
 	interpreter.Storage
 	common.MemoryGauge
@@ -41,6 +47,9 @@ type Config struct {
 	MutationDuringCapabilityControllerIteration bool
 	referencedResourceKindedValues              ReferencedResourceKindedValues
 
+	// OnEventEmitted is triggered when an event is emitted by the program
+	OnEventEmitted OnEventEmittedFunc
+
 	// TODO: These are temporary. Remove once storing/reading is supported for VM values.
 	inter      *interpreter.Interpreter
 	TypeLoader func(location common.Location, typeID interpreter.TypeID) sema.CompositeKindedType

bbq/vm/test/vm_test.go

@@ -3645,3 +3645,41 @@ func TestDefaultFunctionsWithConditions(t *testing.T) {
 		)
 	})
 }
+
+func TestCompileEmit(t *testing.T) {
+
+	t.Parallel()
+
+	var eventEmitted bool
+
+	vmConfig := vm.NewConfig(interpreter.NewInMemoryStorage(nil))
+	vmConfig.OnEventEmitted = func(event *vm.CompositeValue, eventType *interpreter.CompositeStaticType) error {
+		require.False(t, eventEmitted)
+		eventEmitted = true
+
+		assert.Equal(t,
+			common.ScriptLocation{0x1}.TypeID(nil, "Inc"),
+			eventType.ID(),
+		)
+
+		return nil
+	}
+
+	_, err := compileAndInvokeWithOptions(t,
+		`
+          event Inc(val: Int)
+
+          fun test(x: Int) {
+              emit Inc(val: x)
+          }
+        `,
+		"test",
+		CompilerAndVMOptions{
+			VMConfig: vmConfig,
+		},
+		vm.NewIntValue(1),
+	)
+	require.NoError(t, err)
+
+	require.True(t, eventEmitted)
+}

bbq/vm/vm.go

@@ -804,6 +804,8 @@ func (vm *VM) run() {
 			opNot(vm)
 		case opcode.InstructionUnwrap:
 			opUnwrap(vm)
+		case opcode.InstructionEmitEvent:
+			onEmitEvent(vm, ins)
 		default:
 			panic(errors.NewUnexpectedError("cannot execute instruction of type %T", ins))
 		}
@@ -813,6 +815,22 @@ func (vm *VM) run() {
 	}
 }
 
+func onEmitEvent(vm *VM, ins opcode.InstructionEmitEvent) {
+	eventValue := vm.pop().(*CompositeValue)
+
+	onEventEmitted := vm.config.OnEventEmitted
+	if onEventEmitted == nil {
+		return
+	}
+
+	eventType := vm.loadType(ins.TypeIndex).(*interpreter.CompositeStaticType)
+
+	err := onEventEmitted(eventValue, eventType)
+	if err != nil {
+		panic(err)
+	}
+}
+
 func (vm *VM) initializeConstant(index uint16) (value Value) {
 	executable := vm.callFrame.executable