Interface default implementation support

runtime/interpreter/interpreter.go

@@ -206,6 +206,7 @@ type WrapperCode struct {
 	InitializerFunctionWrapper FunctionWrapper
 	DestructorFunctionWrapper  FunctionWrapper
 	FunctionWrappers           map[string]FunctionWrapper
+	Functions                  map[string]FunctionValue
 }
 
 // TypeCodes is the value which stores the "prepared" / "callable" "code"
@@ -1354,7 +1355,13 @@ func (interpreter *Interpreter) declareNonEnumCompositeValue(
 		// the order does not matter.
 
 		for name, functionWrapper := range code.FunctionWrappers { //nolint:maprangecheck
+
+			if functions[name] == nil {
+				functions[name] = code.Functions[name]
+			}
+
 			functions[name] = functionWrapper(functions[name])
+
 		}
 	}
 
@@ -1375,7 +1382,6 @@ func (interpreter *Interpreter) declareNonEnumCompositeValue(
 
 	for i := len(typeRequirements) - 1; i >= 0; i-- {
 		typeRequirement := typeRequirements[i]
-
 		wrapFunctions(interpreter.typeCodes.TypeRequirementCodes[typeRequirement.ID()])
 	}
 
@@ -1668,6 +1674,29 @@ func (interpreter *Interpreter) compositeDestructorFunction(
 	}
 }
 
+func (interpreter *Interpreter) interfaceFunctions(
+	interfaceDeclaration *ast.InterfaceDeclaration,
+	lexicalScope *VariableActivation,
+) map[string]FunctionValue {
+
+	functions := map[string]FunctionValue{}
+
+	for _, functionDeclaration := range interfaceDeclaration.Members.Functions() {
+		name := functionDeclaration.Identifier.Identifier
+		if functionDeclaration.FunctionBlock != nil {
+			if len(functionDeclaration.FunctionBlock.Block.Statements) > 0 {
+				functions[name] =
+					interpreter.compositeFunction(
+						functionDeclaration,
+						lexicalScope,
+					)
+			}
+		}
+	}
+
+	return functions
+}
+
 func (interpreter *Interpreter) compositeFunctions(
 	compositeDeclaration *ast.CompositeDeclaration,
 	lexicalScope *VariableActivation,
@@ -2028,11 +2057,13 @@ func (interpreter *Interpreter) declareInterface(
 	initializerFunctionWrapper := interpreter.initializerFunctionWrapper(declaration.Members, lexicalScope)
 	destructorFunctionWrapper := interpreter.destructorFunctionWrapper(declaration.Members, lexicalScope)
 	functionWrappers := interpreter.functionWrappers(declaration.Members, lexicalScope)
+	interfaceFunctions := interpreter.interfaceFunctions(declaration, lexicalScope)
 
 	interpreter.typeCodes.InterfaceCodes[typeID] = WrapperCode{
 		InitializerFunctionWrapper: initializerFunctionWrapper,
 		DestructorFunctionWrapper:  destructorFunctionWrapper,
 		FunctionWrappers:           functionWrappers,
+		Functions:                  interfaceFunctions,
 	}
 }
 

runtime/sema/check_composite_declaration.go

@@ -158,6 +158,8 @@ func (checker *Checker) visitCompositeDeclaration(declaration *ast.CompositeDecl
 
 	checkMissingMembers := kind != ContainerKindInterface
 
+	overridden := map[string]bool{}
+
 	for i, interfaceType := range compositeType.ExplicitInterfaceConformances {
 		interfaceNominalType := declaration.Conformances[i]
 
@@ -170,6 +172,7 @@ func (checker *Checker) visitCompositeDeclaration(declaration *ast.CompositeDecl
 				checkMissingMembers:            checkMissingMembers,
 				interfaceTypeIsTypeRequirement: false,
 			},
+			&overridden,
 		)
 	}
 
@@ -964,7 +967,9 @@ func (checker *Checker) checkCompositeConformance(
 	interfaceType *InterfaceType,
 	compositeKindMismatchIdentifier ast.Identifier,
 	options compositeConformanceCheckOptions,
+	overridden *map[string]bool,
 ) {
+
 	var missingMembers []*Member
 	var memberMismatches []MemberMismatch
 	var missingNestedCompositeTypes []*CompositeType
@@ -1017,23 +1022,39 @@ func (checker *Checker) checkCompositeConformance(
 		if interfaceMember.Predeclared {
 			return
 		}
-
 		compositeMember, ok := compositeType.Members.Get(name)
 		if !ok {
 			if options.checkMissingMembers {
-				missingMembers = append(missingMembers, interfaceMember)
+				if interfaceMember.DeclarationKind != common.DeclarationKindFunction {
+					missingMembers = append(missingMembers, interfaceMember)
+				} else {
+					if !interfaceMember.HasImplementation {
+						missingMembers = append(missingMembers, interfaceMember)
+					} else {
+						if (*overridden)[name] {
+							checker.report(
+								&MultipleInterfaceDefaultImplementationsError{
+									CompositeType: compositeType,
+									Member:        interfaceMember,
+								},
+							)
+						}
+						(*overridden)[name] = true
+					}
+
+				}
 			}
-			return
 		}
 
-		if !checker.memberSatisfied(compositeMember, interfaceMember) {
+		if compositeMember != nil && !checker.memberSatisfied(compositeMember, interfaceMember) {
 			memberMismatches = append(memberMismatches,
 				MemberMismatch{
 					CompositeMember: compositeMember,
 					InterfaceMember: interfaceMember,
 				},
 			)
 		}
+
 	})
 
 	// Determine missing nested composite type definitions
@@ -1049,6 +1070,7 @@ func (checker *Checker) checkCompositeConformance(
 
 		nestedCompositeType, ok := compositeType.nestedTypes.Get(name)
 		if !ok {
+
 			missingNestedCompositeTypes = append(missingNestedCompositeTypes, requiredCompositeType)
 			return
 		}
@@ -1075,13 +1097,13 @@ func (checker *Checker) checkCompositeConformance(
 			},
 		)
 	}
+
 }
 
 // TODO: return proper error
 func (checker *Checker) memberSatisfied(compositeMember, interfaceMember *Member) bool {
 
 	// Check declaration kind
-
 	if compositeMember.DeclarationKind != interfaceMember.DeclarationKind {
 		return false
 	}
@@ -1150,6 +1172,7 @@ func (checker *Checker) memberSatisfied(compositeMember, interfaceMember *Member
 
 				return false
 			}
+
 		}
 	}
 
@@ -1262,6 +1285,7 @@ func (checker *Checker) checkTypeRequirement(
 	// like a top-level composite declaration to an interface type
 
 	requiredInterfaceType := requiredCompositeType.InterfaceType()
+	overridden := map[string]bool{}
 
 	checker.checkCompositeConformance(
 		compositeDeclaration,
@@ -1272,6 +1296,7 @@ func (checker *Checker) checkTypeRequirement(
 			checkMissingMembers:            true,
 			interfaceTypeIsTypeRequirement: true,
 		},
+		&overridden,
 	)
 }
 
@@ -1475,17 +1500,24 @@ func (checker *Checker) defaultMembersAndOrigins(
 			)
 		}
 
+		hasImplementation := false
+
+		if function.FunctionBlock != nil && len(function.FunctionBlock.Block.Statements) > 0 {
+			hasImplementation = true
+		}
+
 		members.Set(
 			identifier,
 			&Member{
-				ContainerType:   containerType,
-				Access:          function.Access,
-				Identifier:      function.Identifier,
-				DeclarationKind: declarationKind,
-				TypeAnnotation:  fieldTypeAnnotation,
-				VariableKind:    ast.VariableKindConstant,
-				ArgumentLabels:  argumentLabels,
-				DocString:       function.DocString,
+				ContainerType:     containerType,
+				Access:            function.Access,
+				Identifier:        function.Identifier,
+				DeclarationKind:   declarationKind,
+				TypeAnnotation:    fieldTypeAnnotation,
+				VariableKind:      ast.VariableKindConstant,
+				ArgumentLabels:    argumentLabels,
+				DocString:         function.DocString,
+				HasImplementation: hasImplementation,
 			})
 
 		if checker.positionInfoEnabled && origins != nil {
@@ -1730,15 +1762,6 @@ func (checker *Checker) checkSpecialFunction(
 	)
 
 	switch containerKind {
-	case ContainerKindInterface:
-		if specialFunction.FunctionDeclaration.FunctionBlock != nil {
-
-			checker.checkInterfaceSpecialFunctionBlock(
-				specialFunction.FunctionDeclaration.FunctionBlock,
-				containerDeclarationKind,
-				specialFunction.Kind,
-			)
-		}
 
 	case ContainerKindComposite:
 		// Event declarations have an empty initializer as it is synthesized

runtime/sema/check_interface_declaration.go

@@ -177,22 +177,35 @@ func (checker *Checker) checkInterfaceFunctions(
 
 			checker.declareSelfValue(selfType, selfDocString)
 
+			mustExit := false
+			checkResourceLoss := false
+
+			if function.FunctionBlock != nil {
+				if len(function.FunctionBlock.Block.Statements) > 0 {
+					mustExit = true
+					checkResourceLoss = true
+				} else if (function.FunctionBlock.PreConditions == nil || len(*function.FunctionBlock.PreConditions) == 0) &&
+					(function.FunctionBlock.PostConditions == nil || len(*function.FunctionBlock.PostConditions) == 0) {
+
+					checker.report(
+						&InvalidImplementationError{
+							Pos:             function.FunctionBlock.StartPosition(),
+							ContainerKind:   declarationKind,
+							ImplementedKind: common.DeclarationKindFunction,
+						},
+					)
+				}
+			}
+
 			checker.visitFunctionDeclaration(
 				function,
 				functionDeclarationOptions{
-					mustExit:          false,
+					mustExit:          mustExit,
 					declareFunction:   false,
-					checkResourceLoss: false,
+					checkResourceLoss: checkResourceLoss,
 				},
 			)
 
-			if function.FunctionBlock != nil {
-				checker.checkInterfaceSpecialFunctionBlock(
-					function.FunctionBlock,
-					declarationKind,
-					common.DeclarationKindFunction,
-				)
-			}
 		}()
 	}
 }
@@ -338,31 +351,3 @@ func (checker *Checker) declareInterfaceMembers(declaration *ast.InterfaceDeclar
 		checker.declareCompositeMembersAndValue(nestedCompositeDeclaration, ContainerKindInterface)
 	}
 }
-
-func (checker *Checker) checkInterfaceSpecialFunctionBlock(
-	functionBlock *ast.FunctionBlock,
-	containerKind common.DeclarationKind,
-	implementedKind common.DeclarationKind,
-) {
-
-	statements := functionBlock.Block.Statements
-	if len(statements) > 0 {
-		checker.report(
-			&InvalidImplementationError{
-				Pos:             statements[0].StartPosition(),
-				ContainerKind:   containerKind,
-				ImplementedKind: implementedKind,
-			},
-		)
-	} else if (functionBlock.PreConditions == nil || len(*functionBlock.PreConditions) == 0) &&
-		(functionBlock.PostConditions == nil || len(*functionBlock.PostConditions) == 0) {
-
-		checker.report(
-			&InvalidImplementationError{
-				Pos:             functionBlock.StartPosition(),
-				ContainerKind:   containerKind,
-				ImplementedKind: implementedKind,
-			},
-		)
-	}
-}

runtime/sema/errors.go

@@ -1012,6 +1012,26 @@ func (e *DuplicateConformanceError) Error() string {
 
 func (*DuplicateConformanceError) isSemanticError() {}
 
+// MultipleInterfaceDefaultImplementationsError
+
+// TODO: just make this a warning?
+
+type MultipleInterfaceDefaultImplementationsError struct {
+	CompositeType *CompositeType
+	Member        *Member
+}
+
+func (e *MultipleInterfaceDefaultImplementationsError) Error() string {
+	return fmt.Sprintf(
+		"%s `%s` has multiple interface default implementations for function `%s`",
+		e.CompositeType.Kind.Name(),
+		e.CompositeType.QualifiedString(),
+		e.Member.Identifier.Identifier,
+	)
+}
+
+func (*MultipleInterfaceDefaultImplementationsError) isSemanticError() {}
+
 // MissingConformanceError
 
 type MissingConformanceError struct {

runtime/sema/type.go

@@ -3553,7 +3553,8 @@ type Member struct {
 	VariableKind    ast.VariableKind
 	ArgumentLabels  []string
 	// Predeclared fields can be considered initialized
-	Predeclared bool
+	Predeclared       bool
+	HasImplementation bool
 	// IgnoreInSerialization fields are ignored in serialization
 	IgnoreInSerialization bool
 	DocString             string