1 files changed, 352 insertions, 0 deletions

diff --git a/vendor/github.com/hashicorp/hcl2/hcl/traversal.go b/vendor/github.com/hashicorp/hcl2/hcl/traversal.go
new file mode 100644
index 0000000..24f4c91
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/hcl/traversal.go
@@ -0,0 +1,352 @@
+package hcl
+
+import (
+        "fmt"
+
+        "github.com/zclconf/go-cty/cty"
+)
+
+// A Traversal is a description of traversing through a value through a
+// series of operations such as attribute lookup, index lookup, etc.
+//
+// It is used to look up values in scopes, for example.
+//
+// The traversal operations are implementations of interface Traverser.
+// This is a closed set of implementations, so the interface cannot be
+// implemented from outside this package.
+//
+// A traversal can be absolute (its first value is a symbol name) or relative
+// (starts from an existing value).
+type Traversal []Traverser
+
+// TraversalJoin appends a relative traversal to an absolute traversal to
+// produce a new absolute traversal.
+func TraversalJoin(abs Traversal, rel Traversal) Traversal {
+        if abs.IsRelative() {
+                panic("first argument to TraversalJoin must be absolute")
+        }
+        if !rel.IsRelative() {
+                panic("second argument to TraversalJoin must be relative")
+        }
+
+        ret := make(Traversal, len(abs)+len(rel))
+        copy(ret, abs)
+        copy(ret[len(abs):], rel)
+        return ret
+}
+
+// TraverseRel applies the receiving traversal to the given value, returning
+// the resulting value. This is supported only for relative traversals,
+// and will panic if applied to an absolute traversal.
+func (t Traversal) TraverseRel(val cty.Value) (cty.Value, Diagnostics) {
+        if !t.IsRelative() {
+                panic("can't use TraverseRel on an absolute traversal")
+        }
+
+        current := val
+        var diags Diagnostics
+        for _, tr := range t {
+                var newDiags Diagnostics
+                current, newDiags = tr.TraversalStep(current)
+                diags = append(diags, newDiags...)
+                if newDiags.HasErrors() {
+                        return cty.DynamicVal, diags
+                }
+        }
+        return current, diags
+}
+
+// TraverseAbs applies the receiving traversal to the given eval context,
+// returning the resulting value. This is supported only for absolute
+// traversals, and will panic if applied to a relative traversal.
+func (t Traversal) TraverseAbs(ctx *EvalContext) (cty.Value, Diagnostics) {
+        if t.IsRelative() {
+                panic("can't use TraverseAbs on a relative traversal")
+        }
+
+        split := t.SimpleSplit()
+        root := split.Abs[0].(TraverseRoot)
+        name := root.Name
+
+        thisCtx := ctx
+        hasNonNil := false
+        for thisCtx != nil {
+                if thisCtx.Variables == nil {
+                        thisCtx = thisCtx.parent
+                        continue
+                }
+                hasNonNil = true
+                val, exists := thisCtx.Variables[name]
+                if exists {
+                        return split.Rel.TraverseRel(val)
+                }
+                thisCtx = thisCtx.parent
+        }
+
+        if !hasNonNil {
+                return cty.DynamicVal, Diagnostics{
+                        {
+                                Severity: DiagError,
+                                Summary:  "Variables not allowed",
+                                Detail:   "Variables may not be used here.",
+                                Subject:  &root.SrcRange,
+                        },
+                }
+        }
+
+        suggestions := make([]string, 0, len(ctx.Variables))
+        thisCtx = ctx
+        for thisCtx != nil {
+                for k := range thisCtx.Variables {
+                        suggestions = append(suggestions, k)
+                }
+                thisCtx = thisCtx.parent
+        }
+        suggestion := nameSuggestion(name, suggestions)
+        if suggestion != "" {
+                suggestion = fmt.Sprintf(" Did you mean %q?", suggestion)
+        }
+
+        return cty.DynamicVal, Diagnostics{
+                {
+                        Severity: DiagError,
+                        Summary:  "Unknown variable",
+                        Detail:   fmt.Sprintf("There is no variable named %q.%s", name, suggestion),
+                        Subject:  &root.SrcRange,
+                },
+        }
+}
+
+// IsRelative returns true if the receiver is a relative traversal, or false
+// otherwise.
+func (t Traversal) IsRelative() bool {
+        if len(t) == 0 {
+                return true
+        }
+        if _, firstIsRoot := t[0].(TraverseRoot); firstIsRoot {
+                return false
+        }
+        return true
+}
+
+// SimpleSplit returns a TraversalSplit where the name lookup is the absolute
+// part and the remainder is the relative part. Supported only for
+// absolute traversals, and will panic if applied to a relative traversal.
+//
+// This can be used by applications that have a relatively-simple variable
+// namespace where only the top-level is directly populated in the scope, with
+// everything else handled by relative lookups from those initial values.
+func (t Traversal) SimpleSplit() TraversalSplit {
+        if t.IsRelative() {
+                panic("can't use SimpleSplit on a relative traversal")
+        }
+        return TraversalSplit{
+                Abs: t[0:1],
+                Rel: t[1:],
+        }
+}
+
+// RootName returns the root name for a absolute traversal. Will panic if
+// called on a relative traversal.
+func (t Traversal) RootName() string {
+        if t.IsRelative() {
+                panic("can't use RootName on a relative traversal")
+
+        }
+        return t[0].(TraverseRoot).Name
+}
+
+// SourceRange returns the source range for the traversal.
+func (t Traversal) SourceRange() Range {
+        if len(t) == 0 {
+                // Nothing useful to return here, but we'll return something
+                // that's correctly-typed at least.
+                return Range{}
+        }
+
+        return RangeBetween(t[0].SourceRange(), t[len(t)-1].SourceRange())
+}
+
+// TraversalSplit represents a pair of traversals, the first of which is
+// an absolute traversal and the second of which is relative to the first.
+//
+// This is used by calling applications that only populate prefixes of the
+// traversals in the scope, with Abs representing the part coming from the
+// scope and Rel representing the remaining steps once that part is
+// retrieved.
+type TraversalSplit struct {
+        Abs Traversal
+        Rel Traversal
+}
+
+// TraverseAbs traverses from a scope to the value resulting from the
+// absolute traversal.
+func (t TraversalSplit) TraverseAbs(ctx *EvalContext) (cty.Value, Diagnostics) {
+        return t.Abs.TraverseAbs(ctx)
+}
+
+// TraverseRel traverses from a given value, assumed to be the result of
+// TraverseAbs on some scope, to a final result for the entire split traversal.
+func (t TraversalSplit) TraverseRel(val cty.Value) (cty.Value, Diagnostics) {
+        return t.Rel.TraverseRel(val)
+}
+
+// Traverse is a convenience function to apply TraverseAbs followed by
+// TraverseRel.
+func (t TraversalSplit) Traverse(ctx *EvalContext) (cty.Value, Diagnostics) {
+        v1, diags := t.TraverseAbs(ctx)
+        if diags.HasErrors() {
+                return cty.DynamicVal, diags
+        }
+        v2, newDiags := t.TraverseRel(v1)
+        diags = append(diags, newDiags...)
+        return v2, diags
+}
+
+// Join concatenates together the Abs and Rel parts to produce a single
+// absolute traversal.
+func (t TraversalSplit) Join() Traversal {
+        return TraversalJoin(t.Abs, t.Rel)
+}
+
+// RootName returns the root name for the absolute part of the split.
+func (t TraversalSplit) RootName() string {
+        return t.Abs.RootName()
+}
+
+// A Traverser is a step within a Traversal.
+type Traverser interface {
+        TraversalStep(cty.Value) (cty.Value, Diagnostics)
+        SourceRange() Range
+        isTraverserSigil() isTraverser
+}
+
+// Embed this in a struct to declare it as a Traverser
+type isTraverser struct {
+}
+
+func (tr isTraverser) isTraverserSigil() isTraverser {
+        return isTraverser{}
+}
+
+// TraverseRoot looks up a root name in a scope. It is used as the first step
+// of an absolute Traversal, and cannot itself be traversed directly.
+type TraverseRoot struct {
+        isTraverser
+        Name     string
+        SrcRange Range
+}
+
+// TraversalStep on a TraverseName immediately panics, because absolute
+// traversals cannot be directly traversed.
+func (tn TraverseRoot) TraversalStep(cty.Value) (cty.Value, Diagnostics) {
+        panic("Cannot traverse an absolute traversal")
+}
+
+func (tn TraverseRoot) SourceRange() Range {
+        return tn.SrcRange
+}
+
+// TraverseAttr looks up an attribute in its initial value.
+type TraverseAttr struct {
+        isTraverser
+        Name     string
+        SrcRange Range
+}
+
+func (tn TraverseAttr) TraversalStep(val cty.Value) (cty.Value, Diagnostics) {
+        if val.IsNull() {
+                return cty.DynamicVal, Diagnostics{
+                        {
+                                Severity: DiagError,
+                                Summary:  "Attempt to get attribute from null value",
+                                Detail:   "This value is null, so it does not have any attributes.",
+                                Subject:  &tn.SrcRange,
+                        },
+                }
+        }
+
+        ty := val.Type()
+        switch {
+        case ty.IsObjectType():
+                if !ty.HasAttribute(tn.Name) {
+                        return cty.DynamicVal, Diagnostics{
+                                {
+                                        Severity: DiagError,
+                                        Summary:  "Unsupported attribute",
+                                        Detail:   fmt.Sprintf("This object does not have an attribute named %q.", tn.Name),
+                                        Subject:  &tn.SrcRange,
+                                },
+                        }
+                }
+
+                if !val.IsKnown() {
+                        return cty.UnknownVal(ty.AttributeType(tn.Name)), nil
+                }
+
+                return val.GetAttr(tn.Name), nil
+        case ty.IsMapType():
+                if !val.IsKnown() {
+                        return cty.UnknownVal(ty.ElementType()), nil
+                }
+
+                idx := cty.StringVal(tn.Name)
+                if val.HasIndex(idx).False() {
+                        return cty.DynamicVal, Diagnostics{
+                                {
+                                        Severity: DiagError,
+                                        Summary:  "Missing map element",
+                                        Detail:   fmt.Sprintf("This map does not have an element with the key %q.", tn.Name),
+                                        Subject:  &tn.SrcRange,
+                                },
+                        }
+                }
+
+                return val.Index(idx), nil
+        case ty == cty.DynamicPseudoType:
+                return cty.DynamicVal, nil
+        default:
+                return cty.DynamicVal, Diagnostics{
+                        {
+                                Severity: DiagError,
+                                Summary:  "Unsupported attribute",
+                                Detail:   "This value does not have any attributes.",
+                                Subject:  &tn.SrcRange,
+                        },
+                }
+        }
+}
+
+func (tn TraverseAttr) SourceRange() Range {
+        return tn.SrcRange
+}
+
+// TraverseIndex applies the index operation to its initial value.
+type TraverseIndex struct {
+        isTraverser
+        Key      cty.Value
+        SrcRange Range
+}
+
+func (tn TraverseIndex) TraversalStep(val cty.Value) (cty.Value, Diagnostics) {
+        return Index(val, tn.Key, &tn.SrcRange)
+}
+
+func (tn TraverseIndex) SourceRange() Range {
+        return tn.SrcRange
+}
+
+// TraverseSplat applies the splat operation to its initial value.
+type TraverseSplat struct {
+        isTraverser
+        Each     Traversal
+        SrcRange Range
+}
+
+func (tn TraverseSplat) TraversalStep(val cty.Value) (cty.Value, Diagnostics) {
+        panic("TraverseSplat not yet implemented")
+}
+
+func (tn TraverseSplat) SourceRange() Range {
+        return tn.SrcRange
+}