Add ability to specify custom type parameter validation

runtime/sema/check_invocation_expression.go

@@ -493,6 +493,21 @@ func (checker *Checker) checkInvocation(
 		invocationExpression,
 	)
 
+	// The invokable type might have special checks for the type parameters.
+
+	if functionType.TypePrametersCheck != nil {
+		invocationRange := ast.NewRangeFromPositioned(
+			checker.memoryGauge,
+			invocationExpression,
+		)
+
+		functionType.TypePrametersCheck(
+			typeArguments,
+			checker.report,
+			invocationRange,
+		)
+	}
+
 	// Save types in the elaboration
 
 	checker.Elaboration.SetInvocationExpressionTypes(

runtime/sema/errors.go

@@ -3746,7 +3746,7 @@ type InvalidTypeArgumentError struct {
 var _ SemanticError = &InvalidTypeArgumentError{}
 var _ errors.UserError = &InvalidTypeArgumentError{}
 
-func (InvalidTypeArgumentError) isSemanticError() {}
+func (*InvalidTypeArgumentError) isSemanticError() {}
 
 func (*InvalidTypeArgumentError) IsUserError() {}
 

runtime/sema/type.go

@@ -2906,6 +2906,7 @@ type FunctionType struct {
 	ReturnTypeAnnotation     TypeAnnotation
 	Arity                    *Arity
 	ArgumentExpressionsCheck ArgumentExpressionsCheck
+	TypePrametersCheck       TypeParametersCheck
 	Members                  *StringMemberOrderedMap
 	TypeParameters           []*TypeParameter
 	Parameters               []Parameter
@@ -3376,6 +3377,12 @@ type ArgumentExpressionsCheck func(
 	invocationRange ast.Range,
 )
 
+type TypeParametersCheck func(
+	typeArguments *TypeParameterTypeOrderedMap,
+	report func(err error),
+	invocationRange ast.Range,
+)
+
 // BaseTypeActivation is the base activation that contains
 // the types available in programs
 var BaseTypeActivation = NewVariableActivation(nil)

runtime/stdlib/range.go

@@ -21,6 +21,7 @@ package stdlib
 import (
 	"fmt"
 
+	"github.com/onflow/cadence/runtime/ast"
 	"github.com/onflow/cadence/runtime/errors"
 	"github.com/onflow/cadence/runtime/interpreter"
 	"github.com/onflow/cadence/runtime/sema"
@@ -74,6 +75,24 @@ var inclusiveRangeConstructorFunctionType = func() *sema.FunctionType {
 		),
 		// `step` parameter is optional
 		Arity: &sema.Arity{Min: 2, Max: 3},
+		TypePrametersCheck: func(typeArguments *sema.TypeParameterTypeOrderedMap, report func(error), invocationRange ast.Range) {
+			memberType, ok := typeArguments.Get(typeParameter)
+			if !ok || memberType == nil {
+				// checker should prevent this
+				panic(errors.NewUnreachableError())
+			}
+
+			// memberType must only be a leaf integer type.
+			for _, ty := range sema.AllNonLeafIntegerTypes {
+				if memberType == ty {
+					report(&sema.InvalidTypeArgumentError{
+						TypeArgumentName: typeParameter.Name,
+						Range:            invocationRange,
+						Details:          fmt.Sprintf("Creation of InclusiveRange<%s> is disallowed", memberType),
+					})
+				}
+			}
+		},
 	}
 }()
 

runtime/tests/checker/range_value_test.go

@@ -398,13 +398,28 @@ func TestInclusiveRangeNonLeafIntegerTypes(t *testing.T) {
 			_, err := ParseAndCheckWithOptions(t, fmt.Sprintf(`
 				let a: %[1]s = 0
 				let b: %[1]s = 10
-				var range: InclusiveRange<%[1]s> = InclusiveRange<%[1]s>(a, b)
+				var range = InclusiveRange<%[1]s>(a, b)
 			`, ty), options)
 
 			errs := RequireCheckerErrors(t, err, 1)
 			assert.IsType(t, &sema.InvalidTypeArgumentError{}, errs[0])
 		})
 
+		t.Run(fmt.Sprintf("InclusiveRange<%s>", ty), func(t *testing.T) {
+			t.Parallel()
+
+			_, err := ParseAndCheckWithOptions(t, fmt.Sprintf(`
+				let a: %[1]s = 0
+				let b: %[1]s = 10
+				var range: InclusiveRange<%[1]s> = InclusiveRange<%[1]s>(a, b)
+			`, ty), options)
+
+			// One for the invocation and another for the type.
+			errs := RequireCheckerErrors(t, err, 2)
+			assert.IsType(t, &sema.InvalidTypeArgumentError{}, errs[0])
+			assert.IsType(t, &sema.InvalidTypeArgumentError{}, errs[1])
+		})
+
 		t.Run(fmt.Sprintf("InclusiveRange<%s> assignment", ty), func(t *testing.T) {
 			t.Parallel()