10 files changed, 71 insertions, 43 deletions

diff --git a/vendor/github.com/hashicorp/hcl2/ext/dynblock/README.md b/vendor/github.com/hashicorp/hcl2/ext/dynblock/README.md
index 2b24fdb..f59ce92 100644
--- a/vendor/github.com/hashicorp/hcl2/ext/dynblock/README.md
+++ b/vendor/github.com/hashicorp/hcl2/ext/dynblock/README.md
@@ -95,7 +95,7 @@ schema model provides a description of only one level of nested blocks at
 a time, and thus a new schema must be provided for each additional level of
 nesting.
 
-To make this arduous process as convenient as possbile, this package provides
+To make this arduous process as convenient as possible, this package provides
 a helper function `WalkForEachVariables`, which returns a `WalkVariablesNode`
 instance that can be used to find variables directly in a given body and also
 determine which nested blocks require recursive calls. Using this mechanism
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.
diff --git a/vendor/github.com/hashicorp/hcl2/hcl/json/structure.go b/vendor/github.com/hashicorp/hcl2/hcl/json/structure.go
index bdc0e98..74847c7 100644
--- a/vendor/github.com/hashicorp/hcl2/hcl/json/structure.go
+++ b/vendor/github.com/hashicorp/hcl2/hcl/json/structure.go
@@ -416,12 +416,14 @@ func (e *expression) Value(ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) {
         case *booleanVal:
                 return cty.BoolVal(v.Value), nil
         case *arrayVal:
+                var diags hcl.Diagnostics
                 vals := []cty.Value{}
                 for _, jsonVal := range v.Values {
-                        val, _ := (&expression{src: jsonVal}).Value(ctx)
+                        val, valDiags := (&expression{src: jsonVal}).Value(ctx)
                         vals = append(vals, val)
+                        diags = append(diags, valDiags...)
                 }
-                return cty.TupleVal(vals), nil
+                return cty.TupleVal(vals), diags
         case *objectVal:
                 var diags hcl.Diagnostics
                 attrs := map[string]cty.Value{}
diff --git a/vendor/github.com/hashicorp/hcl2/hcl/spec.md b/vendor/github.com/hashicorp/hcl2/hcl/spec.md
index 8bbaff8..97ef613 100644
--- a/vendor/github.com/hashicorp/hcl2/hcl/spec.md
+++ b/vendor/github.com/hashicorp/hcl2/hcl/spec.md
@@ -66,7 +66,7 @@ _block header schemata_:
 Within a schema, it is an error to request the same attribute name twice or
 to request a block type whose name is also an attribute name. While this can
 in principle be supported in some syntaxes, in other syntaxes the attribute
-and block namespaces are combined and so an an attribute cannot coexist with
+and block namespaces are combined and so an attribute cannot coexist with
 a block whose type name is identical to the attribute name.
 
 The result of applying a body schema to a body is _body content_, which
@@ -497,7 +497,7 @@ producing an unknown value of the target type.
 
 Conversion of any value _to_ the dynamic pseudo-type is a no-op. The result
 is the input value, verbatim. This is the only situation where the conversion
-result value is not of the the given target type.
+result value is not of the given target type.
 
 ### Primitive Type Conversions
 
diff --git a/vendor/github.com/hashicorp/hcl2/hcl/structure.go b/vendor/github.com/hashicorp/hcl2/hcl/structure.go
index b336f30..aab0945 100644
--- a/vendor/github.com/hashicorp/hcl2/hcl/structure.go
+++ b/vendor/github.com/hashicorp/hcl2/hcl/structure.go
@@ -33,9 +33,9 @@ type Blocks []*Block
 type Attributes map[string]*Attribute
 
 // Body is a container for attributes and blocks. It serves as the primary
-// unit of heirarchical structure within configuration.
+// unit of hierarchical structure within configuration.
 //
-// The content of a body cannot be meaningfully intepreted without a schema,
+// The content of a body cannot be meaningfully interpreted without a schema,
 // so Body represents the raw body content and has methods that allow the
 // content to be extracted in terms of a given schema.
 type Body interface {
diff --git a/vendor/github.com/hashicorp/hcl2/hcl/traversal_for_expr.go b/vendor/github.com/hashicorp/hcl2/hcl/traversal_for_expr.go
index d4a565a..f69d5fe 100644
--- a/vendor/github.com/hashicorp/hcl2/hcl/traversal_for_expr.go
+++ b/vendor/github.com/hashicorp/hcl2/hcl/traversal_for_expr.go
@@ -36,7 +36,7 @@ func AbsTraversalForExpr(expr Expression) (Traversal, Diagnostics) {
                 &Diagnostic{
                         Severity: DiagError,
                         Summary:  "Invalid expression",
-                        Detail:   "A static variable reference is required.",
+                        Detail:   "A single static variable reference is required: only attribute access and indexing with constant keys. No calculations, function calls, template expressions, etc are allowed here.",
                         Subject:  expr.Range().Ptr(),
                 },
         }
diff --git a/vendor/github.com/hashicorp/hcl2/hclwrite/format.go b/vendor/github.com/hashicorp/hcl2/hclwrite/format.go
index f20ae23..ded7fb4 100644
--- a/vendor/github.com/hashicorp/hcl2/hclwrite/format.go
+++ b/vendor/github.com/hashicorp/hcl2/hclwrite/format.go
@@ -54,22 +54,12 @@ func formatIndent(lines []formatLine) {
         // which should be more than enough for reasonable HCL uses.
         indents := make([]int, 0, 10)
 
-        inHeredoc := false
         for i := range lines {
                 line := &lines[i]
                 if len(line.lead) == 0 {
                         continue
                 }
 
-                if inHeredoc {
-                        for _, token := range line.lead {
-                                if token.Type == hclsyntax.TokenCHeredoc {
-                                        inHeredoc = false
-                                }
-                        }
-                        continue // don't touch indentation inside heredocs
-                }
-
                 if line.lead[0].Type == hclsyntax.TokenNewline {
                         // Never place spaces before a newline
                         line.lead[0].SpacesBefore = 0
@@ -80,9 +70,10 @@ func formatIndent(lines []formatLine) {
                 for _, token := range line.lead {
                         netBrackets += tokenBracketChange(token)
                         if token.Type == hclsyntax.TokenOHeredoc {
-                                inHeredoc = true
+                                break
                         }
                 }
+
                 for _, token := range line.assign {
                         netBrackets += tokenBracketChange(token)
                 }
@@ -391,9 +382,9 @@ func linesForFormat(tokens Tokens) []formatLine {
 
         // Now we'll pick off any trailing comments and attribute assignments
         // to shuffle off into the "comment" and "assign" cells.
-        inHeredoc := false
         for i := range lines {
                 line := &lines[i]
+
                 if len(line.lead) == 0 {
                         // if the line is empty then there's nothing for us to do
                         // (this should happen only for the final line, because all other
@@ -401,26 +392,6 @@ func linesForFormat(tokens Tokens) []formatLine {
                         continue
                 }
 
-                if inHeredoc {
-                        for _, tok := range line.lead {
-                                if tok.Type == hclsyntax.TokenCHeredoc {
-                                        inHeredoc = false
-                                        break
-                                }
-                        }
-                        // Inside a heredoc everything is "lead", even if there's a
-                        // template interpolation embedded in there that might otherwise
-                        // confuse our logic below.
-                        continue
-                }
-
-                for _, tok := range line.lead {
-                        if tok.Type == hclsyntax.TokenOHeredoc {
-                                inHeredoc = true
-                                break
-                        }
-                }
-
                 if len(line.lead) > 1 && line.lead[len(line.lead)-1].Type == hclsyntax.TokenComment {
                         line.comment = line.lead[len(line.lead)-1:]
                         line.lead = line.lead[:len(line.lead)-1]