20 files changed, 2332 insertions, 0 deletions

diff --git a/vendor/github.com/hashicorp/terraform/addrs/count_attr.go b/vendor/github.com/hashicorp/terraform/addrs/count_attr.go
new file mode 100644
index 0000000..90a5faf
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/addrs/count_attr.go
@@ -0,0 +1,12 @@
+package addrs
+
+// CountAttr is the address of an attribute of the "count" object in
+// the interpolation scope, like "count.index".
+type CountAttr struct {
+        referenceable
+        Name string
+}
+
+func (ca CountAttr) String() string {
+        return "count." + ca.Name
+}
diff --git a/vendor/github.com/hashicorp/terraform/addrs/doc.go b/vendor/github.com/hashicorp/terraform/addrs/doc.go
new file mode 100644
index 0000000..4609331
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/addrs/doc.go
@@ -0,0 +1,17 @@
+// Package addrs contains types that represent "addresses", which are
+// references to specific objects within a Terraform configuration or
+// state.
+//
+// All addresses have string representations based on HCL traversal syntax
+// which should be used in the user-interface, and also in-memory
+// representations that can be used internally.
+//
+// For object types that exist within Terraform modules a pair of types is
+// used. The "local" part of the address is represented by a type, and then
+// an absolute path to that object in the context of its module is represented
+// by a type of the same name with an "Abs" prefix added, for "absolute".
+//
+// All types within this package should be treated as immutable, even if this
+// is not enforced by the Go compiler. It is always an implementation error
+// to modify an address object in-place after it is initially constructed.
+package addrs
diff --git a/vendor/github.com/hashicorp/terraform/addrs/input_variable.go b/vendor/github.com/hashicorp/terraform/addrs/input_variable.go
new file mode 100644
index 0000000..d2c046c
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/addrs/input_variable.go
@@ -0,0 +1,41 @@
+package addrs
+
+import (
+        "fmt"
+)
+
+// InputVariable is the address of an input variable.
+type InputVariable struct {
+        referenceable
+        Name string
+}
+
+func (v InputVariable) String() string {
+        return "var." + v.Name
+}
+
+// AbsInputVariableInstance is the address of an input variable within a
+// particular module instance.
+type AbsInputVariableInstance struct {
+        Module   ModuleInstance
+        Variable InputVariable
+}
+
+// InputVariable returns the absolute address of the input variable of the
+// given name inside the receiving module instance.
+func (m ModuleInstance) InputVariable(name string) AbsInputVariableInstance {
+        return AbsInputVariableInstance{
+                Module: m,
+                Variable: InputVariable{
+                        Name: name,
+                },
+        }
+}
+
+func (v AbsInputVariableInstance) String() string {
+        if len(v.Module) == 0 {
+                return v.String()
+        }
+
+        return fmt.Sprintf("%s.%s", v.Module.String(), v.Variable.String())
+}
diff --git a/vendor/github.com/hashicorp/terraform/addrs/instance_key.go b/vendor/github.com/hashicorp/terraform/addrs/instance_key.go
new file mode 100644
index 0000000..cef8b27
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/addrs/instance_key.go
@@ -0,0 +1,123 @@
+package addrs
+
+import (
+        "fmt"
+
+        "github.com/zclconf/go-cty/cty"
+        "github.com/zclconf/go-cty/cty/gocty"
+)
+
+// InstanceKey represents the key of an instance within an object that
+// contains multiple instances due to using "count" or "for_each" arguments
+// in configuration.
+//
+// IntKey and StringKey are the two implementations of this type. No other
+// implementations are allowed. The single instance of an object that _isn't_
+// using "count" or "for_each" is represented by NoKey, which is a nil
+// InstanceKey.
+type InstanceKey interface {
+        instanceKeySigil()
+        String() string
+}
+
+// ParseInstanceKey returns the instance key corresponding to the given value,
+// which must be known and non-null.
+//
+// If an unknown or null value is provided then this function will panic. This
+// function is intended to deal with the values that would naturally be found
+// in a hcl.TraverseIndex, which (when parsed from source, at least) can never
+// contain unknown or null values.
+func ParseInstanceKey(key cty.Value) (InstanceKey, error) {
+        switch key.Type() {
+        case cty.String:
+                return StringKey(key.AsString()), nil
+        case cty.Number:
+                var idx int
+                err := gocty.FromCtyValue(key, &idx)
+                return IntKey(idx), err
+        default:
+                return NoKey, fmt.Errorf("either a string or an integer is required")
+        }
+}
+
+// NoKey represents the absense of an InstanceKey, for the single instance
+// of a configuration object that does not use "count" or "for_each" at all.
+var NoKey InstanceKey
+
+// IntKey is the InstanceKey representation representing integer indices, as
+// used when the "count" argument is specified or if for_each is used with
+// a sequence type.
+type IntKey int
+
+func (k IntKey) instanceKeySigil() {
+}
+
+func (k IntKey) String() string {
+        return fmt.Sprintf("[%d]", int(k))
+}
+
+// StringKey is the InstanceKey representation representing string indices, as
+// used when the "for_each" argument is specified with a map or object type.
+type StringKey string
+
+func (k StringKey) instanceKeySigil() {
+}
+
+func (k StringKey) String() string {
+        // FIXME: This isn't _quite_ right because Go's quoted string syntax is
+        // slightly different than HCL's, but we'll accept it for now.
+        return fmt.Sprintf("[%q]", string(k))
+}
+
+// InstanceKeyLess returns true if the first given instance key i should sort
+// before the second key j, and false otherwise.
+func InstanceKeyLess(i, j InstanceKey) bool {
+        iTy := instanceKeyType(i)
+        jTy := instanceKeyType(j)
+
+        switch {
+        case i == j:
+                return false
+        case i == NoKey:
+                return true
+        case j == NoKey:
+                return false
+        case iTy != jTy:
+                // The ordering here is arbitrary except that we want NoKeyType
+                // to sort before the others, so we'll just use the enum values
+                // of InstanceKeyType here (where NoKey is zero, sorting before
+                // any other).
+                return uint32(iTy) < uint32(jTy)
+        case iTy == IntKeyType:
+                return int(i.(IntKey)) < int(j.(IntKey))
+        case iTy == StringKeyType:
+                return string(i.(StringKey)) < string(j.(StringKey))
+        default:
+                // Shouldn't be possible to get down here in practice, since the
+                // above is exhaustive.
+                return false
+        }
+}
+
+func instanceKeyType(k InstanceKey) InstanceKeyType {
+        if _, ok := k.(StringKey); ok {
+                return StringKeyType
+        }
+        if _, ok := k.(IntKey); ok {
+                return IntKeyType
+        }
+        return NoKeyType
+}
+
+// InstanceKeyType represents the different types of instance key that are
+// supported. Usually it is sufficient to simply type-assert an InstanceKey
+// value to either IntKey or StringKey, but this type and its values can be
+// used to represent the types themselves, rather than specific values
+// of those types.
+type InstanceKeyType rune
+
+const (
+        NoKeyType     InstanceKeyType = 0
+        IntKeyType    InstanceKeyType = 'I'
+        StringKeyType InstanceKeyType = 'S'
+)
diff --git a/vendor/github.com/hashicorp/terraform/addrs/local_value.go b/vendor/github.com/hashicorp/terraform/addrs/local_value.go
new file mode 100644
index 0000000..61a07b9
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/addrs/local_value.go
@@ -0,0 +1,48 @@
+package addrs
+
+import (
+        "fmt"
+)
+
+// LocalValue is the address of a local value.
+type LocalValue struct {
+        referenceable
+        Name string
+}
+
+func (v LocalValue) String() string {
+        return "local." + v.Name
+}
+
+// Absolute converts the receiver into an absolute address within the given
+// module instance.
+func (v LocalValue) Absolute(m ModuleInstance) AbsLocalValue {
+        return AbsLocalValue{
+                Module:     m,
+                LocalValue: v,
+        }
+}
+
+// AbsLocalValue is the absolute address of a local value within a module instance.
+type AbsLocalValue struct {
+        Module     ModuleInstance
+        LocalValue LocalValue
+}
+
+// LocalValue returns the absolute address of a local value of the given
+// name within the receiving module instance.
+func (m ModuleInstance) LocalValue(name string) AbsLocalValue {
+        return AbsLocalValue{
+                Module: m,
+                LocalValue: LocalValue{
+                        Name: name,
+                },
+        }
+}
+
+func (v AbsLocalValue) String() string {
+        if len(v.Module) == 0 {
+                return v.LocalValue.String()
+        }
+        return fmt.Sprintf("%s.%s", v.Module.String(), v.LocalValue.String())
+}
diff --git a/vendor/github.com/hashicorp/terraform/addrs/module.go b/vendor/github.com/hashicorp/terraform/addrs/module.go
new file mode 100644
index 0000000..6420c63
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/addrs/module.go
@@ -0,0 +1,75 @@
+package addrs
+
+import (
+        "strings"
+)
+
+// Module is an address for a module call within configuration. This is
+// the static counterpart of ModuleInstance, representing a traversal through
+// the static module call tree in configuration and does not take into account
+// the potentially-multiple instances of a module that might be created by
+// "count" and "for_each" arguments within those calls.
+//
+// This type should be used only in very specialized cases when working with
+// the static module call tree. Type ModuleInstance is appropriate in more cases.
+//
+// Although Module is a slice, it should be treated as immutable after creation.
+type Module []string
+
+// RootModule is the module address representing the root of the static module
+// call tree, which is also the zero value of Module.
+//
+// Note that this is not the root of the dynamic module tree, which is instead
+// represented by RootModuleInstance.
+var RootModule Module
+
+// IsRoot returns true if the receiver is the address of the root module,
+// or false otherwise.
+func (m Module) IsRoot() bool {
+        return len(m) == 0
+}
+
+func (m Module) String() string {
+        if len(m) == 0 {
+                return ""
+        }
+        return strings.Join([]string(m), ".")
+}
+
+// Child returns the address of a child call in the receiver, identified by the
+// given name.
+func (m Module) Child(name string) Module {
+        ret := make(Module, 0, len(m)+1)
+        ret = append(ret, m...)
+        return append(ret, name)
+}
+
+// Parent returns the address of the parent module of the receiver, or the
+// receiver itself if there is no parent (if it's the root module address).
+func (m Module) Parent() Module {
+        if len(m) == 0 {
+                return m
+        }
+        return m[:len(m)-1]
+}
+
+// Call returns the module call address that corresponds to the given module
+// instance, along with the address of the module that contains it.
+//
+// There is no call for the root module, so this method will panic if called
+// on the root module address.
+//
+// In practice, this just turns the last element of the receiver into a
+// ModuleCall and then returns a slice of the receiever that excludes that
+// last part. This is just a convenience for situations where a call address
+// is required, such as when dealing with *Reference and Referencable values.
+func (m Module) Call() (Module, ModuleCall) {
+        if len(m) == 0 {
+                panic("cannot produce ModuleCall for root module")
+        }
+
+        caller, callName := m[:len(m)-1], m[len(m)-1]
+        return caller, ModuleCall{
+                Name: callName,
+        }
+}
diff --git a/vendor/github.com/hashicorp/terraform/addrs/module_call.go b/vendor/github.com/hashicorp/terraform/addrs/module_call.go
new file mode 100644
index 0000000..09596cc
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/addrs/module_call.go
@@ -0,0 +1,81 @@
+package addrs
+
+import (
+        "fmt"
+)
+
+// ModuleCall is the address of a call from the current module to a child
+// module.
+//
+// There is no "Abs" version of ModuleCall because an absolute module path
+// is represented by ModuleInstance.
+type ModuleCall struct {
+        referenceable
+        Name string
+}
+
+func (c ModuleCall) String() string {
+        return "module." + c.Name
+}
+
+// Instance returns the address of an instance of the receiver identified by
+// the given key.
+func (c ModuleCall) Instance(key InstanceKey) ModuleCallInstance {
+        return ModuleCallInstance{
+                Call: c,
+                Key:  key,
+        }
+}
+
+// ModuleCallInstance is the address of one instance of a module created from
+// a module call, which might create multiple instances using "count" or
+// "for_each" arguments.
+type ModuleCallInstance struct {
+        referenceable
+        Call ModuleCall
+        Key  InstanceKey
+}
+
+func (c ModuleCallInstance) String() string {
+        if c.Key == NoKey {
+                return c.Call.String()
+        }
+        return fmt.Sprintf("module.%s%s", c.Call.Name, c.Key)
+}
+
+// ModuleInstance returns the address of the module instance that corresponds
+// to the receiving call instance when resolved in the given calling module.
+// In other words, it returns the child module instance that the receving
+// call instance creates.
+func (c ModuleCallInstance) ModuleInstance(caller ModuleInstance) ModuleInstance {
+        return caller.Child(c.Call.Name, c.Key)
+}
+
+// Output returns the address of an output of the receiver identified by its
+// name.
+func (c ModuleCallInstance) Output(name string) ModuleCallOutput {
+        return ModuleCallOutput{
+                Call: c,
+                Name: name,
+        }
+}
+
+// ModuleCallOutput is the address of a particular named output produced by
+// an instance of a module call.
+type ModuleCallOutput struct {
+        referenceable
+        Call ModuleCallInstance
+        Name string
+}
+
+func (co ModuleCallOutput) String() string {
+        return fmt.Sprintf("%s.%s", co.Call.String(), co.Name)
+}
+
+// AbsOutputValue returns the absolute output value address that corresponds
+// to the receving module call output address, once resolved in the given
+// calling module.
+func (co ModuleCallOutput) AbsOutputValue(caller ModuleInstance) AbsOutputValue {
+        moduleAddr := co.Call.ModuleInstance(caller)
+        return moduleAddr.OutputValue(co.Name)
+}
diff --git a/vendor/github.com/hashicorp/terraform/addrs/module_instance.go b/vendor/github.com/hashicorp/terraform/addrs/module_instance.go
new file mode 100644
index 0000000..67e73e5
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/addrs/module_instance.go
@@ -0,0 +1,415 @@
+package addrs
+
+import (
+        "bytes"
+        "fmt"
+
+        "github.com/hashicorp/hcl2/hcl"
+        "github.com/hashicorp/hcl2/hcl/hclsyntax"
+        "github.com/zclconf/go-cty/cty"
+        "github.com/zclconf/go-cty/cty/gocty"
+
+        "github.com/hashicorp/terraform/tfdiags"
+)
+
+// ModuleInstance is an address for a particular module instance within the
+// dynamic module tree. This is an extension of the static traversals
+// represented by type Module that deals with the possibility of a single
+// module call producing multiple instances via the "count" and "for_each"
+// arguments.
+//
+// Although ModuleInstance is a slice, it should be treated as immutable after
+// creation.
+type ModuleInstance []ModuleInstanceStep
+
+var (
+        _ Targetable = ModuleInstance(nil)
+)
+
+func ParseModuleInstance(traversal hcl.Traversal) (ModuleInstance, tfdiags.Diagnostics) {
+        mi, remain, diags := parseModuleInstancePrefix(traversal)
+        if len(remain) != 0 {
+                if len(remain) == len(traversal) {
+                        diags = diags.Append(&hcl.Diagnostic{
+                                Severity: hcl.DiagError,
+                                Summary:  "Invalid module instance address",
+                                Detail:   "A module instance address must begin with \"module.\".",
+                                Subject:  remain.SourceRange().Ptr(),
+                        })
+                } else {
+                        diags = diags.Append(&hcl.Diagnostic{
+                                Severity: hcl.DiagError,
+                                Summary:  "Invalid module instance address",
+                                Detail:   "The module instance address is followed by additional invalid content.",
+                                Subject:  remain.SourceRange().Ptr(),
+                        })
+                }
+        }
+        return mi, diags
+}
+
+// ParseModuleInstanceStr is a helper wrapper around ParseModuleInstance
+// that takes a string and parses it with the HCL native syntax traversal parser
+// before interpreting it.
+//
+// This should be used only in specialized situations since it will cause the
+// created references to not have any meaningful source location information.
+// If a reference string is coming from a source that should be identified in
+// error messages then the caller should instead parse it directly using a
+// suitable function from the HCL API and pass the traversal itself to
+// ParseProviderConfigCompact.
+//
+// Error diagnostics are returned if either the parsing fails or the analysis
+// of the traversal fails. There is no way for the caller to distinguish the
+// two kinds of diagnostics programmatically. If error diagnostics are returned
+// then the returned address is invalid.
+func ParseModuleInstanceStr(str string) (ModuleInstance, tfdiags.Diagnostics) {
+        var diags tfdiags.Diagnostics
+
+        traversal, parseDiags := hclsyntax.ParseTraversalAbs([]byte(str), "", hcl.Pos{Line: 1, Column: 1})
+        diags = diags.Append(parseDiags)
+        if parseDiags.HasErrors() {
+                return nil, diags
+        }
+
+        addr, addrDiags := ParseModuleInstance(traversal)
+        diags = diags.Append(addrDiags)
+        return addr, diags
+}
+
+func parseModuleInstancePrefix(traversal hcl.Traversal) (ModuleInstance, hcl.Traversal, tfdiags.Diagnostics) {
+        remain := traversal
+        var mi ModuleInstance
+        var diags tfdiags.Diagnostics
+
+        for len(remain) > 0 {
+                var next string
+                switch tt := remain[0].(type) {
+                case hcl.TraverseRoot:
+                        next = tt.Name
+                case hcl.TraverseAttr:
+                        next = tt.Name
+                default:
+                        diags = diags.Append(&hcl.Diagnostic{
+                                Severity: hcl.DiagError,
+                                Summary:  "Invalid address operator",
+                                Detail:   "Module address prefix must be followed by dot and then a name.",
+                                Subject:  remain[0].SourceRange().Ptr(),
+                        })
+                        break
+                }
+
+                if next != "module" {
+                        break
+                }
+
+                kwRange := remain[0].SourceRange()
+                remain = remain[1:]
+                // If we have the prefix "module" then we should be followed by an
+                // module call name, as an attribute, and then optionally an index step
+                // giving the instance key.
+                if len(remain) == 0 {
+                        diags = diags.Append(&hcl.Diagnostic{
+                                Severity: hcl.DiagError,
+                                Summary:  "Invalid address operator",
+                                Detail:   "Prefix \"module.\" must be followed by a module name.",
+                                Subject:  &kwRange,
+                        })
+                        break
+                }
+
+                var moduleName string
+                switch tt := remain[0].(type) {
+                case hcl.TraverseAttr:
+                        moduleName = tt.Name
+                default:
+                        diags = diags.Append(&hcl.Diagnostic{
+                                Severity: hcl.DiagError,
+                                Summary:  "Invalid address operator",
+                                Detail:   "Prefix \"module.\" must be followed by a module name.",
+                                Subject:  remain[0].SourceRange().Ptr(),
+                        })
+                        break
+                }
+                remain = remain[1:]
+                step := ModuleInstanceStep{
+                        Name: moduleName,
+                }
+
+                if len(remain) > 0 {
+                        if idx, ok := remain[0].(hcl.TraverseIndex); ok {
+                                remain = remain[1:]
+
+                                switch idx.Key.Type() {
+                                case cty.String:
+                                        step.InstanceKey = StringKey(idx.Key.AsString())
+                                case cty.Number:
+                                        var idxInt int
+                                        err := gocty.FromCtyValue(idx.Key, &idxInt)
+                                        if err == nil {
+                                                step.InstanceKey = IntKey(idxInt)
+                                        } else {
+                                                diags = diags.Append(&hcl.Diagnostic{
+                                                        Severity: hcl.DiagError,
+                                                        Summary:  "Invalid address operator",
+                                                        Detail:   fmt.Sprintf("Invalid module index: %s.", err),
+                                                        Subject:  idx.SourceRange().Ptr(),
+                                                })
+                                        }
+                                default:
+                                        // Should never happen, because no other types are allowed in traversal indices.
+                                        diags = diags.Append(&hcl.Diagnostic{
+                                                Severity: hcl.DiagError,
+                                                Summary:  "Invalid address operator",
+                                                Detail:   "Invalid module key: must be either a string or an integer.",
+                                                Subject:  idx.SourceRange().Ptr(),
+                                        })
+                                }
+                        }
+                }
+
+                mi = append(mi, step)
+        }
+
+        var retRemain hcl.Traversal
+        if len(remain) > 0 {
+                retRemain = make(hcl.Traversal, len(remain))
+                copy(retRemain, remain)
+                // The first element here might be either a TraverseRoot or a
+                // TraverseAttr, depending on whether we had a module address on the
+                // front. To make life easier for callers, we'll normalize to always
+                // start with a TraverseRoot.
+                if tt, ok := retRemain[0].(hcl.TraverseAttr); ok {
+                        retRemain[0] = hcl.TraverseRoot{
+                                Name:     tt.Name,
+                                SrcRange: tt.SrcRange,
+                        }
+                }
+        }
+
+        return mi, retRemain, diags
+}
+
+// UnkeyedInstanceShim is a shim method for converting a Module address to the
+// equivalent ModuleInstance address that assumes that no modules have
+// keyed instances.
+//
+// This is a temporary allowance for the fact that Terraform does not presently
+// support "count" and "for_each" on modules, and thus graph building code that
+// derives graph nodes from configuration must just assume unkeyed modules
+// in order to construct the graph. At a later time when "count" and "for_each"
+// support is added for modules, all callers of this method will need to be
+// reworked to allow for keyed module instances.
+func (m Module) UnkeyedInstanceShim() ModuleInstance {
+        path := make(ModuleInstance, len(m))
+        for i, name := range m {
+                path[i] = ModuleInstanceStep{Name: name}
+        }
+        return path
+}
+
+// ModuleInstanceStep is a single traversal step through the dynamic module
+// tree. It is used only as part of ModuleInstance.
+type ModuleInstanceStep struct {
+        Name        string
+        InstanceKey InstanceKey
+}
+
+// RootModuleInstance is the module instance address representing the root
+// module, which is also the zero value of ModuleInstance.
+var RootModuleInstance ModuleInstance
+
+// IsRoot returns true if the receiver is the address of the root module instance,
+// or false otherwise.
+func (m ModuleInstance) IsRoot() bool {
+        return len(m) == 0
+}
+
+// Child returns the address of a child module instance of the receiver,
+// identified by the given name and key.
+func (m ModuleInstance) Child(name string, key InstanceKey) ModuleInstance {
+        ret := make(ModuleInstance, 0, len(m)+1)
+        ret = append(ret, m...)
+        return append(ret, ModuleInstanceStep{
+                Name:        name,
+                InstanceKey: key,
+        })
+}
+
+// Parent returns the address of the parent module instance of the receiver, or
+// the receiver itself if there is no parent (if it's the root module address).
+func (m ModuleInstance) Parent() ModuleInstance {
+        if len(m) == 0 {
+                return m
+        }
+        return m[:len(m)-1]
+}
+
+// String returns a string representation of the receiver, in the format used
+// within e.g. user-provided resource addresses.
+//
+// The address of the root module has the empty string as its representation.
+func (m ModuleInstance) String() string {
+        var buf bytes.Buffer
+        sep := ""
+        for _, step := range m {
+                buf.WriteString(sep)
+                buf.WriteString("module.")
+                buf.WriteString(step.Name)
+                if step.InstanceKey != NoKey {
+                        buf.WriteString(step.InstanceKey.String())
+                }
+                sep = "."
+        }
+        return buf.String()
+}
+
+// Equal returns true if the receiver and the given other value
+// contains the exact same parts.
+func (m ModuleInstance) Equal(o ModuleInstance) bool {
+        return m.String() == o.String()
+}
+
+// Less returns true if the receiver should sort before the given other value
+// in a sorted list of addresses.
+func (m ModuleInstance) Less(o ModuleInstance) bool {
+        if len(m) != len(o) {
+                // Shorter path sorts first.
+                return len(m) < len(o)
+        }
+
+        for i := range m {
+                mS, oS := m[i], o[i]
+                switch {
+                case mS.Name != oS.Name:
+                        return mS.Name < oS.Name
+                case mS.InstanceKey != oS.InstanceKey:
+                        return InstanceKeyLess(mS.InstanceKey, oS.InstanceKey)
+                }
+        }
+
+        return false
+}
+
+// Ancestors returns a slice containing the receiver and all of its ancestor
+// module instances, all the way up to (and including) the root module.
+// The result is ordered by depth, with the root module always first.
+//
+// Since the result always includes the root module, a caller may choose to
+// ignore it by slicing the result with [1:].
+func (m ModuleInstance) Ancestors() []ModuleInstance {
+        ret := make([]ModuleInstance, 0, len(m)+1)
+        for i := 0; i <= len(m); i++ {
+                ret = append(ret, m[:i])
+        }
+        return ret
+}
+
+// IsAncestor returns true if the receiver is an ancestor of the given
+// other value.
+func (m ModuleInstance) IsAncestor(o ModuleInstance) bool {
+        // Longer or equal sized paths means the receiver cannot
+        // be an ancestor of the given module insatnce.
+        if len(m) >= len(o) {
+                return false
+        }
+
+        for i, ms := range m {
+                if ms.Name != o[i].Name {
+                        return false
+                }
+                if ms.InstanceKey != NoKey && ms.InstanceKey != o[i].InstanceKey {
+                        return false
+                }
+        }
+
+        return true
+}
+
+// Call returns the module call address that corresponds to the given module
+// instance, along with the address of the module instance that contains it.
+//
+// There is no call for the root module, so this method will panic if called
+// on the root module address.
+//
+// A single module call can produce potentially many module instances, so the
+// result discards any instance key that might be present on the last step
+// of the instance. To retain this, use CallInstance instead.
+//
+// In practice, this just turns the last element of the receiver into a
+// ModuleCall and then returns a slice of the receiever that excludes that
+// last part. This is just a convenience for situations where a call address
+// is required, such as when dealing with *Reference and Referencable values.
+func (m ModuleInstance) Call() (ModuleInstance, ModuleCall) {
+        if len(m) == 0 {
+                panic("cannot produce ModuleCall for root module")
+        }
+
+        inst, lastStep := m[:len(m)-1], m[len(m)-1]
+        return inst, ModuleCall{
+                Name: lastStep.Name,
+        }
+}
+
+// CallInstance returns the module call instance address that corresponds to
+// the given module instance, along with the address of the module instance
+// that contains it.
+//
+// There is no call for the root module, so this method will panic if called
+// on the root module address.
+//
+// In practice, this just turns the last element of the receiver into a
+// ModuleCallInstance and then returns a slice of the receiever that excludes
+// that last part. This is just a convenience for situations where a call\
+// address is required, such as when dealing with *Reference and Referencable
+// values.
+func (m ModuleInstance) CallInstance() (ModuleInstance, ModuleCallInstance) {
+        if len(m) == 0 {
+                panic("cannot produce ModuleCallInstance for root module")
+        }
+
+        inst, lastStep := m[:len(m)-1], m[len(m)-1]
+        return inst, ModuleCallInstance{
+                Call: ModuleCall{
+                        Name: lastStep.Name,
+                },
+                Key: lastStep.InstanceKey,
+        }
+}
+
+// TargetContains implements Targetable by returning true if the given other
+// address either matches the receiver, is a sub-module-instance of the
+// receiver, or is a targetable absolute address within a module that
+// is contained within the reciever.
+func (m ModuleInstance) TargetContains(other Targetable) bool {
+        switch to := other.(type) {
+
+        case ModuleInstance:
+                if len(to) < len(m) {
+                        // Can't be contained if the path is shorter
+                        return false
+                }
+                // Other is contained if its steps match for the length of our own path.
+                for i, ourStep := range m {
+                        otherStep := to[i]
+                        if ourStep != otherStep {
+                                return false
+                        }
+                }
+                // If we fall out here then the prefixed matched, so it's contained.
+                return true
+
+        case AbsResource:
+                return m.TargetContains(to.Module)
+
+        case AbsResourceInstance:
+                return m.TargetContains(to.Module)
+
+        default:
+                return false
+        }
+}
+
+func (m ModuleInstance) targetableSigil() {
+        // ModuleInstance is targetable
+}
diff --git a/vendor/github.com/hashicorp/terraform/addrs/output_value.go b/vendor/github.com/hashicorp/terraform/addrs/output_value.go
new file mode 100644
index 0000000..bcd923a
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/addrs/output_value.go
@@ -0,0 +1,75 @@
+package addrs
+
+import (
+        "fmt"
+)
+
+// OutputValue is the address of an output value, in the context of the module
+// that is defining it.
+//
+// This is related to but separate from ModuleCallOutput, which represents
+// a module output from the perspective of its parent module. Since output
+// values cannot be represented from the module where they are defined,
+// OutputValue is not Referenceable, while ModuleCallOutput is.
+type OutputValue struct {
+        Name string
+}
+
+func (v OutputValue) String() string {
+        return "output." + v.Name
+}
+
+// Absolute converts the receiver into an absolute address within the given
+// module instance.
+func (v OutputValue) Absolute(m ModuleInstance) AbsOutputValue {
+        return AbsOutputValue{
+                Module:      m,
+                OutputValue: v,
+        }
+}
+
+// AbsOutputValue is the absolute address of an output value within a module instance.
+//
+// This represents an output globally within the namespace of a particular
+// configuration. It is related to but separate from ModuleCallOutput, which
+// represents a module output from the perspective of its parent module.
+type AbsOutputValue struct {
+        Module      ModuleInstance
+        OutputValue OutputValue
+}
+
+// OutputValue returns the absolute address of an output value of the given
+// name within the receiving module instance.
+func (m ModuleInstance) OutputValue(name string) AbsOutputValue {
+        return AbsOutputValue{
+                Module: m,
+                OutputValue: OutputValue{
+                        Name: name,
+                },
+        }
+}
+
+func (v AbsOutputValue) String() string {
+        if v.Module.IsRoot() {
+                return v.OutputValue.String()
+        }
+        return fmt.Sprintf("%s.%s", v.Module.String(), v.OutputValue.String())
+}
+
+// ModuleCallOutput converts an AbsModuleOutput into a ModuleCallOutput,
+// returning also the module instance that the ModuleCallOutput is relative
+// to.
+//
+// The root module does not have a call, and so this method cannot be used
+// with outputs in the root module, and will panic in that case.
+func (v AbsOutputValue) ModuleCallOutput() (ModuleInstance, ModuleCallOutput) {
+        if v.Module.IsRoot() {
+                panic("ReferenceFromCall used with root module output")
+        }
+
+        caller, call := v.Module.CallInstance()
+        return caller, ModuleCallOutput{
+                Call: call,
+                Name: v.OutputValue.Name,
+        }
+}
diff --git a/vendor/github.com/hashicorp/terraform/addrs/parse_ref.go b/vendor/github.com/hashicorp/terraform/addrs/parse_ref.go
new file mode 100644
index 0000000..84fe8a0
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/addrs/parse_ref.go
@@ -0,0 +1,338 @@
+package addrs
+
+import (
+        "fmt"
+
+        "github.com/hashicorp/hcl2/hcl"
+        "github.com/hashicorp/hcl2/hcl/hclsyntax"
+        "github.com/hashicorp/terraform/tfdiags"
+)
+
+// Reference describes a reference to an address with source location
+// information.
+type Reference struct {
+        Subject     Referenceable
+        SourceRange tfdiags.SourceRange
+        Remaining   hcl.Traversal
+}
+
+// ParseRef attempts to extract a referencable address from the prefix of the
+// given traversal, which must be an absolute traversal or this function
+// will panic.
+//
+// If no error diagnostics are returned, the returned reference includes the
+// address that was extracted, the source range it was extracted from, and any
+// remaining relative traversal that was not consumed as part of the
+// reference.
+//
+// If error diagnostics are returned then the Reference value is invalid and
+// must not be used.
+func ParseRef(traversal hcl.Traversal) (*Reference, tfdiags.Diagnostics) {
+        ref, diags := parseRef(traversal)
+
+        // Normalize a little to make life easier for callers.
+        if ref != nil {
+                if len(ref.Remaining) == 0 {
+                        ref.Remaining = nil
+                }
+        }
+
+        return ref, diags
+}
+
+// ParseRefStr is a helper wrapper around ParseRef that takes a string
+// and parses it with the HCL native syntax traversal parser before
+// interpreting it.
+//
+// This should be used only in specialized situations since it will cause the
+// created references to not have any meaningful source location information.
+// If a reference string is coming from a source that should be identified in
+// error messages then the caller should instead parse it directly using a
+// suitable function from the HCL API and pass the traversal itself to
+// ParseRef.
+//
+// Error diagnostics are returned if either the parsing fails or the analysis
+// of the traversal fails. There is no way for the caller to distinguish the
+// two kinds of diagnostics programmatically. If error diagnostics are returned
+// the returned reference may be nil or incomplete.
+func ParseRefStr(str string) (*Reference, tfdiags.Diagnostics) {
+        var diags tfdiags.Diagnostics
+
+        traversal, parseDiags := hclsyntax.ParseTraversalAbs([]byte(str), "", hcl.Pos{Line: 1, Column: 1})
+        diags = diags.Append(parseDiags)
+        if parseDiags.HasErrors() {
+                return nil, diags
+        }
+
+        ref, targetDiags := ParseRef(traversal)
+        diags = diags.Append(targetDiags)
+        return ref, diags
+}
+
+func parseRef(traversal hcl.Traversal) (*Reference, tfdiags.Diagnostics) {
+        var diags tfdiags.Diagnostics
+
+        root := traversal.RootName()
+        rootRange := traversal[0].SourceRange()
+
+        switch root {
+
+        case "count":
+                name, rng, remain, diags := parseSingleAttrRef(traversal)
+                return &Reference{
+                        Subject:     CountAttr{Name: name},
+                        SourceRange: tfdiags.SourceRangeFromHCL(rng),
+                        Remaining:   remain,
+                }, diags
+
+        case "data":
+                if len(traversal) < 3 {
+                        diags = diags.Append(&hcl.Diagnostic{
+                                Severity: hcl.DiagError,
+                                Summary:  "Invalid reference",
+                                Detail:   `The "data" object must be followed by two attribute names: the data source type and the resource name.`,
+                                Subject:  traversal.SourceRange().Ptr(),
+                        })
+                        return nil, diags
+                }
+                remain := traversal[1:] // trim off "data" so we can use our shared resource reference parser
+                return parseResourceRef(DataResourceMode, rootRange, remain)
+
+        case "local":
+                name, rng, remain, diags := parseSingleAttrRef(traversal)
+                return &Reference{
+                        Subject:     LocalValue{Name: name},
+                        SourceRange: tfdiags.SourceRangeFromHCL(rng),
+                        Remaining:   remain,
+                }, diags
+
+        case "module":
+                callName, callRange, remain, diags := parseSingleAttrRef(traversal)
+                if diags.HasErrors() {
+                        return nil, diags
+                }
+
+                // A traversal starting with "module" can either be a reference to
+                // an entire module instance or to a single output from a module
+                // instance, depending on what we find after this introducer.
+
+                callInstance := ModuleCallInstance{
+                        Call: ModuleCall{
+                                Name: callName,
+                        },
+                        Key: NoKey,
+                }
+
+                if len(remain) == 0 {
+                        // Reference to an entire module instance. Might alternatively
+                        // be a reference to a collection of instances of a particular
+                        // module, but the caller will need to deal with that ambiguity
+                        // since we don't have enough context here.
+                        return &Reference{
+                                Subject:     callInstance,
+                                SourceRange: tfdiags.SourceRangeFromHCL(callRange),
+                                Remaining:   remain,
+                        }, diags
+                }
+
+                if idxTrav, ok := remain[0].(hcl.TraverseIndex); ok {
+                        var err error
+                        callInstance.Key, err = ParseInstanceKey(idxTrav.Key)
+                        if err != nil {
+                                diags = diags.Append(&hcl.Diagnostic{
+                                        Severity: hcl.DiagError,
+                                        Summary:  "Invalid index key",
+                                        Detail:   fmt.Sprintf("Invalid index for module instance: %s.", err),
+                                        Subject:  &idxTrav.SrcRange,
+                                })
+                                return nil, diags
+                        }
+                        remain = remain[1:]
+
+                        if len(remain) == 0 {
+                                // Also a reference to an entire module instance, but we have a key
+                                // now.
+                                return &Reference{
+                                        Subject:     callInstance,
+                                        SourceRange: tfdiags.SourceRangeFromHCL(hcl.RangeBetween(callRange, idxTrav.SrcRange)),
+                                        Remaining:   remain,
+                                }, diags
+                        }
+                }
+
+                if attrTrav, ok := remain[0].(hcl.TraverseAttr); ok {
+                        remain = remain[1:]
+                        return &Reference{
+                                Subject: ModuleCallOutput{
+                                        Name: attrTrav.Name,
+                                        Call: callInstance,
+                                },
+                                SourceRange: tfdiags.SourceRangeFromHCL(hcl.RangeBetween(callRange, attrTrav.SrcRange)),
+                                Remaining:   remain,
+                        }, diags
+                }
+
+                diags = diags.Append(&hcl.Diagnostic{
+                        Severity: hcl.DiagError,
+                        Summary:  "Invalid reference",
+                        Detail:   "Module instance objects do not support this operation.",
+                        Subject:  remain[0].SourceRange().Ptr(),
+                })
+                return nil, diags
+
+        case "path":
+                name, rng, remain, diags := parseSingleAttrRef(traversal)
+                return &Reference{
+                        Subject:     PathAttr{Name: name},
+                        SourceRange: tfdiags.SourceRangeFromHCL(rng),
+                        Remaining:   remain,
+                }, diags
+
+        case "self":
+                return &Reference{
+                        Subject:     Self,
+                        SourceRange: tfdiags.SourceRangeFromHCL(rootRange),
+                        Remaining:   traversal[1:],
+                }, diags
+
+        case "terraform":
+                name, rng, remain, diags := parseSingleAttrRef(traversal)
+                return &Reference{
+                        Subject:     TerraformAttr{Name: name},
+                        SourceRange: tfdiags.SourceRangeFromHCL(rng),
+                        Remaining:   remain,
+                }, diags
+
+        case "var":
+                name, rng, remain, diags := parseSingleAttrRef(traversal)
+                return &Reference{
+                        Subject:     InputVariable{Name: name},
+                        SourceRange: tfdiags.SourceRangeFromHCL(rng),
+                        Remaining:   remain,
+                }, diags
+
+        default:
+                return parseResourceRef(ManagedResourceMode, rootRange, traversal)
+        }
+}
+
+func parseResourceRef(mode ResourceMode, startRange hcl.Range, traversal hcl.Traversal) (*Reference, tfdiags.Diagnostics) {
+        var diags tfdiags.Diagnostics
+
+        if len(traversal) < 2 {
+                diags = diags.Append(&hcl.Diagnostic{
+                        Severity: hcl.DiagError,
+                        Summary:  "Invalid reference",
+                        Detail:   `A reference to a resource type must be followed by at least one attribute access, specifying the resource name.`,
+                        Subject:  hcl.RangeBetween(traversal[0].SourceRange(), traversal[len(traversal)-1].SourceRange()).Ptr(),
+                })
+                return nil, diags
+        }
+
+        var typeName, name string
+        switch tt := traversal[0].(type) { // Could be either root or attr, depending on our resource mode
+        case hcl.TraverseRoot:
+                typeName = tt.Name
+        case hcl.TraverseAttr:
+                typeName = tt.Name
+        default:
+                // If it isn't a TraverseRoot then it must be a "data" reference.
+                diags = diags.Append(&hcl.Diagnostic{
+                        Severity: hcl.DiagError,
+                        Summary:  "Invalid reference",
+                        Detail:   `The "data" object does not support this operation.`,
+                        Subject:  traversal[0].SourceRange().Ptr(),
+                })
+                return nil, diags
+        }
+
+        attrTrav, ok := traversal[1].(hcl.TraverseAttr)
+        if !ok {
+                var what string
+                switch mode {
+                case DataResourceMode:
+                        what = "data source"
+                default:
+                        what = "resource type"
+                }
+                diags = diags.Append(&hcl.Diagnostic{
+                        Severity: hcl.DiagError,
+                        Summary:  "Invalid reference",
+                        Detail:   fmt.Sprintf(`A reference to a %s must be followed by at least one attribute access, specifying the resource name.`, what),
+                        Subject:  traversal[1].SourceRange().Ptr(),
+                })
+                return nil, diags
+        }
+        name = attrTrav.Name
+        rng := hcl.RangeBetween(startRange, attrTrav.SrcRange)
+        remain := traversal[2:]
+
+        resourceAddr := Resource{
+                Mode: mode,
+                Type: typeName,
+                Name: name,
+        }
+        resourceInstAddr := ResourceInstance{
+                Resource: resourceAddr,
+                Key:      NoKey,
+        }
+
+        if len(remain) == 0 {
+                // This might actually be a reference to the collection of all instances
+                // of the resource, but we don't have enough context here to decide
+                // so we'll let the caller resolve that ambiguity.
+                return &Reference{
+                        Subject:     resourceInstAddr,
+                        SourceRange: tfdiags.SourceRangeFromHCL(rng),
+                }, diags
+        }
+
+        if idxTrav, ok := remain[0].(hcl.TraverseIndex); ok {
+                var err error
+                resourceInstAddr.Key, err = ParseInstanceKey(idxTrav.Key)
+                if err != nil {
+                        diags = diags.Append(&hcl.Diagnostic{
+                                Severity: hcl.DiagError,
+                                Summary:  "Invalid index key",
+                                Detail:   fmt.Sprintf("Invalid index for resource instance: %s.", err),
+                                Subject:  &idxTrav.SrcRange,
+                        })
+                        return nil, diags
+                }
+                remain = remain[1:]
+                rng = hcl.RangeBetween(rng, idxTrav.SrcRange)
+        }
+
+        return &Reference{
+                Subject:     resourceInstAddr,
+                SourceRange: tfdiags.SourceRangeFromHCL(rng),
+                Remaining:   remain,
+        }, diags
+}
+
+func parseSingleAttrRef(traversal hcl.Traversal) (string, hcl.Range, hcl.Traversal, tfdiags.Diagnostics) {
+        var diags tfdiags.Diagnostics
+
+        root := traversal.RootName()
+        rootRange := traversal[0].SourceRange()
+
+        if len(traversal) < 2 {
+                diags = diags.Append(&hcl.Diagnostic{
+                        Severity: hcl.DiagError,
+                        Summary:  "Invalid reference",
+                        Detail:   fmt.Sprintf("The %q object cannot be accessed directly. Instead, access one of its attributes.", root),
+                        Subject:  &rootRange,
+                })
+                return "", hcl.Range{}, nil, diags
+        }
+        if attrTrav, ok := traversal[1].(hcl.TraverseAttr); ok {
+                return attrTrav.Name, hcl.RangeBetween(rootRange, attrTrav.SrcRange), traversal[2:], diags
+        }
+        diags = diags.Append(&hcl.Diagnostic{
+                Severity: hcl.DiagError,
+                Summary:  "Invalid reference",
+                Detail:   fmt.Sprintf("The %q object does not support this operation.", root),
+                Subject:  traversal[1].SourceRange().Ptr(),
+        })
+        return "", hcl.Range{}, nil, diags
+}
diff --git a/vendor/github.com/hashicorp/terraform/addrs/parse_target.go b/vendor/github.com/hashicorp/terraform/addrs/parse_target.go
new file mode 100644
index 0000000..057443a
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/addrs/parse_target.go
@@ -0,0 +1,318 @@
+package addrs
+
+import (
+        "fmt"
+
+        "github.com/hashicorp/hcl2/hcl/hclsyntax"
+
+        "github.com/hashicorp/hcl2/hcl"
+        "github.com/hashicorp/terraform/tfdiags"
+)
+
+// Target describes a targeted address with source location information.
+type Target struct {
+        Subject     Targetable
+        SourceRange tfdiags.SourceRange
+}
+
+// ParseTarget attempts to interpret the given traversal as a targetable
+// address. The given traversal must be absolute, or this function will
+// panic.
+//
+// If no error diagnostics are returned, the returned target includes the
+// address that was extracted and the source range it was extracted from.
+//
+// If error diagnostics are returned then the Target value is invalid and
+// must not be used.
+func ParseTarget(traversal hcl.Traversal) (*Target, tfdiags.Diagnostics) {
+        path, remain, diags := parseModuleInstancePrefix(traversal)
+        if diags.HasErrors() {
+                return nil, diags
+        }
+
+        rng := tfdiags.SourceRangeFromHCL(traversal.SourceRange())
+
+        if len(remain) == 0 {
+                return &Target{
+                        Subject:     path,
+                        SourceRange: rng,
+                }, diags
+        }
+
+        mode := ManagedResourceMode
+        if remain.RootName() == "data" {
+                mode = DataResourceMode
+                remain = remain[1:]
+        }
+
+        if len(remain) < 2 {
+                diags = diags.Append(&hcl.Diagnostic{
+                        Severity: hcl.DiagError,
+                        Summary:  "Invalid address",
+                        Detail:   "Resource specification must include a resource type and name.",
+                        Subject:  remain.SourceRange().Ptr(),
+                })
+                return nil, diags
+        }
+
+        var typeName, name string
+        switch tt := remain[0].(type) {
+        case hcl.TraverseRoot:
+                typeName = tt.Name
+        case hcl.TraverseAttr:
+                typeName = tt.Name
+        default:
+                switch mode {
+                case ManagedResourceMode:
+                        diags = diags.Append(&hcl.Diagnostic{
+                                Severity: hcl.DiagError,
+                                Summary:  "Invalid address",
+                                Detail:   "A resource type name is required.",
+                                Subject:  remain[0].SourceRange().Ptr(),
+                        })
+                case DataResourceMode:
+                        diags = diags.Append(&hcl.Diagnostic{
+                                Severity: hcl.DiagError,
+                                Summary:  "Invalid address",
+                                Detail:   "A data source name is required.",
+                                Subject:  remain[0].SourceRange().Ptr(),
+                        })
+                default:
+                        panic("unknown mode")
+                }
+                return nil, diags
+        }
+
+        switch tt := remain[1].(type) {
+        case hcl.TraverseAttr:
+                name = tt.Name
+        default:
+                diags = diags.Append(&hcl.Diagnostic{
+                        Severity: hcl.DiagError,
+                        Summary:  "Invalid address",
+                        Detail:   "A resource name is required.",
+                        Subject:  remain[1].SourceRange().Ptr(),
+                })
+                return nil, diags
+        }
+
+        var subject Targetable
+        remain = remain[2:]
+        switch len(remain) {
+        case 0:
+                subject = path.Resource(mode, typeName, name)
+        case 1:
+                if tt, ok := remain[0].(hcl.TraverseIndex); ok {
+                        key, err := ParseInstanceKey(tt.Key)
+                        if err != nil {
+                                diags = diags.Append(&hcl.Diagnostic{
+                                        Severity: hcl.DiagError,
+                                        Summary:  "Invalid address",
+                                        Detail:   fmt.Sprintf("Invalid resource instance key: %s.", err),
+                                        Subject:  remain[0].SourceRange().Ptr(),
+                                })
+                                return nil, diags
+                        }
+
+                        subject = path.ResourceInstance(mode, typeName, name, key)
+                } else {
+                        diags = diags.Append(&hcl.Diagnostic{
+                                Severity: hcl.DiagError,
+                                Summary:  "Invalid address",
+                                Detail:   "Resource instance key must be given in square brackets.",
+                                Subject:  remain[0].SourceRange().Ptr(),
+                        })
+                        return nil, diags
+                }
+        default:
+                diags = diags.Append(&hcl.Diagnostic{
+                        Severity: hcl.DiagError,
+                        Summary:  "Invalid address",
+                        Detail:   "Unexpected extra operators after address.",
+                        Subject:  remain[1].SourceRange().Ptr(),
+                })
+                return nil, diags
+        }
+
+        return &Target{
+                Subject:     subject,
+                SourceRange: rng,
+        }, diags
+}
+
+// ParseTargetStr is a helper wrapper around ParseTarget that takes a string
+// and parses it with the HCL native syntax traversal parser before
+// interpreting it.
+//
+// This should be used only in specialized situations since it will cause the
+// created references to not have any meaningful source location information.
+// If a target string is coming from a source that should be identified in
+// error messages then the caller should instead parse it directly using a
+// suitable function from the HCL API and pass the traversal itself to
+// ParseTarget.
+//
+// Error diagnostics are returned if either the parsing fails or the analysis
+// of the traversal fails. There is no way for the caller to distinguish the
+// two kinds of diagnostics programmatically. If error diagnostics are returned
+// the returned target may be nil or incomplete.
+func ParseTargetStr(str string) (*Target, tfdiags.Diagnostics) {
+        var diags tfdiags.Diagnostics
+
+        traversal, parseDiags := hclsyntax.ParseTraversalAbs([]byte(str), "", hcl.Pos{Line: 1, Column: 1})
+        diags = diags.Append(parseDiags)
+        if parseDiags.HasErrors() {
+                return nil, diags
+        }
+
+        target, targetDiags := ParseTarget(traversal)
+        diags = diags.Append(targetDiags)
+        return target, diags
+}
+
+// ParseAbsResource attempts to interpret the given traversal as an absolute
+// resource address, using the same syntax as expected by ParseTarget.
+//
+// If no error diagnostics are returned, the returned target includes the
+// address that was extracted and the source range it was extracted from.
+//
+// If error diagnostics are returned then the AbsResource value is invalid and
+// must not be used.
+func ParseAbsResource(traversal hcl.Traversal) (AbsResource, tfdiags.Diagnostics) {
+        addr, diags := ParseTarget(traversal)
+        if diags.HasErrors() {
+                return AbsResource{}, diags
+        }
+
+        switch tt := addr.Subject.(type) {
+
+        case AbsResource:
+                return tt, diags
+
+        case AbsResourceInstance: // Catch likely user error with specialized message
+                // Assume that the last element of the traversal must be the index,
+                // since that's required for a valid resource instance address.
+                indexStep := traversal[len(traversal)-1]
+                diags = diags.Append(&hcl.Diagnostic{
+                        Severity: hcl.DiagError,
+                        Summary:  "Invalid address",
+                        Detail:   "A resource address is required. This instance key identifies a specific resource instance, which is not expected here.",
+                        Subject:  indexStep.SourceRange().Ptr(),
+                })
+                return AbsResource{}, diags
+
+        case ModuleInstance: // Catch likely user error with specialized message
+                diags = diags.Append(&hcl.Diagnostic{
+                        Severity: hcl.DiagError,
+                        Summary:  "Invalid address",
+                        Detail:   "A resource address is required here. The module path must be followed by a resource specification.",
+                        Subject:  traversal.SourceRange().Ptr(),
+                })
+                return AbsResource{}, diags
+
+        default: // Generic message for other address types
+                diags = diags.Append(&hcl.Diagnostic{
+                        Severity: hcl.DiagError,
+                        Summary:  "Invalid address",
+                        Detail:   "A resource address is required here.",
+                        Subject:  traversal.SourceRange().Ptr(),
+                })
+                return AbsResource{}, diags
+
+        }
+}
+
+// ParseAbsResourceStr is a helper wrapper around ParseAbsResource that takes a
+// string and parses it with the HCL native syntax traversal parser before
+// interpreting it.
+//
+// Error diagnostics are returned if either the parsing fails or the analysis
+// of the traversal fails. There is no way for the caller to distinguish the
+// two kinds of diagnostics programmatically. If error diagnostics are returned
+// the returned address may be incomplete.
+//
+// Since this function has no context about the source of the given string,
+// any returned diagnostics will not have meaningful source location
+// information.
+func ParseAbsResourceStr(str string) (AbsResource, tfdiags.Diagnostics) {
+        var diags tfdiags.Diagnostics
+
+        traversal, parseDiags := hclsyntax.ParseTraversalAbs([]byte(str), "", hcl.Pos{Line: 1, Column: 1})
+        diags = diags.Append(parseDiags)
+        if parseDiags.HasErrors() {
+                return AbsResource{}, diags
+        }
+
+        addr, addrDiags := ParseAbsResource(traversal)
+        diags = diags.Append(addrDiags)
+        return addr, diags
+}
+
+// ParseAbsResourceInstance attempts to interpret the given traversal as an
+// absolute resource instance address, using the same syntax as expected by
+// ParseTarget.
+//
+// If no error diagnostics are returned, the returned target includes the
+// address that was extracted and the source range it was extracted from.
+//
+// If error diagnostics are returned then the AbsResource value is invalid and
+// must not be used.
+func ParseAbsResourceInstance(traversal hcl.Traversal) (AbsResourceInstance, tfdiags.Diagnostics) {
+        addr, diags := ParseTarget(traversal)
+        if diags.HasErrors() {
+                return AbsResourceInstance{}, diags
+        }
+
+        switch tt := addr.Subject.(type) {
+
+        case AbsResource:
+                return tt.Instance(NoKey), diags
+
+        case AbsResourceInstance:
+                return tt, diags
+
+        case ModuleInstance: // Catch likely user error with specialized message
+                diags = diags.Append(&hcl.Diagnostic{
+                        Severity: hcl.DiagError,
+                        Summary:  "Invalid address",
+                        Detail:   "A resource instance address is required here. The module path must be followed by a resource instance specification.",
+                        Subject:  traversal.SourceRange().Ptr(),
+                })
+                return AbsResourceInstance{}, diags
+
+        default: // Generic message for other address types
+                diags = diags.Append(&hcl.Diagnostic{
+                        Severity: hcl.DiagError,
+                        Summary:  "Invalid address",
+                        Detail:   "A resource address is required here.",
+                        Subject:  traversal.SourceRange().Ptr(),
+                })
+                return AbsResourceInstance{}, diags
+
+        }
+}
+
+// ParseAbsResourceInstanceStr is a helper wrapper around
+// ParseAbsResourceInstance that takes a string and parses it with the HCL
+// native syntax traversal parser before interpreting it.
+//
+// Error diagnostics are returned if either the parsing fails or the analysis
+// of the traversal fails. There is no way for the caller to distinguish the
+// two kinds of diagnostics programmatically. If error diagnostics are returned
+// the returned address may be incomplete.
+//
+// Since this function has no context about the source of the given string,
+// any returned diagnostics will not have meaningful source location
+// information.
+func ParseAbsResourceInstanceStr(str string) (AbsResourceInstance, tfdiags.Diagnostics) {
+        var diags tfdiags.Diagnostics
+
+        traversal, parseDiags := hclsyntax.ParseTraversalAbs([]byte(str), "", hcl.Pos{Line: 1, Column: 1})
+        diags = diags.Append(parseDiags)
+        if parseDiags.HasErrors() {
+                return AbsResourceInstance{}, diags
+        }
+
+        addr, addrDiags := ParseAbsResourceInstance(traversal)
+        diags = diags.Append(addrDiags)
+        return addr, diags
+}
diff --git a/vendor/github.com/hashicorp/terraform/addrs/path_attr.go b/vendor/github.com/hashicorp/terraform/addrs/path_attr.go
new file mode 100644
index 0000000..cfc13f4
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/addrs/path_attr.go
@@ -0,0 +1,12 @@
+package addrs
+
+// PathAttr is the address of an attribute of the "path" object in
+// the interpolation scope, like "path.module".
+type PathAttr struct {
+        referenceable
+        Name string
+}
+
+func (pa PathAttr) String() string {
+        return "path." + pa.Name
+}
diff --git a/vendor/github.com/hashicorp/terraform/addrs/provider_config.go b/vendor/github.com/hashicorp/terraform/addrs/provider_config.go
new file mode 100644
index 0000000..340dd19
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/addrs/provider_config.go
@@ -0,0 +1,297 @@
+package addrs
+
+import (
+        "fmt"
+
+        "github.com/hashicorp/terraform/tfdiags"
+
+        "github.com/hashicorp/hcl2/hcl"
+        "github.com/hashicorp/hcl2/hcl/hclsyntax"
+)
+
+// ProviderConfig is the address of a provider configuration.
+type ProviderConfig struct {
+        Type string
+
+        // If not empty, Alias identifies which non-default (aliased) provider
+        // configuration this address refers to.
+        Alias string
+}
+
+// NewDefaultProviderConfig returns the address of the default (un-aliased)
+// configuration for the provider with the given type name.
+func NewDefaultProviderConfig(typeName string) ProviderConfig {
+        return ProviderConfig{
+                Type: typeName,
+        }
+}
+
+// ParseProviderConfigCompact parses the given absolute traversal as a relative
+// provider address in compact form. The following are examples of traversals
+// that can be successfully parsed as compact relative provider configuration
+// addresses:
+//
+//     aws
+//     aws.foo
+//
+// This function will panic if given a relative traversal.
+//
+// If the returned diagnostics contains errors then the result value is invalid
+// and must not be used.
+func ParseProviderConfigCompact(traversal hcl.Traversal) (ProviderConfig, tfdiags.Diagnostics) {
+        var diags tfdiags.Diagnostics
+        ret := ProviderConfig{
+                Type: traversal.RootName(),
+        }
+
+        if len(traversal) < 2 {
+                // Just a type name, then.
+                return ret, diags
+        }
+
+        aliasStep := traversal[1]
+        switch ts := aliasStep.(type) {
+        case hcl.TraverseAttr:
+                ret.Alias = ts.Name
+                return ret, diags
+        default:
+                diags = diags.Append(&hcl.Diagnostic{
+                        Severity: hcl.DiagError,
+                        Summary:  "Invalid provider configuration address",
+                        Detail:   "The provider type name must either stand alone or be followed by an alias name separated with a dot.",
+                        Subject:  aliasStep.SourceRange().Ptr(),
+                })
+        }
+
+        if len(traversal) > 2 {
+                diags = diags.Append(&hcl.Diagnostic{
+                        Severity: hcl.DiagError,
+                        Summary:  "Invalid provider configuration address",
+                        Detail:   "Extraneous extra operators after provider configuration address.",
+                        Subject:  traversal[2:].SourceRange().Ptr(),
+                })
+        }
+
+        return ret, diags
+}
+
+// ParseProviderConfigCompactStr is a helper wrapper around ParseProviderConfigCompact
+// that takes a string and parses it with the HCL native syntax traversal parser
+// before interpreting it.
+//
+// This should be used only in specialized situations since it will cause the
+// created references to not have any meaningful source location information.
+// If a reference string is coming from a source that should be identified in
+// error messages then the caller should instead parse it directly using a
+// suitable function from the HCL API and pass the traversal itself to
+// ParseProviderConfigCompact.
+//
+// Error diagnostics are returned if either the parsing fails or the analysis
+// of the traversal fails. There is no way for the caller to distinguish the
+// two kinds of diagnostics programmatically. If error diagnostics are returned
+// then the returned address is invalid.
+func ParseProviderConfigCompactStr(str string) (ProviderConfig, tfdiags.Diagnostics) {
+        var diags tfdiags.Diagnostics
+
+        traversal, parseDiags := hclsyntax.ParseTraversalAbs([]byte(str), "", hcl.Pos{Line: 1, Column: 1})
+        diags = diags.Append(parseDiags)
+        if parseDiags.HasErrors() {
+                return ProviderConfig{}, diags
+        }
+
+        addr, addrDiags := ParseProviderConfigCompact(traversal)
+        diags = diags.Append(addrDiags)
+        return addr, diags
+}
+
+// Absolute returns an AbsProviderConfig from the receiver and the given module
+// instance address.
+func (pc ProviderConfig) Absolute(module ModuleInstance) AbsProviderConfig {
+        return AbsProviderConfig{
+                Module:         module,
+                ProviderConfig: pc,
+        }
+}
+
+func (pc ProviderConfig) String() string {
+        if pc.Type == "" {
+                // Should never happen; always indicates a bug
+                return "provider.<invalid>"
+        }
+
+        if pc.Alias != "" {
+                return fmt.Sprintf("provider.%s.%s", pc.Type, pc.Alias)
+        }
+
+        return "provider." + pc.Type
+}
+
+// StringCompact is an alternative to String that returns the form that can
+// be parsed by ParseProviderConfigCompact, without the "provider." prefix.
+func (pc ProviderConfig) StringCompact() string {
+        if pc.Alias != "" {
+                return fmt.Sprintf("%s.%s", pc.Type, pc.Alias)
+        }
+        return pc.Type
+}
+
+// AbsProviderConfig is the absolute address of a provider configuration
+// within a particular module instance.
+type AbsProviderConfig struct {
+        Module         ModuleInstance
+        ProviderConfig ProviderConfig
+}
+
+// ParseAbsProviderConfig parses the given traversal as an absolute provider
+// address. The following are examples of traversals that can be successfully
+// parsed as absolute provider configuration addresses:
+//
+//     provider.aws
+//     provider.aws.foo
+//     module.bar.provider.aws
+//     module.bar.module.baz.provider.aws.foo
+//     module.foo[1].provider.aws.foo
+//
+// This type of address is used, for example, to record the relationships
+// between resources and provider configurations in the state structure.
+// This type of address is not generally used in the UI, except in error
+// messages that refer to provider configurations.
+func ParseAbsProviderConfig(traversal hcl.Traversal) (AbsProviderConfig, tfdiags.Diagnostics) {
+        modInst, remain, diags := parseModuleInstancePrefix(traversal)
+        ret := AbsProviderConfig{
+                Module: modInst,
+        }
+        if len(remain) < 2 || remain.RootName() != "provider" {
+                diags = diags.Append(&hcl.Diagnostic{
+                        Severity: hcl.DiagError,
+                        Summary:  "Invalid provider configuration address",
+                        Detail:   "Provider address must begin with \"provider.\", followed by a provider type name.",
+                        Subject:  remain.SourceRange().Ptr(),
+                })
+                return ret, diags
+        }
+        if len(remain) > 3 {
+                diags = diags.Append(&hcl.Diagnostic{
+                        Severity: hcl.DiagError,
+                        Summary:  "Invalid provider configuration address",
+                        Detail:   "Extraneous operators after provider configuration alias.",
+                        Subject:  hcl.Traversal(remain[3:]).SourceRange().Ptr(),
+                })
+                return ret, diags
+        }
+
+        if tt, ok := remain[1].(hcl.TraverseAttr); ok {
+                ret.ProviderConfig.Type = tt.Name
+        } else {
+                diags = diags.Append(&hcl.Diagnostic{
+                        Severity: hcl.DiagError,
+                        Summary:  "Invalid provider configuration address",
+                        Detail:   "The prefix \"provider.\" must be followed by a provider type name.",
+                        Subject:  remain[1].SourceRange().Ptr(),
+                })
+                return ret, diags
+        }
+
+        if len(remain) == 3 {
+                if tt, ok := remain[2].(hcl.TraverseAttr); ok {
+                        ret.ProviderConfig.Alias = tt.Name
+                } else {
+                        diags = diags.Append(&hcl.Diagnostic{
+                                Severity: hcl.DiagError,
+                                Summary:  "Invalid provider configuration address",
+                                Detail:   "Provider type name must be followed by a configuration alias name.",
+                                Subject:  remain[2].SourceRange().Ptr(),
+                        })
+                        return ret, diags
+                }
+        }
+
+        return ret, diags
+}
+
+// ParseAbsProviderConfigStr is a helper wrapper around ParseAbsProviderConfig
+// that takes a string and parses it with the HCL native syntax traversal parser
+// before interpreting it.
+//
+// This should be used only in specialized situations since it will cause the
+// created references to not have any meaningful source location information.
+// If a reference string is coming from a source that should be identified in
+// error messages then the caller should instead parse it directly using a
+// suitable function from the HCL API and pass the traversal itself to
+// ParseAbsProviderConfig.
+//
+// Error diagnostics are returned if either the parsing fails or the analysis
+// of the traversal fails. There is no way for the caller to distinguish the
+// two kinds of diagnostics programmatically. If error diagnostics are returned
+// the returned address is invalid.
+func ParseAbsProviderConfigStr(str string) (AbsProviderConfig, tfdiags.Diagnostics) {
+        var diags tfdiags.Diagnostics
+
+        traversal, parseDiags := hclsyntax.ParseTraversalAbs([]byte(str), "", hcl.Pos{Line: 1, Column: 1})
+        diags = diags.Append(parseDiags)
+        if parseDiags.HasErrors() {
+                return AbsProviderConfig{}, diags
+        }
+
+        addr, addrDiags := ParseAbsProviderConfig(traversal)
+        diags = diags.Append(addrDiags)
+        return addr, diags
+}
+
+// ProviderConfigDefault returns the address of the default provider config
+// of the given type inside the recieving module instance.
+func (m ModuleInstance) ProviderConfigDefault(name string) AbsProviderConfig {
+        return AbsProviderConfig{
+                Module: m,
+                ProviderConfig: ProviderConfig{
+                        Type: name,
+                },
+        }
+}
+
+// ProviderConfigAliased returns the address of an aliased provider config
+// of with given type and alias inside the recieving module instance.
+func (m ModuleInstance) ProviderConfigAliased(name, alias string) AbsProviderConfig {
+        return AbsProviderConfig{
+                Module: m,
+                ProviderConfig: ProviderConfig{
+                        Type:  name,
+                        Alias: alias,
+                },
+        }
+}
+
+// Inherited returns an address that the receiving configuration address might
+// inherit from in a parent module. The second bool return value indicates if
+// such inheritance is possible, and thus whether the returned address is valid.
+//
+// Inheritance is possible only for default (un-aliased) providers in modules
+// other than the root module. Even if a valid address is returned, inheritence
+// may not be performed for other reasons, such as if the calling module
+// provided explicit provider configurations within the call for this module.
+// The ProviderTransformer graph transform in the main terraform module has
+// the authoritative logic for provider inheritance, and this method is here
+// mainly just for its benefit.
+func (pc AbsProviderConfig) Inherited() (AbsProviderConfig, bool) {
+        // Can't inherit if we're already in the root.
+        if len(pc.Module) == 0 {
+                return AbsProviderConfig{}, false
+        }
+
+        // Can't inherit if we have an alias.
+        if pc.ProviderConfig.Alias != "" {
+                return AbsProviderConfig{}, false
+        }
+
+        // Otherwise, we might inherit from a configuration with the same
+        // provider name in the parent module instance.
+        parentMod := pc.Module.Parent()
+        return pc.ProviderConfig.Absolute(parentMod), true
+}
+
+func (pc AbsProviderConfig) String() string {
+        if len(pc.Module) == 0 {
+                return pc.ProviderConfig.String()
+        }
+        return fmt.Sprintf("%s.%s", pc.Module.String(), pc.ProviderConfig.String())
+}
diff --git a/vendor/github.com/hashicorp/terraform/addrs/referenceable.go b/vendor/github.com/hashicorp/terraform/addrs/referenceable.go
new file mode 100644
index 0000000..211083a
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/addrs/referenceable.go
@@ -0,0 +1,20 @@
+package addrs
+
+// Referenceable is an interface implemented by all address types that can
+// appear as references in configuration language expressions.
+type Referenceable interface {
+        // All implementations of this interface must be covered by the type switch
+        // in lang.Scope.buildEvalContext.
+        referenceableSigil()
+
+        // String produces a string representation of the address that could be
+        // parsed as a HCL traversal and passed to ParseRef to produce an identical
+        // result.
+        String() string
+}
+
+type referenceable struct {
+}
+
+func (r referenceable) referenceableSigil() {
+}
diff --git a/vendor/github.com/hashicorp/terraform/addrs/resource.go b/vendor/github.com/hashicorp/terraform/addrs/resource.go
new file mode 100644
index 0000000..2866770
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/addrs/resource.go
@@ -0,0 +1,270 @@
+package addrs
+
+import (
+        "fmt"
+        "strings"
+)
+
+// Resource is an address for a resource block within configuration, which
+// contains potentially-multiple resource instances if that configuration
+// block uses "count" or "for_each".
+type Resource struct {
+        referenceable
+        Mode ResourceMode
+        Type string
+        Name string
+}
+
+func (r Resource) String() string {
+        switch r.Mode {
+        case ManagedResourceMode:
+                return fmt.Sprintf("%s.%s", r.Type, r.Name)
+        case DataResourceMode:
+                return fmt.Sprintf("data.%s.%s", r.Type, r.Name)
+        default:
+                // Should never happen, but we'll return a string here rather than
+                // crashing just in case it does.
+                return fmt.Sprintf("<invalid>.%s.%s", r.Type, r.Name)
+        }
+}
+
+func (r Resource) Equal(o Resource) bool {
+        return r.String() == o.String()
+}
+
+// Instance produces the address for a specific instance of the receiver
+// that is idenfied by the given key.
+func (r Resource) Instance(key InstanceKey) ResourceInstance {
+        return ResourceInstance{
+                Resource: r,
+                Key:      key,
+        }
+}
+
+// Absolute returns an AbsResource from the receiver and the given module
+// instance address.
+func (r Resource) Absolute(module ModuleInstance) AbsResource {
+        return AbsResource{
+                Module:   module,
+                Resource: r,
+        }
+}
+
+// DefaultProviderConfig returns the address of the provider configuration
+// that should be used for the resource identified by the reciever if it
+// does not have a provider configuration address explicitly set in
+// configuration.
+//
+// This method is not able to verify that such a configuration exists, nor
+// represent the behavior of automatically inheriting certain provider
+// configurations from parent modules. It just does a static analysis of the
+// receiving address and returns an address to start from, relative to the
+// same module that contains the resource.
+func (r Resource) DefaultProviderConfig() ProviderConfig {
+        typeName := r.Type
+        if under := strings.Index(typeName, "_"); under != -1 {
+                typeName = typeName[:under]
+        }
+        return ProviderConfig{
+                Type: typeName,
+        }
+}
+
+// ResourceInstance is an address for a specific instance of a resource.
+// When a resource is defined in configuration with "count" or "for_each" it
+// produces zero or more instances, which can be addressed using this type.
+type ResourceInstance struct {
+        referenceable
+        Resource Resource
+        Key      InstanceKey
+}
+
+func (r ResourceInstance) ContainingResource() Resource {
+        return r.Resource
+}
+
+func (r ResourceInstance) String() string {
+        if r.Key == NoKey {
+                return r.Resource.String()
+        }
+        return r.Resource.String() + r.Key.String()
+}
+
+func (r ResourceInstance) Equal(o ResourceInstance) bool {
+        return r.String() == o.String()
+}
+
+// Absolute returns an AbsResourceInstance from the receiver and the given module
+// instance address.
+func (r ResourceInstance) Absolute(module ModuleInstance) AbsResourceInstance {
+        return AbsResourceInstance{
+                Module:   module,
+                Resource: r,
+        }
+}
+
+// AbsResource is an absolute address for a resource under a given module path.
+type AbsResource struct {
+        targetable
+        Module   ModuleInstance
+        Resource Resource
+}
+
+// Resource returns the address of a particular resource within the receiver.
+func (m ModuleInstance) Resource(mode ResourceMode, typeName string, name string) AbsResource {
+        return AbsResource{
+                Module: m,
+                Resource: Resource{
+                        Mode: mode,
+                        Type: typeName,
+                        Name: name,
+                },
+        }
+}
+
+// Instance produces the address for a specific instance of the receiver
+// that is idenfied by the given key.
+func (r AbsResource) Instance(key InstanceKey) AbsResourceInstance {
+        return AbsResourceInstance{
+                Module:   r.Module,
+                Resource: r.Resource.Instance(key),
+        }
+}
+
+// TargetContains implements Targetable by returning true if the given other
+// address is either equal to the receiver or is an instance of the
+// receiver.
+func (r AbsResource) TargetContains(other Targetable) bool {
+        switch to := other.(type) {
+
+        case AbsResource:
+                // We'll use our stringification as a cheat-ish way to test for equality.
+                return to.String() == r.String()
+
+        case AbsResourceInstance:
+                return r.TargetContains(to.ContainingResource())
+
+        default:
+                return false
+
+        }
+}
+
+func (r AbsResource) String() string {
+        if len(r.Module) == 0 {
+                return r.Resource.String()
+        }
+        return fmt.Sprintf("%s.%s", r.Module.String(), r.Resource.String())
+}
+
+func (r AbsResource) Equal(o AbsResource) bool {
+        return r.String() == o.String()
+}
+
+// AbsResourceInstance is an absolute address for a resource instance under a
+// given module path.
+type AbsResourceInstance struct {
+        targetable
+        Module   ModuleInstance
+        Resource ResourceInstance
+}
+
+// ResourceInstance returns the address of a particular resource instance within the receiver.
+func (m ModuleInstance) ResourceInstance(mode ResourceMode, typeName string, name string, key InstanceKey) AbsResourceInstance {
+        return AbsResourceInstance{
+                Module: m,
+                Resource: ResourceInstance{
+                        Resource: Resource{
+                                Mode: mode,
+                                Type: typeName,
+                                Name: name,
+                        },
+                        Key: key,
+                },
+        }
+}
+
+// ContainingResource returns the address of the resource that contains the
+// receving resource instance. In other words, it discards the key portion
+// of the address to produce an AbsResource value.
+func (r AbsResourceInstance) ContainingResource() AbsResource {
+        return AbsResource{
+                Module:   r.Module,
+                Resource: r.Resource.ContainingResource(),
+        }
+}
+
+// TargetContains implements Targetable by returning true if the given other
+// address is equal to the receiver.
+func (r AbsResourceInstance) TargetContains(other Targetable) bool {
+        switch to := other.(type) {
+
+        case AbsResourceInstance:
+                // We'll use our stringification as a cheat-ish way to test for equality.
+                return to.String() == r.String()
+
+        default:
+                return false
+
+        }
+}
+
+func (r AbsResourceInstance) String() string {
+        if len(r.Module) == 0 {
+                return r.Resource.String()
+        }
+        return fmt.Sprintf("%s.%s", r.Module.String(), r.Resource.String())
+}
+
+func (r AbsResourceInstance) Equal(o AbsResourceInstance) bool {
+        return r.String() == o.String()
+}
+
+// Less returns true if the receiver should sort before the given other value
+// in a sorted list of addresses.
+func (r AbsResourceInstance) Less(o AbsResourceInstance) bool {
+        switch {
+
+        case len(r.Module) != len(o.Module):
+                return len(r.Module) < len(o.Module)
+
+        case r.Module.String() != o.Module.String():
+                return r.Module.Less(o.Module)
+
+        case r.Resource.Resource.Mode != o.Resource.Resource.Mode:
+                return r.Resource.Resource.Mode == DataResourceMode
+
+        case r.Resource.Resource.Type != o.Resource.Resource.Type:
+                return r.Resource.Resource.Type < o.Resource.Resource.Type
+
+        case r.Resource.Resource.Name != o.Resource.Resource.Name:
+                return r.Resource.Resource.Name < o.Resource.Resource.Name
+
+        case r.Resource.Key != o.Resource.Key:
+                return InstanceKeyLess(r.Resource.Key, o.Resource.Key)
+
+        default:
+                return false
+
+        }
+}
+
+// ResourceMode defines which lifecycle applies to a given resource. Each
+// resource lifecycle has a slightly different address format.
+type ResourceMode rune
+
+//go:generate stringer -type ResourceMode
+
+const (
+        // InvalidResourceMode is the zero value of ResourceMode and is not
+        // a valid resource mode.
+        InvalidResourceMode ResourceMode = 0
+
+        // ManagedResourceMode indicates a managed resource, as defined by
+        // "resource" blocks in configuration.
+        ManagedResourceMode ResourceMode = 'M'
+
+        // DataResourceMode indicates a data resource, as defined by
+        // "data" blocks in configuration.
+        DataResourceMode ResourceMode = 'D'
+)
diff --git a/vendor/github.com/hashicorp/terraform/addrs/resource_phase.go b/vendor/github.com/hashicorp/terraform/addrs/resource_phase.go
new file mode 100644
index 0000000..9bdbdc4
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/addrs/resource_phase.go
@@ -0,0 +1,105 @@
+package addrs
+
+import "fmt"
+
+// ResourceInstancePhase is a special kind of reference used only internally
+// during graph building to represent resource instances that are in a
+// non-primary state.
+//
+// Graph nodes can declare themselves referenceable via an instance phase
+// or can declare that they reference an instance phase in order to accomodate
+// secondary graph nodes dealing with, for example, destroy actions.
+//
+// This special reference type cannot be accessed directly by end-users, and
+// should never be shown in the UI.
+type ResourceInstancePhase struct {
+        referenceable
+        ResourceInstance ResourceInstance
+        Phase            ResourceInstancePhaseType
+}
+
+var _ Referenceable = ResourceInstancePhase{}
+
+// Phase returns a special "phase address" for the receving instance. See the
+// documentation of ResourceInstancePhase for the limited situations where this
+// is intended to be used.
+func (r ResourceInstance) Phase(rpt ResourceInstancePhaseType) ResourceInstancePhase {
+        return ResourceInstancePhase{
+                ResourceInstance: r,
+                Phase:            rpt,
+        }
+}
+
+// ContainingResource returns an address for the same phase of the resource
+// that this instance belongs to.
+func (rp ResourceInstancePhase) ContainingResource() ResourcePhase {
+        return rp.ResourceInstance.Resource.Phase(rp.Phase)
+}
+
+func (rp ResourceInstancePhase) String() string {
+        // We use a different separator here than usual to ensure that we'll
+        // never conflict with any non-phased resource instance string. This
+        // is intentionally something that would fail parsing with ParseRef,
+        // because this special address type should never be exposed in the UI.
+        return fmt.Sprintf("%s#%s", rp.ResourceInstance, rp.Phase)
+}
+
+// ResourceInstancePhaseType is an enumeration used with ResourceInstancePhase.
+type ResourceInstancePhaseType string
+
+const (
+        // ResourceInstancePhaseDestroy represents the "destroy" phase of a
+        // resource instance.
+        ResourceInstancePhaseDestroy ResourceInstancePhaseType = "destroy"
+
+        // ResourceInstancePhaseDestroyCBD is similar to ResourceInstancePhaseDestroy
+        // but is used for resources that have "create_before_destroy" set, thus
+        // requiring a different dependency ordering.
+        ResourceInstancePhaseDestroyCBD ResourceInstancePhaseType = "destroy-cbd"
+)
+
+func (rpt ResourceInstancePhaseType) String() string {
+        return string(rpt)
+}
+
+// ResourcePhase is a special kind of reference used only internally
+// during graph building to represent resources that are in a
+// non-primary state.
+//
+// Graph nodes can declare themselves referenceable via a resource phase
+// or can declare that they reference a resource phase in order to accomodate
+// secondary graph nodes dealing with, for example, destroy actions.
+//
+// Since resources (as opposed to instances) aren't actually phased, this
+// address type is used only as an approximation during initial construction
+// of the resource-oriented plan graph, under the assumption that resource
+// instances with ResourceInstancePhase addresses will be created in dynamic
+// subgraphs during the graph walk.
+//
+// This special reference type cannot be accessed directly by end-users, and
+// should never be shown in the UI.
+type ResourcePhase struct {
+        referenceable
+        Resource Resource
+        Phase    ResourceInstancePhaseType
+}
+
+var _ Referenceable = ResourcePhase{}
+
+// Phase returns a special "phase address" for the receving instance. See the
+// documentation of ResourceInstancePhase for the limited situations where this
+// is intended to be used.
+func (r Resource) Phase(rpt ResourceInstancePhaseType) ResourcePhase {
+        return ResourcePhase{
+                Resource: r,
+                Phase:    rpt,
+        }
+}
+
+func (rp ResourcePhase) String() string {
+        // We use a different separator here than usual to ensure that we'll
+        // never conflict with any non-phased resource instance string. This
+        // is intentionally something that would fail parsing with ParseRef,
+        // because this special address type should never be exposed in the UI.
+        return fmt.Sprintf("%s#%s", rp.Resource, rp.Phase)
+}
diff --git a/vendor/github.com/hashicorp/terraform/addrs/resourcemode_string.go b/vendor/github.com/hashicorp/terraform/addrs/resourcemode_string.go
new file mode 100644
index 0000000..0b5c33f
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/addrs/resourcemode_string.go
@@ -0,0 +1,33 @@
+// Code generated by "stringer -type ResourceMode"; DO NOT EDIT.
+
+package addrs
+
+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[InvalidResourceMode-0]
+        _ = x[ManagedResourceMode-77]
+        _ = x[DataResourceMode-68]
+}
+
+const (
+        _ResourceMode_name_0 = "InvalidResourceMode"
+        _ResourceMode_name_1 = "DataResourceMode"
+        _ResourceMode_name_2 = "ManagedResourceMode"
+)
+
+func (i ResourceMode) String() string {
+        switch {
+        case i == 0:
+                return _ResourceMode_name_0
+        case i == 68:
+                return _ResourceMode_name_1
+        case i == 77:
+                return _ResourceMode_name_2
+        default:
+                return "ResourceMode(" + strconv.FormatInt(int64(i), 10) + ")"
+        }
+}
diff --git a/vendor/github.com/hashicorp/terraform/addrs/self.go b/vendor/github.com/hashicorp/terraform/addrs/self.go
new file mode 100644
index 0000000..7f24eaf
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/addrs/self.go
@@ -0,0 +1,14 @@
+package addrs
+
+// Self is the address of the special object "self" that behaves as an alias
+// for a containing object currently in scope.
+const Self selfT = 0
+
+type selfT int
+
+func (s selfT) referenceableSigil() {
+}
+
+func (s selfT) String() string {
+        return "self"
+}
diff --git a/vendor/github.com/hashicorp/terraform/addrs/targetable.go b/vendor/github.com/hashicorp/terraform/addrs/targetable.go
new file mode 100644
index 0000000..16819a5
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/addrs/targetable.go
@@ -0,0 +1,26 @@
+package addrs
+
+// Targetable is an interface implemented by all address types that can be
+// used as "targets" for selecting sub-graphs of a graph.
+type Targetable interface {
+        targetableSigil()
+
+        // TargetContains returns true if the receiver is considered to contain
+        // the given other address. Containment, for the purpose of targeting,
+        // means that if a container address is targeted then all of the
+        // addresses within it are also implicitly targeted.
+        //
+        // A targetable address always contains at least itself.
+        TargetContains(other Targetable) bool
+
+        // String produces a string representation of the address that could be
+        // parsed as a HCL traversal and passed to ParseTarget to produce an
+        // identical result.
+        String() string
+}
+
+type targetable struct {
+}
+
+func (r targetable) targetableSigil() {
+}
diff --git a/vendor/github.com/hashicorp/terraform/addrs/terraform_attr.go b/vendor/github.com/hashicorp/terraform/addrs/terraform_attr.go
new file mode 100644
index 0000000..a880182
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/addrs/terraform_attr.go
@@ -0,0 +1,12 @@
+package addrs
+
+// TerraformAttr is the address of an attribute of the "terraform" object in
+// the interpolation scope, like "terraform.workspace".
+type TerraformAttr struct {
+        referenceable
+        Name string
+}
+
+func (ta TerraformAttr) String() string {
+        return "terraform." + ta.Name
+}