1 files changed, 99 insertions, 0 deletions

diff --git a/vendor/github.com/hashicorp/hil/ast/ast.go b/vendor/github.com/hashicorp/hil/ast/ast.go
new file mode 100644
index 0000000..c6350f8
--- /dev/null
+++ b/vendor/github.com/hashicorp/hil/ast/ast.go
@@ -0,0 +1,99 @@
+package ast
+
+import (
+        "fmt"
+)
+
+// Node is the interface that all AST nodes must implement.
+type Node interface {
+        // Accept is called to dispatch to the visitors. It must return the
+        // resulting Node (which might be different in an AST transform).
+        Accept(Visitor) Node
+
+        // Pos returns the position of this node in some source.
+        Pos() Pos
+
+        // Type returns the type of this node for the given context.
+        Type(Scope) (Type, error)
+}
+
+// Pos is the starting position of an AST node
+type Pos struct {
+        Column, Line int    // Column/Line number, starting at 1
+        Filename     string // Optional source filename, if known
+}
+
+func (p Pos) String() string {
+        if p.Filename == "" {
+                return fmt.Sprintf("%d:%d", p.Line, p.Column)
+        } else {
+                return fmt.Sprintf("%s:%d:%d", p.Filename, p.Line, p.Column)
+        }
+}
+
+// InitPos is an initiaial position value. This should be used as
+// the starting position (presets the column and line to 1).
+var InitPos = Pos{Column: 1, Line: 1}
+
+// Visitors are just implementations of this function.
+//
+// The function must return the Node to replace this node with. "nil" is
+// _not_ a valid return value. If there is no replacement, the original node
+// should be returned. We build this replacement directly into the visitor
+// pattern since AST transformations are a common and useful tool and
+// building it into the AST itself makes it required for future Node
+// implementations and very easy to do.
+//
+// Note that this isn't a true implementation of the visitor pattern, which
+// generally requires proper type dispatch on the function. However,
+// implementing this basic visitor pattern style is still very useful even
+// if you have to type switch.
+type Visitor func(Node) Node
+
+//go:generate stringer -type=Type
+
+// Type is the type of any value.
+type Type uint32
+
+const (
+        TypeInvalid Type = 0
+        TypeAny     Type = 1 << iota
+        TypeBool
+        TypeString
+        TypeInt
+        TypeFloat
+        TypeList
+        TypeMap
+
+        // This is a special type used by Terraform to mark "unknown" values.
+        // It is impossible for this type to be introduced into your HIL programs
+        // unless you explicitly set a variable to this value. In that case,
+        // any operation including the variable will return "TypeUnknown" as the
+        // type.
+        TypeUnknown
+)
+
+func (t Type) Printable() string {
+        switch t {
+        case TypeInvalid:
+                return "invalid type"
+        case TypeAny:
+                return "any type"
+        case TypeBool:
+                return "type bool"
+        case TypeString:
+                return "type string"
+        case TypeInt:
+                return "type int"
+        case TypeFloat:
+                return "type float"
+        case TypeList:
+                return "type list"
+        case TypeMap:
+                return "type map"
+        case TypeUnknown:
+                return "type unknown"
+        default:
+                return "unknown type"
+        }
+}