11 files changed, 683 insertions, 2 deletions

diff --git a/vendor/github.com/hashicorp/terraform/tfdiags/config_traversals.go b/vendor/github.com/hashicorp/terraform/tfdiags/config_traversals.go
new file mode 100644
index 0000000..8e41f46
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/tfdiags/config_traversals.go
@@ -0,0 +1,68 @@
+package tfdiags
+
+import (
+        "bytes"
+        "fmt"
+        "strconv"
+
+        "github.com/zclconf/go-cty/cty"
+)
+
+// FormatCtyPath is a helper function to produce a user-friendly string
+// representation of a cty.Path. The result uses a syntax similar to the
+// HCL expression language in the hope of it being familiar to users.
+func FormatCtyPath(path cty.Path) string {
+        var buf bytes.Buffer
+        for _, step := range path {
+                switch ts := step.(type) {
+                case cty.GetAttrStep:
+                        fmt.Fprintf(&buf, ".%s", ts.Name)
+                case cty.IndexStep:
+                        buf.WriteByte('[')
+                        key := ts.Key
+                        keyTy := key.Type()
+                        switch {
+                        case key.IsNull():
+                                buf.WriteString("null")
+                        case !key.IsKnown():
+                                buf.WriteString("(not yet known)")
+                        case keyTy == cty.Number:
+                                bf := key.AsBigFloat()
+                                buf.WriteString(bf.Text('g', -1))
+                        case keyTy == cty.String:
+                                buf.WriteString(strconv.Quote(key.AsString()))
+                        default:
+                                buf.WriteString("...")
+                        }
+                        buf.WriteByte(']')
+                }
+        }
+        return buf.String()
+}
+
+// FormatError is a helper function to produce a user-friendly string
+// representation of certain special error types that we might want to
+// include in diagnostic messages.
+//
+// This currently has special behavior only for cty.PathError, where a
+// non-empty path is rendered in a HCL-like syntax as context.
+func FormatError(err error) string {
+        perr, ok := err.(cty.PathError)
+        if !ok || len(perr.Path) == 0 {
+                return err.Error()
+        }
+
+        return fmt.Sprintf("%s: %s", FormatCtyPath(perr.Path), perr.Error())
+}
+
+// FormatErrorPrefixed is like FormatError except that it presents any path
+// information after the given prefix string, which is assumed to contain
+// an HCL syntax representation of the value that errors are relative to.
+func FormatErrorPrefixed(err error, prefix string) string {
+        perr, ok := err.(cty.PathError)
+        if !ok || len(perr.Path) == 0 {
+                return fmt.Sprintf("%s: %s", prefix, err.Error())
+        }
+
+        return fmt.Sprintf("%s%s: %s", prefix, FormatCtyPath(perr.Path), perr.Error())
+}
diff --git a/vendor/github.com/hashicorp/terraform/tfdiags/contextual.go b/vendor/github.com/hashicorp/terraform/tfdiags/contextual.go
new file mode 100644
index 0000000..25b2140
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/tfdiags/contextual.go
@@ -0,0 +1,372 @@
+package tfdiags
+
+import (
+        "github.com/hashicorp/hcl2/hcl"
+        "github.com/zclconf/go-cty/cty"
+        "github.com/zclconf/go-cty/cty/gocty"
+)
+
+// The "contextual" family of diagnostics are designed to allow separating
+// the detection of a problem from placing that problem in context. For
+// example, some code that is validating an object extracted from configuration
+// may not have access to the configuration that generated it, but can still
+// report problems within that object which the caller can then place in
+// context by calling IsConfigBody on the returned diagnostics.
+//
+// When contextual diagnostics are used, the documentation for a method must
+// be very explicit about what context is implied for any diagnostics returned,
+// to help ensure the expected result.
+
+// contextualFromConfig is an interface type implemented by diagnostic types
+// that can elaborate themselves when given information about the configuration
+// body they are embedded in.
+//
+// Usually this entails extracting source location information in order to
+// populate the "Subject" range.
+type contextualFromConfigBody interface {
+        ElaborateFromConfigBody(hcl.Body) Diagnostic
+}
+
+// InConfigBody returns a copy of the receiver with any config-contextual
+// diagnostics elaborated in the context of the given body.
+func (d Diagnostics) InConfigBody(body hcl.Body) Diagnostics {
+        if len(d) == 0 {
+                return nil
+        }
+
+        ret := make(Diagnostics, len(d))
+        for i, srcDiag := range d {
+                if cd, isCD := srcDiag.(contextualFromConfigBody); isCD {
+                        ret[i] = cd.ElaborateFromConfigBody(body)
+                } else {
+                        ret[i] = srcDiag
+                }
+        }
+
+        return ret
+}
+
+// AttributeValue returns a diagnostic about an attribute value in an implied current
+// configuration context. This should be returned only from functions whose
+// interface specifies a clear configuration context that this will be
+// resolved in.
+//
+// The given path is relative to the implied configuration context. To describe
+// a top-level attribute, it should be a single-element cty.Path with a
+// cty.GetAttrStep. It's assumed that the path is returning into a structure
+// that would be produced by our conventions in the configschema package; it
+// may return unexpected results for structures that can't be represented by
+// configschema.
+//
+// Since mapping attribute paths back onto configuration is an imprecise
+// operation (e.g. dynamic block generation may cause the same block to be
+// evaluated multiple times) the diagnostic detail should include the attribute
+// name and other context required to help the user understand what is being
+// referenced in case the identified source range is not unique.
+//
+// The returned attribute will not have source location information until
+// context is applied to the containing diagnostics using diags.InConfigBody.
+// After context is applied, the source location is the value assigned to the
+// named attribute, or the containing body's "missing item range" if no
+// value is present.
+func AttributeValue(severity Severity, summary, detail string, attrPath cty.Path) Diagnostic {
+        return &attributeDiagnostic{
+                diagnosticBase: diagnosticBase{
+                        severity: severity,
+                        summary:  summary,
+                        detail:   detail,
+                },
+                attrPath: attrPath,
+        }
+}
+
+// GetAttribute extracts an attribute cty.Path from a diagnostic if it contains
+// one. Normally this is not accessed directly, and instead the config body is
+// added to the Diagnostic to create a more complete message for the user. In
+// some cases however, we may want to know just the name of the attribute that
+// generated the Diagnostic message.
+// This returns a nil cty.Path if it does not exist in the Diagnostic.
+func GetAttribute(d Diagnostic) cty.Path {
+        if d, ok := d.(*attributeDiagnostic); ok {
+                return d.attrPath
+        }
+        return nil
+}
+
+type attributeDiagnostic struct {
+        diagnosticBase
+        attrPath cty.Path
+        subject  *SourceRange // populated only after ElaborateFromConfigBody
+}
+
+// ElaborateFromConfigBody finds the most accurate possible source location
+// for a diagnostic's attribute path within the given body.
+//
+// Backing out from a path back to a source location is not always entirely
+// possible because we lose some information in the decoding process, so
+// if an exact position cannot be found then the returned diagnostic will
+// refer to a position somewhere within the containing body, which is assumed
+// to be better than no location at all.
+//
+// If possible it is generally better to report an error at a layer where
+// source location information is still available, for more accuracy. This
+// is not always possible due to system architecture, so this serves as a
+// "best effort" fallback behavior for such situations.
+func (d *attributeDiagnostic) ElaborateFromConfigBody(body hcl.Body) Diagnostic {
+        if len(d.attrPath) < 1 {
+                // Should never happen, but we'll allow it rather than crashing.
+                return d
+        }
+
+        if d.subject != nil {
+                // Don't modify an already-elaborated diagnostic.
+                return d
+        }
+
+        ret := *d
+
+        // This function will often end up re-decoding values that were already
+        // decoded by an earlier step. This is non-ideal but is architecturally
+        // more convenient than arranging for source location information to be
+        // propagated to every place in Terraform, and this happens only in the
+        // presence of errors where performance isn't a concern.
+
+        traverse := d.attrPath[:]
+        final := d.attrPath[len(d.attrPath)-1]
+
+        // Index should never be the first step
+        // as indexing of top blocks (such as resources & data sources)
+        // is handled elsewhere
+        if _, isIdxStep := traverse[0].(cty.IndexStep); isIdxStep {
+                subject := SourceRangeFromHCL(body.MissingItemRange())
+                ret.subject = &subject
+                return &ret
+        }
+
+        // Process index separately
+        idxStep, hasIdx := final.(cty.IndexStep)
+        if hasIdx {
+                final = d.attrPath[len(d.attrPath)-2]
+                traverse = d.attrPath[:len(d.attrPath)-1]
+        }
+
+        // If we have more than one step after removing index
+        // then we'll first try to traverse to a child body
+        // corresponding to the requested path.
+        if len(traverse) > 1 {
+                body = traversePathSteps(traverse, body)
+        }
+
+        // Default is to indicate a missing item in the deepest body we reached
+        // while traversing.
+        subject := SourceRangeFromHCL(body.MissingItemRange())
+        ret.subject = &subject
+
+        // Once we get here, "final" should be a GetAttr step that maps to an
+        // attribute in our current body.
+        finalStep, isAttr := final.(cty.GetAttrStep)
+        if !isAttr {
+                return &ret
+        }
+
+        content, _, contentDiags := body.PartialContent(&hcl.BodySchema{
+                Attributes: []hcl.AttributeSchema{
+                        {
+                                Name:     finalStep.Name,
+                                Required: true,
+                        },
+                },
+        })
+        if contentDiags.HasErrors() {
+                return &ret
+        }
+
+        if attr, ok := content.Attributes[finalStep.Name]; ok {
+                hclRange := attr.Expr.Range()
+                if hasIdx {
+                        // Try to be more precise by finding index range
+                        hclRange = hclRangeFromIndexStepAndAttribute(idxStep, attr)
+                }
+                subject = SourceRangeFromHCL(hclRange)
+                ret.subject = &subject
+        }
+
+        return &ret
+}
+
+func traversePathSteps(traverse []cty.PathStep, body hcl.Body) hcl.Body {
+        for i := 0; i < len(traverse); i++ {
+                step := traverse[i]
+
+                switch tStep := step.(type) {
+                case cty.GetAttrStep:
+
+                        var next cty.PathStep
+                        if i < (len(traverse) - 1) {
+                                next = traverse[i+1]
+                        }
+
+                        // Will be indexing into our result here?
+                        var indexType cty.Type
+                        var indexVal cty.Value
+                        if nextIndex, ok := next.(cty.IndexStep); ok {
+                                indexVal = nextIndex.Key
+                                indexType = indexVal.Type()
+                                i++ // skip over the index on subsequent iterations
+                        }
+
+                        var blockLabelNames []string
+                        if indexType == cty.String {
+                                // Map traversal means we expect one label for the key.
+                                blockLabelNames = []string{"key"}
+                        }
+
+                        // For intermediate steps we expect to be referring to a child
+                        // block, so we'll attempt decoding under that assumption.
+                        content, _, contentDiags := body.PartialContent(&hcl.BodySchema{
+                                Blocks: []hcl.BlockHeaderSchema{
+                                        {
+                                                Type:       tStep.Name,
+                                                LabelNames: blockLabelNames,
+                                        },
+                                },
+                        })
+                        if contentDiags.HasErrors() {
+                                return body
+                        }
+                        filtered := make([]*hcl.Block, 0, len(content.Blocks))
+                        for _, block := range content.Blocks {
+                                if block.Type == tStep.Name {
+                                        filtered = append(filtered, block)
+                                }
+                        }
+                        if len(filtered) == 0 {
+                                // Step doesn't refer to a block
+                                continue
+                        }
+
+                        switch indexType {
+                        case cty.NilType: // no index at all
+                                if len(filtered) != 1 {
+                                        return body
+                                }
+                                body = filtered[0].Body
+                        case cty.Number:
+                                var idx int
+                                err := gocty.FromCtyValue(indexVal, &idx)
+                                if err != nil || idx >= len(filtered) {
+                                        return body
+                                }
+                                body = filtered[idx].Body
+                        case cty.String:
+                                key := indexVal.AsString()
+                                var block *hcl.Block
+                                for _, candidate := range filtered {
+                                        if candidate.Labels[0] == key {
+                                                block = candidate
+                                                break
+                                        }
+                                }
+                                if block == nil {
+                                        // No block with this key, so we'll just indicate a
+                                        // missing item in the containing block.
+                                        return body
+                                }
+                                body = block.Body
+                        default:
+                                // Should never happen, because only string and numeric indices
+                                // are supported by cty collections.
+                                return body
+                        }
+
+                default:
+                        // For any other kind of step, we'll just return our current body
+                        // as the subject and accept that this is a little inaccurate.
+                        return body
+                }
+        }
+        return body
+}
+
+func hclRangeFromIndexStepAndAttribute(idxStep cty.IndexStep, attr *hcl.Attribute) hcl.Range {
+        switch idxStep.Key.Type() {
+        case cty.Number:
+                var idx int
+                err := gocty.FromCtyValue(idxStep.Key, &idx)
+                items, diags := hcl.ExprList(attr.Expr)
+                if diags.HasErrors() {
+                        return attr.Expr.Range()
+                }
+                if err != nil || idx >= len(items) {
+                        return attr.NameRange
+                }
+                return items[idx].Range()
+        case cty.String:
+                pairs, diags := hcl.ExprMap(attr.Expr)
+                if diags.HasErrors() {
+                        return attr.Expr.Range()
+                }
+                stepKey := idxStep.Key.AsString()
+                for _, kvPair := range pairs {
+                        key, err := kvPair.Key.Value(nil)
+                        if err != nil {
+                                return attr.Expr.Range()
+                        }
+                        if key.AsString() == stepKey {
+                                startRng := kvPair.Value.StartRange()
+                                return startRng
+                        }
+                }
+                return attr.NameRange
+        }
+        return attr.Expr.Range()
+}
+
+func (d *attributeDiagnostic) Source() Source {
+        return Source{
+                Subject: d.subject,
+        }
+}
+
+// WholeContainingBody returns a diagnostic about the body that is an implied
+// current configuration context. This should be returned only from
+// functions whose interface specifies a clear configuration context that this
+// will be resolved in.
+//
+// The returned attribute will not have source location information until
+// context is applied to the containing diagnostics using diags.InConfigBody.
+// After context is applied, the source location is currently the missing item
+// range of the body. In future, this may change to some other suitable
+// part of the containing body.
+func WholeContainingBody(severity Severity, summary, detail string) Diagnostic {
+        return &wholeBodyDiagnostic{
+                diagnosticBase: diagnosticBase{
+                        severity: severity,
+                        summary:  summary,
+                        detail:   detail,
+                },
+        }
+}
+
+type wholeBodyDiagnostic struct {
+        diagnosticBase
+        subject *SourceRange // populated only after ElaborateFromConfigBody
+}
+
+func (d *wholeBodyDiagnostic) ElaborateFromConfigBody(body hcl.Body) Diagnostic {
+        if d.subject != nil {
+                // Don't modify an already-elaborated diagnostic.
+                return d
+        }
+
+        ret := *d
+        rng := SourceRangeFromHCL(body.MissingItemRange())
+        ret.subject = &rng
+        return &ret
+}
+
+func (d *wholeBodyDiagnostic) Source() Source {
+        return Source{
+                Subject: d.subject,
+        }
+}
diff --git a/vendor/github.com/hashicorp/terraform/tfdiags/diagnostic.go b/vendor/github.com/hashicorp/terraform/tfdiags/diagnostic.go
index 2c23f76..c91ba9a 100644
--- a/vendor/github.com/hashicorp/terraform/tfdiags/diagnostic.go
+++ b/vendor/github.com/hashicorp/terraform/tfdiags/diagnostic.go
@@ -1,9 +1,18 @@
 package tfdiags
 
+import (
+        "github.com/hashicorp/hcl2/hcl"
+)
+
 type Diagnostic interface {
         Severity() Severity
         Description() Description
         Source() Source
+
+        // FromExpr returns the expression-related context for the diagnostic, if
+        // available. Returns nil if the diagnostic is not related to an
+        // expression evaluation.
+        FromExpr() *FromExpr
 }
 
 type Severity rune
@@ -24,3 +33,8 @@ type Source struct {
         Subject *SourceRange
         Context *SourceRange
 }
+
+type FromExpr struct {
+        Expression  hcl.Expression
+        EvalContext *hcl.EvalContext
+}
diff --git a/vendor/github.com/hashicorp/terraform/tfdiags/diagnostic_base.go b/vendor/github.com/hashicorp/terraform/tfdiags/diagnostic_base.go
new file mode 100644
index 0000000..50bf9d8
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/tfdiags/diagnostic_base.go
@@ -0,0 +1,31 @@
+package tfdiags
+
+// diagnosticBase can be embedded in other diagnostic structs to get
+// default implementations of Severity and Description. This type also
+// has default implementations of Source and FromExpr that return no source
+// location or expression-related information, so embedders should generally
+// override those method to return more useful results where possible.
+type diagnosticBase struct {
+        severity Severity
+        summary  string
+        detail   string
+}
+
+func (d diagnosticBase) Severity() Severity {
+        return d.severity
+}
+
+func (d diagnosticBase) Description() Description {
+        return Description{
+                Summary: d.summary,
+                Detail:  d.detail,
+        }
+}
+
+func (d diagnosticBase) Source() Source {
+        return Source{}
+}
+
+func (d diagnosticBase) FromExpr() *FromExpr {
+        return nil
+}
diff --git a/vendor/github.com/hashicorp/terraform/tfdiags/diagnostics.go b/vendor/github.com/hashicorp/terraform/tfdiags/diagnostics.go
index 667ba80..465b230 100644
--- a/vendor/github.com/hashicorp/terraform/tfdiags/diagnostics.go
+++ b/vendor/github.com/hashicorp/terraform/tfdiags/diagnostics.go
@@ -3,6 +3,9 @@ package tfdiags
 import (
         "bytes"
         "fmt"
+        "path/filepath"
+        "sort"
+        "strings"
 
         "github.com/hashicorp/errwrap"
         multierror "github.com/hashicorp/go-multierror"
@@ -54,6 +57,8 @@ func (diags Diagnostics) Append(new ...interface{}) Diagnostics {
                         diags = append(diags, ti...) // flatten
                 case diagnosticsAsError:
                         diags = diags.Append(ti.Diagnostics) // unwrap
+                case NonFatalError:
+                        diags = diags.Append(ti.Diagnostics) // unwrap
                 case hcl.Diagnostics:
                         for _, hclDiag := range ti {
                                 diags = append(diags, hclDiagnostic{hclDiag})
@@ -136,6 +141,54 @@ func (diags Diagnostics) Err() error {
         return diagnosticsAsError{diags}
 }
 
+// ErrWithWarnings is similar to Err except that it will also return a non-nil
+// error if the receiver contains only warnings.
+//
+// In the warnings-only situation, the result is guaranteed to be of dynamic
+// type NonFatalError, allowing diagnostics-aware callers to type-assert
+// and unwrap it, treating it as non-fatal.
+//
+// This should be used only in contexts where the caller is able to recognize
+// and handle NonFatalError. For normal callers that expect a lack of errors
+// to be signaled by nil, use just Diagnostics.Err.
+func (diags Diagnostics) ErrWithWarnings() error {
+        if len(diags) == 0 {
+                return nil
+        }
+        if diags.HasErrors() {
+                return diags.Err()
+        }
+        return NonFatalError{diags}
+}
+
+// NonFatalErr is similar to Err except that it always returns either nil
+// (if there are no diagnostics at all) or NonFatalError.
+//
+// This allows diagnostics to be returned over an error return channel while
+// being explicit that the diagnostics should not halt processing.
+//
+// This should be used only in contexts where the caller is able to recognize
+// and handle NonFatalError. For normal callers that expect a lack of errors
+// to be signaled by nil, use just Diagnostics.Err.
+func (diags Diagnostics) NonFatalErr() error {
+        if len(diags) == 0 {
+                return nil
+        }
+        return NonFatalError{diags}
+}
+
+// Sort applies an ordering to the diagnostics in the receiver in-place.
+//
+// The ordering is: warnings before errors, sourceless before sourced,
+// short source paths before long source paths, and then ordering by
+// position within each file.
+//
+// Diagnostics that do not differ by any of these sortable characteristics
+// will remain in the same relative order after this method returns.
+func (diags Diagnostics) Sort() {
+        sort.Stable(sortDiagnostics(diags))
+}
+
 type diagnosticsAsError struct {
         Diagnostics
 }
@@ -179,3 +232,99 @@ func (dae diagnosticsAsError) WrappedErrors() []error {
         }
         return errs
 }
+
+// NonFatalError is a special error type, returned by
+// Diagnostics.ErrWithWarnings and Diagnostics.NonFatalErr,
+// that indicates that the wrapped diagnostics should be treated as non-fatal.
+// Callers can conditionally type-assert an error to this type in order to
+// detect the non-fatal scenario and handle it in a different way.
+type NonFatalError struct {
+        Diagnostics
+}
+
+func (woe NonFatalError) Error() string {
+        diags := woe.Diagnostics
+        switch {
+        case len(diags) == 0:
+                // should never happen, since we don't create this wrapper if
+                // there are no diagnostics in the list.
+                return "no errors or warnings"
+        case len(diags) == 1:
+                desc := diags[0].Description()
+                if desc.Detail == "" {
+                        return desc.Summary
+                }
+                return fmt.Sprintf("%s: %s", desc.Summary, desc.Detail)
+        default:
+                var ret bytes.Buffer
+                if diags.HasErrors() {
+                        fmt.Fprintf(&ret, "%d problems:\n", len(diags))
+                } else {
+                        fmt.Fprintf(&ret, "%d warnings:\n", len(diags))
+                }
+                for _, diag := range woe.Diagnostics {
+                        desc := diag.Description()
+                        if desc.Detail == "" {
+                                fmt.Fprintf(&ret, "\n- %s", desc.Summary)
+                        } else {
+                                fmt.Fprintf(&ret, "\n- %s: %s", desc.Summary, desc.Detail)
+                        }
+                }
+                return ret.String()
+        }
+}
+
+// sortDiagnostics is an implementation of sort.Interface
+type sortDiagnostics []Diagnostic
+
+var _ sort.Interface = sortDiagnostics(nil)
+
+func (sd sortDiagnostics) Len() int {
+        return len(sd)
+}
+
+func (sd sortDiagnostics) Less(i, j int) bool {
+        iD, jD := sd[i], sd[j]
+        iSev, jSev := iD.Severity(), jD.Severity()
+        iSrc, jSrc := iD.Source(), jD.Source()
+
+        switch {
+
+        case iSev != jSev:
+                return iSev == Warning
+
+        case (iSrc.Subject == nil) != (jSrc.Subject == nil):
+                return iSrc.Subject == nil
+
+        case iSrc.Subject != nil && *iSrc.Subject != *jSrc.Subject:
+                iSubj := iSrc.Subject
+                jSubj := jSrc.Subject
+                switch {
+                case iSubj.Filename != jSubj.Filename:
+                        // Path with fewer segments goes first if they are different lengths
+                        sep := string(filepath.Separator)
+                        iCount := strings.Count(iSubj.Filename, sep)
+                        jCount := strings.Count(jSubj.Filename, sep)
+                        if iCount != jCount {
+                                return iCount < jCount
+                        }
+                        return iSubj.Filename < jSubj.Filename
+                case iSubj.Start.Byte != jSubj.Start.Byte:
+                        return iSubj.Start.Byte < jSubj.Start.Byte
+                case iSubj.End.Byte != jSubj.End.Byte:
+                        return iSubj.End.Byte < jSubj.End.Byte
+                }
+                fallthrough
+
+        default:
+                // The remaining properties do not have a defined ordering, so
+                // we'll leave it unspecified. Since we use sort.Stable in
+                // the caller of this, the ordering of remaining items will
+                // be preserved.
+                return false
+        }
+}
+
+func (sd sortDiagnostics) Swap(i, j int) {
+        sd[i], sd[j] = sd[j], sd[i]
+}
diff --git a/vendor/github.com/hashicorp/terraform/tfdiags/error.go b/vendor/github.com/hashicorp/terraform/tfdiags/error.go
index 35edc30..13f7a71 100644
--- a/vendor/github.com/hashicorp/terraform/tfdiags/error.go
+++ b/vendor/github.com/hashicorp/terraform/tfdiags/error.go
@@ -13,7 +13,7 @@ func (e nativeError) Severity() Severity {
 
 func (e nativeError) Description() Description {
         return Description{
-                Summary: e.err.Error(),
+                Summary: FormatError(e.err),
         }
 }
 
@@ -21,3 +21,8 @@ func (e nativeError) Source() Source {
         // No source information available for a native error
         return Source{}
 }
+
+func (e nativeError) FromExpr() *FromExpr {
+        // Native errors are not expression-related
+        return nil
+}
diff --git a/vendor/github.com/hashicorp/terraform/tfdiags/hcl.go b/vendor/github.com/hashicorp/terraform/tfdiags/hcl.go
index 24851f4..f9aec41 100644
--- a/vendor/github.com/hashicorp/terraform/tfdiags/hcl.go
+++ b/vendor/github.com/hashicorp/terraform/tfdiags/hcl.go
@@ -40,6 +40,16 @@ func (d hclDiagnostic) Source() Source {
         return ret
 }
 
+func (d hclDiagnostic) FromExpr() *FromExpr {
+        if d.diag.Expression == nil || d.diag.EvalContext == nil {
+                return nil
+        }
+        return &FromExpr{
+                Expression:  d.diag.Expression,
+                EvalContext: d.diag.EvalContext,
+        }
+}
+
 // SourceRangeFromHCL constructs a SourceRange from the corresponding range
 // type within the HCL package.
 func SourceRangeFromHCL(hclRange hcl.Range) SourceRange {
diff --git a/vendor/github.com/hashicorp/terraform/tfdiags/rpc_friendly.go b/vendor/github.com/hashicorp/terraform/tfdiags/rpc_friendly.go
index 6cc95cc..485063b 100644
--- a/vendor/github.com/hashicorp/terraform/tfdiags/rpc_friendly.go
+++ b/vendor/github.com/hashicorp/terraform/tfdiags/rpc_friendly.go
@@ -48,6 +48,12 @@ func (d *rpcFriendlyDiag) Source() Source {
         }
 }
 
+func (d rpcFriendlyDiag) FromExpr() *FromExpr {
+        // RPC-friendly diagnostics cannot preserve expression information because
+        // expressions themselves are not RPC-friendly.
+        return nil
+}
+
 func init() {
         gob.Register((*rpcFriendlyDiag)(nil))
 }
diff --git a/vendor/github.com/hashicorp/terraform/tfdiags/severity_string.go b/vendor/github.com/hashicorp/terraform/tfdiags/severity_string.go
index 0b1249b..78a7210 100644
--- a/vendor/github.com/hashicorp/terraform/tfdiags/severity_string.go
+++ b/vendor/github.com/hashicorp/terraform/tfdiags/severity_string.go
@@ -4,6 +4,14 @@ package tfdiags
 
 import "strconv"
 
+func _() {
+        // An "invalid array index" compiler error signifies that the constant values have changed.
+        // Re-run the stringer command to generate them again.
+        var x [1]struct{}
+        _ = x[Error-69]
+        _ = x[Warning-87]
+}
+
 const (
         _Severity_name_0 = "Error"
         _Severity_name_1 = "Warning"
diff --git a/vendor/github.com/hashicorp/terraform/tfdiags/simple_warning.go b/vendor/github.com/hashicorp/terraform/tfdiags/simple_warning.go
index fb3ac98..b0f1ecd 100644
--- a/vendor/github.com/hashicorp/terraform/tfdiags/simple_warning.go
+++ b/vendor/github.com/hashicorp/terraform/tfdiags/simple_warning.go
@@ -20,6 +20,11 @@ func (e simpleWarning) Description() Description {
 }
 
 func (e simpleWarning) Source() Source {
-        // No source information available for a native error
+        // No source information available for a simple warning
         return Source{}
 }
+
+func (e simpleWarning) FromExpr() *FromExpr {
+        // Simple warnings are not expression-related
+        return nil
+}
diff --git a/vendor/github.com/hashicorp/terraform/tfdiags/sourceless.go b/vendor/github.com/hashicorp/terraform/tfdiags/sourceless.go
new file mode 100644
index 0000000..eaa2737
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/tfdiags/sourceless.go
@@ -0,0 +1,13 @@
+package tfdiags
+
+// Sourceless creates and returns a diagnostic with no source location
+// information. This is generally used for operational-type errors that are
+// caused by or relate to the environment where Terraform is running rather
+// than to the provided configuration.
+func Sourceless(severity Severity, summary, detail string) Diagnostic {
+        return diagnosticBase{
+                severity: severity,
+                summary:  summary,
+                detail:   detail,
+        }
+}