detect other unsupported recursive types. requires making all types h…

…ashable

encoding/json/encode.go

@@ -566,7 +566,7 @@ func prepareComposite(kind, id string, fieldTypes []cadence.Field, fields []cade
 	nonFunctionFieldTypes := make([]cadence.Field, 0)
 
 	for _, field := range fieldTypes {
-		if _, ok := field.Type.(cadence.FunctionType); !ok {
+		if _, ok := field.Type.(*cadence.FunctionType); !ok {
 			nonFunctionFieldTypes = append(nonFunctionFieldTypes, field)
 		}
 	}
@@ -661,11 +661,21 @@ func prepareInitializers(initializerTypes [][]cadence.Parameter, results typeRes
 
 func prepareType(typ cadence.Type, results typeResults) jsonValue {
 
-	switch typ := typ.(type) {
+	var supportedRecursiveType bool
+	switch typ.(type) {
 	case cadence.CompositeType, cadence.InterfaceType:
-		if _, ok := results[typ]; ok {
-			return typ.ID()
+		supportedRecursiveType = true
+	}
+
+	if _, ok := results[typ]; ok {
+		if !supportedRecursiveType {
+			panic(fmt.Errorf("failed to prepare type: unsupported recursive type: %T", typ))
 		}
+
+		return typ.ID()
+	}
+
+	if supportedRecursiveType {
 		results[typ] = struct{}{}
 	}
 
@@ -801,7 +811,7 @@ func prepareType(typ cadence.Type, results typeResults) jsonValue {
 			Fields:       prepareFields(typ.Fields, results),
 			Initializers: prepareInitializers(typ.Initializers, results),
 		}
-	case cadence.FunctionType:
+	case *cadence.FunctionType:
 		return jsonFunctionType{
 			Kind:       "Function",
 			TypeID:     typ.ID(),
@@ -814,7 +824,7 @@ func prepareType(typ cadence.Type, results typeResults) jsonValue {
 			Authorized: typ.Authorized,
 			Type:       prepareType(typ.Type, results),
 		}
-	case cadence.RestrictedType:
+	case *cadence.RestrictedType:
 		restrictions := make([]jsonValue, 0)
 		for _, restriction := range typ.Restrictions {
 			restrictions = append(restrictions, prepareType(restriction, results))

encoding/json/encoding_test.go

@@ -1481,12 +1481,12 @@ func TestEncodeType(t *testing.T) {
 		testEncodeAndDecode(
 			t,
 			cadence.TypeValue{
-				StaticType: cadence.FunctionType{
+				StaticType: (&cadence.FunctionType{
 					Parameters: []cadence.Parameter{
 						{Label: "qux", Identifier: "baz", Type: cadence.StringType{}},
 					},
 					ReturnType: cadence.IntType{},
-				}.WithID("Foo"),
+				}).WithID("Foo"),
 			},
 			`{"type":"Type","value":{"staticType":
 				{	
@@ -1521,12 +1521,12 @@ func TestEncodeType(t *testing.T) {
 		testEncodeAndDecode(
 			t,
 			cadence.TypeValue{
-				StaticType: cadence.RestrictedType{
+				StaticType: (&cadence.RestrictedType{
 					Restrictions: []cadence.Type{
 						cadence.StringType{},
 					},
 					Type: cadence.IntType{},
-				}.WithID("Int{String}"),
+				}).WithID("Int{String}"),
 			},
 			`{"type":"Type","value":{"staticType":
 				{	

runtime/convertTypes.go

@@ -586,7 +586,7 @@ func exportRestrictedType(
 	gauge common.MemoryGauge,
 	t *sema.RestrictedType,
 	results map[sema.TypeID]cadence.Type,
-) cadence.RestrictedType {
+) *cadence.RestrictedType {
 
 	convertedType := ExportMeteredType(gauge, t.Type, results)
 
@@ -745,7 +745,7 @@ func ImportType(memoryGauge common.MemoryGauge, t cadence.Type) interpreter.Stat
 			ImportType(memoryGauge, t.Type),
 			nil,
 		)
-	case cadence.RestrictedType:
+	case *cadence.RestrictedType:
 		restrictions := make([]interpreter.InterfaceStaticType, 0, len(t.Restrictions))
 		for _, restriction := range t.Restrictions {
 			intf, ok := restriction.(cadence.InterfaceType)

runtime/convertValues_test.go

@@ -1176,7 +1176,7 @@ func TestImportRuntimeType(t *testing.T) {
 		},
 		{
 			label: "RestrictedType",
-			actual: cadence.RestrictedType{
+			actual: &cadence.RestrictedType{
 				Type: &cadence.StructType{
 					Location:            TestLocation,
 					QualifiedIdentifier: "S",
@@ -1769,7 +1769,7 @@ func TestExportTypeValue(t *testing.T) {
 
 		assert.Equal(t,
 			cadence.TypeValue{
-				StaticType: cadence.RestrictedType{
+				StaticType: (&cadence.RestrictedType{
 					Type: &cadence.StructType{
 						QualifiedIdentifier: "S",
 						Location:            TestLocation,
@@ -1782,7 +1782,7 @@ func TestExportTypeValue(t *testing.T) {
 							Fields:              []cadence.Field{},
 						},
 					},
-				}.WithID("S.test.S{S.test.SI}"),
+				}).WithID("S.test.S{S.test.SI}"),
 			},
 			actual,
 		)

types.go

@@ -1364,8 +1364,8 @@ func NewFunctionType(
 	typeID string,
 	parameters []Parameter,
 	returnType Type,
-) FunctionType {
-	return FunctionType{
+) *FunctionType {
+	return &FunctionType{
 		typeID:     typeID,
 		Parameters: parameters,
 		ReturnType: returnType,
@@ -1377,18 +1377,18 @@ func NewMeteredFunctionType(
 	typeID string,
 	parameters []Parameter,
 	returnType Type,
-) FunctionType {
+) *FunctionType {
 	common.UseMemory(gauge, common.CadenceFunctionTypeMemoryUsage)
 	return NewFunctionType(typeID, parameters, returnType)
 }
 
-func (FunctionType) isType() {}
+func (*FunctionType) isType() {}
 
-func (t FunctionType) ID() string {
+func (t *FunctionType) ID() string {
 	return t.typeID
 }
 
-func (t FunctionType) WithID(id string) FunctionType {
+func (t *FunctionType) WithID(id string) *FunctionType {
 	t.typeID = id
 	return t
 }
@@ -1459,13 +1459,13 @@ func NewMeteredRestrictedType(
 	return NewRestrictedType(typeID, typ, restrictions)
 }
 
-func (RestrictedType) isType() {}
+func (*RestrictedType) isType() {}
 
-func (t RestrictedType) ID() string {
+func (t *RestrictedType) ID() string {
 	return t.typeID
 }
 
-func (t RestrictedType) WithID(id string) RestrictedType {
+func (t *RestrictedType) WithID(id string) *RestrictedType {
 	t.typeID = id
 	return t
 }

types_test.go

@@ -144,7 +144,7 @@ func TestType_ID(t *testing.T) {
 			"S.test.FooI",
 		},
 		{
-			RestrictedType{}.WithID("S.test.Foo{S.test.FooI}"),
+			(&RestrictedType{}).WithID("S.test.Foo{S.test.FooI}"),
 			"S.test.Foo{S.test.FooI}",
 		},
 	}