Extend type bounds

encoding/ccf/ccf_test.go

@@ -10426,7 +10426,7 @@ func TestEncodeType(t *testing.T) {
 			cadence.TypeValue{
 				StaticType: &cadence.FunctionType{
 					TypeParameters: []cadence.TypeParameter{
-						{Name: "T", TypeBound: cadence.AnyStructType},
+						{Name: "T", TypeBound: cadence.NewSubtypeTypeBound(cadence.AnyStructType)},
 					},
 					Parameters: []cadence.Parameter{
 						{Label: "qux", Identifier: "baz", Type: cadence.StringType},

encoding/ccf/decode.go

@@ -2182,9 +2182,15 @@ func (d *Decoder) decodeTypeParameterTypeValue(visited *cadenceTypeByCCFTypeID)
 		return cadence.TypeParameter{}, err
 	}
 
+	var typeBound cadence.TypeBound
+	if t != nil {
+		typeBound = cadence.NewSubtypeTypeBound(t)
+	}
+
 	// Unmetered because decodeTypeParamTypeValue is metered in decodeTypeParamTypeValues and called nowhere else
 	// Type is metered.
-	return cadence.NewTypeParameter(name, t), nil
+	// TODO: implement this for generalized bounds
+	return cadence.NewTypeParameter(name, typeBound), nil
 }
 
 // decodeParameterTypeValues decodes composite initializer parameter types as

encoding/ccf/encode.go

@@ -1945,8 +1945,18 @@
 		return err
 	}
 
+	// TODO: perhaps generalize this?
+	if typeParameter.TypeBound == nil {
+		return e.encodeNullableTypeValue(nil, visited)
+	}
+
+	subTypeBound, isSubtypeBound := typeParameter.TypeBound.(cadence.SubtypeTypeBound)
+	if !isSubtypeBound {
+		panic(cadenceErrors.NewUnexpectedError("cannot store non-subtype bounded function type parameter %s", typeParameter.TypeBound))
+	}
+
 	// element 1: type as type-bound.
-	return e.encodeNullableTypeValue(typeParameter.TypeBound, visited)
+	return e.encodeNullableTypeValue(subTypeBound.Type, visited)
 }
 
 // encodeParameterTypeValues encodes composite initializer parameter types as

encoding/json/decode.go

@@ -928,13 +928,47 @@
 	)
 }
 
+func (d *Decoder) decodeTypeBound(valueJSON any, results typeDecodingResults) cadence.TypeBound {
+	obj := toObject(valueJSON)
+
+	kind := obj.Get("kind")
+
+	switch kind {
+	case "subtype":
+		ty := obj.Get("type")
+		decodedType := d.decodeType(ty, results)
+		return cadence.NewSubtypeTypeBound(decodedType)
+	case "supertype":
+		ty := obj.Get("type")
+		decodedType := d.decodeType(ty, results)
+		return cadence.NewSupertypeTypeBound(decodedType)
+	case "equal":
+		ty := obj.Get("type")
+		decodedType := d.decodeType(ty, results)
+		return cadence.NewEqualTypeBound(decodedType)
+	case "negation":
+		bounds := toSlice(obj.Get("bounds"))
+		decodedBound := d.decodeTypeBound(bounds[0], results)
+		return cadence.NewNegationTypeBound(decodedBound)
+	case "conjunction":
+		bounds := toSlice(obj.Get("bounds"))
+		var decodedBounds []cadence.TypeBound
+		for _, bound := range bounds {
+			decodedBounds = append(decodedBounds, d.decodeTypeBound(bound, results))
+		}
+		return cadence.NewConjunctionTypeBound(decodedBounds)
+	}
+
+	panic(errors.NewDefaultUserError("invalid kind in type bound: %s", kind))
+}
+
 func (d *Decoder) decodeTypeParameter(valueJSON any, results typeDecodingResults) cadence.TypeParameter {
 	obj := toObject(valueJSON)
 	// Unmetered because decodeTypeParameter is metered in decodeTypeParameters and called nowhere else
 	typeBoundObj, ok := obj[typeBoundKey]
-	var typeBound cadence.Type
+	var typeBound cadence.TypeBound
 	if ok {
-		typeBound = d.decodeType(typeBoundObj, results)
+		typeBound = d.decodeTypeBound(typeBoundObj, results)
 	}
 
 	return cadence.NewTypeParameter(

encoding/json/encode.go

@@ -189,8 +189,14 @@
 }
 
 type jsonTypeParameter struct {
-	Name      string    `json:"name"`
-	TypeBound jsonValue `json:"typeBound"`
+	Name      string        `json:"name"`
+	TypeBound jsonTypeBound `json:"typeBound"`
+}
+
+type jsonTypeBound struct {
+	Kind   string          `json:"kind"`
+	Type   jsonValue       `json:"type"`
+	Bounds []jsonTypeBound `json:"bounds"`
 }
 
 type jsonParameterType struct {
@@ -710,11 +716,54 @@
 	}
 }
 
+func prepareTypeBound(typeBound cadence.TypeBound, results TypePreparationResults) jsonTypeBound {
+	switch bound := typeBound.(type) {
+	case cadence.SubtypeTypeBound:
+		preparedType := PrepareType(bound.Type, results)
+		return jsonTypeBound{
+			Kind: "subtype",
+			Type: preparedType,
+		}
+	case cadence.EqualTypeBound:
+		preparedType := PrepareType(bound.Type, results)
+		return jsonTypeBound{
+			Kind: "equal",
+			Type: preparedType,
+		}
+	case cadence.SupertypeTypeBound:
+		preparedType := PrepareType(bound.Type, results)
+		return jsonTypeBound{
+			Kind: "supertype",
+			Type: preparedType,
+		}
+	case cadence.NegationTypeBound:
+		preparedBound := prepareTypeBound(bound.NegatedBound, results)
+		return jsonTypeBound{
+			Kind:   "negation",
+			Bounds: []jsonTypeBound{preparedBound},
+		}
+	case cadence.ConjunctionTypeBound:
+		var preparedBounds []jsonTypeBound
+
+		for _, typeBound := range bound.TypeBounds {
+			preparedBounds = append(preparedBounds, prepareTypeBound(typeBound, results))
+
+		}
+
+		return jsonTypeBound{
+			Kind:   "conjunction",
+			Bounds: preparedBounds,
+		}
+	}
+
+	panic(fmt.Errorf("failed to prepare type: unsupported type bound: %T", typeBound))
+}
+
 func prepareTypeParameter(typeParameter cadence.TypeParameter, results TypePreparationResults) jsonTypeParameter {
 	typeBound := typeParameter.TypeBound
-	var preparedTypeBound jsonValue
+	var preparedTypeBound jsonTypeBound
 	if typeBound != nil {
-		preparedTypeBound = PrepareType(typeBound, results)
+		preparedTypeBound = prepareTypeBound(typeBound, results)
 	}
 	return jsonTypeParameter{
 		Name:      typeParameter.Name,