Merge pull request #1043 from onflow/bastian/static-types-in-dynamic-…

…container-types

Include and consider static types of arrays and dictionaries

runtime/interpreter/dynamictype.go

@@ -79,6 +79,7 @@ func (BoolDynamicType) IsImportable() bool {
 
 type ArrayDynamicType struct {
 	ElementTypes []DynamicType
+	StaticType   ArrayStaticType
 }
 
 func (ArrayDynamicType) IsDynamicType() {}
@@ -119,8 +120,14 @@ func (t CompositeDynamicType) IsImportable() bool {
 
 // DictionaryDynamicType
 
+type DictionaryStaticTypeEntry struct {
+	KeyType   DynamicType
+	ValueType DynamicType
+}
+
 type DictionaryDynamicType struct {
-	EntryTypes []struct{ KeyType, ValueType DynamicType }
+	EntryTypes []DictionaryStaticTypeEntry
+	StaticType DictionaryStaticType
 }
 
 func (DictionaryDynamicType) IsDynamicType() {}

runtime/interpreter/interpreter.go

@@ -1769,7 +1769,7 @@ func (interpreter *Interpreter) checkValueTransferTargetType(value Value, target
 	dynamicTypeResults := DynamicTypeResults{}
 
 	valueDynamicType := value.DynamicType(interpreter, dynamicTypeResults)
-	if IsSubType(valueDynamicType, targetType) {
+	if interpreter.IsSubType(valueDynamicType, targetType) {
 		return true
 	}
 
@@ -2635,7 +2635,7 @@ func defineStringFunction(activation *VariableActivation) {
 // - Character
 // - Block
 
-func IsSubType(subType DynamicType, superType sema.Type) bool {
+func (interpreter *Interpreter) IsSubType(subType DynamicType, superType sema.Type) bool {
 	switch typedSubType := subType.(type) {
 	case MetaTypeDynamicType:
 		switch superType {
@@ -2684,9 +2684,19 @@ func IsSubType(subType DynamicType, superType sema.Type) bool {
 		case *sema.VariableSizedType:
 			superTypeElementType = typedSuperType.Type
 
+			subTypeStaticType := interpreter.ConvertStaticToSemaType(typedSubType.StaticType)
+			if !sema.IsSubType(subTypeStaticType, typedSuperType) {
+				return false
+			}
+
 		case *sema.ConstantSizedType:
 			superTypeElementType = typedSuperType.Type
 
+			subTypeStaticType := interpreter.ConvertStaticToSemaType(typedSubType.StaticType)
+			if !sema.IsSubType(subTypeStaticType, typedSuperType) {
+				return false
+			}
+
 		default:
 			switch superType {
 			case sema.AnyStructType, sema.AnyResourceType:
@@ -2697,7 +2707,7 @@ func IsSubType(subType DynamicType, superType sema.Type) bool {
 		}
 
 		for _, elementType := range typedSubType.ElementTypes {
-			if !IsSubType(elementType, superTypeElementType) {
+			if !interpreter.IsSubType(elementType, superTypeElementType) {
 				return false
 			}
 		}
@@ -2707,9 +2717,15 @@ func IsSubType(subType DynamicType, superType sema.Type) bool {
 	case DictionaryDynamicType:
 
 		if typedSuperType, ok := superType.(*sema.DictionaryType); ok {
+
+			subTypeStaticType := interpreter.ConvertStaticToSemaType(typedSubType.StaticType)
+			if !sema.IsSubType(subTypeStaticType, typedSuperType) {
+				return false
+			}
+
 			for _, entryTypes := range typedSubType.EntryTypes {
-				if !IsSubType(entryTypes.KeyType, typedSuperType.KeyType) ||
-					!IsSubType(entryTypes.ValueType, typedSuperType.ValueType) {
+				if !interpreter.IsSubType(entryTypes.KeyType, typedSuperType.KeyType) ||
+					!interpreter.IsSubType(entryTypes.ValueType, typedSuperType.ValueType) {
 
 					return false
 				}
@@ -2735,7 +2751,7 @@ func IsSubType(subType DynamicType, superType sema.Type) bool {
 
 	case SomeDynamicType:
 		if typedSuperType, ok := superType.(*sema.OptionalType); ok {
-			return IsSubType(typedSubType.InnerType, typedSuperType.Type)
+			return interpreter.IsSubType(typedSubType.InnerType, typedSuperType.Type)
 		}
 
 		switch superType {
@@ -2749,7 +2765,7 @@ func IsSubType(subType DynamicType, superType sema.Type) bool {
 			// First, check that the dynamic type of the referenced value
 			// is a subtype of the super type
 
-			if !IsSubType(typedSubType.InnerType(), typedSuperType.Type) {
+			if !interpreter.IsSubType(typedSubType.InnerType(), typedSuperType.Type) {
 				return false
 			}
 
@@ -2919,7 +2935,7 @@ func (interpreter *Interpreter) authAccountReadFunction(addressValue AddressValu
 			dynamicTypeResults := DynamicTypeResults{}
 
 			dynamicType := value.Value.DynamicType(interpreter, dynamicTypeResults)
-			if !IsSubType(dynamicType, ty) {
+			if !interpreter.IsSubType(dynamicType, ty) {
 				return NilValue{}
 			}
 
@@ -3412,7 +3428,7 @@ func (interpreter *Interpreter) isInstanceFunction(self Value) HostFunctionValue
 			// NOTE: not invocation.Self, as that is only set for composite values
 			dynamicTypeResults := DynamicTypeResults{}
 			dynamicType := self.DynamicType(interpreter, dynamicTypeResults)
-			result := IsSubType(dynamicType, semaType)
+			result := interpreter.IsSubType(dynamicType, semaType)
 			return BoolValue(result)
 		},
 	)

runtime/interpreter/interpreter_expression.go

@@ -636,7 +636,7 @@ func (interpreter *Interpreter) VisitCastingExpression(expression *ast.CastingEx
 	case ast.OperationFailableCast, ast.OperationForceCast:
 		dynamicTypeResults := DynamicTypeResults{}
 		dynamicType := value.DynamicType(interpreter, dynamicTypeResults)
-		isSubType := IsSubType(dynamicType, expectedType)
+		isSubType := interpreter.IsSubType(dynamicType, expectedType)
 
 		switch expression.Operation {
 		case ast.OperationFailableCast:

runtime/interpreter/value.go

@@ -720,6 +720,7 @@ func (v *ArrayValue) DynamicType(interpreter *Interpreter, results DynamicTypeRe
 
 	return ArrayDynamicType{
 		ElementTypes: elementTypes,
+		StaticType:   v.Type,
 	}
 }
 
@@ -1101,6 +1102,16 @@ func (v *ArrayValue) Equal(other Value, interpreter *Interpreter, loadDeferred b
 		return false
 	}
 
+	if v.Type == nil {
+		if otherArray.Type != nil {
+			return false
+		}
+	} else if otherArray.Type == nil ||
+		!v.Type.Equal(otherArray.Type) {
+
+		return false
+	}
+
 	for i, value := range elements {
 		otherValue := otherElements[i]
 
@@ -7160,7 +7171,7 @@ func (v *CompositeValue) ConformsToDynamicType(
 		dynamicTypeResults := DynamicTypeResults{}
 		fieldDynamicType := field.DynamicType(interpreter, dynamicTypeResults)
 
-		if !IsSubType(fieldDynamicType, member.TypeAnnotation.Type) {
+		if !interpreter.IsSubType(fieldDynamicType, member.TypeAnnotation.Type) {
 			return false
 		}
 
@@ -7459,21 +7470,22 @@ func (v *DictionaryValue) Walk(walkChild func(Value)) {
 
 func (v *DictionaryValue) DynamicType(interpreter *Interpreter, results DynamicTypeResults) DynamicType {
 	keys := v.Keys().Elements()
-	entryTypes := make([]struct{ KeyType, ValueType DynamicType }, len(keys))
+	entryTypes := make([]DictionaryStaticTypeEntry, len(keys))
 
 	for i, key := range keys {
 		// NOTE: Force unwrap, otherwise dynamic type check is for optional type.
 		// This is safe because we are iterating over the keys.
 		value := v.Get(interpreter, ReturnEmptyLocationRange, key).(*SomeValue).Value
 		entryTypes[i] =
-			struct{ KeyType, ValueType DynamicType }{
+			DictionaryStaticTypeEntry{
 				KeyType:   key.DynamicType(interpreter, results),
 				ValueType: value.DynamicType(interpreter, results),
 			}
 	}
 
 	return DictionaryDynamicType{
 		EntryTypes: entryTypes,
+		StaticType: v.Type,
 	}
 }
 
@@ -7966,6 +7978,10 @@ func (v *DictionaryValue) Equal(other Value, interpreter *Interpreter, loadDefer
 	v.ensureLoaded()
 	otherDictionary.ensureLoaded()
 
+	if !v.Type.Equal(otherDictionary.Type) {
+		return false
+	}
+
 	if !v.keys.Equal(otherDictionary.keys, interpreter, loadDeferred) {
 		return false
 	}
@@ -8388,8 +8404,8 @@ func (v *StorageReferenceValue) ReferencedValue(interpreter *Interpreter) *Value
 		if v.BorrowedType != nil {
 			dynamicTypeResults := DynamicTypeResults{}
 			dynamicType := value.DynamicType(interpreter, dynamicTypeResults)
-			if !IsSubType(dynamicType, v.BorrowedType) {
-				IsSubType(dynamicType, v.BorrowedType)
+			if !interpreter.IsSubType(dynamicType, v.BorrowedType) {
+				interpreter.IsSubType(dynamicType, v.BorrowedType)
 				return nil
 			}
 		}

runtime/interpreter/value_test.go

@@ -1723,6 +1723,78 @@ func TestArrayValue_Equal(t *testing.T) {
 		)
 	})
 
+	t.Run("different types", func(t *testing.T) {
+
+		t.Parallel()
+
+		uint16ArrayStaticType := VariableSizedStaticType{
+			Type: PrimitiveStaticTypeUInt16,
+		}
+
+		require.False(t,
+			NewArrayValueUnownedNonCopying(
+				uint8ArrayStaticType,
+			).Equal(
+				NewArrayValueUnownedNonCopying(
+					uint16ArrayStaticType,
+				),
+				nil,
+				true,
+			),
+		)
+	})
+
+	t.Run("no type, type", func(t *testing.T) {
+
+		t.Parallel()
+
+		require.False(t,
+			NewArrayValueUnownedNonCopying(
+				nil,
+			).Equal(
+				NewArrayValueUnownedNonCopying(
+					uint8ArrayStaticType,
+				),
+				nil,
+				true,
+			),
+		)
+	})
+
+	t.Run("type, no type", func(t *testing.T) {
+
+		t.Parallel()
+
+		require.False(t,
+			NewArrayValueUnownedNonCopying(
+				uint8ArrayStaticType,
+			).Equal(
+				NewArrayValueUnownedNonCopying(
+					nil,
+				),
+				nil,
+				true,
+			),
+		)
+	})
+
+	t.Run("no types", func(t *testing.T) {
+
+		t.Parallel()
+
+		require.True(t,
+			NewArrayValueUnownedNonCopying(
+				nil,
+			).Equal(
+				NewArrayValueUnownedNonCopying(
+					nil,
+				),
+				nil,
+				true,
+			),
+		)
+	})
+
 	t.Run("different kind", func(t *testing.T) {
 
 		t.Parallel()
@@ -1871,6 +1943,28 @@ func TestDictionaryValue_Equal(t *testing.T) {
 		)
 	})
 
+	t.Run("different types", func(t *testing.T) {
+
+		t.Parallel()
+
+		stringByteDictionaryStaticType := DictionaryStaticType{
+			KeyType:   PrimitiveStaticTypeString,
+			ValueType: PrimitiveStaticTypeUInt8,
+		}
+
+		require.False(t,
+			NewDictionaryValueUnownedNonCopying(
+				byteStringDictionaryType,
+			).Equal(
+				NewDictionaryValueUnownedNonCopying(
+					stringByteDictionaryStaticType,
+				),
+				nil,
+				true,
+			),
+		)
+	})
+
 	t.Run("different kind", func(t *testing.T) {
 
 		t.Parallel()

runtime/runtime.go

@@ -695,7 +695,7 @@ func validateArgumentParams(
 		}
 
 		// Check that decoded value is a subtype of static parameter type
-		if !interpreter.IsSubType(dynamicType, parameterType) {
+		if !inter.IsSubType(dynamicType, parameterType) {
 			return nil, &InvalidEntryPointArgumentError{
 				Index: i,
 				Err: &InvalidValueTypeError{