CHANGELOG.md

@@ -1,3 +1,11 @@
+## 1.0.7 (September 15, 2021)
+
+BUG FIXES:
+
+* core: Remove check for computed attributes which is no longer valid with optional structural attributes ([#29563](https://github.com/hashicorp/terraform/issues/29563))
+* core: Prevent object types with optional attributes from being instantiated as concrete values, which can lead to failures in type comparison ([#29559](https://github.com/hashicorp/terraform/issues/29559))
+* core: Empty containers in the configuration were not planned correctly when used with optional structural attributes ([#29580](https://github.com/hashicorp/terraform/issues/29580))
+
 ## 1.0.6 (September 03, 2021)
 
 ENHANCEMENTS:

internal/backend/unparsed_value_test.go

@@ -24,30 +24,33 @@ func TestParseVariableValuesUndeclared(t *testing.T) {
 	}
 	decls := map[string]*configs.Variable{
 		"declared1": {
-			Name:        "declared1",
-			Type:        cty.String,
-			ParsingMode: configs.VariableParseLiteral,
+			Name:           "declared1",
+			Type:           cty.String,
+			ConstraintType: cty.String,
+			ParsingMode:    configs.VariableParseLiteral,
 			DeclRange: hcl.Range{
 				Filename: "fake.tf",
 				Start:    hcl.Pos{Line: 2, Column: 1, Byte: 0},
 				End:      hcl.Pos{Line: 2, Column: 1, Byte: 0},
 			},
 		},
 		"missing1": {
-			Name:        "missing1",
-			Type:        cty.String,
-			ParsingMode: configs.VariableParseLiteral,
+			Name:           "missing1",
+			Type:           cty.String,
+			ConstraintType: cty.String,
+			ParsingMode:    configs.VariableParseLiteral,
 			DeclRange: hcl.Range{
 				Filename: "fake.tf",
 				Start:    hcl.Pos{Line: 3, Column: 1, Byte: 0},
 				End:      hcl.Pos{Line: 3, Column: 1, Byte: 0},
 			},
 		},
 		"missing2": {
-			Name:        "missing1",
-			Type:        cty.String,
-			ParsingMode: configs.VariableParseLiteral,
-			Default:     cty.StringVal("default for missing2"),
+			Name:           "missing1",
+			Type:           cty.String,
+			ConstraintType: cty.String,
+			ParsingMode:    configs.VariableParseLiteral,
+			Default:        cty.StringVal("default for missing2"),
 			DeclRange: hcl.Range{
 				Filename: "fake.tf",
 				Start:    hcl.Pos{Line: 4, Column: 1, Byte: 0},

internal/configs/configschema/coerce_value.go

@@ -27,16 +27,19 @@ func (b *Block) CoerceValue(in cty.Value) (cty.Value, error) {
 }
 
 func (b *Block) coerceValue(in cty.Value, path cty.Path) (cty.Value, error) {
+	convType := b.specType()
+	impliedType := convType.WithoutOptionalAttributesDeep()
+
 	switch {
 	case in.IsNull():
-		return cty.NullVal(b.ImpliedType()), nil
+		return cty.NullVal(impliedType), nil
 	case !in.IsKnown():
-		return cty.UnknownVal(b.ImpliedType()), nil
+		return cty.UnknownVal(impliedType), nil
 	}
 
 	ty := in.Type()
 	if !ty.IsObjectType() {
-		return cty.UnknownVal(b.ImpliedType()), path.NewErrorf("an object is required")
+		return cty.UnknownVal(impliedType), path.NewErrorf("an object is required")
 	}
 
 	for name := range ty.AttributeTypes() {
@@ -46,29 +49,32 @@ func (b *Block) coerceValue(in cty.Value, path cty.Path) (cty.Value, error) {
 		if _, defined := b.BlockTypes[name]; defined {
 			continue
 		}
-		return cty.UnknownVal(b.ImpliedType()), path.NewErrorf("unexpected attribute %q", name)
+		return cty.UnknownVal(impliedType), path.NewErrorf("unexpected attribute %q", name)
 	}
 
 	attrs := make(map[string]cty.Value)
 
 	for name, attrS := range b.Attributes {
+		attrType := impliedType.AttributeType(name)
+		attrConvType := convType.AttributeType(name)
+
 		var val cty.Value
 		switch {
 		case ty.HasAttribute(name):
 			val = in.GetAttr(name)
 		case attrS.Computed || attrS.Optional:
-			val = cty.NullVal(attrS.Type)
+			val = cty.NullVal(attrType)
 		default:
-			return cty.UnknownVal(b.ImpliedType()), path.NewErrorf("attribute %q is required", name)
+			return cty.UnknownVal(impliedType), path.NewErrorf("attribute %q is required", name)
 		}
 
-		val, err := attrS.coerceValue(val, append(path, cty.GetAttrStep{Name: name}))
+		val, err := convert.Convert(val, attrConvType)
 		if err != nil {
-			return cty.UnknownVal(b.ImpliedType()), err
+			return cty.UnknownVal(impliedType), append(path, cty.GetAttrStep{Name: name}).NewError(err)
 		}
-
 		attrs[name] = val
 	}
+
 	for typeName, blockS := range b.BlockTypes {
 		switch blockS.Nesting {
 
@@ -79,7 +85,7 @@ func (b *Block) coerceValue(in cty.Value, path cty.Path) (cty.Value, error) {
 				val := in.GetAttr(typeName)
 				attrs[typeName], err = blockS.coerceValue(val, append(path, cty.GetAttrStep{Name: typeName}))
 				if err != nil {
-					return cty.UnknownVal(b.ImpliedType()), err
+					return cty.UnknownVal(impliedType), err
 				}
 			default:
 				attrs[typeName] = blockS.EmptyValue()
@@ -100,7 +106,7 @@ func (b *Block) coerceValue(in cty.Value, path cty.Path) (cty.Value, error) {
 				}
 
 				if !coll.CanIterateElements() {
-					return cty.UnknownVal(b.ImpliedType()), path.NewErrorf("must be a list")
+					return cty.UnknownVal(impliedType), path.NewErrorf("must be a list")
 				}
 				l := coll.LengthInt()
 
@@ -116,7 +122,7 @@ func (b *Block) coerceValue(in cty.Value, path cty.Path) (cty.Value, error) {
 						idx, val := it.Element()
 						val, err = blockS.coerceValue(val, append(path, cty.IndexStep{Key: idx}))
 						if err != nil {
-							return cty.UnknownVal(b.ImpliedType()), err
+							return cty.UnknownVal(impliedType), err
 						}
 						elems = append(elems, val)
 					}
@@ -141,7 +147,7 @@ func (b *Block) coerceValue(in cty.Value, path cty.Path) (cty.Value, error) {
 				}
 
 				if !coll.CanIterateElements() {
-					return cty.UnknownVal(b.ImpliedType()), path.NewErrorf("must be a set")
+					return cty.UnknownVal(impliedType), path.NewErrorf("must be a set")
 				}
 				l := coll.LengthInt()
 
@@ -157,7 +163,7 @@ func (b *Block) coerceValue(in cty.Value, path cty.Path) (cty.Value, error) {
 						idx, val := it.Element()
 						val, err = blockS.coerceValue(val, append(path, cty.IndexStep{Key: idx}))
 						if err != nil {
-							return cty.UnknownVal(b.ImpliedType()), err
+							return cty.UnknownVal(impliedType), err
 						}
 						elems = append(elems, val)
 					}
@@ -182,7 +188,7 @@ func (b *Block) coerceValue(in cty.Value, path cty.Path) (cty.Value, error) {
 				}
 
 				if !coll.CanIterateElements() {
-					return cty.UnknownVal(b.ImpliedType()), path.NewErrorf("must be a map")
+					return cty.UnknownVal(impliedType), path.NewErrorf("must be a map")
 				}
 				l := coll.LengthInt()
 				if l == 0 {
@@ -196,11 +202,11 @@ func (b *Block) coerceValue(in cty.Value, path cty.Path) (cty.Value, error) {
 						var err error
 						key, val := it.Element()
 						if key.Type() != cty.String || key.IsNull() || !key.IsKnown() {
-							return cty.UnknownVal(b.ImpliedType()), path.NewErrorf("must be a map")
+							return cty.UnknownVal(impliedType), path.NewErrorf("must be a map")
 						}
 						val, err = blockS.coerceValue(val, append(path, cty.IndexStep{Key: key}))
 						if err != nil {
-							return cty.UnknownVal(b.ImpliedType()), err
+							return cty.UnknownVal(impliedType), err
 						}
 						elems[key.AsString()] = val
 					}
@@ -240,11 +246,3 @@ func (b *Block) coerceValue(in cty.Value, path cty.Path) (cty.Value, error) {
 
 	return cty.ObjectVal(attrs), nil
 }
-
-func (a *Attribute) coerceValue(in cty.Value, path cty.Path) (cty.Value, error) {
-	val, err := convert.Convert(in, a.Type)
-	if err != nil {
-		return cty.UnknownVal(a.Type), path.NewError(err)
-	}
-	return val, nil
-}

internal/configs/configschema/coerce_value_test.go

@@ -538,6 +538,67 @@ func TestCoerceValue(t *testing.T) {
 			}),
 			``,
 		},
+		"nested types": {
+			// handle NestedTypes
+			&Block{
+				Attributes: map[string]*Attribute{
+					"foo": {
+						NestedType: &Object{
+							Nesting: NestingList,
+							Attributes: map[string]*Attribute{
+								"bar": {
+									Type:     cty.String,
+									Required: true,
+								},
+								"baz": {
+									Type:     cty.Map(cty.String),
+									Optional: true,
+								},
+							},
+						},
+						Optional: true,
+					},
+					"fob": {
+						NestedType: &Object{
+							Nesting: NestingSet,
+							Attributes: map[string]*Attribute{
+								"bar": {
+									Type:     cty.String,
+									Optional: true,
+								},
+							},
+						},
+						Optional: true,
+					},
+				},
+			},
+			cty.ObjectVal(map[string]cty.Value{
+				"foo": cty.ListVal([]cty.Value{
+					cty.ObjectVal(map[string]cty.Value{
+						"bar": cty.StringVal("beep"),
+					}),
+					cty.ObjectVal(map[string]cty.Value{
+						"bar": cty.StringVal("boop"),
+					}),
+				}),
+			}),
+			cty.ObjectVal(map[string]cty.Value{
+				"foo": cty.ListVal([]cty.Value{
+					cty.ObjectVal(map[string]cty.Value{
+						"bar": cty.StringVal("beep"),
+						"baz": cty.NullVal(cty.Map(cty.String)),
+					}),
+					cty.ObjectVal(map[string]cty.Value{
+						"bar": cty.StringVal("boop"),
+						"baz": cty.NullVal(cty.Map(cty.String)),
+					}),
+				}),
+				"fob": cty.NullVal(cty.Set(cty.Object(map[string]cty.Type{
+					"bar": cty.String,
+				}))),
+			}),
+			``,
+		},
 	}
 
 	for name, test := range tests {

internal/configs/configschema/decoder_spec.go

@@ -121,7 +121,7 @@ func (b *Block) DecoderSpec() hcldec.Spec {
 			// implied type more complete, but if there are any
 			// dynamically-typed attributes inside we must use a tuple
 			// instead, at the expense of our type then not being predictable.
-			if blockS.Block.ImpliedType().HasDynamicTypes() {
+			if blockS.Block.specType().HasDynamicTypes() {
 				ret[name] = &hcldec.BlockTupleSpec{
 					TypeName: name,
 					Nested:   childSpec,
@@ -153,7 +153,7 @@ func (b *Block) DecoderSpec() hcldec.Spec {
 			// implied type more complete, but if there are any
 			// dynamically-typed attributes inside we must use a tuple
 			// instead, at the expense of our type then not being predictable.
-			if blockS.Block.ImpliedType().HasDynamicTypes() {
+			if blockS.Block.specType().HasDynamicTypes() {
 				ret[name] = &hcldec.BlockObjectSpec{
 					TypeName:   name,
 					Nested:     childSpec,
@@ -191,7 +191,7 @@ func (a *Attribute) decoderSpec(name string) hcldec.Spec {
 			panic("Invalid attribute schema: NestedType and Type cannot both be set. This is a bug in the provider.")
 		}
 
-		ty := a.NestedType.ImpliedType()
+		ty := a.NestedType.specType()
 		ret.Type = ty
 		ret.Required = a.Required || a.NestedType.MinItems > 0
 		return ret

internal/configs/configschema/implied_type.go

@@ -8,11 +8,23 @@ import (
 // ImpliedType returns the cty.Type that would result from decoding a
 // configuration block using the receiving block schema.
 //
+// The type returned from Block.ImpliedType differs from the type returned by
+// hcldec.ImpliedType in that there will be no objects with optional
+// attributes, since this value is not to be used for the decoding of
+// configuration.
+//
 // ImpliedType always returns a result, even if the given schema is
 // inconsistent. Code that creates configschema.Block objects should be
 // tested using the InternalValidate method to detect any inconsistencies
 // that would cause this method to fall back on defaults and assumptions.
 func (b *Block) ImpliedType() cty.Type {
+	return b.specType().WithoutOptionalAttributesDeep()
+}
+
+// specType returns the cty.Type used for decoding a configuration
+// block using the receiving block schema. This is the type used internally by
+// hcldec to decode configuration.
+func (b *Block) specType() cty.Type {
 	if b == nil {
 		return cty.EmptyObject
 	}
@@ -41,22 +53,28 @@ func (b *Block) ContainsSensitive() bool {
 	return false
 }
 
-// ImpliedType returns the cty.Type that would result from decoding a NestedType
-// Attribute using the receiving block schema.
+// ImpliedType returns the cty.Type that would result from decoding a
+// NestedType Attribute using the receiving block schema.
 //
 // ImpliedType always returns a result, even if the given schema is
 // inconsistent. Code that creates configschema.Object objects should be tested
 // using the InternalValidate method to detect any inconsistencies that would
 // cause this method to fall back on defaults and assumptions.
 func (o *Object) ImpliedType() cty.Type {
+	return o.specType().WithoutOptionalAttributesDeep()
+}
+
+// specType returns the cty.Type used for decoding a NestedType Attribute using
+// the receiving block schema.
+func (o *Object) specType() cty.Type {
 	if o == nil {
 		return cty.EmptyObject
 	}
 
 	attrTys := make(map[string]cty.Type, len(o.Attributes))
 	for name, attrS := range o.Attributes {
 		if attrS.NestedType != nil {
-			attrTys[name] = attrS.NestedType.ImpliedType()
+			attrTys[name] = attrS.NestedType.specType()
 		} else {
 			attrTys[name] = attrS.Type
 		}