Merge range type feature

encoding/ccf/consts.go

@@ -64,7 +64,7 @@ const (
 	CBORTagReferenceType
 	CBORTagIntersectionType
 	CBORTagCapabilityType
-	_
+	CBORTagInclusiveRangeType
 	_
 	_
 	_
@@ -120,7 +120,7 @@ const (
 	CBORTagIntersectionTypeValue
 	CBORTagCapabilityTypeValue
 	CBORTagFunctionTypeValue
-	_
+	CBORTagInclusiveRangeTypeValue // InclusiveRange is stored as a composite value.
 	_
 	_
 	_

encoding/ccf/decode.go

@@ -358,6 +358,7 @@ func (d *Decoder) decodeTypeAndValue(types *cadenceTypeByCCFTypeID) (cadence.Val
 //	/ path-value
 //	/ path-capability-value
 //	/ id-capability-value
+//	/ inclusiverange-value
 //	/ function-value
 //	/ type-value
 //
@@ -549,6 +550,9 @@ func (d *Decoder) decodeValue(t cadence.Type, types *cadenceTypeByCCFTypeID) (ca
 		// When static type is a reference type, encoded value is its deferenced type.
 		return d.decodeValue(t.Type, types)
 
+	case *cadence.InclusiveRangeType:
+		return d.decodeInclusiveRange(t, types)
+
 	default:
 		nt, err := d.dec.NextType()
 		if err != nil {
@@ -1311,6 +1315,52 @@ func (d *Decoder) decodeEnum(typ *cadence.EnumType, types *cadenceTypeByCCFTypeI
 	return v.WithType(typ), nil
 }
 
+// decodeInclusiveRange decodes encoded inclusiverange-value as
+// language=CDDL
+// inclusiverange-value = [
+//
+//	start: value,
+//	end: value,
+//	step: value,
+//
+// ]
+func (d *Decoder) decodeInclusiveRange(typ *cadence.InclusiveRangeType, types *cadenceTypeByCCFTypeID) (cadence.Value, error) {
+	// Decode array head of length 3.
+	err := decodeCBORArrayWithKnownSize(d.dec, 3)
+	if err != nil {
+		return nil, err
+	}
+
+	elementType := typ.ElementType
+
+	// Decode start.
+	start, err := d.decodeValue(elementType, types)
+	if err != nil {
+		return nil, err
+	}
+
+	// Decode end.
+	end, err := d.decodeValue(elementType, types)
+	if err != nil {
+		return nil, err
+	}
+
+	// Decode step.
+	step, err := d.decodeValue(elementType, types)
+	if err != nil {
+		return nil, err
+	}
+
+	v := cadence.NewMeteredInclusiveRange(
+		d.gauge,
+		start,
+		end,
+		step,
+	)
+
+	return v.WithType(typ), nil
+}
+
 // decodePath decodes path-value as
 // language=CDDL
 // path-value = [
@@ -1423,6 +1473,7 @@ func (d *Decoder) decodeCapability(typ *cadence.CapabilityType, types *cadenceTy
 //	/ varsized-array-type-value
 //	/ constsized-array-type-value
 //	/ dict-type-value
+//	/ inclusiverange-type-value
 //	/ struct-type-value
 //	/ resource-type-value
 //	/ contract-type-value
@@ -1463,6 +1514,9 @@ func (d *Decoder) decodeTypeValue(visited *cadenceTypeByCCFTypeID) (cadence.Type
 	case CBORTagDictTypeValue:
 		return d.decodeDictType(visited, d.decodeTypeValue)
 
+	case CBORTagInclusiveRangeTypeValue:
+		return d.decodeInclusiveRangeType(visited, d.decodeTypeValue)
+
 	case CBORTagCapabilityTypeValue:
 		return d.decodeCapabilityType(visited, d.decodeNullableTypeValue)
 

encoding/ccf/decode_type.go

@@ -45,6 +45,7 @@
 //	/ reference-type
 //	/ intersection-type
 //	/ capability-type
+//	/ inclusiverange-type
 //	/ type-ref
 //
 // All exported Cadence types needs to be handled in this function,
@@ -71,6 +72,9 @@
 	case CBORTagDictType:
 		return d.decodeDictType(types, d.decodeInlineType)
 
+	case CBORTagInclusiveRangeType:
+		return d.decodeInclusiveRangeType(types, d.decodeInlineType)
+
 	case CBORTagReferenceType:
 		return d.decodeReferenceType(types, d.decodeInlineType)
 
@@ -273,6 +277,36 @@
 	return cadence.NewMeteredDictionaryType(d.gauge, keyType, elementType), nil
 }
 
+// decodeInclusiveRangeType decodes inclusiverange-type or inclusiverange-type-value as
+// language=CDDL
+// inclusiverange-type =
+//
+//	; cbor-tag-inclusiverange-type
+//	#6.145(inline-type)
+//
+// inclusiverange-type-value =
+//
+//	; cbor-tag-inclusiverange-type-value
+//	#6.194(type-value)
+//
+// NOTE: decodeTypeFn is responsible for decoding inline-type or type-value.
+func (d *Decoder) decodeInclusiveRangeType(
+	types *cadenceTypeByCCFTypeID,
+	decodeTypeFn decodeTypeFn,
+) (cadence.Type, error) {
+	// element 0: element type (inline-type or type-value)
+	elementType, err := decodeTypeFn(types)
+	if err != nil {
+		return nil, err
+	}
+
+	if elementType == nil {
+		return nil, errors.New("unexpected nil type as inclusiverange element type")
+	}
+
+	return cadence.NewMeteredInclusiveRangeType(d.gauge, elementType), nil
+}
+
 // decodeCapabilityType decodes capability-type or capability-type-value as
 // language=CDDL
 // capability-type =

encoding/ccf/encode.go

@@ -378,6 +378,7 @@
 //	/ path-value
 //	/ path-capability-value
 //	/ id-capability-value
+//	/ inclusiverange-value
 //	/ function-value
 //	/ type-value
 //
@@ -563,6 +564,9 @@
 	case cadence.Dictionary:
 		return e.encodeDictionary(v, tids)
 
+	case *cadence.InclusiveRange:
+		return e.encodeInclusiveRange(v, tids)
+
 	case cadence.Struct:
 		return e.encodeStruct(v, tids)
 
@@ -974,6 +978,34 @@
 	return encodedPairs, nil
 }
 
+// encodeInclusiveRange encodes cadence.InclusiveRange as
+// language=CDDL
+// inclusiverange-value = [3*3 (key: value, value: value)]
+func (e *Encoder) encodeInclusiveRange(v *cadence.InclusiveRange, tids ccfTypeIDByCadenceType) error {
+	staticElementType := v.InclusiveRangeType.ElementType
+
+	// Encode array head with array size of 3.
+	err := e.enc.EncodeArrayHead(3)
+	if err != nil {
+		return err
+	}
+
+	// Encode start key as value.
+	err = e.encodeValue(v.Start, staticElementType, tids)
+	if err != nil {
+		return err
+	}
+
+	// Encode end as value.
+	err = e.encodeValue(v.End, staticElementType, tids)
+	if err != nil {
+		return err
+	}
+
+	// Encode step key as value.
+	return e.encodeValue(v.Step, staticElementType, tids)
+}
+
 // encodeStruct encodes cadence.Struct as
 // language=CDDL
 // composite-value = [* (field: value)]
@@ -1201,6 +1233,7 @@
 //	/ reference-type-value
 //	/ intersection-type-value
 //	/ capability-type-value
+//	/ inclusiverange-type-value
 //	/ type-value-ref
 //
 // TypeValue is used differently from inline type or type definition.
@@ -1251,6 +1284,9 @@
 	case *cadence.ContractType:
 		return e.encodeContractTypeValue(typ, visited)
 
+	case *cadence.InclusiveRangeType:
+		return e.encodeInclusiveRangeTypeValue(typ, visited)
+
 	case *cadence.StructInterfaceType:
 		return e.encodeStructInterfaceTypeValue(typ, visited)
 
@@ -1380,6 +1416,22 @@
 	)
 }
 
+// encodeInclusiveRangeTypeValue encodes cadence.InclusiveRangeType as
+// language=CDDL
+// inclusiverange-type-value =
+//
+//	; cbor-tag-inclusiverange-type-value
+//	#6.194(type-value)
+func (e *Encoder) encodeInclusiveRangeTypeValue(typ *cadence.InclusiveRangeType, visited ccfTypeIDByCadenceType) error {
+	rawTagNum := []byte{0xd8, CBORTagInclusiveRangeTypeValue}
+	return e.encodeInclusiveRangeTypeWithRawTag(
+		typ,
+		visited,
+		e.encodeTypeValue,
+		rawTagNum,
+	)
+}
+
 // encodeReferenceTypeValue encodes cadence.ReferenceType as
 // language=CDDL
 // reference-type-value =

encoding/ccf/encode_type.go

@@ -39,6 +39,7 @@
 //	/ reference-type
 //	/ intersection-type
 //	/ capability-type
+//	/ inclusiverange-type
 //	/ type-ref
 //
 // All exported Cadence types need to be supported by this function,
@@ -62,6 +63,9 @@
 	case *cadence.DictionaryType:
 		return e.encodeDictType(typ, tids)
 
+	case *cadence.InclusiveRangeType:
+		return e.encodeInclusiveRangeType(typ, tids)
+
 	case cadence.CompositeType, cadence.InterfaceType:
 		id, err := tids.id(typ)
 		if err != nil {
@@ -296,6 +300,43 @@
 	return encodeTypeFn(typ.ElementType, tids)
 }
 
+// encodeInclusiveRangeType encodes cadence.InclusiveRangeType as
+// language=CDDL
+// inclusiverange-type =
+//
+// ; cbor-tag-inclusiverange-type
+// #6.145(inline-type)
+func (e *Encoder) encodeInclusiveRangeType(
+	typ *cadence.InclusiveRangeType,
+	tids ccfTypeIDByCadenceType,
+) error {
+	rawTagNum := []byte{0xd8, CBORTagInclusiveRangeType}
+	return e.encodeInclusiveRangeTypeWithRawTag(
+		typ,
+		tids,
+		e.encodeInlineType,
+		rawTagNum,
+	)
+}
+
+// encodeInclusiveRangeTypeWithRawTag encodes cadence.InclusiveRangeType
+// with given tag number and encode type function.
+func (e *Encoder) encodeInclusiveRangeTypeWithRawTag(
+	typ *cadence.InclusiveRangeType,
+	tids ccfTypeIDByCadenceType,
+	encodeTypeFn encodeTypeFn,
+	rawTagNumber []byte,
+) error {
+	// Encode CBOR tag number.
+	err := e.enc.EncodeRawBytes(rawTagNumber)
+	if err != nil {
+		return err
+	}
+
+	// Encode element type with given encodeTypeFn
+	return encodeTypeFn(typ.ElementType, tids)
+}
+
 // encodeReferenceType encodes cadence.ReferenceType as
 // language=CDDL
 // reference-type =

encoding/ccf/traverse_value.go

@@ -181,7 +181,8 @@ func (ct *compositeTypes) traverseType(typ cadence.Type) (checkRuntimeType bool)
 		return true
 
 	case cadence.BytesType,
-		*cadence.FunctionType:
+		*cadence.FunctionType,
+		*cadence.InclusiveRangeType:
 		// TODO: Maybe there are more types that we can skip checking runtime type for composite type.
 
 		return false

encoding/json/decode.go

@@ -139,6 +139,10 @@ const (
 	typeBoundKey         = "typeBound"
 	purityKey            = "purity"
 	functionTypeKey      = "functionType"
+	elementKey           = "element"
+	startKey             = "start"
+	endKey               = "end"
+	stepKey              = "step"
 )
 
 func (d *Decoder) decodeJSON(v any) cadence.Value {
@@ -225,6 +229,8 @@ func (d *Decoder) decodeJSON(v any) cadence.Value {
 		return d.decodeEvent(valueJSON)
 	case contractTypeStr:
 		return d.decodeContract(valueJSON)
+	case inclusiveRangeTypeStr:
+		return d.decodeInclusiveRange(valueJSON)
 	case pathTypeStr:
 		return d.decodePath(valueJSON)
 	case typeTypeStr:
@@ -869,6 +875,26 @@ func (d *Decoder) decodeEnum(valueJSON any) cadence.Enum {
 	))
 }
 
+func (d *Decoder) decodeInclusiveRange(valueJSON any) *cadence.InclusiveRange {
+	obj := toObject(valueJSON)
+
+	start := obj.GetValue(d, startKey)
+	end := obj.GetValue(d, endKey)
+	step := obj.GetValue(d, stepKey)
+
+	value := cadence.NewMeteredInclusiveRange(
+		d.gauge,
+		start,
+		end,
+		step,
+	)
+
+	return value.WithType(cadence.NewMeteredInclusiveRangeType(
+		d.gauge,
+		start.Type(),
+	))
+}
+
 func (d *Decoder) decodePath(valueJSON any) cadence.Path {
 	obj := toObject(valueJSON)
 
@@ -1263,6 +1289,11 @@ func (d *Decoder) decodeType(valueJSON any, results typeDecodingResults) cadence
 			d.decodeType(obj.Get(keyKey), results),
 			d.decodeType(obj.Get(valueKey), results),
 		)
+	case "InclusiveRange":
+		return cadence.NewMeteredInclusiveRangeType(
+			d.gauge,
+			d.decodeType(obj.Get(elementKey), results),
+		)
 	case "ConstantSizedArray":
 		size := toUInt(obj.Get(sizeKey))
 		return cadence.NewMeteredConstantSizedArrayType(