14 files changed, 789 insertions, 0 deletions

diff --git a/vendor/github.com/hashicorp/hil/ast/arithmetic.go b/vendor/github.com/hashicorp/hil/ast/arithmetic.go
new file mode 100644
index 0000000..94dc24f
--- /dev/null
+++ b/vendor/github.com/hashicorp/hil/ast/arithmetic.go
@@ -0,0 +1,43 @@
+package ast
+
+import (
+        "bytes"
+        "fmt"
+)
+
+// Arithmetic represents a node where the result is arithmetic of
+// two or more operands in the order given.
+type Arithmetic struct {
+        Op    ArithmeticOp
+        Exprs []Node
+        Posx  Pos
+}
+
+func (n *Arithmetic) Accept(v Visitor) Node {
+        for i, expr := range n.Exprs {
+                n.Exprs[i] = expr.Accept(v)
+        }
+
+        return v(n)
+}
+
+func (n *Arithmetic) Pos() Pos {
+        return n.Posx
+}
+
+func (n *Arithmetic) GoString() string {
+        return fmt.Sprintf("*%#v", *n)
+}
+
+func (n *Arithmetic) String() string {
+        var b bytes.Buffer
+        for _, expr := range n.Exprs {
+                b.WriteString(fmt.Sprintf("%s", expr))
+        }
+
+        return b.String()
+}
+
+func (n *Arithmetic) Type(Scope) (Type, error) {
+        return TypeInt, nil
+}
diff --git a/vendor/github.com/hashicorp/hil/ast/arithmetic_op.go b/vendor/github.com/hashicorp/hil/ast/arithmetic_op.go
new file mode 100644
index 0000000..18880c6
--- /dev/null
+++ b/vendor/github.com/hashicorp/hil/ast/arithmetic_op.go
@@ -0,0 +1,24 @@
+package ast
+
+// ArithmeticOp is the operation to use for the math.
+type ArithmeticOp int
+
+const (
+        ArithmeticOpInvalid ArithmeticOp = 0
+
+        ArithmeticOpAdd ArithmeticOp = iota
+        ArithmeticOpSub
+        ArithmeticOpMul
+        ArithmeticOpDiv
+        ArithmeticOpMod
+
+        ArithmeticOpLogicalAnd
+        ArithmeticOpLogicalOr
+
+        ArithmeticOpEqual
+        ArithmeticOpNotEqual
+        ArithmeticOpLessThan
+        ArithmeticOpLessThanOrEqual
+        ArithmeticOpGreaterThan
+        ArithmeticOpGreaterThanOrEqual
+)
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"
+        }
+}
diff --git a/vendor/github.com/hashicorp/hil/ast/call.go b/vendor/github.com/hashicorp/hil/ast/call.go
new file mode 100644
index 0000000..0557011
--- /dev/null
+++ b/vendor/github.com/hashicorp/hil/ast/call.go
@@ -0,0 +1,47 @@
+package ast
+
+import (
+        "fmt"
+        "strings"
+)
+
+// Call represents a function call.
+type Call struct {
+        Func string
+        Args []Node
+        Posx Pos
+}
+
+func (n *Call) Accept(v Visitor) Node {
+        for i, a := range n.Args {
+                n.Args[i] = a.Accept(v)
+        }
+
+        return v(n)
+}
+
+func (n *Call) Pos() Pos {
+        return n.Posx
+}
+
+func (n *Call) String() string {
+        args := make([]string, len(n.Args))
+        for i, arg := range n.Args {
+                args[i] = fmt.Sprintf("%s", arg)
+        }
+
+        return fmt.Sprintf("Call(%s, %s)", n.Func, strings.Join(args, ", "))
+}
+
+func (n *Call) Type(s Scope) (Type, error) {
+        f, ok := s.LookupFunc(n.Func)
+        if !ok {
+                return TypeInvalid, fmt.Errorf("unknown function: %s", n.Func)
+        }
+
+        return f.ReturnType, nil
+}
+
+func (n *Call) GoString() string {
+        return fmt.Sprintf("*%#v", *n)
+}
diff --git a/vendor/github.com/hashicorp/hil/ast/conditional.go b/vendor/github.com/hashicorp/hil/ast/conditional.go
new file mode 100644
index 0000000..be48f89
--- /dev/null
+++ b/vendor/github.com/hashicorp/hil/ast/conditional.go
@@ -0,0 +1,36 @@
+package ast
+
+import (
+        "fmt"
+)
+
+type Conditional struct {
+        CondExpr  Node
+        TrueExpr  Node
+        FalseExpr Node
+        Posx      Pos
+}
+
+// Accept passes the given visitor to the child nodes in this order:
+// CondExpr, TrueExpr, FalseExpr. It then finally passes itself to the visitor.
+func (n *Conditional) Accept(v Visitor) Node {
+        n.CondExpr = n.CondExpr.Accept(v)
+        n.TrueExpr = n.TrueExpr.Accept(v)
+        n.FalseExpr = n.FalseExpr.Accept(v)
+
+        return v(n)
+}
+
+func (n *Conditional) Pos() Pos {
+        return n.Posx
+}
+
+func (n *Conditional) Type(Scope) (Type, error) {
+        // This is not actually a useful value; the type checker ignores
+        // this function when analyzing conditionals, just as with Arithmetic.
+        return TypeInt, nil
+}
+
+func (n *Conditional) GoString() string {
+        return fmt.Sprintf("*%#v", *n)
+}
diff --git a/vendor/github.com/hashicorp/hil/ast/index.go b/vendor/github.com/hashicorp/hil/ast/index.go
new file mode 100644
index 0000000..860c25f
--- /dev/null
+++ b/vendor/github.com/hashicorp/hil/ast/index.go
@@ -0,0 +1,76 @@
+package ast
+
+import (
+        "fmt"
+        "strings"
+)
+
+// Index represents an indexing operation into another data structure
+type Index struct {
+        Target Node
+        Key    Node
+        Posx   Pos
+}
+
+func (n *Index) Accept(v Visitor) Node {
+        n.Target = n.Target.Accept(v)
+        n.Key = n.Key.Accept(v)
+        return v(n)
+}
+
+func (n *Index) Pos() Pos {
+        return n.Posx
+}
+
+func (n *Index) String() string {
+        return fmt.Sprintf("Index(%s, %s)", n.Target, n.Key)
+}
+
+func (n *Index) Type(s Scope) (Type, error) {
+        variableAccess, ok := n.Target.(*VariableAccess)
+        if !ok {
+                return TypeInvalid, fmt.Errorf("target is not a variable")
+        }
+
+        variable, ok := s.LookupVar(variableAccess.Name)
+        if !ok {
+                return TypeInvalid, fmt.Errorf("unknown variable accessed: %s", variableAccess.Name)
+        }
+
+        switch variable.Type {
+        case TypeList:
+                return n.typeList(variable, variableAccess.Name)
+        case TypeMap:
+                return n.typeMap(variable, variableAccess.Name)
+        default:
+                return TypeInvalid, fmt.Errorf("invalid index operation into non-indexable type: %s", variable.Type)
+        }
+}
+
+func (n *Index) typeList(variable Variable, variableName string) (Type, error) {
+        // We assume type checking has already determined that this is a list
+        list := variable.Value.([]Variable)
+
+        return VariableListElementTypesAreHomogenous(variableName, list)
+}
+
+func (n *Index) typeMap(variable Variable, variableName string) (Type, error) {
+        // We assume type checking has already determined that this is a map
+        vmap := variable.Value.(map[string]Variable)
+
+        return VariableMapValueTypesAreHomogenous(variableName, vmap)
+}
+
+func reportTypes(typesFound map[Type]struct{}) string {
+        stringTypes := make([]string, len(typesFound))
+        i := 0
+        for k, _ := range typesFound {
+                stringTypes[0] = k.String()
+                i++
+        }
+        return strings.Join(stringTypes, ", ")
+}
+
+func (n *Index) GoString() string {
+        return fmt.Sprintf("*%#v", *n)
+}
diff --git a/vendor/github.com/hashicorp/hil/ast/literal.go b/vendor/github.com/hashicorp/hil/ast/literal.go
new file mode 100644
index 0000000..da6014f
--- /dev/null
+++ b/vendor/github.com/hashicorp/hil/ast/literal.go
@@ -0,0 +1,88 @@
+package ast
+
+import (
+        "fmt"
+        "reflect"
+)
+
+// LiteralNode represents a single literal value, such as "foo" or
+// 42 or 3.14159. Based on the Type, the Value can be safely cast.
+type LiteralNode struct {
+        Value interface{}
+        Typex Type
+        Posx  Pos
+}
+
+// NewLiteralNode returns a new literal node representing the given
+// literal Go value, which must correspond to one of the primitive types
+// supported by HIL. Lists and maps cannot currently be constructed via
+// this function.
+//
+// If an inappropriately-typed value is provided, this function will
+// return an error. The main intended use of this function is to produce
+// "synthetic" literals from constants in code, where the value type is
+// well known at compile time. To easily store these in global variables,
+// see also MustNewLiteralNode.
+func NewLiteralNode(value interface{}, pos Pos) (*LiteralNode, error) {
+        goType := reflect.TypeOf(value)
+        var hilType Type
+
+        switch goType.Kind() {
+        case reflect.Bool:
+                hilType = TypeBool
+        case reflect.Int:
+                hilType = TypeInt
+        case reflect.Float64:
+                hilType = TypeFloat
+        case reflect.String:
+                hilType = TypeString
+        default:
+                return nil, fmt.Errorf("unsupported literal node type: %T", value)
+        }
+
+        return &LiteralNode{
+                Value: value,
+                Typex: hilType,
+                Posx:  pos,
+        }, nil
+}
+
+// MustNewLiteralNode wraps NewLiteralNode and panics if an error is
+// returned, thus allowing valid literal nodes to be easily assigned to
+// global variables.
+func MustNewLiteralNode(value interface{}, pos Pos) *LiteralNode {
+        node, err := NewLiteralNode(value, pos)
+        if err != nil {
+                panic(err)
+        }
+        return node
+}
+
+func (n *LiteralNode) Accept(v Visitor) Node {
+        return v(n)
+}
+
+func (n *LiteralNode) Pos() Pos {
+        return n.Posx
+}
+
+func (n *LiteralNode) GoString() string {
+        return fmt.Sprintf("*%#v", *n)
+}
+
+func (n *LiteralNode) String() string {
+        return fmt.Sprintf("Literal(%s, %v)", n.Typex, n.Value)
+}
+
+func (n *LiteralNode) Type(Scope) (Type, error) {
+        return n.Typex, nil
+}
+
+// IsUnknown returns true either if the node's value is itself unknown
+// of if it is a collection containing any unknown elements, deeply.
+func (n *LiteralNode) IsUnknown() bool {
+        return IsUnknown(Variable{
+                Type:  n.Typex,
+                Value: n.Value,
+        })
+}
diff --git a/vendor/github.com/hashicorp/hil/ast/output.go b/vendor/github.com/hashicorp/hil/ast/output.go
new file mode 100644
index 0000000..1e27f97
--- /dev/null
+++ b/vendor/github.com/hashicorp/hil/ast/output.go
@@ -0,0 +1,78 @@
+package ast
+
+import (
+        "bytes"
+        "fmt"
+)
+
+// Output represents the root node of all interpolation evaluations. If the
+// output only has one expression which is either a TypeList or TypeMap, the
+// Output can be type-asserted to []interface{} or map[string]interface{}
+// respectively. Otherwise the Output evaluates as a string, and concatenates
+// the evaluation of each expression.
+type Output struct {
+        Exprs []Node
+        Posx  Pos
+}
+
+func (n *Output) Accept(v Visitor) Node {
+        for i, expr := range n.Exprs {
+                n.Exprs[i] = expr.Accept(v)
+        }
+
+        return v(n)
+}
+
+func (n *Output) Pos() Pos {
+        return n.Posx
+}
+
+func (n *Output) GoString() string {
+        return fmt.Sprintf("*%#v", *n)
+}
+
+func (n *Output) String() string {
+        var b bytes.Buffer
+        for _, expr := range n.Exprs {
+                b.WriteString(fmt.Sprintf("%s", expr))
+        }
+
+        return b.String()
+}
+
+func (n *Output) Type(s Scope) (Type, error) {
+        // Special case no expressions for backward compatibility
+        if len(n.Exprs) == 0 {
+                return TypeString, nil
+        }
+
+        // Special case a single expression of types list or map
+        if len(n.Exprs) == 1 {
+                exprType, err := n.Exprs[0].Type(s)
+                if err != nil {
+                        return TypeInvalid, err
+                }
+                switch exprType {
+                case TypeList:
+                        return TypeList, nil
+                case TypeMap:
+                        return TypeMap, nil
+                }
+        }
+
+        // Otherwise ensure all our expressions are strings
+        for index, expr := range n.Exprs {
+                exprType, err := expr.Type(s)
+                if err != nil {
+                        return TypeInvalid, err
+                }
+                // We only look for things we know we can't coerce with an implicit conversion func
+                if exprType == TypeList || exprType == TypeMap {
+                        return TypeInvalid, fmt.Errorf(
+                                "multi-expression HIL outputs may only have string inputs: %d is type %s",
+                                index, exprType)
+                }
+        }
+
+        return TypeString, nil
+}
diff --git a/vendor/github.com/hashicorp/hil/ast/scope.go b/vendor/github.com/hashicorp/hil/ast/scope.go
new file mode 100644
index 0000000..7a975d9
--- /dev/null
+++ b/vendor/github.com/hashicorp/hil/ast/scope.go
@@ -0,0 +1,90 @@
+package ast
+
+import (
+        "fmt"
+        "reflect"
+)
+
+// Scope is the interface used to look up variables and functions while
+// evaluating. How these functions/variables are defined are up to the caller.
+type Scope interface {
+        LookupFunc(string) (Function, bool)
+        LookupVar(string) (Variable, bool)
+}
+
+// Variable is a variable value for execution given as input to the engine.
+// It records the value of a variables along with their type.
+type Variable struct {
+        Value interface{}
+        Type  Type
+}
+
+// NewVariable creates a new Variable for the given value. This will
+// attempt to infer the correct type. If it can't, an error will be returned.
+func NewVariable(v interface{}) (result Variable, err error) {
+        switch v := reflect.ValueOf(v); v.Kind() {
+        case reflect.String:
+                result.Type = TypeString
+        default:
+                err = fmt.Errorf("Unknown type: %s", v.Kind())
+        }
+
+        result.Value = v
+        return
+}
+
+// String implements Stringer on Variable, displaying the type and value
+// of the Variable.
+func (v Variable) String() string {
+        return fmt.Sprintf("{Variable (%s): %+v}", v.Type, v.Value)
+}
+
+// Function defines a function that can be executed by the engine.
+// The type checker will validate that the proper types will be called
+// to the callback.
+type Function struct {
+        // ArgTypes is the list of types in argument order. These are the
+        // required arguments.
+        //
+        // ReturnType is the type of the returned value. The Callback MUST
+        // return this type.
+        ArgTypes   []Type
+        ReturnType Type
+
+        // Variadic, if true, says that this function is variadic, meaning
+        // it takes a variable number of arguments. In this case, the
+        // VariadicType must be set.
+        Variadic     bool
+        VariadicType Type
+
+        // Callback is the function called for a function. The argument
+        // types are guaranteed to match the spec above by the type checker.
+        // The length of the args is strictly == len(ArgTypes) unless Varidiac
+        // is true, in which case its >= len(ArgTypes).
+        Callback func([]interface{}) (interface{}, error)
+}
+
+// BasicScope is a simple scope that looks up variables and functions
+// using a map.
+type BasicScope struct {
+        FuncMap map[string]Function
+        VarMap  map[string]Variable
+}
+
+func (s *BasicScope) LookupFunc(n string) (Function, bool) {
+        if s == nil {
+                return Function{}, false
+        }
+
+        v, ok := s.FuncMap[n]
+        return v, ok
+}
+
+func (s *BasicScope) LookupVar(n string) (Variable, bool) {
+        if s == nil {
+                return Variable{}, false
+        }
+
+        v, ok := s.VarMap[n]
+        return v, ok
+}
diff --git a/vendor/github.com/hashicorp/hil/ast/stack.go b/vendor/github.com/hashicorp/hil/ast/stack.go
new file mode 100644
index 0000000..bd2bc15
--- /dev/null
+++ b/vendor/github.com/hashicorp/hil/ast/stack.go
@@ -0,0 +1,25 @@
+package ast
+
+// Stack is a stack of Node.
+type Stack struct {
+        stack []Node
+}
+
+func (s *Stack) Len() int {
+        return len(s.stack)
+}
+
+func (s *Stack) Push(n Node) {
+        s.stack = append(s.stack, n)
+}
+
+func (s *Stack) Pop() Node {
+        x := s.stack[len(s.stack)-1]
+        s.stack[len(s.stack)-1] = nil
+        s.stack = s.stack[:len(s.stack)-1]
+        return x
+}
+
+func (s *Stack) Reset() {
+        s.stack = nil
+}
diff --git a/vendor/github.com/hashicorp/hil/ast/type_string.go b/vendor/github.com/hashicorp/hil/ast/type_string.go
new file mode 100644
index 0000000..1f51a98
--- /dev/null
+++ b/vendor/github.com/hashicorp/hil/ast/type_string.go
@@ -0,0 +1,54 @@
+// Code generated by "stringer -type=Type"; DO NOT EDIT
+
+package ast
+
+import "fmt"
+
+const (
+        _Type_name_0 = "TypeInvalid"
+        _Type_name_1 = "TypeAny"
+        _Type_name_2 = "TypeBool"
+        _Type_name_3 = "TypeString"
+        _Type_name_4 = "TypeInt"
+        _Type_name_5 = "TypeFloat"
+        _Type_name_6 = "TypeList"
+        _Type_name_7 = "TypeMap"
+        _Type_name_8 = "TypeUnknown"
+)
+
+var (
+        _Type_index_0 = [...]uint8{0, 11}
+        _Type_index_1 = [...]uint8{0, 7}
+        _Type_index_2 = [...]uint8{0, 8}
+        _Type_index_3 = [...]uint8{0, 10}
+        _Type_index_4 = [...]uint8{0, 7}
+        _Type_index_5 = [...]uint8{0, 9}
+        _Type_index_6 = [...]uint8{0, 8}
+        _Type_index_7 = [...]uint8{0, 7}
+        _Type_index_8 = [...]uint8{0, 11}
+)
+
+func (i Type) String() string {
+        switch {
+        case i == 0:
+                return _Type_name_0
+        case i == 2:
+                return _Type_name_1
+        case i == 4:
+                return _Type_name_2
+        case i == 8:
+                return _Type_name_3
+        case i == 16:
+                return _Type_name_4
+        case i == 32:
+                return _Type_name_5
+        case i == 64:
+                return _Type_name_6
+        case i == 128:
+                return _Type_name_7
+        case i == 256:
+                return _Type_name_8
+        default:
+                return fmt.Sprintf("Type(%d)", i)
+        }
+}
diff --git a/vendor/github.com/hashicorp/hil/ast/unknown.go b/vendor/github.com/hashicorp/hil/ast/unknown.go
new file mode 100644
index 0000000..d6ddaec
--- /dev/null
+++ b/vendor/github.com/hashicorp/hil/ast/unknown.go
@@ -0,0 +1,30 @@
+package ast
+
+// IsUnknown reports whether a variable is unknown or contains any value
+// that is unknown. This will recurse into lists and maps and so on.
+func IsUnknown(v Variable) bool {
+        // If it is unknown itself, return true
+        if v.Type == TypeUnknown {
+                return true
+        }
+
+        // If it is a container type, check the values
+        switch v.Type {
+        case TypeList:
+                for _, el := range v.Value.([]Variable) {
+                        if IsUnknown(el) {
+                                return true
+                        }
+                }
+        case TypeMap:
+                for _, el := range v.Value.(map[string]Variable) {
+                        if IsUnknown(el) {
+                                return true
+                        }
+                }
+        default:
+        }
+
+        // Not a container type or survive the above checks
+        return false
+}
diff --git a/vendor/github.com/hashicorp/hil/ast/variable_access.go b/vendor/github.com/hashicorp/hil/ast/variable_access.go
new file mode 100644
index 0000000..4c1362d
--- /dev/null
+++ b/vendor/github.com/hashicorp/hil/ast/variable_access.go
@@ -0,0 +1,36 @@
+package ast
+
+import (
+        "fmt"
+)
+
+// VariableAccess represents a variable access.
+type VariableAccess struct {
+        Name string
+        Posx Pos
+}
+
+func (n *VariableAccess) Accept(v Visitor) Node {
+        return v(n)
+}
+
+func (n *VariableAccess) Pos() Pos {
+        return n.Posx
+}
+
+func (n *VariableAccess) GoString() string {
+        return fmt.Sprintf("*%#v", *n)
+}
+
+func (n *VariableAccess) String() string {
+        return fmt.Sprintf("Variable(%s)", n.Name)
+}
+
+func (n *VariableAccess) Type(s Scope) (Type, error) {
+        v, ok := s.LookupVar(n.Name)
+        if !ok {
+                return TypeInvalid, fmt.Errorf("unknown variable: %s", n.Name)
+        }
+
+        return v.Type, nil
+}
diff --git a/vendor/github.com/hashicorp/hil/ast/variables_helper.go b/vendor/github.com/hashicorp/hil/ast/variables_helper.go
new file mode 100644
index 0000000..06bd18d
--- /dev/null
+++ b/vendor/github.com/hashicorp/hil/ast/variables_helper.go
@@ -0,0 +1,63 @@
+package ast
+
+import "fmt"
+
+func VariableListElementTypesAreHomogenous(variableName string, list []Variable) (Type, error) {
+        if len(list) == 0 {
+                return TypeInvalid, fmt.Errorf("list %q does not have any elements so cannot determine type.", variableName)
+        }
+
+        elemType := TypeUnknown
+        for _, v := range list {
+                if v.Type == TypeUnknown {
+                        continue
+                }
+
+                if elemType == TypeUnknown {
+                        elemType = v.Type
+                        continue
+                }
+
+                if v.Type != elemType {
+                        return TypeInvalid, fmt.Errorf(
+                                "list %q does not have homogenous types. found %s and then %s",
+                                variableName,
+                                elemType, v.Type,
+                        )
+                }
+
+                elemType = v.Type
+        }
+
+        return elemType, nil
+}
+
+func VariableMapValueTypesAreHomogenous(variableName string, vmap map[string]Variable) (Type, error) {
+        if len(vmap) == 0 {
+                return TypeInvalid, fmt.Errorf("map %q does not have any elements so cannot determine type.", variableName)
+        }
+
+        elemType := TypeUnknown
+        for _, v := range vmap {
+                if v.Type == TypeUnknown {
+                        continue
+                }
+
+                if elemType == TypeUnknown {
+                        elemType = v.Type
+                        continue
+                }
+
+                if v.Type != elemType {
+                        return TypeInvalid, fmt.Errorf(
+                                "map %q does not have homogenous types. found %s and then %s",
+                                variableName,
+                                elemType, v.Type,
+                        )
+                }
+
+                elemType = v.Type
+        }
+
+        return elemType, nil
+}