Merge pull request onflow#4052 from onflow/raymond/attachments

[Compiler] Attachments #1/3

Author: RZhang05

bbq/compiler/compiler.go

@@ -575,6 +575,7 @@ func (c *Compiler[E, T]) Compile() *bbq.Program[E, T] {
 	variableDeclarations := c.Program.VariableDeclarations()
 	functionDeclarations := c.Program.FunctionDeclarations()
 	interfaceDeclarations := c.Program.InterfaceDeclarations()
+	attachmentDeclarations := c.Program.AttachmentDeclarations()
 
 	// Reserve globals for functions/types before visiting their implementations.
 	c.reserveGlobals(
@@ -583,6 +584,7 @@ func (c *Compiler[E, T]) Compile() *bbq.Program[E, T] {
 		functionDeclarations,
 		compositeDeclarations,
 		interfaceDeclarations,
+		attachmentDeclarations,
 	)
 
 	// Compile declarations
@@ -598,6 +600,9 @@ func (c *Compiler[E, T]) Compile() *bbq.Program[E, T] {
 	for _, declaration := range interfaceDeclarations {
 		c.compileDeclaration(declaration)
 	}
+	for _, declaration := range attachmentDeclarations {
+		c.compileDeclaration(declaration)
+	}
 
 	functions := c.exportFunctions()
 	constants := c.exportConstants()
@@ -621,6 +626,7 @@ func (c *Compiler[_, _]) reserveGlobals(
 	functionDecls []*ast.FunctionDeclaration,
 	compositeDecls []*ast.CompositeDeclaration,
 	interfaceDecls []*ast.InterfaceDeclaration,
+	attachmentDecls []*ast.AttachmentDeclaration,
 ) {
 	// Reserve globals for the contract values before everything.
 	// Contract values must be always start at the zero-th index.
@@ -641,6 +647,7 @@ func (c *Compiler[_, _]) reserveGlobals(
 		functionDecls,
 		compositeDecls,
 		interfaceDecls,
+		attachmentDecls,
 	)
 }
 
@@ -676,6 +683,8 @@ func (c *Compiler[_, _]) reserveVariableGlobals(
 			members.Composites(),
 		)
 	}
+
+	// attachments will not have nested enum/composite declarations
 }
 
 func (c *Compiler[_, _]) reserveFunctionGlobals(
@@ -684,6 +693,7 @@ func (c *Compiler[_, _]) reserveFunctionGlobals(
 	functionDecls []*ast.FunctionDeclaration,
 	compositeDecls []*ast.CompositeDeclaration,
 	interfaceDecls []*ast.InterfaceDeclaration,
+	attachmentDecls []*ast.AttachmentDeclaration,
 ) {
 	for _, declaration := range specialFunctionDecls {
 		switch declaration.Kind {
@@ -765,6 +775,7 @@ func (c *Compiler[_, _]) reserveFunctionGlobals(
 			members.Functions(),
 			members.Composites(),
 			members.Interfaces(),
+			members.Attachments(),
 		)
 	}
 
@@ -780,6 +791,26 @@ func (c *Compiler[_, _]) reserveFunctionGlobals(
 			members.Functions(),
 			members.Composites(),
 			members.Interfaces(),
+			members.Attachments(),
+		)
+	}
+
+	for _, declaration := range attachmentDecls {
+		compositeType := c.DesugaredElaboration.CompositeDeclarationType(declaration)
+		// Reserve a global for the constructor function.
+
+		constructorName := commons.TypeQualifier(compositeType)
+		c.addGlobal(constructorName)
+
+		members := declaration.Members
+
+		c.reserveFunctionGlobals(
+			compositeType,
+			members.SpecialFunctions(),
+			members.Functions(),
+			members.Composites(),
+			members.Interfaces(),
+			members.Attachments(),
 		)
 	}
 }
@@ -2086,7 +2117,11 @@ func (c *Compiler[_, _]) emitVariableStore(name string) {
 	})
 }
 
-func (c *Compiler[_, _]) VisitInvocationExpression(expression *ast.InvocationExpression) (_ struct{}) {
+func (c *Compiler[_, _]) visitInvocationExpressionWithImplicitArgument(
+	expression *ast.InvocationExpression,
+	implicitArgIndex uint16,
+	implicitArgType sema.Type,
+) (_ struct{}) {
 	// TODO: copy
 
 	invocationTypes := c.DesugaredElaboration.InvocationExpressionTypes(expression)
@@ -2130,10 +2165,29 @@ func (c *Compiler[_, _]) VisitInvocationExpression(expression *ast.InvocationExp
 	c.compileArguments(expression.Arguments, invocationTypes)
 
 	typeArgs := c.loadTypeArguments(invocationTypes)
+	if implicitArgType != nil {
+		// Add the implicit argument to the end of the argument list, if it exists.
+		// Used in attachments, the attachment constructor/init expects an implicit argument:
+		// a reference to the base value used to set base.
+		// This hides the base argument away from the user.
+		typeArgs = append(typeArgs, c.getOrAddType(implicitArgType))
+		argumentCount += 1
+		if argumentCount >= math.MaxUint16 {
+			panic(errors.NewDefaultUserError("invalid number of arguments"))
+		}
+		// Load implicit argument from locals
+		c.emitGetLocal(implicitArgIndex)
+	}
+
 	c.emit(opcode.InstructionInvoke{
 		TypeArgs: typeArgs,
 		ArgCount: uint16(argumentCount),
 	})
+	return
+}
+
+func (c *Compiler[_, _]) VisitInvocationExpression(expression *ast.InvocationExpression) (_ struct{}) {
+	c.visitInvocationExpressionWithImplicitArgument(expression, 0, nil)
 
 	return
 }
@@ -2468,9 +2522,16 @@ func (c *Compiler[_, _]) compileMemberAccess(expression *ast.MemberExpression) {
 
 func (c *Compiler[_, _]) VisitIndexExpression(expression *ast.IndexExpression) (_ struct{}) {
 	c.compileExpression(expression.TargetExpression)
-	c.compileExpression(expression.IndexingExpression)
 
-	c.compileIndexAccess(expression)
+	if attachmentType, ok := c.DesugaredElaboration.AttachmentAccessTypes(expression); ok {
+		c.emit(opcode.InstructionGetTypeIndex{
+			Type: c.getOrAddType(attachmentType),
+		})
+	} else {
+		c.compileExpression(expression.IndexingExpression)
+
+		c.compileIndexAccess(expression)
+	}
 
 	return
 }
@@ -2892,6 +2953,31 @@ func (c *Compiler[_, _]) compileInitializer(declaration *ast.SpecialFunctionDecl
 		},
 	)
 
+	// stores the return value of the constructor
+	var returnLocalIndex uint16
+	// `self` in attachments is a reference.
+	if kind == common.CompositeKindAttachment {
+		// Store the new composite as the return value.
+		returnLocalIndex = c.currentFunction.generateLocalIndex()
+		c.emitSetLocal(returnLocalIndex)
+		c.emitGetLocal(returnLocalIndex)
+		baseTyp := enclosingType.(sema.EntitlementSupportingType)
+		baseAccess := baseTyp.SupportedEntitlements().Access()
+		refType := &sema.ReferenceType{
+			Type:          baseTyp,
+			Authorization: baseAccess,
+		}
+		// Set `self` to be a reference.
+		c.emit(opcode.InstructionNewRef{
+			Type:       c.getOrAddType(refType),
+			IsImplicit: false,
+		})
+
+		// TODO: expose base, a reference to the attachment's base value
+	} else {
+		returnLocalIndex = self.index
+	}
+
 	if kind == common.CompositeKindContract {
 		// During contract init, update the global variable with the newly initialized contract value.
 		// So accessing the contract through the global variable while initializing itself, would work.
@@ -2923,7 +3009,7 @@ func (c *Compiler[_, _]) compileInitializer(declaration *ast.SpecialFunctionDecl
 	)
 
 	// Constructor should return the created the struct. i.e: return `self`
-	c.emitGetLocal(self.index)
+	c.emitGetLocal(returnLocalIndex)
 
 	// No need to transfer, since the type is same as the constructed value, for initializers.
 	c.emit(opcode.InstructionReturnValue{})
@@ -3025,9 +3111,7 @@ func (c *Compiler[_, _]) VisitCompositeDeclaration(declaration *ast.CompositeDec
 	}
 
 	c.compositeTypeStack.push(compositeType)
-	defer func() {
-		c.compositeTypeStack.pop()
-	}()
+	defer c.compositeTypeStack.pop()
 
 	// Compile members
 	hasInit := false
@@ -3085,14 +3169,15 @@ func (c *Compiler[_, _]) compileCompositeMembers(
 	for _, nestedType := range members.Interfaces() {
 		c.compileDeclaration(nestedType)
 	}
+	for _, nestedAttachments := range members.Attachments() {
+		c.compileDeclaration(nestedAttachments)
+	}
 }
 
 func (c *Compiler[_, _]) VisitInterfaceDeclaration(declaration *ast.InterfaceDeclaration) (_ struct{}) {
 	interfaceType := c.DesugaredElaboration.InterfaceDeclarationType(declaration)
 	c.compositeTypeStack.push(interfaceType)
-	defer func() {
-		c.compositeTypeStack.pop()
-	}()
+	defer c.compositeTypeStack.pop()
 
 	// Visit members.
 	c.compileCompositeMembers(interfaceType, declaration.Members)
@@ -3229,9 +3314,32 @@ func (c *Compiler[_, _]) compileEnumCaseDeclaration(
 	return
 }
 
-func (c *Compiler[_, _]) VisitAttachmentDeclaration(_ *ast.AttachmentDeclaration) (_ struct{}) {
-	// TODO
-	panic(errors.NewUnreachableError())
+func (c *Compiler[_, _]) VisitAttachmentDeclaration(declaration *ast.AttachmentDeclaration) (_ struct{}) {
+	// Similar to VisitCompositeDeclaration
+	// Not combined because need to access fields not accessible in CompositeLikeDeclaration
+	compositeType := c.DesugaredElaboration.CompositeDeclarationType(declaration)
+
+	c.compositeTypeStack.push(compositeType)
+	defer c.compositeTypeStack.pop()
+
+	// Compile members
+	hasInit := false
+	for _, specialFunc := range declaration.Members.SpecialFunctions() {
+		if specialFunc.Kind == common.DeclarationKindInitializer {
+			hasInit = true
+		}
+		c.compileDeclaration(specialFunc)
+	}
+
+	// If the initializer is not declared, generate an empty initializer
+	if !hasInit {
+		c.generateEmptyInit()
+	}
+
+	// Visit members.
+	c.compileCompositeMembers(compositeType, declaration.Members)
+
+	return
 }
 
 func (c *Compiler[_, _]) VisitEntitlementDeclaration(_ *ast.EntitlementDeclaration) (_ struct{}) {
@@ -3244,14 +3352,59 @@ func (c *Compiler[_, _]) VisitEntitlementMappingDeclaration(_ *ast.EntitlementMa
 	panic(errors.NewUnreachableError())
 }
 
-func (c *Compiler[_, _]) VisitRemoveStatement(_ *ast.RemoveStatement) (_ struct{}) {
-	// TODO
-	panic(errors.NewUnreachableError())
+func (c *Compiler[_, _]) VisitRemoveStatement(statement *ast.RemoveStatement) (_ struct{}) {
+	// load base onto stack
+	c.compileExpression(statement.Value)
+	// remove attachment from base
+	nominalType := c.DesugaredElaboration.AttachmentRemoveTypes(statement)
+	c.emit(opcode.InstructionRemoveTypeIndex{
+		Type: c.getOrAddType(nominalType),
+	})
+	return
 }
 
-func (c *Compiler[_, _]) VisitAttachExpression(_ *ast.AttachExpression) (_ struct{}) {
-	// TODO
-	panic(errors.NewUnreachableError())
+func (c *Compiler[_, _]) VisitAttachExpression(expression *ast.AttachExpression) (_ struct{}) {
+	types := c.DesugaredElaboration.AttachTypes(expression)
+	baseType := types.BaseType
+	attachmentType := types.AttachType
+
+	// base on stack
+	c.compileExpression(expression.Base)
+	// store base locally
+	baseLocalIndex := c.currentFunction.generateLocalIndex()
+	c.emitSetLocal(baseLocalIndex)
+	// get base back on stack
+	c.emitGetLocal(baseLocalIndex)
+	baseTyp := baseType.(sema.EntitlementSupportingType)
+	baseAccess := baseTyp.SupportedEntitlements().Access()
+	refType := &sema.ReferenceType{
+		Type:          baseTyp,
+		Authorization: baseAccess,
+	}
+	// create reference to base to pass as implicit arg
+	c.emit(opcode.InstructionNewRef{
+		Type:       c.getOrAddType(refType),
+		IsImplicit: false,
+	})
+	refLocalIndex := c.currentFunction.generateLocalIndex()
+	c.emitSetLocal(refLocalIndex)
+
+	// create the attachment
+	c.visitInvocationExpressionWithImplicitArgument(expression.Attachment, refLocalIndex, baseType)
+	// attachment on stack
+
+	// base back on stack
+	c.emitGetLocal(baseLocalIndex)
+	// TODO: do attachment.setbaseValue(...)
+	// base should now be transferred
+	c.emitTransfer()
+
+	// add attachment value as a member of transferred base
+	// returns the result
+	c.emit(opcode.InstructionSetTypeIndex{
+		Type: c.getOrAddType(attachmentType),
+	})
+	return
 }
 
 func (c *Compiler[_, _]) emitTransferAndConvert(targetType sema.Type) {