fix the export of type values with restricted static types

runtime/convertValues_test.go

@@ -685,6 +685,51 @@ func TestExportTypeValue(t *testing.T) {
 
 		assert.Equal(t, expected, actual)
 	})
+
+	t.Run("with restricted static type", func(t *testing.T) {
+
+		t.Parallel()
+
+		program, err := parser2.ParseProgram(`
+          pub struct interface SI {}
+
+          pub struct S: SI {}
+
+        `)
+		require.NoError(t, err)
+
+		checker, err := sema.NewChecker(program, utils.TestLocation)
+		require.NoError(t, err)
+
+		err = checker.Check()
+		require.NoError(t, err)
+
+		inter, err := interpreter.NewInterpreter(checker)
+		require.NoError(t, err)
+
+		ty := interpreter.TypeValue{
+			Type: &interpreter.RestrictedStaticType{
+				Type: interpreter.CompositeStaticType{
+					Location:            utils.TestLocation,
+					QualifiedIdentifier: "S",
+				},
+				Restrictions: []interpreter.InterfaceStaticType{
+					{
+						Location:            utils.TestLocation,
+						QualifiedIdentifier: "SI",
+					},
+				},
+			},
+		}
+
+		assert.Equal(t,
+			cadence.TypeValue{
+				StaticType: "S.test.S{S.test.SI}",
+			},
+			ExportValue(ty, inter),
+		)
+	})
+
 }
 
 func TestExportCapabilityValue(t *testing.T) {

runtime/interpreter/decode.go

@@ -1429,7 +1429,7 @@ func (d *Decoder) decodeRestrictedStaticType(v interface{}) (StaticType, error)
 		restrictions[i] = restriction
 	}
 
-	return RestrictedStaticType{
+	return &RestrictedStaticType{
 		Type:         restrictedType,
 		Restrictions: restrictions,
 	}, nil

runtime/interpreter/encode.go

@@ -931,7 +931,7 @@ func (e *Encoder) prepareStaticType(t StaticType) (interface{}, error) {
 	case DictionaryStaticType:
 		return e.prepareDictionaryStaticType(v)
 
-	case RestrictedStaticType:
+	case *RestrictedStaticType:
 		return e.prepareRestrictedStaticType(v)
 
 	case CapabilityStaticType:
@@ -1091,7 +1091,7 @@ const (
 	encodedRestrictedStaticTypeRestrictionsFieldKey uint64 = 1
 )
 
-func (e *Encoder) prepareRestrictedStaticType(v RestrictedStaticType) (interface{}, error) {
+func (e *Encoder) prepareRestrictedStaticType(v *RestrictedStaticType) (interface{}, error) {
 	restrictedType, err := e.prepareStaticType(v.Type)
 	if err != nil {
 		return nil, err

runtime/interpreter/encoding_test.go

@@ -3867,7 +3867,7 @@ func TestEncodeDecodeLinkValue(t *testing.T) {
 			encodeDecodeTest{
 				value: LinkValue{
 					TargetPath: publicPathValue,
-					Type: RestrictedStaticType{
+					Type: &RestrictedStaticType{
 						Type: CompositeStaticType{
 							Location:            utils.TestLocation,
 							QualifiedIdentifier: "S",

runtime/interpreter/statictype.go

@@ -130,9 +130,14 @@ type RestrictedStaticType struct {
 	Restrictions []InterfaceStaticType
 }
 
-func (RestrictedStaticType) IsStaticType() {}
+// NOTE: must be pointer receiver, as static types get used in type values,
+// which are used as keys in maps when exporting.
+// Key types in Go maps must be (transitively) hashable types,
+// and slices are not, but `Restrictions` is one.
+//
+func (*RestrictedStaticType) IsStaticType() {}
 
-func (t RestrictedStaticType) String() string {
+func (t *RestrictedStaticType) String() string {
 	restrictions := make([]string, len(t.Restrictions))
 
 	for i, restriction := range t.Restrictions {
@@ -217,7 +222,7 @@ func ConvertSemaToStaticType(t sema.Type) StaticType {
 			restrictions[i] = convertToInterfaceStaticType(restriction)
 		}
 
-		return RestrictedStaticType{
+		return &RestrictedStaticType{
 			Type:         ConvertSemaToStaticType(t.Type),
 			Restrictions: restrictions,
 		}
@@ -288,7 +293,7 @@ func ConvertStaticToSemaType(
 			Type: ConvertStaticToSemaType(t.Type, getInterface, getComposite),
 		}
 
-	case RestrictedStaticType:
+	case *RestrictedStaticType:
 		restrictions := make([]*sema.InterfaceType, len(t.Restrictions))
 
 		for i, restriction := range t.Restrictions {