Interpreting for default events

runtime/environment.go

@@ -981,7 +981,7 @@ func (e *interpreterEnvironment) newCompositeValueFunctionsHandler() interpreter
 		inter *interpreter.Interpreter,
 		locationRange interpreter.LocationRange,
 		compositeValue *interpreter.CompositeValue,
-	) map[string]interpreter.FunctionValue {
+	) *interpreter.FunctionOrderedMap {
 
 		handler := e.compositeValueFunctionsHandlers[compositeValue.TypeID()]
 		if handler == nil {

runtime/interpreter/interpreter.go

@@ -37,6 +37,7 @@
 	"github.com/onflow/cadence/runtime/activations"
 	"github.com/onflow/cadence/runtime/ast"
 	"github.com/onflow/cadence/runtime/common"
+	"github.com/onflow/cadence/runtime/common/orderedmap"
 	"github.com/onflow/cadence/runtime/errors"
 	"github.com/onflow/cadence/runtime/sema"
 )
@@ -165,7 +166,7 @@
 	inter *Interpreter,
 	locationRange LocationRange,
 	compositeValue *CompositeValue,
-) map[string]FunctionValue
+) *FunctionOrderedMap
 
 // CompositeTypeCode contains the "prepared" / "callable" "code"
 // for the functions and the destructor of a composite
@@ -174,7 +175,7 @@
 // As there is no support for inheritance of concrete types,
 // these are the "leaf" nodes in the call chain, and are functions.
 type CompositeTypeCode struct {
-	CompositeFunctions map[string]FunctionValue
+	CompositeFunctions *FunctionOrderedMap
 }
 
 type FunctionWrapper = func(inner FunctionValue) FunctionValue
@@ -185,9 +186,10 @@
 // These are "branch" nodes in the call chain, and are function wrappers,
 // i.e. they wrap the functions / function wrappers that inherit them.
 type WrapperCode struct {
-	InitializerFunctionWrapper FunctionWrapper
-	FunctionWrappers           map[string]FunctionWrapper
-	Functions                  map[string]FunctionValue
+	InitializerFunctionWrapper     FunctionWrapper
+	FunctionWrappers               map[string]FunctionWrapper
+	Functions                      *FunctionOrderedMap
+	DefaultDestroyEventConstructor FunctionValue
 }
 
 // TypeCodes is the value which stores the "prepared" / "callable" "code"
@@ -978,6 +980,47 @@
 	return interpreter.declareCompositeValue(declaration, lexicalScope)
 }
 
+// evaluates all the implicit default arguments to the default destroy event
+//
+// the handling of default arguments makes a number of assumptions to simplify the implementation;
+// namely that a) all default arguments are lazily evaluated at the site of the invocation,
+// b) that either all the parameters or none of the parameters of a function have default arguments,
+// and c) functions cannot currently be explicitly invoked if they have default arguments
+//
+// if we plan to generalize this further, we will need to relax those assumptions
+func (interpreter *Interpreter) evaluateDefaultDestroyEvent(
+	containerComposite *CompositeValue,
+	compositeDecl *ast.CompositeDeclaration,
+	compositeType *sema.CompositeType,
+	locationRange LocationRange,
+) (arguments []Value) {
+	parameters := compositeDecl.DeclarationMembers().Initializers()[0].FunctionDeclaration.ParameterList.Parameters
+
+	interpreter.activations.PushNewWithParent(interpreter.activations.CurrentOrNew())
+	defer interpreter.activations.Pop()
+
+	var self MemberAccessibleValue = containerComposite
+	if containerComposite.Kind == common.CompositeKindAttachment {
+		var base *EphemeralReferenceValue
+		base, self = attachmentBaseAndSelfValues(interpreter, containerComposite)
+		interpreter.declareVariable(sema.BaseIdentifier, base)
+	}
+	interpreter.declareVariable(sema.SelfIdentifier, self)
+
+	for _, parameter := range parameters {
+		// lazily evaluate the default argument expressions
+		// note that we must evaluate them in the interpreter context that existed when the event
+		// was defined (i.e. the contract defining the resource) rather than the interpreter context
+		// that exists when the resource is destroyed. We accomplish this by using the original interpreter of the
+		// composite declaration, rather than the interpreter of the destroy expression
+
+		defaultArg := interpreter.evalExpression(parameter.DefaultArgument)
+		arguments = append(arguments, defaultArg)
+	}
+
+	return
+}
+
 // declareCompositeValue creates and declares the value for
 // the composite declaration.
 //
@@ -1027,6 +1070,8 @@
 
 	nestedVariables := map[string]*Variable{}
 
+	var destroyEventConstructor FunctionValue
+
 	(func() {
 		interpreter.activations.PushNewWithCurrent()
 		defer interpreter.activations.Pop()
@@ -1073,6 +1118,11 @@
 
 			memberIdentifier := nestedCompositeDeclaration.Identifier.Identifier
 			nestedVariables[memberIdentifier] = nestedVariable
+
+			// statically we know there is at most one of these
+			if nestedCompositeDeclaration.IsResourceDestructionDefaultEvent() {
+				destroyEventConstructor = nestedVariable.GetValue().(FunctionValue)
+			}
 		}
 
 		for _, nestedAttachmentDeclaration := range members.Attachments() {
@@ -1107,6 +1157,23 @@
 				locationRange := invocation.LocationRange
 				self := *invocation.Self
 
+				if len(compositeType.ConstructorParameters) < 1 {
+					return nil
+				}
+
+				// event interfaces do not exist
+				compositeDecl := declaration.(*ast.CompositeDeclaration)
+				if compositeDecl.IsResourceDestructionDefaultEvent() {
+					// we implicitly pass the containing composite value as an argument to this invocation
+					containerComposite := invocation.Arguments[0].(*CompositeValue)
+					invocation.Arguments = interpreter.evaluateDefaultDestroyEvent(
+						containerComposite,
+						compositeDecl,
+						compositeType,
+						locationRange,
+					)
+				}
+
 				for i, argument := range invocation.Arguments {
 					parameter := compositeType.ConstructorParameters[i]
 					self.SetMember(
@@ -1128,7 +1195,11 @@
 
 	functions := interpreter.compositeFunctions(declaration, lexicalScope)
 
-	wrapFunctions := func(code WrapperCode) {
+	if destroyEventConstructor != nil {
+		functions.Set(resourceDefaultDestroyEventName(compositeType), destroyEventConstructor)
+	}
+
+	wrapFunctions := func(ty *sema.InterfaceType, code WrapperCode) {
 
 		// Wrap initializer
 
@@ -1145,14 +1216,16 @@
 		// we only apply the function wrapper to each function,
 		// the order does not matter.
 
-		for name, function := range code.Functions { //nolint:maprange
-			if functions[name] != nil {
-				continue
-			}
-			if functions == nil {
-				functions = map[string]FunctionValue{}
-			}
-			functions[name] = function
+		if code.Functions != nil {
+			code.Functions.Foreach(func(name string, function FunctionValue) {
+				if functions == nil {
+					functions = orderedmap.New[FunctionOrderedMap](code.Functions.Len())
+				}
+				if functions.Contains(name) {
+					return
+				}
+				functions.Set(name, function)
+			})
 		}
 
 		// Wrap functions
@@ -1162,14 +1235,19 @@
 		// the order does not matter.
 
 		for name, functionWrapper := range code.FunctionWrappers { //nolint:maprange
-			functions[name] = functionWrapper(functions[name])
+			fn, _ := functions.Get(name)
+			functions.Set(name, functionWrapper(fn))
+		}
+
+		if code.DefaultDestroyEventConstructor != nil {
+			functions.Set(resourceDefaultDestroyEventName(ty), code.DefaultDestroyEventConstructor)
 		}
 	}
 
 	conformances := compositeType.EffectiveInterfaceConformances()
 	for i := len(conformances) - 1; i >= 0; i-- {
 		conformance := conformances[i].InterfaceType
-		wrapFunctions(interpreter.SharedState.typeCodes.InterfaceCodes[conformance.ID()])
+		wrapFunctions(conformance, interpreter.SharedState.typeCodes.InterfaceCodes[conformance.ID()])
 	}
 
 	interpreter.SharedState.typeCodes.CompositeCodes[compositeType.ID()] = CompositeTypeCode{
@@ -1520,7 +1598,7 @@
 func (interpreter *Interpreter) defaultFunctions(
 	members *ast.Members,
 	lexicalScope *VariableActivation,
-) map[string]FunctionValue {
+) *FunctionOrderedMap {
 
 	functionDeclarations := members.Functions()
 	functionCount := len(functionDeclarations)
@@ -1529,17 +1607,20 @@
 		return nil
 	}
 
-	functions := make(map[string]FunctionValue, functionCount)
+	functions := orderedmap.New[FunctionOrderedMap](functionCount)
 
 	for _, functionDeclaration := range functionDeclarations {
 		name := functionDeclaration.Identifier.Identifier
 		if !functionDeclaration.FunctionBlock.HasStatements() {
 			continue
 		}
 
-		functions[name] = interpreter.compositeFunction(
-			functionDeclaration,
-			lexicalScope,
+		functions.Set(
+			name,
+			interpreter.compositeFunction(
+				functionDeclaration,
+				lexicalScope,
+			),
 		)
 	}
 
@@ -1549,17 +1630,19 @@
 func (interpreter *Interpreter) compositeFunctions(
 	compositeDeclaration ast.CompositeLikeDeclaration,
 	lexicalScope *VariableActivation,
-) map[string]FunctionValue {
+) *FunctionOrderedMap {
 
-	functions := map[string]FunctionValue{}
+	functions := orderedmap.New[FunctionOrderedMap](len(compositeDeclaration.DeclarationMembers().Functions()))
 
 	for _, functionDeclaration := range compositeDeclaration.DeclarationMembers().Functions() {
 		name := functionDeclaration.Identifier.Identifier
-		functions[name] =
+		functions.Set(
+			name,
 			interpreter.compositeFunction(
 				functionDeclaration,
 				lexicalScope,
-			)
+			),
+		)
 	}
 
 	return functions
@@ -2180,13 +2263,25 @@
 		interfaceType.InitializerParameters,
 		lexicalScope,
 	)
+
+	var defaultDestroyEventConstructor FunctionValue
+	if defautlDestroyEvent := interpreter.Program.Elaboration.DefaultDestroyDeclaration(declaration); defautlDestroyEvent != nil {
+		var nestedVariable *Variable
+		lexicalScope, nestedVariable = interpreter.declareCompositeValue(
+			defautlDestroyEvent,
+			lexicalScope,
+		)
+		defaultDestroyEventConstructor = nestedVariable.GetValue().(FunctionValue)
+	}
+
 	functionWrappers := interpreter.functionWrappers(declaration.Members, lexicalScope)
 	defaultFunctions := interpreter.defaultFunctions(declaration.Members, lexicalScope)
 
 	interpreter.SharedState.typeCodes.InterfaceCodes[typeID] = WrapperCode{
-		InitializerFunctionWrapper: initializerFunctionWrapper,
-		FunctionWrappers:           functionWrappers,
-		Functions:                  defaultFunctions,
+		InitializerFunctionWrapper:     initializerFunctionWrapper,
+		FunctionWrappers:               functionWrappers,
+		Functions:                      defaultFunctions,
+		DefaultDestroyEventConstructor: defaultDestroyEventConstructor,
 	}
 }
 
@@ -4529,9 +4624,9 @@
 func (interpreter *Interpreter) GetCompositeValueFunctions(
 	v *CompositeValue,
 	locationRange LocationRange,
-) map[string]FunctionValue {
+) *FunctionOrderedMap {
 
-	var functions map[string]FunctionValue
+	var functions *FunctionOrderedMap
 
 	typeID := v.TypeID()
 

runtime/interpreter/interpreter_statement.go

@@ -24,6 +24,7 @@
 	"github.com/onflow/cadence/runtime/ast"
 	"github.com/onflow/cadence/runtime/common"
 	"github.com/onflow/cadence/runtime/errors"
+	"github.com/onflow/cadence/runtime/sema"
 )
 
 func (interpreter *Interpreter) evalStatement(statement ast.Statement) StatementResult {
@@ -411,18 +412,7 @@
 	return nil, false
 }
 
-func (interpreter *Interpreter) VisitEmitStatement(statement *ast.EmitStatement) StatementResult {
-	event, ok := interpreter.evalExpression(statement.InvocationExpression).(*CompositeValue)
-	if !ok {
-		panic(errors.NewUnreachableError())
-	}
-
-	eventType := interpreter.Program.Elaboration.EmitStatementEventType(statement)
-
-	locationRange := LocationRange{
-		Location:    interpreter.Location,
-		HasPosition: statement,
-	}
+func (interpreter *Interpreter) emitEvent(event *CompositeValue, eventType *sema.CompositeType, locationRange LocationRange) {
 
 	config := interpreter.SharedState.Config
 
@@ -437,6 +427,23 @@
 	if err != nil {
 		panic(err)
 	}
+}
+
+func (interpreter *Interpreter) VisitEmitStatement(statement *ast.EmitStatement) StatementResult {
+
+	event, ok := interpreter.evalExpression(statement.InvocationExpression).(*CompositeValue)
+	if !ok {
+		panic(errors.NewUnreachableError())
+	}
+
+	eventType := interpreter.Program.Elaboration.EmitStatementEventType(statement)
+
+	locationRange := LocationRange{
+		Location:    interpreter.Location,
+		HasPosition: statement,
+	}
+
+	interpreter.emitEvent(event, eventType, locationRange)
 
 	return nil
 }