pass AST type argument range in Instantiate, also fix tests

runtime/sema/checker.go

@@ -2244,15 +2244,11 @@ func (checker *Checker) convertInstantiationType(t *ast.InstantiationType) Type
 		return ty
 	}
 
-	astRange := ast.NewRange(
-		checker.memoryGauge,
-		t.TypeArgumentsStartPos,
-		t.EndPos,
-	)
 	return parameterizedType.Instantiate(
+		checker.memoryGauge,
 		typeArguments,
+		t.TypeArguments,
 		checker.report,
-		&astRange,
 	)
 }
 

runtime/sema/type.go

@@ -277,18 +277,19 @@ type LocatedType interface {
 type ParameterizedType interface {
 	Type
 	TypeParameters() []*TypeParameter
-	Instantiate(typeArguments []Type, report func(err error), astRange *ast.Range) Type
+	Instantiate(memoryGauge common.MemoryGauge, typeArguments []Type, astTypeArguments []*ast.TypeAnnotation, report func(err error)) Type
 	BaseType() Type
 	TypeArguments() []Type
 }
 
 func MustInstantiate(t ParameterizedType, typeArguments ...Type) Type {
 	return t.Instantiate(
+		nil, /* memoryGauge */
 		typeArguments,
+		nil, /* astTypeArguments */
 		func(err error) {
 			panic(errors.NewUnexpectedErrorFromCause(err))
 		},
-		nil,
 	)
 }
 
@@ -5410,22 +5411,24 @@ func (t *InclusiveRangeType) BaseType() Type {
 }
 
 func (t *InclusiveRangeType) Instantiate(
+	memoryGauge common.MemoryGauge,
 	typeArguments []Type,
+	astTypeArguments []*ast.TypeAnnotation,
 	report func(err error),
-	astRange *ast.Range,
 ) Type {
 	memberType := typeArguments[0]
 
-	if astRange == nil {
+	if astTypeArguments == nil || astTypeArguments[0] == nil {
 		panic(errors.NewUnreachableError())
 	}
+	paramAstRange := ast.NewRangeFromPositioned(memoryGauge, astTypeArguments[0])
 
 	// memberType must only be a leaf integer type.
 	for _, ty := range AllNonLeafIntegerTypes {
 		if memberType == ty {
 			report(&InvalidTypeArgumentError{
 				TypeArgumentName: inclusiveRangeTypeParameter.Name,
-				Range:            *astRange,
+				Range:            paramAstRange,
 				Details:          fmt.Sprintf("Creation of InclusiveRange<%s> is disallowed", memberType),
 			})
 		}
@@ -7288,7 +7291,12 @@ func (t *CapabilityType) TypeParameters() []*TypeParameter {
 	}
 }
 
-func (t *CapabilityType) Instantiate(typeArguments []Type, _ func(err error), _ *ast.Range) Type {
+func (t *CapabilityType) Instantiate(
+	memoryGauge common.MemoryGauge,
+	typeArguments []Type,
+	_ []*ast.TypeAnnotation,
+	_ func(err error),
+) Type {
 	borrowType := typeArguments[0]
 	return &CapabilityType{
 		BorrowType: borrowType,

runtime/tests/checker/range_value_test.go

@@ -376,6 +376,28 @@ func TestCheckInclusiveRangeConstructionInvalid(t *testing.T) {
 		"let r: InclusiveRange = InclusiveRange(1, 10)",
 		[]error{&sema.MissingTypeArgumentError{}},
 	)
+
+	runInvalidCase(
+		t,
+		"same_supertype_different_subtype_start_end",
+		`
+			let a: Integer = UInt8(0)
+			let b: Integer = Int16(10)
+			let r = InclusiveRange(a, b)
+		`,
+		[]error{&sema.InvalidTypeArgumentError{}},
+	)
+	runInvalidCase(
+		t,
+		"same_supertype_different_subtype_start_step",
+		`
+			let a: Integer = UInt8(0)
+			let b: Integer = UInt8(10)
+			let s: Integer = UInt16(2)
+			let r = InclusiveRange(a, b, step: s)
+		`,
+		[]error{&sema.InvalidTypeArgumentError{}},
+	)
 }
 
 func TestInclusiveRangeNonLeafIntegerTypes(t *testing.T) {

runtime/tests/interpreter/range_value_test.go

@@ -586,28 +586,4 @@ func TestInclusiveRangeConstructionInvalid(t *testing.T) {
 			"step value cannot be negative for unsigned integer type",
 		)
 	}
-
-	runInvalidCase(
-		t,
-		"same_supertype_different_subtype_start_end",
-		`
-			let a: Integer = UInt8(0)
-			let b: Integer = Int16(10)
-			let r = InclusiveRange(a, b)
-		`,
-		&interpreter.InclusiveRangeConstructionError{},
-		"start and end are of different types",
-	)
-	runInvalidCase(
-		t,
-		"same_supertype_different_subtype_start_step",
-		`
-			let a: Integer = UInt8(0)
-			let b: Integer = UInt8(10)
-			let s: Integer = UInt16(2)
-			let r = InclusiveRange(a, b, step: s)
-		`,
-		&interpreter.InclusiveRangeConstructionError{},
-		"step must be of the same type as start and end",
-	)
 }