Fix Value.Type() returning Type referencing nil ptr for eight external values

values.go

@@ -1426,7 +1426,7 @@ func (v Array) String() string {
 // Dictionary
 
 type Dictionary struct {
-	DictionaryType Type
+	DictionaryType *DictionaryType
 	Pairs          []KeyValuePair
 }
 
@@ -1453,6 +1453,11 @@ func NewMeteredDictionary(
 func (Dictionary) isValue() {}
 
 func (v Dictionary) Type() Type {
+	if v.DictionaryType == nil {
+		// Return nil Type instead of Type referencing nil *DictionaryType,
+		// so caller can check if v's type is nil and also prevent nil pointer dereference.
+		return nil
+	}
 	return v.DictionaryType
 }
 
@@ -1541,6 +1546,11 @@ func NewMeteredStruct(
 func (Struct) isValue() {}
 
 func (v Struct) Type() Type {
+	if v.StructType == nil {
+		// Return nil Type instead of Type referencing nil *StructType,
+		// so caller can check if v's type is nil and also prevent nil pointer dereference.
+		return nil
+	}
 	return v.StructType
 }
 
@@ -1619,6 +1629,11 @@ func NewMeteredResource(
 func (Resource) isValue() {}
 
 func (v Resource) Type() Type {
+	if v.ResourceType == nil {
+		// Return nil Type instead of Type referencing nil *ResourceType,
+		// so caller can check if v's type is nil and also prevent nil pointer dereference.
+		return nil
+	}
 	return v.ResourceType
 }
 
@@ -1676,6 +1691,11 @@ func NewMeteredAttachment(
 func (Attachment) isValue() {}
 
 func (v Attachment) Type() Type {
+	if v.AttachmentType == nil {
+		// Return nil Type instead of Type referencing nil *AttachmentType,
+		// so caller can check if v's type is nil and also prevent nil pointer dereference.
+		return nil
+	}
 	return v.AttachmentType
 }
 
@@ -1733,6 +1753,11 @@ func NewMeteredEvent(
 func (Event) isValue() {}
 
 func (v Event) Type() Type {
+	if v.EventType == nil {
+		// Return nil Type instead of Type referencing nil *EventType,
+		// so caller can check if v's type is nil and also prevent nil pointer dereference.
+		return nil
+	}
 	return v.EventType
 }
 
@@ -1789,6 +1814,11 @@ func NewMeteredContract(
 func (Contract) isValue() {}
 
 func (v Contract) Type() Type {
+	if v.ContractType == nil {
+		// Return nil Type instead of Type referencing nil *ContractType,
+		// so caller can check if v's type is nil and also prevent nil pointer dereference.
+		return nil
+	}
 	return v.ContractType
 }
 
@@ -2012,6 +2042,11 @@ func NewMeteredEnum(
 func (Enum) isValue() {}
 
 func (v Enum) Type() Type {
+	if v.EnumType == nil {
+		// Return nil Type instead of Type referencing nil *EnumType,
+		// so caller can check if v's type is nil and also prevent nil pointer dereference.
+		return nil
+	}
 	return v.EnumType
 }
 
@@ -2059,6 +2094,11 @@ func NewMeteredFunction(gauge common.MemoryGauge, functionType *FunctionType) Fu
 func (Function) isValue() {}
 
 func (v Function) Type() Type {
+	if v.FunctionType == nil {
+		// Return nil Type instead of Type referencing nil *FunctionType,
+		// so caller can check if v's type is nil and also prevent nil pointer dereference.
+		return nil
+	}
 	return v.FunctionType
 }
 

values_test.go

@@ -635,6 +635,8 @@ func TestGetType(t *testing.T) {
 			reflect.TypeOf(Event{}):      {},
 			reflect.TypeOf(Resource{}):   {},
 			reflect.TypeOf(Struct{}):     {},
+			reflect.TypeOf(Enum{}):       {},
+			reflect.TypeOf(Attachment{}): {},
 		}
 
 		typelessTypes := map[reflect.Type]struct{}{
@@ -681,14 +683,54 @@ func TestGetType(t *testing.T) {
 		}
 	})
 
-	t.Run("array value", func(t *testing.T) {
+	t.Run("array value without type", func(t *testing.T) {
 		t.Parallel()
 
-		typ := NewConstantSizedArrayType(4, TheInt8Type)
+		// Type is not set.
+		value := NewArray([]Value{})
+		assert.Nil(t, value.Type())
+
+		// Type is nil.
+		value = value.WithType(nil)
+		assert.Nil(t, value.Type())
+
+		// Type is ArrayType(nil).
+		value = value.WithType(ArrayType(nil))
+		assert.Nil(t, value.Type())
+	})
+
+	t.Run("constant sized array value", func(t *testing.T) {
+		t.Parallel()
+
+		typ := NewConstantSizedArrayType(1, TheInt8Type)
+		arrayValue := NewArray([]Value{NewInt8(0)}).WithType(typ)
+		assert.Equal(t, arrayValue.Type(), typ)
+	})
+
+	t.Run("variable sized array value", func(t *testing.T) {
+		t.Parallel()
+
+		typ := NewVariableSizedArrayType(TheInt8Type)
 		arrayValue := NewArray([]Value{}).WithType(typ)
 		assert.Equal(t, arrayValue.Type(), typ)
 	})
 
+	t.Run("contract value without type", func(t *testing.T) {
+		t.Parallel()
+
+		// Type is not set.
+		value := NewContract([]Value{})
+		assert.Nil(t, value.Type())
+
+		// Type is nil.
+		value = value.WithType(nil)
+		assert.Nil(t, value.Type())
+
+		// Type is (*ContractType)(nil).
+		value = value.WithType((*ContractType)(nil))
+		assert.Nil(t, value.Type())
+	})
+
 	t.Run("contract value", func(t *testing.T) {
 		t.Parallel()
 
@@ -697,6 +739,22 @@ func TestGetType(t *testing.T) {
 		assert.Equal(t, typ, value.Type())
 	})
 
+	t.Run("dictionary value without type", func(t *testing.T) {
+		t.Parallel()
+
+		// Type is not set.
+		value := NewDictionary([]KeyValuePair{})
+		assert.Nil(t, value.Type())
+
+		// Type is nil.
+		value = value.WithType(nil)
+		assert.Nil(t, value.Type())
+
+		// Type is (*DictionaryType)(nil).
+		value = value.WithType((*DictionaryType)(nil))
+		assert.Nil(t, value.Type())
+	})
+
 	t.Run("dictionary value", func(t *testing.T) {
 		t.Parallel()
 
@@ -705,6 +763,22 @@ func TestGetType(t *testing.T) {
 		assert.Equal(t, typ, value.Type())
 	})
 
+	t.Run("event value without type", func(t *testing.T) {
+		t.Parallel()
+
+		// Type is not set.
+		value := NewEvent([]Value{})
+		assert.Nil(t, value.Type())
+
+		// Type is nil.
+		value = value.WithType(nil)
+		assert.Nil(t, value.Type())
+
+		// Type is (*EventType)(nil).
+		value = value.WithType((*EventType)(nil))
+		assert.Nil(t, value.Type())
+	})
+
 	t.Run("event value", func(t *testing.T) {
 		t.Parallel()
 
@@ -713,6 +787,22 @@ func TestGetType(t *testing.T) {
 		assert.Equal(t, typ, value.Type())
 	})
 
+	t.Run("resource value without type", func(t *testing.T) {
+		t.Parallel()
+
+		// Type is not set.
+		value := NewResource([]Value{})
+		assert.Nil(t, value.Type())
+
+		// Type is nil.
+		value = value.WithType(nil)
+		assert.Nil(t, value.Type())
+
+		// Type is (*ResourceType)(nil).
+		value = value.WithType((*ResourceType)(nil))
+		assert.Nil(t, value.Type())
+	})
+
 	t.Run("resource value", func(t *testing.T) {
 		t.Parallel()
 
@@ -721,11 +811,75 @@ func TestGetType(t *testing.T) {
 		assert.Equal(t, typ, value.Type())
 	})
 
+	t.Run("struct value without type", func(t *testing.T) {
+		t.Parallel()
+
+		// Type is not set.
+		value := NewStruct([]Value{})
+		assert.Nil(t, value.Type())
+
+		// Type is nil.
+		value = value.WithType(nil)
+		assert.Nil(t, value.Type())
+
+		// Type is (*StructType)(nil).
+		value = value.WithType((*StructType)(nil))
+		assert.Nil(t, value.Type())
+	})
+
 	t.Run("struct value", func(t *testing.T) {
 		t.Parallel()
 
 		typ := NewStructType(nil, "Foo", nil, nil)
 		value := NewStruct([]Value{}).WithType(typ)
 		assert.Equal(t, typ, value.Type())
 	})
+
+	t.Run("enum value without type", func(t *testing.T) {
+		t.Parallel()
+
+		// Type is not set.
+		value := NewEnum([]Value{})
+		assert.Nil(t, value.Type())
+
+		// Type is nil.
+		value = value.WithType(nil)
+		assert.Nil(t, value.Type())
+
+		// Type is (*EnumType)(nil).
+		value = value.WithType((*EnumType)(nil))
+		assert.Nil(t, value.Type())
+	})
+
+	t.Run("enum value", func(t *testing.T) {
+		t.Parallel()
+
+		typ := NewEnumType(nil, "Foo", nil, nil, nil)
+		value := NewEnum([]Value{}).WithType(typ)
+		assert.Equal(t, typ, value.Type())
+	})
+
+	t.Run("attachment value without type", func(t *testing.T) {
+		t.Parallel()
+
+		// Type is not set.
+		value := NewAttachment([]Value{})
+		assert.Nil(t, value.Type())
+
+		// Type is nil.
+		value = value.WithType(nil)
+		assert.Nil(t, value.Type())
+
+		// Type is (*AttachmentType)(nil).
+		value = value.WithType((*AttachmentType)(nil))
+		assert.Nil(t, value.Type())
+	})
+
+	t.Run("attachment value", func(t *testing.T) {
+		t.Parallel()
+
+		typ := NewAttachmentType(nil, nil, "Foo", nil, nil)
+		value := NewAttachment([]Value{}).WithType(typ)
+		assert.Equal(t, typ, value.Type())
+	})
 }