Simplify function types

runtime/convertTypes.go

@@ -57,8 +57,6 @@ func ExportType(t sema.Type, results map[sema.TypeID]cadence.Type) cadence.Type
 			return exportReferenceType(t, results)
 		case *sema.RestrictedType:
 			return exportRestrictedType(t, results)
-		case *sema.CheckedFunctionType:
-			return exportFunctionType(t.FunctionType, results)
 		case *sema.CapabilityType:
 			return exportCapabilityType(t, results)
 		}

runtime/interpreter/interpreter.go

@@ -1437,7 +1437,7 @@ func (interpreter *Interpreter) compositeInitializerFunction(
 	}
 
 	initializer = initializers[0]
-	functionType := interpreter.Program.Elaboration.SpecialFunctionTypes[initializer].FunctionType
+	functionType := interpreter.Program.Elaboration.ConstructorFunctionTypes[initializer].FunctionType
 
 	parameterList := initializer.FunctionDeclaration.ParameterList
 

runtime/sema/check_composite_declaration.go

@@ -672,7 +672,7 @@ func (checker *Checker) declareCompositeMembersAndValue(
 
 func (checker *Checker) declareCompositeConstructor(
 	declaration *ast.CompositeDeclaration,
-	constructorType *SpecialFunctionType,
+	constructorType *ConstructorFunctionType,
 	constructorArgumentLabels []string,
 ) {
 	// Resource and event constructors are effectively always private,
@@ -738,7 +738,7 @@ func (checker *Checker) declareEnumConstructor(
 		constructorOrigins = make(map[string]*Origin, len(enumCases))
 	}
 
-	constructorType := &SpecialFunctionType{
+	constructorType := &ConstructorFunctionType{
 		FunctionType: &FunctionType{
 			Parameters: []*Parameter{
 				{
@@ -751,8 +751,8 @@ func (checker *Checker) declareEnumConstructor(
 					Type: compositeType,
 				},
 			),
+			Members: constructorMembers,
 		},
-		Members: constructorMembers,
 	}
 
 	memberCaseTypeAnnotation := NewTypeAnnotation(compositeType)
@@ -1271,11 +1271,11 @@ func (checker *Checker) compositeConstructorType(
 	compositeDeclaration *ast.CompositeDeclaration,
 	compositeType *CompositeType,
 ) (
-	constructorFunctionType *SpecialFunctionType,
+	constructorFunctionType *ConstructorFunctionType,
 	argumentLabels []string,
 ) {
 
-	constructorFunctionType = &SpecialFunctionType{
+	constructorFunctionType = &ConstructorFunctionType{
 		FunctionType: &FunctionType{
 			ReturnTypeAnnotation: NewTypeAnnotation(compositeType),
 		},
@@ -1297,8 +1297,8 @@ func (checker *Checker) compositeConstructorType(
 		// NOTE: Don't use `constructorFunctionType`, as it has a return type.
 		//   The initializer itself has a `Void` return type.
 
-		checker.Elaboration.SpecialFunctionTypes[firstInitializer] =
-			&SpecialFunctionType{
+		checker.Elaboration.ConstructorFunctionTypes[firstInitializer] =
+			&ConstructorFunctionType{
 				FunctionType: &FunctionType{
 					Parameters:           constructorFunctionType.Parameters,
 					ReturnTypeAnnotation: NewTypeAnnotation(VoidType),

runtime/sema/check_invocation_expression.go

@@ -207,7 +207,7 @@ func (checker *Checker) checkConstructorInvocationWithResourceResult(
 	returnType Type,
 	inCreate bool,
 ) {
-	if _, ok := invokableType.(*SpecialFunctionType); !ok {
+	if _, ok := invokableType.(*ConstructorFunctionType); !ok {
 		return
 	}
 

runtime/sema/elaboration.go

@@ -39,7 +39,7 @@ type Elaboration struct {
 	AssignmentStatementValueTypes       map[*ast.AssignmentStatement]Type
 	AssignmentStatementTargetTypes      map[*ast.AssignmentStatement]Type
 	CompositeDeclarationTypes           map[*ast.CompositeDeclaration]*CompositeType
-	SpecialFunctionTypes                map[*ast.SpecialFunctionDeclaration]*SpecialFunctionType
+	ConstructorFunctionTypes            map[*ast.SpecialFunctionDeclaration]*ConstructorFunctionType
 	FunctionExpressionFunctionType      map[*ast.FunctionExpression]*FunctionType
 	InvocationExpressionArgumentTypes   map[*ast.InvocationExpression][]Type
 	InvocationExpressionParameterTypes  map[*ast.InvocationExpression][]Type
@@ -88,7 +88,7 @@ func NewElaboration() *Elaboration {
 		AssignmentStatementValueTypes:       map[*ast.AssignmentStatement]Type{},
 		AssignmentStatementTargetTypes:      map[*ast.AssignmentStatement]Type{},
 		CompositeDeclarationTypes:           map[*ast.CompositeDeclaration]*CompositeType{},
-		SpecialFunctionTypes:                map[*ast.SpecialFunctionDeclaration]*SpecialFunctionType{},
+		ConstructorFunctionTypes:            map[*ast.SpecialFunctionDeclaration]*ConstructorFunctionType{},
 		FunctionExpressionFunctionType:      map[*ast.FunctionExpression]*FunctionType{},
 		InvocationExpressionArgumentTypes:   map[*ast.InvocationExpression][]Type{},
 		InvocationExpressionParameterTypes:  map[*ast.InvocationExpression][]Type{},

runtime/sema/type.go

@@ -1908,10 +1908,12 @@ func formatFunctionType(
 // FunctionType
 //
 type FunctionType struct {
-	TypeParameters        []*TypeParameter
-	Parameters            []*Parameter
-	ReturnTypeAnnotation  *TypeAnnotation
-	RequiredArgumentCount *int
+	TypeParameters           []*TypeParameter
+	Parameters               []*Parameter
+	ReturnTypeAnnotation     *TypeAnnotation
+	RequiredArgumentCount    *int
+	ArgumentExpressionsCheck ArgumentExpressionsCheck
+	Members                  *StringMemberOrderedMap
 }
 
 func RequiredArgumentCount(count int) *int {
@@ -1924,8 +1926,15 @@ func (t *FunctionType) InvocationFunctionType() *FunctionType {
 	return t
 }
 
-func (*FunctionType) CheckArgumentExpressions(_ *Checker, _ []ast.Expression, _ ast.Range) {
-	// NO-OP: no checks for normal functions
+func (t *FunctionType) CheckArgumentExpressions(
+	checker *Checker,
+	argumentExpressions []ast.Expression,
+	invocationRange ast.Range,
+) {
+	if t.ArgumentExpressionsCheck == nil {
+		return
+	}
+	t.ArgumentExpressionsCheck(checker, argumentExpressions, invocationRange)
 }
 
 func (t *FunctionType) String() string {
@@ -2304,18 +2313,6 @@ func (t *FunctionType) Resolve(typeArguments *TypeParameterTypeOrderedMap) Type
 }
 
 func (t *FunctionType) GetMembers() map[string]MemberResolver {
-	return withBuiltinMembers(t, nil)
-}
-
-// SpecialFunctionType is the the type representing a special function,
-// i.e., a constructor or destructor
-
-type SpecialFunctionType struct {
-	*FunctionType
-	Members *StringMemberOrderedMap
-}
-
-func (t *SpecialFunctionType) GetMembers() map[string]MemberResolver {
 	// TODO: optimize
 	members := make(map[string]MemberResolver, t.Members.Len())
 	t.Members.Foreach(func(name string, loopMember *Member) {
@@ -2332,6 +2329,12 @@ func (t *SpecialFunctionType) GetMembers() map[string]MemberResolver {
 	return withBuiltinMembers(t, members)
 }
 
+// ConstructorFunctionType is the the type representing a constructor function
+
+type ConstructorFunctionType struct {
+	*FunctionType
+}
+
 // CheckedFunctionType is the the type representing a function that checks the arguments,
 // e.g., integer functions
 
@@ -2341,19 +2344,6 @@ type ArgumentExpressionsCheck func(
 	invocationRange ast.Range,
 )
 
-type CheckedFunctionType struct {
-	*FunctionType
-	ArgumentExpressionsCheck ArgumentExpressionsCheck
-}
-
-func (t *CheckedFunctionType) CheckArgumentExpressions(
-	checker *Checker,
-	argumentExpressions []ast.Expression,
-	invocationRange ast.Range,
-) {
-	t.ArgumentExpressionsCheck(checker, argumentExpressions, invocationRange)
-}
-
 // BaseTypeActivation is the base activation that contains
 // the types available in programs
 //
@@ -2513,23 +2503,23 @@ func init() {
 				panic(errors.NewUnreachableError())
 			}
 
+			functionType := &FunctionType{
+				Parameters: []*Parameter{
+					{
+						Label:          ArgumentLabelNotRequired,
+						Identifier:     "value",
+						TypeAnnotation: NewTypeAnnotation(NumberType),
+					},
+				},
+				ReturnTypeAnnotation:     NewTypeAnnotation(numberType),
+				ArgumentExpressionsCheck: numberFunctionArgumentExpressionsChecker(numberType),
+			}
+
 			BaseValueActivation.Set(
 				typeName,
 				baseFunctionVariable(
 					typeName,
-					&CheckedFunctionType{
-						FunctionType: &FunctionType{
-							Parameters: []*Parameter{
-								{
-									Label:          ArgumentLabelNotRequired,
-									Identifier:     "value",
-									TypeAnnotation: NewTypeAnnotation(NumberType),
-								},
-							},
-							ReturnTypeAnnotation: NewTypeAnnotation(numberType),
-						},
-						ArgumentExpressionsCheck: numberFunctionArgumentExpressionsChecker(numberType),
-					},
+					functionType,
 				),
 			)
 		}
@@ -2560,34 +2550,33 @@ func init() {
 		panic(errors.NewUnreachableError())
 	}
 
+	functionType := &FunctionType{
+		Parameters: []*Parameter{
+			{
+				Label:          ArgumentLabelNotRequired,
+				Identifier:     "value",
+				TypeAnnotation: NewTypeAnnotation(IntegerType),
+			},
+		},
+		ReturnTypeAnnotation: NewTypeAnnotation(addressType),
+		ArgumentExpressionsCheck: func(checker *Checker, argumentExpressions []ast.Expression, _ ast.Range) {
+			if len(argumentExpressions) < 1 {
+				return
+			}
+
+			intExpression, ok := argumentExpressions[0].(*ast.IntegerExpression)
+			if !ok {
+				return
+			}
+
+			CheckAddressLiteral(intExpression, checker.report)
+		},
+	}
 	BaseValueActivation.Set(
 		typeName,
 		baseFunctionVariable(
 			typeName,
-			&CheckedFunctionType{
-				FunctionType: &FunctionType{
-					Parameters: []*Parameter{
-						{
-							Label:          ArgumentLabelNotRequired,
-							Identifier:     "value",
-							TypeAnnotation: NewTypeAnnotation(IntegerType),
-						},
-					},
-					ReturnTypeAnnotation: NewTypeAnnotation(addressType),
-				},
-				ArgumentExpressionsCheck: func(checker *Checker, argumentExpressions []ast.Expression, _ ast.Range) {
-					if len(argumentExpressions) < 1 {
-						return
-					}
-
-					intExpression, ok := argumentExpressions[0].(*ast.IntegerExpression)
-					if !ok {
-						return
-					}
-
-					CheckAddressLiteral(intExpression, checker.report)
-				},
-			},
+			functionType,
 		),
 	)
 }
@@ -4522,17 +4511,17 @@ func (t *TransactionType) EntryPointFunctionType() *FunctionType {
 	}
 }
 
-func (t *TransactionType) PrepareFunctionType() *SpecialFunctionType {
-	return &SpecialFunctionType{
+func (t *TransactionType) PrepareFunctionType() *ConstructorFunctionType {
+	return &ConstructorFunctionType{
 		FunctionType: &FunctionType{
 			Parameters:           t.PrepareParameters,
 			ReturnTypeAnnotation: NewTypeAnnotation(VoidType),
 		},
 	}
 }
 
-func (*TransactionType) ExecuteFunctionType() *SpecialFunctionType {
-	return &SpecialFunctionType{
+func (*TransactionType) ExecuteFunctionType() *ConstructorFunctionType {
+	return &ConstructorFunctionType{
 		FunctionType: &FunctionType{
 			Parameters:           []*Parameter{},
 			ReturnTypeAnnotation: NewTypeAnnotation(VoidType),

runtime/stdlib/builtin.go

@@ -186,7 +186,7 @@ var HashAlgorithmValue = StandardLibraryValue{
 	Kind:  common.DeclarationKindEnum,
 }
 
-func cryptoAlgorithmEnumType(enumType *sema.CompositeType, enumCases []sema.CryptoAlgorithm) *sema.SpecialFunctionType {
+func cryptoAlgorithmEnumType(enumType *sema.CompositeType, enumCases []sema.CryptoAlgorithm) *sema.ConstructorFunctionType {
 	members := make([]*sema.Member, len(enumCases))
 	for i, algo := range enumCases {
 		members[i] = sema.NewPublicEnumCaseMember(
@@ -196,7 +196,7 @@ func cryptoAlgorithmEnumType(enumType *sema.CompositeType, enumCases []sema.Cryp
 		)
 	}
 
-	constructorType := &sema.SpecialFunctionType{
+	constructorType := &sema.ConstructorFunctionType{
 		FunctionType: &sema.FunctionType{
 			Parameters: []*sema.Parameter{
 				{
@@ -209,8 +209,8 @@ func cryptoAlgorithmEnumType(enumType *sema.CompositeType, enumCases []sema.Cryp
 					Type: enumType,
 				},
 			),
+			Members: sema.GetMembersAsMap(members),
 		},
-		Members: sema.GetMembersAsMap(members),
 	}
 
 	return constructorType