4 files changed, 58 insertions, 3 deletions

diff --git a/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/expression.go b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/expression.go
index 26819a2..d3f7a74 100644
--- a/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/expression.go
+++ b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/expression.go
@@ -473,8 +473,35 @@ func (e *ConditionalExpr) Value(ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostic
         falseResult, falseDiags := e.FalseResult.Value(ctx)
         var diags hcl.Diagnostics
 
-        // Try to find a type that both results can be converted to.
-        resultType, convs := convert.UnifyUnsafe([]cty.Type{trueResult.Type(), falseResult.Type()})
+        resultType := cty.DynamicPseudoType
+        convs := make([]convert.Conversion, 2)
+
+        switch {
+        // If either case is a dynamic null value (which would result from a
+        // literal null in the config), we know that it can convert to the expected
+        // type of the opposite case, and we don't need to speculatively reduce the
+        // final result type to DynamicPseudoType.
+
+        // If we know that either Type is a DynamicPseudoType, we can be certain
+        // that the other value can convert since it's a pass-through, and we don't
+        // need to unify the types. If the final evaluation results in the dynamic
+        // value being returned, there's no conversion we can do, so we return the
+        // value directly.
+        case trueResult.RawEquals(cty.NullVal(cty.DynamicPseudoType)):
+                resultType = falseResult.Type()
+                convs[0] = convert.GetConversionUnsafe(cty.DynamicPseudoType, resultType)
+        case falseResult.RawEquals(cty.NullVal(cty.DynamicPseudoType)):
+                resultType = trueResult.Type()
+                convs[1] = convert.GetConversionUnsafe(cty.DynamicPseudoType, resultType)
+        case trueResult.Type() == cty.DynamicPseudoType, falseResult.Type() == cty.DynamicPseudoType:
+                // the final resultType type is still unknown
+                // we don't need to get the conversion, because both are a noop.
+
+        default:
+                // Try to find a type that both results can be converted to.
+                resultType, convs = convert.UnifyUnsafe([]cty.Type{trueResult.Type(), falseResult.Type()})
+        }
+
         if resultType == cty.NilType {
                 return cty.DynamicVal, hcl.Diagnostics{
                         {
diff --git a/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/expression_template.go b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/expression_template.go
index fa79e3d..ca3dae1 100644
--- a/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/expression_template.go
+++ b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/expression_template.go
@@ -89,6 +89,26 @@ func (e *TemplateExpr) StartRange() hcl.Range {
         return e.Parts[0].StartRange()
 }
 
+// IsStringLiteral returns true if and only if the template consists only of
+// single string literal, as would be created for a simple quoted string like
+// "foo".
+//
+// If this function returns true, then calling Value on the same expression
+// with a nil EvalContext will return the literal value.
+//
+// Note that "${"foo"}", "${1}", etc aren't considered literal values for the
+// purposes of this method, because the intent of this method is to identify
+// situations where the user seems to be explicitly intending literal string
+// interpretation, not situations that result in literals as a technicality
+// of the template expression unwrapping behavior.
+func (e *TemplateExpr) IsStringLiteral() bool {
+        if len(e.Parts) != 1 {
+                return false
+        }
+        _, ok := e.Parts[0].(*LiteralValueExpr)
+        return ok
+}
+
 // TemplateJoinExpr is used to convert tuples of strings produced by template
 // constructs (i.e. for loops) into flat strings, by converting the values
 // tos strings and joining them. This AST node is not used directly; it's
diff --git a/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/parser.go b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/parser.go
index 253ad50..772ebae 100644
--- a/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/parser.go
+++ b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/parser.go
@@ -853,6 +853,14 @@ Traversal:
                                                 SrcRange: rng,
                                         }
                                         ret = makeRelativeTraversal(ret, step, rng)
+                                } else if tmpl, isTmpl := keyExpr.(*TemplateExpr); isTmpl && tmpl.IsStringLiteral() {
+                                        litKey, _ := tmpl.Value(nil)
+                                        rng := hcl.RangeBetween(open.Range, close.Range)
+                                        step := hcl.TraverseIndex{
+                                                Key:      litKey,
+                                                SrcRange: rng,
+                                        }
+                                        ret = makeRelativeTraversal(ret, step, rng)
                                 } else {
                                         rng := hcl.RangeBetween(open.Range, close.Range)
                                         ret = &IndexExpr{
diff --git a/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/spec.md b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/spec.md
index 091c1c2..d7faeed 100644
--- a/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/spec.md
+++ b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/spec.md
@@ -187,7 +187,7 @@ for later evaluation by the calling application.
 ### Blocks
 
 A _block_ creates a child body that is annotated with a block _type_ and
-zero or more block _labels_. Blocks create a structural hierachy which can be
+zero or more block _labels_. Blocks create a structural hierarchy which can be
 interpreted by the calling application.
 
 Block labels can either be quoted literal strings or naked identifiers.