47 files changed, 5858 insertions, 0 deletions

diff --git a/vendor/github.com/hashicorp/terraform/configs/backend.go b/vendor/github.com/hashicorp/terraform/configs/backend.go
new file mode 100644
index 0000000..6df7ddd
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/configs/backend.go
@@ -0,0 +1,55 @@
+package configs
+
+import (
+        "github.com/hashicorp/hcl2/hcl"
+        "github.com/hashicorp/hcl2/hcldec"
+        "github.com/hashicorp/terraform/configs/configschema"
+        "github.com/zclconf/go-cty/cty"
+)
+
+// Backend represents a "backend" block inside a "terraform" block in a module
+// or file.
+type Backend struct {
+        Type   string
+        Config hcl.Body
+
+        TypeRange hcl.Range
+        DeclRange hcl.Range
+}
+
+func decodeBackendBlock(block *hcl.Block) (*Backend, hcl.Diagnostics) {
+        return &Backend{
+                Type:      block.Labels[0],
+                TypeRange: block.LabelRanges[0],
+                Config:    block.Body,
+                DeclRange: block.DefRange,
+        }, nil
+}
+
+// Hash produces a hash value for the reciever that covers the type and the
+// portions of the config that conform to the given schema.
+//
+// If the config does not conform to the schema then the result is not
+// meaningful for comparison since it will be based on an incomplete result.
+//
+// As an exception, required attributes in the schema are treated as optional
+// for the purpose of hashing, so that an incomplete configuration can still
+// be hashed. Other errors, such as extraneous attributes, have no such special
+// case.
+func (b *Backend) Hash(schema *configschema.Block) int {
+        // Don't fail if required attributes are not set. Instead, we'll just
+        // hash them as nulls.
+        schema = schema.NoneRequired()
+        spec := schema.DecoderSpec()
+        val, _ := hcldec.Decode(b.Config, spec, nil)
+        if val == cty.NilVal {
+                val = cty.UnknownVal(schema.ImpliedType())
+        }
+
+        toHash := cty.TupleVal([]cty.Value{
+                cty.StringVal(b.Type),
+                val,
+        })
+
+        return toHash.Hash()
+}
diff --git a/vendor/github.com/hashicorp/terraform/configs/compat_shim.go b/vendor/github.com/hashicorp/terraform/configs/compat_shim.go
new file mode 100644
index 0000000..66037fc
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/configs/compat_shim.go
@@ -0,0 +1,116 @@
+package configs
+
+import (
+        "github.com/hashicorp/hcl2/hcl"
+        "github.com/hashicorp/hcl2/hcl/hclsyntax"
+        "github.com/zclconf/go-cty/cty"
+)
+
+// -------------------------------------------------------------------------
+// Functions in this file are compatibility shims intended to ease conversion
+// from the old configuration loader. Any use of these functions that makes
+// a change should generate a deprecation warning explaining to the user how
+// to update their code for new patterns.
+//
+// Shims are particularly important for any patterns that have been widely
+// documented in books, tutorials, etc. Users will still be starting from
+// these examples and we want to help them adopt the latest patterns rather
+// than leave them stranded.
+// -------------------------------------------------------------------------
+
+// shimTraversalInString takes any arbitrary expression and checks if it is
+// a quoted string in the native syntax. If it _is_, then it is parsed as a
+// traversal and re-wrapped into a synthetic traversal expression and a
+// warning is generated. Otherwise, the given expression is just returned
+// verbatim.
+//
+// This function has no effect on expressions from the JSON syntax, since
+// traversals in strings are the required pattern in that syntax.
+//
+// If wantKeyword is set, the generated warning diagnostic will talk about
+// keywords rather than references. The behavior is otherwise unchanged, and
+// the caller remains responsible for checking that the result is indeed
+// a keyword, e.g. using hcl.ExprAsKeyword.
+func shimTraversalInString(expr hcl.Expression, wantKeyword bool) (hcl.Expression, hcl.Diagnostics) {
+        // ObjectConsKeyExpr is a special wrapper type used for keys on object
+        // constructors to deal with the fact that naked identifiers are normally
+        // handled as "bareword" strings rather than as variable references. Since
+        // we know we're interpreting as a traversal anyway (and thus it won't
+        // matter whether it's a string or an identifier) we can safely just unwrap
+        // here and then process whatever we find inside as normal.
+        if ocke, ok := expr.(*hclsyntax.ObjectConsKeyExpr); ok {
+                expr = ocke.Wrapped
+        }
+
+        if !exprIsNativeQuotedString(expr) {
+                return expr, nil
+        }
+
+        strVal, diags := expr.Value(nil)
+        if diags.HasErrors() || strVal.IsNull() || !strVal.IsKnown() {
+                // Since we're not even able to attempt a shim here, we'll discard
+                // the diagnostics we saw so far and let the caller's own error
+                // handling take care of reporting the invalid expression.
+                return expr, nil
+        }
+
+        // The position handling here isn't _quite_ right because it won't
+        // take into account any escape sequences in the literal string, but
+        // it should be close enough for any error reporting to make sense.
+        srcRange := expr.Range()
+        startPos := srcRange.Start // copy
+        startPos.Column++          // skip initial quote
+        startPos.Byte++            // skip initial quote
+
+        traversal, tDiags := hclsyntax.ParseTraversalAbs(
+                []byte(strVal.AsString()),
+                srcRange.Filename,
+                startPos,
+        )
+        diags = append(diags, tDiags...)
+
+        // For initial release our deprecation warnings are disabled to allow
+        // a period where modules can be compatible with both old and new
+        // conventions.
+        // FIXME: Re-enable these deprecation warnings in a release prior to
+        // Terraform 0.13 and then remove the shims altogether for 0.13.
+        /*
+                if wantKeyword {
+                        diags = append(diags, &hcl.Diagnostic{
+                                Severity: hcl.DiagWarning,
+                                Summary:  "Quoted keywords are deprecated",
+                                Detail:   "In this context, keywords are expected literally rather than in quotes. Previous versions of Terraform required quotes, but that usage is now deprecated. Remove the quotes surrounding this keyword to silence this warning.",
+                                Subject:  &srcRange,
+                        })
+                } else {
+                        diags = append(diags, &hcl.Diagnostic{
+                                Severity: hcl.DiagWarning,
+                                Summary:  "Quoted references are deprecated",
+                                Detail:   "In this context, references are expected literally rather than in quotes. Previous versions of Terraform required quotes, but that usage is now deprecated. Remove the quotes surrounding this reference to silence this warning.",
+                                Subject:  &srcRange,
+                        })
+                }
+        */
+
+        return &hclsyntax.ScopeTraversalExpr{
+                Traversal: traversal,
+                SrcRange:  srcRange,
+        }, diags
+}
+
+// shimIsIgnoreChangesStar returns true if the given expression seems to be
+// a string literal whose value is "*". This is used to support a legacy
+// form of ignore_changes = all .
+//
+// This function does not itself emit any diagnostics, so it's the caller's
+// responsibility to emit a warning diagnostic when this function returns true.
+func shimIsIgnoreChangesStar(expr hcl.Expression) bool {
+        val, valDiags := expr.Value(nil)
+        if valDiags.HasErrors() {
+                return false
+        }
+        if val.Type() != cty.String || val.IsNull() || !val.IsKnown() {
+                return false
+        }
+        return val.AsString() == "*"
+}
diff --git a/vendor/github.com/hashicorp/terraform/configs/config.go b/vendor/github.com/hashicorp/terraform/configs/config.go
new file mode 100644
index 0000000..8294312
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/configs/config.go
@@ -0,0 +1,205 @@
+package configs
+
+import (
+        "sort"
+
+        version "github.com/hashicorp/go-version"
+        "github.com/hashicorp/hcl2/hcl"
+        "github.com/hashicorp/terraform/addrs"
+)
+
+// A Config is a node in the tree of modules within a configuration.
+//
+// The module tree is constructed by following ModuleCall instances recursively
+// through the root module transitively into descendent modules.
+//
+// A module tree described in *this* package represents the static tree
+// represented by configuration. During evaluation a static ModuleNode may
+// expand into zero or more module instances depending on the use of count and
+// for_each configuration attributes within each call.
+type Config struct {
+        // RootModule points to the Config for the root module within the same
+        // module tree as this module. If this module _is_ the root module then
+        // this is self-referential.
+        Root *Config
+
+        // ParentModule points to the Config for the module that directly calls
+        // this module. If this is the root module then this field is nil.
+        Parent *Config
+
+        // Path is a sequence of module logical names that traverse from the root
+        // module to this config. Path is empty for the root module.
+        //
+        // This should only be used to display paths to the end-user in rare cases
+        // where we are talking about the static module tree, before module calls
+        // have been resolved. In most cases, an addrs.ModuleInstance describing
+        // a node in the dynamic module tree is better, since it will then include
+        // any keys resulting from evaluating "count" and "for_each" arguments.
+        Path addrs.Module
+
+        // ChildModules points to the Config for each of the direct child modules
+        // called from this module. The keys in this map match the keys in
+        // Module.ModuleCalls.
+        Children map[string]*Config
+
+        // Module points to the object describing the configuration for the
+        // various elements (variables, resources, etc) defined by this module.
+        Module *Module
+
+        // CallRange is the source range for the header of the module block that
+        // requested this module.
+        //
+        // This field is meaningless for the root module, where its contents are undefined.
+        CallRange hcl.Range
+
+        // SourceAddr is the source address that the referenced module was requested
+        // from, as specified in configuration.
+        //
+        // This field is meaningless for the root module, where its contents are undefined.
+        SourceAddr string
+
+        // SourceAddrRange is the location in the configuration source where the
+        // SourceAddr value was set, for use in diagnostic messages.
+        //
+        // This field is meaningless for the root module, where its contents are undefined.
+        SourceAddrRange hcl.Range
+
+        // Version is the specific version that was selected for this module,
+        // based on version constraints given in configuration.
+        //
+        // This field is nil if the module was loaded from a non-registry source,
+        // since versions are not supported for other sources.
+        //
+        // This field is meaningless for the root module, where it will always
+        // be nil.
+        Version *version.Version
+}
+
+// NewEmptyConfig constructs a single-node configuration tree with an empty
+// root module. This is generally a pretty useless thing to do, so most callers
+// should instead use BuildConfig.
+func NewEmptyConfig() *Config {
+        ret := &Config{}
+        ret.Root = ret
+        ret.Children = make(map[string]*Config)
+        ret.Module = &Module{}
+        return ret
+}
+
+// Depth returns the number of "hops" the receiver is from the root of its
+// module tree, with the root module having a depth of zero.
+func (c *Config) Depth() int {
+        ret := 0
+        this := c
+        for this.Parent != nil {
+                ret++
+                this = this.Parent
+        }
+        return ret
+}
+
+// DeepEach calls the given function once for each module in the tree, starting
+// with the receiver.
+//
+// A parent is always called before its children and children of a particular
+// node are visited in lexicographic order by their names.
+func (c *Config) DeepEach(cb func(c *Config)) {
+        cb(c)
+
+        names := make([]string, 0, len(c.Children))
+        for name := range c.Children {
+                names = append(names, name)
+        }
+
+        for _, name := range names {
+                c.Children[name].DeepEach(cb)
+        }
+}
+
+// AllModules returns a slice of all the receiver and all of its descendent
+// nodes in the module tree, in the same order they would be visited by
+// DeepEach.
+func (c *Config) AllModules() []*Config {
+        var ret []*Config
+        c.DeepEach(func(c *Config) {
+                ret = append(ret, c)
+        })
+        return ret
+}
+
+// Descendent returns the descendent config that has the given path beneath
+// the receiver, or nil if there is no such module.
+//
+// The path traverses the static module tree, prior to any expansion to handle
+// count and for_each arguments.
+//
+// An empty path will just return the receiver, and is therefore pointless.
+func (c *Config) Descendent(path addrs.Module) *Config {
+        current := c
+        for _, name := range path {
+                current = current.Children[name]
+                if current == nil {
+                        return nil
+                }
+        }
+        return current
+}
+
+// DescendentForInstance is like Descendent except that it accepts a path
+// to a particular module instance in the dynamic module graph, returning
+// the node from the static module graph that corresponds to it.
+//
+// All instances created by a particular module call share the same
+// configuration, so the keys within the given path are disregarded.
+func (c *Config) DescendentForInstance(path addrs.ModuleInstance) *Config {
+        current := c
+        for _, step := range path {
+                current = current.Children[step.Name]
+                if current == nil {
+                        return nil
+                }
+        }
+        return current
+}
+
+// ProviderTypes returns the names of each distinct provider type referenced
+// in the receiving configuration.
+//
+// This is a helper for easily determining which provider types are required
+// to fully interpret the configuration, though it does not include version
+// information and so callers are expected to have already dealt with
+// provider version selection in an earlier step and have identified suitable
+// versions for each provider.
+func (c *Config) ProviderTypes() []string {
+        m := make(map[string]struct{})
+        c.gatherProviderTypes(m)
+
+        ret := make([]string, 0, len(m))
+        for k := range m {
+                ret = append(ret, k)
+        }
+        sort.Strings(ret)
+        return ret
+}
+func (c *Config) gatherProviderTypes(m map[string]struct{}) {
+        if c == nil {
+                return
+        }
+
+        for _, pc := range c.Module.ProviderConfigs {
+                m[pc.Name] = struct{}{}
+        }
+        for _, rc := range c.Module.ManagedResources {
+                providerAddr := rc.ProviderConfigAddr()
+                m[providerAddr.Type] = struct{}{}
+        }
+        for _, rc := range c.Module.DataResources {
+                providerAddr := rc.ProviderConfigAddr()
+                m[providerAddr.Type] = struct{}{}
+        }
+
+        // Must also visit our child modules, recursively.
+        for _, cc := range c.Children {
+                cc.gatherProviderTypes(m)
+        }
+}
diff --git a/vendor/github.com/hashicorp/terraform/configs/config_build.go b/vendor/github.com/hashicorp/terraform/configs/config_build.go
new file mode 100644
index 0000000..948b2c8
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/configs/config_build.go
@@ -0,0 +1,179 @@
+package configs
+
+import (
+        "sort"
+
+        version "github.com/hashicorp/go-version"
+        "github.com/hashicorp/hcl2/hcl"
+        "github.com/hashicorp/terraform/addrs"
+)
+
+// BuildConfig constructs a Config from a root module by loading all of its
+// descendent modules via the given ModuleWalker.
+//
+// The result is a module tree that has so far only had basic module- and
+// file-level invariants validated. If the returned diagnostics contains errors,
+// the returned module tree may be incomplete but can still be used carefully
+// for static analysis.
+func BuildConfig(root *Module, walker ModuleWalker) (*Config, hcl.Diagnostics) {
+        var diags hcl.Diagnostics
+        cfg := &Config{
+                Module: root,
+        }
+        cfg.Root = cfg // Root module is self-referential.
+        cfg.Children, diags = buildChildModules(cfg, walker)
+        return cfg, diags
+}
+
+func buildChildModules(parent *Config, walker ModuleWalker) (map[string]*Config, hcl.Diagnostics) {
+        var diags hcl.Diagnostics
+        ret := map[string]*Config{}
+
+        calls := parent.Module.ModuleCalls
+
+        // We'll sort the calls by their local names so that they'll appear in a
+        // predictable order in any logging that's produced during the walk.
+        callNames := make([]string, 0, len(calls))
+        for k := range calls {
+                callNames = append(callNames, k)
+        }
+        sort.Strings(callNames)
+
+        for _, callName := range callNames {
+                call := calls[callName]
+                path := make([]string, len(parent.Path)+1)
+                copy(path, parent.Path)
+                path[len(path)-1] = call.Name
+
+                req := ModuleRequest{
+                        Name:              call.Name,
+                        Path:              path,
+                        SourceAddr:        call.SourceAddr,
+                        SourceAddrRange:   call.SourceAddrRange,
+                        VersionConstraint: call.Version,
+                        Parent:            parent,
+                        CallRange:         call.DeclRange,
+                }
+
+                mod, ver, modDiags := walker.LoadModule(&req)
+                diags = append(diags, modDiags...)
+                if mod == nil {
+                        // nil can be returned if the source address was invalid and so
+                        // nothing could be loaded whatsoever. LoadModule should've
+                        // returned at least one error diagnostic in that case.
+                        continue
+                }
+
+                child := &Config{
+                        Parent:          parent,
+                        Root:            parent.Root,
+                        Path:            path,
+                        Module:          mod,
+                        CallRange:       call.DeclRange,
+                        SourceAddr:      call.SourceAddr,
+                        SourceAddrRange: call.SourceAddrRange,
+                        Version:         ver,
+                }
+
+                child.Children, modDiags = buildChildModules(child, walker)
+
+                ret[call.Name] = child
+        }
+
+        return ret, diags
+}
+
+// A ModuleWalker knows how to find and load a child module given details about
+// the module to be loaded and a reference to its partially-loaded parent
+// Config.
+type ModuleWalker interface {
+        // LoadModule finds and loads a requested child module.
+        //
+        // If errors are detected during loading, implementations should return them
+        // in the diagnostics object. If the diagnostics object contains any errors
+        // then the caller will tolerate the returned module being nil or incomplete.
+        // If no errors are returned, it should be non-nil and complete.
+        //
+        // Full validation need not have been performed but an implementation should
+        // ensure that the basic file- and module-validations performed by the
+        // LoadConfigDir function (valid syntax, no namespace collisions, etc) have
+        // been performed before returning a module.
+        LoadModule(req *ModuleRequest) (*Module, *version.Version, hcl.Diagnostics)
+}
+
+// ModuleWalkerFunc is an implementation of ModuleWalker that directly wraps
+// a callback function, for more convenient use of that interface.
+type ModuleWalkerFunc func(req *ModuleRequest) (*Module, *version.Version, hcl.Diagnostics)
+
+// LoadModule implements ModuleWalker.
+func (f ModuleWalkerFunc) LoadModule(req *ModuleRequest) (*Module, *version.Version, hcl.Diagnostics) {
+        return f(req)
+}
+
+// ModuleRequest is used with the ModuleWalker interface to describe a child
+// module that must be loaded.
+type ModuleRequest struct {
+        // Name is the "logical name" of the module call within configuration.
+        // This is provided in case the name is used as part of a storage key
+        // for the module, but implementations must otherwise treat it as an
+        // opaque string. It is guaranteed to have already been validated as an
+        // HCL identifier and UTF-8 encoded.
+        Name string
+
+        // Path is a list of logical names that traverse from the root module to
+        // this module. This can be used, for example, to form a lookup key for
+        // each distinct module call in a configuration, allowing for multiple
+        // calls with the same name at different points in the tree.
+        Path addrs.Module
+
+        // SourceAddr is the source address string provided by the user in
+        // configuration.
+        SourceAddr string
+
+        // SourceAddrRange is the source range for the SourceAddr value as it
+        // was provided in configuration. This can and should be used to generate
+        // diagnostics about the source address having invalid syntax, referring
+        // to a non-existent object, etc.
+        SourceAddrRange hcl.Range
+
+        // VersionConstraint is the version constraint applied to the module in
+        // configuration. This data structure includes the source range for
+        // the constraint, which can and should be used to generate diagnostics
+        // about constraint-related issues, such as constraints that eliminate all
+        // available versions of a module whose source is otherwise valid.
+        VersionConstraint VersionConstraint
+
+        // Parent is the partially-constructed module tree node that the loaded
+        // module will be added to. Callers may refer to any field of this
+        // structure except Children, which is still under construction when
+        // ModuleRequest objects are created and thus has undefined content.
+        // The main reason this is provided is so that full module paths can
+        // be constructed for uniqueness.
+        Parent *Config
+
+        // CallRange is the source range for the header of the "module" block
+        // in configuration that prompted this request. This can be used as the
+        // subject of an error diagnostic that relates to the module call itself,
+        // rather than to either its source address or its version number.
+        CallRange hcl.Range
+}
+
+// DisabledModuleWalker is a ModuleWalker that doesn't support
+// child modules at all, and so will return an error if asked to load one.
+//
+// This is provided primarily for testing. There is no good reason to use this
+// in the main application.
+var DisabledModuleWalker ModuleWalker
+
+func init() {
+        DisabledModuleWalker = ModuleWalkerFunc(func(req *ModuleRequest) (*Module, *version.Version, hcl.Diagnostics) {
+                return nil, nil, hcl.Diagnostics{
+                        {
+                                Severity: hcl.DiagError,
+                                Summary:  "Child modules are not supported",
+                                Detail:   "Child module calls are not allowed in this context.",
+                                Subject:  &req.CallRange,
+                        },
+                }
+        })
+}
diff --git a/vendor/github.com/hashicorp/terraform/configs/configload/copy_dir.go b/vendor/github.com/hashicorp/terraform/configs/configload/copy_dir.go
new file mode 100644
index 0000000..ebbeb3b
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/configs/configload/copy_dir.go
@@ -0,0 +1,125 @@
+package configload
+
+import (
+        "io"
+        "os"
+        "path/filepath"
+        "strings"
+)
+
+// copyDir copies the src directory contents into dst. Both directories
+// should already exist.
+func copyDir(dst, src string) error {
+        src, err := filepath.EvalSymlinks(src)
+        if err != nil {
+                return err
+        }
+
+        walkFn := func(path string, info os.FileInfo, err error) error {
+                if err != nil {
+                        return err
+                }
+
+                if path == src {
+                        return nil
+                }
+
+                if strings.HasPrefix(filepath.Base(path), ".") {
+                        // Skip any dot files
+                        if info.IsDir() {
+                                return filepath.SkipDir
+                        } else {
+                                return nil
+                        }
+                }
+
+                // The "path" has the src prefixed to it. We need to join our
+                // destination with the path without the src on it.
+                dstPath := filepath.Join(dst, path[len(src):])
+
+                // we don't want to try and copy the same file over itself.
+                if eq, err := sameFile(path, dstPath); eq {
+                        return nil
+                } else if err != nil {
+                        return err
+                }
+
+                // If we have a directory, make that subdirectory, then continue
+                // the walk.
+                if info.IsDir() {
+                        if path == filepath.Join(src, dst) {
+                                // dst is in src; don't walk it.
+                                return nil
+                        }
+
+                        if err := os.MkdirAll(dstPath, 0755); err != nil {
+                                return err
+                        }
+
+                        return nil
+                }
+
+                // If the current path is a symlink, recreate the symlink relative to
+                // the dst directory
+                if info.Mode()&os.ModeSymlink == os.ModeSymlink {
+                        target, err := os.Readlink(path)
+                        if err != nil {
+                                return err
+                        }
+
+                        return os.Symlink(target, dstPath)
+                }
+
+                // If we have a file, copy the contents.
+                srcF, err := os.Open(path)
+                if err != nil {
+                        return err
+                }
+                defer srcF.Close()
+
+                dstF, err := os.Create(dstPath)
+                if err != nil {
+                        return err
+                }
+                defer dstF.Close()
+
+                if _, err := io.Copy(dstF, srcF); err != nil {
+                        return err
+                }
+
+                // Chmod it
+                return os.Chmod(dstPath, info.Mode())
+        }
+
+        return filepath.Walk(src, walkFn)
+}
+
+// sameFile tried to determine if to paths are the same file.
+// If the paths don't match, we lookup the inode on supported systems.
+func sameFile(a, b string) (bool, error) {
+        if a == b {
+                return true, nil
+        }
+
+        aIno, err := inode(a)
+        if err != nil {
+                if os.IsNotExist(err) {
+                        return false, nil
+                }
+                return false, err
+        }
+
+        bIno, err := inode(b)
+        if err != nil {
+                if os.IsNotExist(err) {
+                        return false, nil
+                }
+                return false, err
+        }
+
+        if aIno > 0 && aIno == bIno {
+                return true, nil
+        }
+
+        return false, nil
+}
diff --git a/vendor/github.com/hashicorp/terraform/configs/configload/doc.go b/vendor/github.com/hashicorp/terraform/configs/configload/doc.go
new file mode 100644
index 0000000..8b615f9
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/configs/configload/doc.go
@@ -0,0 +1,4 @@
+// Package configload knows how to install modules into the .terraform/modules
+// directory and to load modules from those installed locations. It is used
+// in conjunction with the LoadConfig function in the parent package.
+package configload
diff --git a/vendor/github.com/hashicorp/terraform/configs/configload/getter.go b/vendor/github.com/hashicorp/terraform/configs/configload/getter.go
new file mode 100644
index 0000000..4a3dace
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/configs/configload/getter.go
@@ -0,0 +1,150 @@
+package configload
+
+import (
+        "fmt"
+        "log"
+        "os"
+        "path/filepath"
+
+        cleanhttp "github.com/hashicorp/go-cleanhttp"
+        getter "github.com/hashicorp/go-getter"
+)
+
+// We configure our own go-getter detector and getter sets here, because
+// the set of sources we support is part of Terraform's documentation and
+// so we don't want any new sources introduced in go-getter to sneak in here
+// and work even though they aren't documented. This also insulates us from
+// any meddling that might be done by other go-getter callers linked into our
+// executable.
+
+var goGetterDetectors = []getter.Detector{
+        new(getter.GitHubDetector),
+        new(getter.BitBucketDetector),
+        new(getter.S3Detector),
+        new(getter.FileDetector),
+}
+
+var goGetterNoDetectors = []getter.Detector{}
+
+var goGetterDecompressors = map[string]getter.Decompressor{
+        "bz2": new(getter.Bzip2Decompressor),
+        "gz":  new(getter.GzipDecompressor),
+        "xz":  new(getter.XzDecompressor),
+        "zip": new(getter.ZipDecompressor),
+
+        "tar.bz2":  new(getter.TarBzip2Decompressor),
+        "tar.tbz2": new(getter.TarBzip2Decompressor),
+
+        "tar.gz": new(getter.TarGzipDecompressor),
+        "tgz":    new(getter.TarGzipDecompressor),
+
+        "tar.xz": new(getter.TarXzDecompressor),
+        "txz":    new(getter.TarXzDecompressor),
+}
+
+var goGetterGetters = map[string]getter.Getter{
+        "file":  new(getter.FileGetter),
+        "git":   new(getter.GitGetter),
+        "hg":    new(getter.HgGetter),
+        "s3":    new(getter.S3Getter),
+        "http":  getterHTTPGetter,
+        "https": getterHTTPGetter,
+}
+
+var getterHTTPClient = cleanhttp.DefaultClient()
+
+var getterHTTPGetter = &getter.HttpGetter{
+        Client: getterHTTPClient,
+        Netrc:  true,
+}
+
+// A reusingGetter is a helper for the module installer that remembers
+// the final resolved addresses of all of the sources it has already been
+// asked to install, and will copy from a prior installation directory if
+// it has the same resolved source address.
+//
+// The keys in a reusingGetter are resolved and trimmed source addresses
+// (with a scheme always present, and without any "subdir" component),
+// and the values are the paths where each source was previously installed.
+type reusingGetter map[string]string
+
+// getWithGoGetter retrieves the package referenced in the given address
+// into the installation path and then returns the full path to any subdir
+// indicated in the address.
+//
+// The errors returned by this function are those surfaced by the underlying
+// go-getter library, which have very inconsistent quality as
+// end-user-actionable error messages. At this time we do not have any
+// reasonable way to improve these error messages at this layer because
+// the underlying errors are not separatelyr recognizable.
+func (g reusingGetter) getWithGoGetter(instPath, addr string) (string, error) {
+        packageAddr, subDir := splitAddrSubdir(addr)
+
+        log.Printf("[DEBUG] will download %q to %s", packageAddr, instPath)
+
+        realAddr, err := getter.Detect(packageAddr, instPath, getter.Detectors)
+        if err != nil {
+                return "", err
+        }
+
+        var realSubDir string
+        realAddr, realSubDir = splitAddrSubdir(realAddr)
+        if realSubDir != "" {
+                subDir = filepath.Join(realSubDir, subDir)
+        }
+
+        if realAddr != packageAddr {
+                log.Printf("[TRACE] go-getter detectors rewrote %q to %q", packageAddr, realAddr)
+        }
+
+        if prevDir, exists := g[realAddr]; exists {
+                log.Printf("[TRACE] copying previous install %s to %s", prevDir, instPath)
+                err := os.Mkdir(instPath, os.ModePerm)
+                if err != nil {
+                        return "", fmt.Errorf("failed to create directory %s: %s", instPath, err)
+                }
+                err = copyDir(instPath, prevDir)
+                if err != nil {
+                        return "", fmt.Errorf("failed to copy from %s to %s: %s", prevDir, instPath, err)
+                }
+        } else {
+                log.Printf("[TRACE] fetching %q to %q", realAddr, instPath)
+                client := getter.Client{
+                        Src: realAddr,
+                        Dst: instPath,
+                        Pwd: instPath,
+
+                        Mode: getter.ClientModeDir,
+
+                        Detectors:     goGetterNoDetectors, // we already did detection above
+                        Decompressors: goGetterDecompressors,
+                        Getters:       goGetterGetters,
+                }
+                err = client.Get()
+                if err != nil {
+                        return "", err
+                }
+                // Remember where we installed this so we might reuse this directory
+                // on subsequent calls to avoid re-downloading.
+                g[realAddr] = instPath
+        }
+
+        // Our subDir string can contain wildcards until this point, so that
+        // e.g. a subDir of * can expand to one top-level directory in a .tar.gz
+        // archive. Now that we've expanded the archive successfully we must
+        // resolve that into a concrete path.
+        var finalDir string
+        if subDir != "" {
+                finalDir, err = getter.SubdirGlob(instPath, subDir)
+                log.Printf("[TRACE] expanded %q to %q", subDir, finalDir)
+                if err != nil {
+                        return "", err
+                }
+        } else {
+                finalDir = instPath
+        }
+
+        // If we got this far then we have apparently succeeded in downloading
+        // the requested object!
+        return filepath.Clean(finalDir), nil
+}
diff --git a/vendor/github.com/hashicorp/terraform/configs/configload/inode.go b/vendor/github.com/hashicorp/terraform/configs/configload/inode.go
new file mode 100644
index 0000000..57df041
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/configs/configload/inode.go
@@ -0,0 +1,21 @@
+// +build linux darwin openbsd netbsd solaris dragonfly
+
+package configload
+
+import (
+        "fmt"
+        "os"
+        "syscall"
+)
+
+// lookup the inode of a file on posix systems
+func inode(path string) (uint64, error) {
+        stat, err := os.Stat(path)
+        if err != nil {
+                return 0, err
+        }
+        if st, ok := stat.Sys().(*syscall.Stat_t); ok {
+                return st.Ino, nil
+        }
+        return 0, fmt.Errorf("could not determine file inode")
+}
diff --git a/vendor/github.com/hashicorp/terraform/configs/configload/inode_freebsd.go b/vendor/github.com/hashicorp/terraform/configs/configload/inode_freebsd.go
new file mode 100644
index 0000000..4dc28ea
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/configs/configload/inode_freebsd.go
@@ -0,0 +1,21 @@
+// +build freebsd
+
+package configload
+
+import (
+        "fmt"
+        "os"
+        "syscall"
+)
+
+// lookup the inode of a file on posix systems
+func inode(path string) (uint64, error) {
+        stat, err := os.Stat(path)
+        if err != nil {
+                return 0, err
+        }
+        if st, ok := stat.Sys().(*syscall.Stat_t); ok {
+                return uint64(st.Ino), nil
+        }
+        return 0, fmt.Errorf("could not determine file inode")
+}
diff --git a/vendor/github.com/hashicorp/terraform/configs/configload/inode_windows.go b/vendor/github.com/hashicorp/terraform/configs/configload/inode_windows.go
new file mode 100644
index 0000000..0d22e67
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/configs/configload/inode_windows.go
@@ -0,0 +1,8 @@
+// +build windows
+
+package configload
+
+// no syscall.Stat_t on windows, return 0 for inodes
+func inode(path string) (uint64, error) {
+        return 0, nil
+}
diff --git a/vendor/github.com/hashicorp/terraform/configs/configload/loader.go b/vendor/github.com/hashicorp/terraform/configs/configload/loader.go
new file mode 100644
index 0000000..416b48f
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/configs/configload/loader.go
@@ -0,0 +1,150 @@
+package configload
+
+import (
+        "fmt"
+        "path/filepath"
+
+        "github.com/hashicorp/terraform/configs"
+        "github.com/hashicorp/terraform/registry"
+        "github.com/hashicorp/terraform/svchost/disco"
+        "github.com/spf13/afero"
+)
+
+// A Loader instance is the main entry-point for loading configurations via
+// this package.
+//
+// It extends the general config-loading functionality in the parent package
+// "configs" to support installation of modules from remote sources and
+// loading full configurations using modules that were previously installed.
+type Loader struct {
+        // parser is used to read configuration
+        parser *configs.Parser
+
+        // modules is used to install and locate descendent modules that are
+        // referenced (directly or indirectly) from the root module.
+        modules moduleMgr
+}
+
+// Config is used with NewLoader to specify configuration arguments for the
+// loader.
+type Config struct {
+        // ModulesDir is a path to a directory where descendent modules are
+        // (or should be) installed. (This is usually the
+        // .terraform/modules directory, in the common case where this package
+        // is being loaded from the main Terraform CLI package.)
+        ModulesDir string
+
+        // Services is the service discovery client to use when locating remote
+        // module registry endpoints. If this is nil then registry sources are
+        // not supported, which should be true only in specialized circumstances
+        // such as in tests.
+        Services *disco.Disco
+}
+
+// NewLoader creates and returns a loader that reads configuration from the
+// real OS filesystem.
+//
+// The loader has some internal state about the modules that are currently
+// installed, which is read from disk as part of this function. If that
+// manifest cannot be read then an error will be returned.
+func NewLoader(config *Config) (*Loader, error) {
+        fs := afero.NewOsFs()
+        parser := configs.NewParser(fs)
+        reg := registry.NewClient(config.Services, nil)
+
+        ret := &Loader{
+                parser: parser,
+                modules: moduleMgr{
+                        FS:         afero.Afero{Fs: fs},
+                        CanInstall: true,
+                        Dir:        config.ModulesDir,
+                        Services:   config.Services,
+                        Registry:   reg,
+                },
+        }
+
+        err := ret.modules.readModuleManifestSnapshot()
+        if err != nil {
+                return nil, fmt.Errorf("failed to read module manifest: %s", err)
+        }
+
+        return ret, nil
+}
+
+// ModulesDir returns the path to the directory where the loader will look for
+// the local cache of remote module packages.
+func (l *Loader) ModulesDir() string {
+        return l.modules.Dir
+}
+
+// RefreshModules updates the in-memory cache of the module manifest from the
+// module manifest file on disk. This is not necessary in normal use because
+// module installation and configuration loading are separate steps, but it
+// can be useful in tests where module installation is done as a part of
+// configuration loading by a helper function.
+//
+// Call this function after any module installation where an existing loader
+// is already alive and may be used again later.
+//
+// An error is returned if the manifest file cannot be read.
+func (l *Loader) RefreshModules() error {
+        if l == nil {
+                // Nothing to do, then.
+                return nil
+        }
+        return l.modules.readModuleManifestSnapshot()
+}
+
+// Parser returns the underlying parser for this loader.
+//
+// This is useful for loading other sorts of files than the module directories
+// that a loader deals with, since then they will share the source code cache
+// for this loader and can thus be shown as snippets in diagnostic messages.
+func (l *Loader) Parser() *configs.Parser {
+        return l.parser
+}
+
+// Sources returns the source code cache for the underlying parser of this
+// loader. This is a shorthand for l.Parser().Sources().
+func (l *Loader) Sources() map[string][]byte {
+        return l.parser.Sources()
+}
+
+// IsConfigDir returns true if and only if the given directory contains at
+// least one Terraform configuration file. This is a wrapper around calling
+// the same method name on the loader's parser.
+func (l *Loader) IsConfigDir(path string) bool {
+        return l.parser.IsConfigDir(path)
+}
+
+// ImportSources writes into the receiver's source code the given source
+// code buffers.
+//
+// This is useful in the situation where an ancillary loader is created for
+// some reason (e.g. loading config from a plan file) but the cached source
+// code from that loader must be imported into the "main" loader in order
+// to return source code snapshots in diagnostic messages.
+//
+//     loader.ImportSources(otherLoader.Sources())
+func (l *Loader) ImportSources(sources map[string][]byte) {
+        p := l.Parser()
+        for name, src := range sources {
+                p.ForceFileSource(name, src)
+        }
+}
+
+// ImportSourcesFromSnapshot writes into the receiver's source code the
+// source files from the given snapshot.
+//
+// This is similar to ImportSources but knows how to unpack and flatten a
+// snapshot data structure to get the corresponding flat source file map.
+func (l *Loader) ImportSourcesFromSnapshot(snap *Snapshot) {
+        p := l.Parser()
+        for _, m := range snap.Modules {
+                baseDir := m.Dir
+                for fn, src := range m.Files {
+                        fullPath := filepath.Join(baseDir, fn)
+                        p.ForceFileSource(fullPath, src)
+                }
+        }
+}
diff --git a/vendor/github.com/hashicorp/terraform/configs/configload/loader_load.go b/vendor/github.com/hashicorp/terraform/configs/configload/loader_load.go
new file mode 100644
index 0000000..93a9420
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/configs/configload/loader_load.go
@@ -0,0 +1,97 @@
+package configload
+
+import (
+        "fmt"
+
+        version "github.com/hashicorp/go-version"
+        "github.com/hashicorp/hcl2/hcl"
+        "github.com/hashicorp/terraform/configs"
+)
+
+// LoadConfig reads the Terraform module in the given directory and uses it as the
+// root module to build the static module tree that represents a configuration,
+// assuming that all required descendent modules have already been installed.
+//
+// If error diagnostics are returned, the returned configuration may be either
+// nil or incomplete. In the latter case, cautious static analysis is possible
+// in spite of the errors.
+//
+// LoadConfig performs the basic syntax and uniqueness validations that are
+// required to process the individual modules, and also detects
+func (l *Loader) LoadConfig(rootDir string) (*configs.Config, hcl.Diagnostics) {
+        rootMod, diags := l.parser.LoadConfigDir(rootDir)
+        if rootMod == nil {
+                return nil, diags
+        }
+
+        cfg, cDiags := configs.BuildConfig(rootMod, configs.ModuleWalkerFunc(l.moduleWalkerLoad))
+        diags = append(diags, cDiags...)
+
+        return cfg, diags
+}
+
+// moduleWalkerLoad is a configs.ModuleWalkerFunc for loading modules that
+// are presumed to have already been installed. A different function
+// (moduleWalkerInstall) is used for installation.
+func (l *Loader) moduleWalkerLoad(req *configs.ModuleRequest) (*configs.Module, *version.Version, hcl.Diagnostics) {
+        // Since we're just loading here, we expect that all referenced modules
+        // will be already installed and described in our manifest. However, we
+        // do verify that the manifest and the configuration are in agreement
+        // so that we can prompt the user to run "terraform init" if not.
+
+        key := l.modules.manifest.ModuleKey(req.Path)
+        record, exists := l.modules.manifest[key]
+
+        if !exists {
+                return nil, nil, hcl.Diagnostics{
+                        {
+                                Severity: hcl.DiagError,
+                                Summary:  "Module not installed",
+                                Detail:   "This module is not yet installed. Run \"terraform init\" to install all modules required by this configuration.",
+                                Subject:  &req.CallRange,
+                        },
+                }
+        }
+
+        var diags hcl.Diagnostics
+
+        // Check for inconsistencies between manifest and config
+        if req.SourceAddr != record.SourceAddr {
+                diags = append(diags, &hcl.Diagnostic{
+                        Severity: hcl.DiagError,
+                        Summary:  "Module source has changed",
+                        Detail:   "The source address was changed since this module was installed. Run \"terraform init\" to install all modules required by this configuration.",
+                        Subject:  &req.SourceAddrRange,
+                })
+        }
+        if !req.VersionConstraint.Required.Check(record.Version) {
+                diags = append(diags, &hcl.Diagnostic{
+                        Severity: hcl.DiagError,
+                        Summary:  "Module version requirements have changed",
+                        Detail: fmt.Sprintf(
+                                "The version requirements have changed since this module was installed and the installed version (%s) is no longer acceptable. Run \"terraform init\" to install all modules required by this configuration.",
+                                record.Version,
+                        ),
+                        Subject: &req.SourceAddrRange,
+                })
+        }
+
+        mod, mDiags := l.parser.LoadConfigDir(record.Dir)
+        diags = append(diags, mDiags...)
+        if mod == nil {
+                // nil specifically indicates that the directory does not exist or
+                // cannot be read, so in this case we'll discard any generic diagnostics
+                // returned from LoadConfigDir and produce our own context-sensitive
+                // error message.
+                return nil, nil, hcl.Diagnostics{
+                        {
+                                Severity: hcl.DiagError,
+                                Summary:  "Module not installed",
+                                Detail:   fmt.Sprintf("This module's local cache directory %s could not be read. Run \"terraform init\" to install all modules required by this configuration.", record.Dir),
+                                Subject:  &req.CallRange,
+                        },
+                }
+        }
+
+        return mod, record.Version, diags
+}
diff --git a/vendor/github.com/hashicorp/terraform/configs/configload/loader_snapshot.go b/vendor/github.com/hashicorp/terraform/configs/configload/loader_snapshot.go
new file mode 100644
index 0000000..44c6439
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/configs/configload/loader_snapshot.go
@@ -0,0 +1,504 @@
+package configload
+
+import (
+        "fmt"
+        "io"
+        "os"
+        "path/filepath"
+        "sort"
+        "time"
+
+        version "github.com/hashicorp/go-version"
+        "github.com/hashicorp/hcl2/hcl"
+        "github.com/hashicorp/terraform/configs"
+        "github.com/hashicorp/terraform/internal/modsdir"
+        "github.com/spf13/afero"
+)
+
+// LoadConfigWithSnapshot is a variant of LoadConfig that also simultaneously
+// creates an in-memory snapshot of the configuration files used, which can
+// be later used to create a loader that may read only from this snapshot.
+func (l *Loader) LoadConfigWithSnapshot(rootDir string) (*configs.Config, *Snapshot, hcl.Diagnostics) {
+        rootMod, diags := l.parser.LoadConfigDir(rootDir)
+        if rootMod == nil {
+                return nil, nil, diags
+        }
+
+        snap := &Snapshot{
+                Modules: map[string]*SnapshotModule{},
+        }
+        walker := l.makeModuleWalkerSnapshot(snap)
+        cfg, cDiags := configs.BuildConfig(rootMod, walker)
+        diags = append(diags, cDiags...)
+
+        addDiags := l.addModuleToSnapshot(snap, "", rootDir, "", nil)
+        diags = append(diags, addDiags...)
+
+        return cfg, snap, diags
+}
+
+// NewLoaderFromSnapshot creates a Loader that reads files only from the
+// given snapshot.
+//
+// A snapshot-based loader cannot install modules, so calling InstallModules
+// on the return value will cause a panic.
+//
+// A snapshot-based loader also has access only to configuration files. Its
+// underlying parser does not have access to other files in the native
+// filesystem, such as values files. For those, either use a normal loader
+// (created by NewLoader) or use the configs.Parser API directly.
+func NewLoaderFromSnapshot(snap *Snapshot) *Loader {
+        fs := snapshotFS{snap}
+        parser := configs.NewParser(fs)
+
+        ret := &Loader{
+                parser: parser,
+                modules: moduleMgr{
+                        FS:         afero.Afero{Fs: fs},
+                        CanInstall: false,
+                        manifest:   snap.moduleManifest(),
+                },
+        }
+
+        return ret
+}
+
+// Snapshot is an in-memory representation of the source files from a
+// configuration, which can be used as an alternative configurations source
+// for a loader with NewLoaderFromSnapshot.
+//
+// The primary purpose of a Snapshot is to build the configuration portion
+// of a plan file (see ../../plans/planfile) so that it can later be reloaded
+// and used to recover the exact configuration that the plan was built from.
+type Snapshot struct {
+        // Modules is a map from opaque module keys (suitable for use as directory
+        // names on all supported operating systems) to the snapshot information
+        // about each module.
+        Modules map[string]*SnapshotModule
+}
+
+// NewEmptySnapshot constructs and returns a snapshot containing only an empty
+// root module. This is not useful for anything except placeholders in tests.
+func NewEmptySnapshot() *Snapshot {
+        return &Snapshot{
+                Modules: map[string]*SnapshotModule{
+                        "": &SnapshotModule{
+                                Files: map[string][]byte{},
+                        },
+                },
+        }
+}
+
+// SnapshotModule represents a single module within a Snapshot.
+type SnapshotModule struct {
+        // Dir is the path, relative to the root directory given when the
+        // snapshot was created, where the module appears in the snapshot's
+        // virtual filesystem.
+        Dir string
+
+        // Files is a map from each configuration file filename for the
+        // module to a raw byte representation of the source file contents.
+        Files map[string][]byte
+
+        // SourceAddr is the source address given for this module in configuration.
+        SourceAddr string `json:"Source"`
+
+        // Version is the version of the module that is installed, or nil if
+        // the module is installed from a source that does not support versions.
+        Version *version.Version `json:"-"`
+}
+
+// moduleManifest constructs a module manifest based on the contents of
+// the receiving snapshot.
+func (s *Snapshot) moduleManifest() modsdir.Manifest {
+        ret := make(modsdir.Manifest)
+
+        for k, modSnap := range s.Modules {
+                ret[k] = modsdir.Record{
+                        Key:        k,
+                        Dir:        modSnap.Dir,
+                        SourceAddr: modSnap.SourceAddr,
+                        Version:    modSnap.Version,
+                }
+        }
+
+        return ret
+}
+
+// makeModuleWalkerSnapshot creates a configs.ModuleWalker that will exhibit
+// the same lookup behaviors as l.moduleWalkerLoad but will additionally write
+// source files from the referenced modules into the given snapshot.
+func (l *Loader) makeModuleWalkerSnapshot(snap *Snapshot) configs.ModuleWalker {
+        return configs.ModuleWalkerFunc(
+                func(req *configs.ModuleRequest) (*configs.Module, *version.Version, hcl.Diagnostics) {
+                        mod, v, diags := l.moduleWalkerLoad(req)
+                        if diags.HasErrors() {
+                                return mod, v, diags
+                        }
+
+                        key := l.modules.manifest.ModuleKey(req.Path)
+                        record, exists := l.modules.manifest[key]
+
+                        if !exists {
+                                // Should never happen, since otherwise moduleWalkerLoader would've
+                                // returned an error and we would've returned already.
+                                panic(fmt.Sprintf("module %s is not present in manifest", key))
+                        }
+
+                        addDiags := l.addModuleToSnapshot(snap, key, record.Dir, record.SourceAddr, record.Version)
+                        diags = append(diags, addDiags...)
+
+                        return mod, v, diags
+                },
+        )
+}
+
+func (l *Loader) addModuleToSnapshot(snap *Snapshot, key string, dir string, sourceAddr string, v *version.Version) hcl.Diagnostics {
+        var diags hcl.Diagnostics
+
+        primaryFiles, overrideFiles, moreDiags := l.parser.ConfigDirFiles(dir)
+        if moreDiags.HasErrors() {
+                // Any diagnostics we get here should be already present
+                // in diags, so it's weird if we get here but we'll allow it
+                // and return a general error message in that case.
+                diags = append(diags, &hcl.Diagnostic{
+                        Severity: hcl.DiagError,
+                        Summary:  "Failed to read directory for module",
+                        Detail:   fmt.Sprintf("The source directory %s could not be read", dir),
+                })
+                return diags
+        }
+
+        snapMod := &SnapshotModule{
+                Dir:        dir,
+                Files:      map[string][]byte{},
+                SourceAddr: sourceAddr,
+                Version:    v,
+        }
+
+        files := make([]string, 0, len(primaryFiles)+len(overrideFiles))
+        files = append(files, primaryFiles...)
+        files = append(files, overrideFiles...)
+        sources := l.Sources() // should be populated with all the files we need by now
+        for _, filePath := range files {
+                filename := filepath.Base(filePath)
+                src, exists := sources[filePath]
+                if !exists {
+                        diags = append(diags, &hcl.Diagnostic{
+                                Severity: hcl.DiagError,
+                                Summary:  "Missing source file for snapshot",
+                                Detail:   fmt.Sprintf("The source code for file %s could not be found to produce a configuration snapshot.", filePath),
+                        })
+                        continue
+                }
+                snapMod.Files[filepath.Clean(filename)] = src
+        }
+
+        snap.Modules[key] = snapMod
+
+        return diags
+}
+
+// snapshotFS is an implementation of afero.Fs that reads from a snapshot.
+//
+// This is not intended as a general-purpose filesystem implementation. Instead,
+// it just supports the minimal functionality required to support the
+// configuration loader and parser as an implementation detail of creating
+// a loader from a snapshot.
+type snapshotFS struct {
+        snap *Snapshot
+}
+
+var _ afero.Fs = snapshotFS{}
+
+func (fs snapshotFS) Create(name string) (afero.File, error) {
+        return nil, fmt.Errorf("cannot create file inside configuration snapshot")
+}
+
+func (fs snapshotFS) Mkdir(name string, perm os.FileMode) error {
+        return fmt.Errorf("cannot create directory inside configuration snapshot")
+}
+
+func (fs snapshotFS) MkdirAll(name string, perm os.FileMode) error {
+        return fmt.Errorf("cannot create directories inside configuration snapshot")
+}
+
+func (fs snapshotFS) Open(name string) (afero.File, error) {
+
+        // Our "filesystem" is sparsely populated only with the directories
+        // mentioned by modules in our snapshot, so the high-level process
+        // for opening a file is:
+        // - Find the module snapshot corresponding to the containing directory
+        // - Find the file within that snapshot
+        // - Wrap the resulting byte slice in a snapshotFile to return
+        //
+        // The other possibility handled here is if the given name is for the
+        // module directory itself, in which case we'll return a snapshotDir
+        // instead.
+        //
+        // This function doesn't try to be incredibly robust in supporting
+        // different permutations of paths, etc because in practice we only
+        // need to support the path forms that our own loader and parser will
+        // generate.
+
+        dir := filepath.Dir(name)
+        fn := filepath.Base(name)
+        directDir := filepath.Clean(name)
+
+        // First we'll check to see if this is an exact path for a module directory.
+        // We need to do this first (rather than as part of the next loop below)
+        // because a module in a child directory of another module can otherwise
+        // appear to be a file in that parent directory.
+        for _, candidate := range fs.snap.Modules {
+                modDir := filepath.Clean(candidate.Dir)
+                if modDir == directDir {
+                        // We've matched the module directory itself
+                        filenames := make([]string, 0, len(candidate.Files))
+                        for n := range candidate.Files {
+                                filenames = append(filenames, n)
+                        }
+                        sort.Strings(filenames)
+                        return snapshotDir{
+                                filenames: filenames,
+                        }, nil
+                }
+        }
+
+        // If we get here then the given path isn't a module directory exactly, so
+        // we'll treat it as a file path and try to find a module directory it
+        // could be located in.
+        var modSnap *SnapshotModule
+        for _, candidate := range fs.snap.Modules {
+                modDir := filepath.Clean(candidate.Dir)
+                if modDir == dir {
+                        modSnap = candidate
+                        break
+                }
+        }
+        if modSnap == nil {
+                return nil, os.ErrNotExist
+        }
+
+        src, exists := modSnap.Files[fn]
+        if !exists {
+                return nil, os.ErrNotExist
+        }
+
+        return &snapshotFile{
+                src: src,
+        }, nil
+}
+
+func (fs snapshotFS) OpenFile(name string, flag int, perm os.FileMode) (afero.File, error) {
+        return fs.Open(name)
+}
+
+func (fs snapshotFS) Remove(name string) error {
+        return fmt.Errorf("cannot remove file inside configuration snapshot")
+}
+
+func (fs snapshotFS) RemoveAll(path string) error {
+        return fmt.Errorf("cannot remove files inside configuration snapshot")
+}
+
+func (fs snapshotFS) Rename(old, new string) error {
+        return fmt.Errorf("cannot rename file inside configuration snapshot")
+}
+
+func (fs snapshotFS) Stat(name string) (os.FileInfo, error) {
+        f, err := fs.Open(name)
+        if err != nil {
+                return nil, err
+        }
+        _, isDir := f.(snapshotDir)
+        return snapshotFileInfo{
+                name:  filepath.Base(name),
+                isDir: isDir,
+        }, nil
+}
+
+func (fs snapshotFS) Name() string {
+        return "ConfigSnapshotFS"
+}
+
+func (fs snapshotFS) Chmod(name string, mode os.FileMode) error {
+        return fmt.Errorf("cannot set file mode inside configuration snapshot")
+}
+
+func (fs snapshotFS) Chtimes(name string, atime, mtime time.Time) error {
+        return fmt.Errorf("cannot set file times inside configuration snapshot")
+}
+
+type snapshotFile struct {
+        snapshotFileStub
+        src []byte
+        at  int64
+}
+
+var _ afero.File = (*snapshotFile)(nil)
+
+func (f *snapshotFile) Read(p []byte) (n int, err error) {
+        if len(p) > 0 && f.at == int64(len(f.src)) {
+                return 0, io.EOF
+        }
+        if f.at > int64(len(f.src)) {
+                return 0, io.ErrUnexpectedEOF
+        }
+        if int64(len(f.src))-f.at >= int64(len(p)) {
+                n = len(p)
+        } else {
+                n = int(int64(len(f.src)) - f.at)
+        }
+        copy(p, f.src[f.at:f.at+int64(n)])
+        f.at += int64(n)
+        return
+}
+
+func (f *snapshotFile) ReadAt(p []byte, off int64) (n int, err error) {
+        f.at = off
+        return f.Read(p)
+}
+
+func (f *snapshotFile) Seek(offset int64, whence int) (int64, error) {
+        switch whence {
+        case 0:
+                f.at = offset
+        case 1:
+                f.at += offset
+        case 2:
+                f.at = int64(len(f.src)) + offset
+        }
+        return f.at, nil
+}
+
+type snapshotDir struct {
+        snapshotFileStub
+        filenames []string
+        at        int
+}
+
+var _ afero.File = snapshotDir{}
+
+func (f snapshotDir) Readdir(count int) ([]os.FileInfo, error) {
+        names, err := f.Readdirnames(count)
+        if err != nil {
+                return nil, err
+        }
+        ret := make([]os.FileInfo, len(names))
+        for i, name := range names {
+                ret[i] = snapshotFileInfo{
+                        name:  name,
+                        isDir: false,
+                }
+        }
+        return ret, nil
+}
+
+func (f snapshotDir) Readdirnames(count int) ([]string, error) {
+        var outLen int
+        names := f.filenames[f.at:]
+        if count > 0 {
+                if len(names) < count {
+                        outLen = len(names)
+                } else {
+                        outLen = count
+                }
+                if len(names) == 0 {
+                        return nil, io.EOF
+                }
+        } else {
+                outLen = len(names)
+        }
+        f.at += outLen
+
+        return names[:outLen], nil
+}
+
+// snapshotFileInfo is a minimal implementation of os.FileInfo to support our
+// virtual filesystem from snapshots.
+type snapshotFileInfo struct {
+        name  string
+        isDir bool
+}
+
+var _ os.FileInfo = snapshotFileInfo{}
+
+func (fi snapshotFileInfo) Name() string {
+        return fi.name
+}
+
+func (fi snapshotFileInfo) Size() int64 {
+        // In practice, our parser and loader never call Size
+        return -1
+}
+
+func (fi snapshotFileInfo) Mode() os.FileMode {
+        return os.ModePerm
+}
+
+func (fi snapshotFileInfo) ModTime() time.Time {
+        return time.Now()
+}
+
+func (fi snapshotFileInfo) IsDir() bool {
+        return fi.isDir
+}
+
+func (fi snapshotFileInfo) Sys() interface{} {
+        return nil
+}
+
+type snapshotFileStub struct{}
+
+func (f snapshotFileStub) Close() error {
+        return nil
+}
+
+func (f snapshotFileStub) Read(p []byte) (n int, err error) {
+        return 0, fmt.Errorf("cannot read")
+}
+
+func (f snapshotFileStub) ReadAt(p []byte, off int64) (n int, err error) {
+        return 0, fmt.Errorf("cannot read")
+}
+
+func (f snapshotFileStub) Seek(offset int64, whence int) (int64, error) {
+        return 0, fmt.Errorf("cannot seek")
+}
+
+func (f snapshotFileStub) Write(p []byte) (n int, err error) {
+        return f.WriteAt(p, 0)
+}
+
+func (f snapshotFileStub) WriteAt(p []byte, off int64) (n int, err error) {
+        return 0, fmt.Errorf("cannot write to file in snapshot")
+}
+
+func (f snapshotFileStub) WriteString(s string) (n int, err error) {
+        return 0, fmt.Errorf("cannot write to file in snapshot")
+}
+
+func (f snapshotFileStub) Name() string {
+        // in practice, the loader and parser never use this
+        return "<unimplemented>"
+}
+
+func (f snapshotFileStub) Readdir(count int) ([]os.FileInfo, error) {
+        return nil, fmt.Errorf("cannot use Readdir on a file")
+}
+
+func (f snapshotFileStub) Readdirnames(count int) ([]string, error) {
+        return nil, fmt.Errorf("cannot use Readdir on a file")
+}
+
+func (f snapshotFileStub) Stat() (os.FileInfo, error) {
+        return nil, fmt.Errorf("cannot stat")
+}
+
+func (f snapshotFileStub) Sync() error {
+        return nil
+}
+
+func (f snapshotFileStub) Truncate(size int64) error {
+        return fmt.Errorf("cannot write to file in snapshot")
+}
diff --git a/vendor/github.com/hashicorp/terraform/configs/configload/module_mgr.go b/vendor/github.com/hashicorp/terraform/configs/configload/module_mgr.go
new file mode 100644
index 0000000..3c410ee
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/configs/configload/module_mgr.go
@@ -0,0 +1,76 @@
+package configload
+
+import (
+        "os"
+        "path/filepath"
+
+        "github.com/hashicorp/terraform/internal/modsdir"
+        "github.com/hashicorp/terraform/registry"
+        "github.com/hashicorp/terraform/svchost/disco"
+        "github.com/spf13/afero"
+)
+
+type moduleMgr struct {
+        FS afero.Afero
+
+        // CanInstall is true for a module manager that can support installation.
+        //
+        // This must be set only if FS is an afero.OsFs, because the installer
+        // (which uses go-getter) is not aware of the virtual filesystem
+        // abstraction and will always write into the "real" filesystem.
+        CanInstall bool
+
+        // Dir is the path where descendent modules are (or will be) installed.
+        Dir string
+
+        // Services is a service discovery client that will be used to find
+        // remote module registry endpoints. This object may be pre-loaded with
+        // cached discovery information.
+        Services *disco.Disco
+
+        // Registry is a client for the module registry protocol, which is used
+        // when a module is requested from a registry source.
+        Registry *registry.Client
+
+        // manifest tracks the currently-installed modules for this manager.
+        //
+        // The loader may read this. Only the installer may write to it, and
+        // after a set of updates are completed the installer must call
+        // writeModuleManifestSnapshot to persist a snapshot of the manifest
+        // to disk for use on subsequent runs.
+        manifest modsdir.Manifest
+}
+
+func (m *moduleMgr) manifestSnapshotPath() string {
+        return filepath.Join(m.Dir, modsdir.ManifestSnapshotFilename)
+}
+
+// readModuleManifestSnapshot loads a manifest snapshot from the filesystem.
+func (m *moduleMgr) readModuleManifestSnapshot() error {
+        r, err := m.FS.Open(m.manifestSnapshotPath())
+        if err != nil {
+                if os.IsNotExist(err) {
+                        // We'll treat a missing file as an empty manifest
+                        m.manifest = make(modsdir.Manifest)
+                        return nil
+                }
+                return err
+        }
+
+        m.manifest, err = modsdir.ReadManifestSnapshot(r)
+        return err
+}
+
+// writeModuleManifestSnapshot writes a snapshot of the current manifest
+// to the filesystem.
+//
+// The caller must guarantee no concurrent modifications of the manifest for
+// the duration of a call to this function, or the behavior is undefined.
+func (m *moduleMgr) writeModuleManifestSnapshot() error {
+        w, err := m.FS.Create(m.manifestSnapshotPath())
+        if err != nil {
+                return err
+        }
+
+        return m.manifest.WriteSnapshot(w)
+}
diff --git a/vendor/github.com/hashicorp/terraform/configs/configload/source_addr.go b/vendor/github.com/hashicorp/terraform/configs/configload/source_addr.go
new file mode 100644
index 0000000..594cf64
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/configs/configload/source_addr.go
@@ -0,0 +1,45 @@
+package configload
+
+import (
+        "strings"
+
+        "github.com/hashicorp/go-getter"
+
+        "github.com/hashicorp/terraform/registry/regsrc"
+)
+
+var localSourcePrefixes = []string{
+        "./",
+        "../",
+        ".\\",
+        "..\\",
+}
+
+func isLocalSourceAddr(addr string) bool {
+        for _, prefix := range localSourcePrefixes {
+                if strings.HasPrefix(addr, prefix) {
+                        return true
+                }
+        }
+        return false
+}
+
+func isRegistrySourceAddr(addr string) bool {
+        _, err := regsrc.ParseModuleSource(addr)
+        return err == nil
+}
+
+// splitAddrSubdir splits the given address (which is assumed to be a
+// registry address or go-getter-style address) into a package portion
+// and a sub-directory portion.
+//
+// The package portion defines what should be downloaded and then the
+// sub-directory portion, if present, specifies a sub-directory within
+// the downloaded object (an archive, VCS repository, etc) that contains
+// the module's configuration files.
+//
+// The subDir portion will be returned as empty if no subdir separator
+// ("//") is present in the address.
+func splitAddrSubdir(addr string) (packageAddr, subDir string) {
+        return getter.SourceDirSubdir(addr)
+}
diff --git a/vendor/github.com/hashicorp/terraform/configs/configload/testing.go b/vendor/github.com/hashicorp/terraform/configs/configload/testing.go
new file mode 100644
index 0000000..86ca9d1
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/configs/configload/testing.go
@@ -0,0 +1,43 @@
+package configload
+
+import (
+        "io/ioutil"
+        "os"
+        "testing"
+)
+
+// NewLoaderForTests is a variant of NewLoader that is intended to be more
+// convenient for unit tests.
+//
+// The loader's modules directory is a separate temporary directory created
+// for each call. Along with the created loader, this function returns a
+// cleanup function that should be called before the test completes in order
+// to remove that temporary directory.
+//
+// In the case of any errors, t.Fatal (or similar) will be called to halt
+// execution of the test, so the calling test does not need to handle errors
+// itself.
+func NewLoaderForTests(t *testing.T) (*Loader, func()) {
+        t.Helper()
+
+        modulesDir, err := ioutil.TempDir("", "tf-configs")
+        if err != nil {
+                t.Fatalf("failed to create temporary modules dir: %s", err)
+                return nil, func() {}
+        }
+
+        cleanup := func() {
+                os.RemoveAll(modulesDir)
+        }
+
+        loader, err := NewLoader(&Config{
+                ModulesDir: modulesDir,
+        })
+        if err != nil {
+                cleanup()
+                t.Fatalf("failed to create config loader: %s", err)
+                return nil, func() {}
+        }
+
+        return loader, cleanup
+}
diff --git a/vendor/github.com/hashicorp/terraform/configs/configschema/coerce_value.go b/vendor/github.com/hashicorp/terraform/configs/configschema/coerce_value.go
new file mode 100644
index 0000000..e59f58d
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/configs/configschema/coerce_value.go
@@ -0,0 +1,274 @@
+package configschema
+
+import (
+        "fmt"
+
+        "github.com/zclconf/go-cty/cty"
+        "github.com/zclconf/go-cty/cty/convert"
+)
+
+// CoerceValue attempts to force the given value to conform to the type
+// implied by the receiever, while also applying the same validation and
+// transformation rules that would be applied by the decoder specification
+// returned by method DecoderSpec.
+//
+// This is useful in situations where a configuration must be derived from
+// an already-decoded value. It is always better to decode directly from
+// configuration where possible since then source location information is
+// still available to produce diagnostics, but in special situations this
+// function allows a compatible result to be obtained even if the
+// configuration objects are not available.
+//
+// If the given value cannot be converted to conform to the receiving schema
+// then an error is returned describing one of possibly many problems. This
+// error may be a cty.PathError indicating a position within the nested
+// data structure where the problem applies.
+func (b *Block) CoerceValue(in cty.Value) (cty.Value, error) {
+        var path cty.Path
+        return b.coerceValue(in, path)
+}
+
+func (b *Block) coerceValue(in cty.Value, path cty.Path) (cty.Value, error) {
+        switch {
+        case in.IsNull():
+                return cty.NullVal(b.ImpliedType()), nil
+        case !in.IsKnown():
+                return cty.UnknownVal(b.ImpliedType()), nil
+        }
+
+        ty := in.Type()
+        if !ty.IsObjectType() {
+                return cty.UnknownVal(b.ImpliedType()), path.NewErrorf("an object is required")
+        }
+
+        for name := range ty.AttributeTypes() {
+                if _, defined := b.Attributes[name]; defined {
+                        continue
+                }
+                if _, defined := b.BlockTypes[name]; defined {
+                        continue
+                }
+                return cty.UnknownVal(b.ImpliedType()), path.NewErrorf("unexpected attribute %q", name)
+        }
+
+        attrs := make(map[string]cty.Value)
+
+        for name, attrS := range b.Attributes {
+                var val cty.Value
+                switch {
+                case ty.HasAttribute(name):
+                        val = in.GetAttr(name)
+                case attrS.Computed || attrS.Optional:
+                        val = cty.NullVal(attrS.Type)
+                default:
+                        return cty.UnknownVal(b.ImpliedType()), path.NewErrorf("attribute %q is required", name)
+                }
+
+                val, err := attrS.coerceValue(val, append(path, cty.GetAttrStep{Name: name}))
+                if err != nil {
+                        return cty.UnknownVal(b.ImpliedType()), err
+                }
+
+                attrs[name] = val
+        }
+        for typeName, blockS := range b.BlockTypes {
+                switch blockS.Nesting {
+
+                case NestingSingle, NestingGroup:
+                        switch {
+                        case ty.HasAttribute(typeName):
+                                var err error
+                                val := in.GetAttr(typeName)
+                                attrs[typeName], err = blockS.coerceValue(val, append(path, cty.GetAttrStep{Name: typeName}))
+                                if err != nil {
+                                        return cty.UnknownVal(b.ImpliedType()), err
+                                }
+                        case blockS.MinItems != 1 && blockS.MaxItems != 1:
+                                if blockS.Nesting == NestingGroup {
+                                        attrs[typeName] = blockS.EmptyValue()
+                                } else {
+                                        attrs[typeName] = cty.NullVal(blockS.ImpliedType())
+                                }
+                        default:
+                                // We use the word "attribute" here because we're talking about
+                                // the cty sense of that word rather than the HCL sense.
+                                return cty.UnknownVal(b.ImpliedType()), path.NewErrorf("attribute %q is required", typeName)
+                        }
+
+                case NestingList:
+                        switch {
+                        case ty.HasAttribute(typeName):
+                                coll := in.GetAttr(typeName)
+
+                                switch {
+                                case coll.IsNull():
+                                        attrs[typeName] = cty.NullVal(cty.List(blockS.ImpliedType()))
+                                        continue
+                                case !coll.IsKnown():
+                                        attrs[typeName] = cty.UnknownVal(cty.List(blockS.ImpliedType()))
+                                        continue
+                                }
+
+                                if !coll.CanIterateElements() {
+                                        return cty.UnknownVal(b.ImpliedType()), path.NewErrorf("must be a list")
+                                }
+                                l := coll.LengthInt()
+                                if l < blockS.MinItems {
+                                        return cty.UnknownVal(b.ImpliedType()), path.NewErrorf("insufficient items for attribute %q; must have at least %d", typeName, blockS.MinItems)
+                                }
+                                if l > blockS.MaxItems && blockS.MaxItems > 0 {
+                                        return cty.UnknownVal(b.ImpliedType()), path.NewErrorf("too many items for attribute %q; cannot have more than %d", typeName, blockS.MaxItems)
+                                }
+                                if l == 0 {
+                                        attrs[typeName] = cty.ListValEmpty(blockS.ImpliedType())
+                                        continue
+                                }
+                                elems := make([]cty.Value, 0, l)
+                                {
+                                        path = append(path, cty.GetAttrStep{Name: typeName})
+                                        for it := coll.ElementIterator(); it.Next(); {
+                                                var err error
+                                                idx, val := it.Element()
+                                                val, err = blockS.coerceValue(val, append(path, cty.IndexStep{Key: idx}))
+                                                if err != nil {
+                                                        return cty.UnknownVal(b.ImpliedType()), err
+                                                }
+                                                elems = append(elems, val)
+                                        }
+                                }
+                                attrs[typeName] = cty.ListVal(elems)
+                        case blockS.MinItems == 0:
+                                attrs[typeName] = cty.ListValEmpty(blockS.ImpliedType())
+                        default:
+                                return cty.UnknownVal(b.ImpliedType()), path.NewErrorf("attribute %q is required", typeName)
+                        }
+
+                case NestingSet:
+                        switch {
+                        case ty.HasAttribute(typeName):
+                                coll := in.GetAttr(typeName)
+
+                                switch {
+                                case coll.IsNull():
+                                        attrs[typeName] = cty.NullVal(cty.Set(blockS.ImpliedType()))
+                                        continue
+                                case !coll.IsKnown():
+                                        attrs[typeName] = cty.UnknownVal(cty.Set(blockS.ImpliedType()))
+                                        continue
+                                }
+
+                                if !coll.CanIterateElements() {
+                                        return cty.UnknownVal(b.ImpliedType()), path.NewErrorf("must be a set")
+                                }
+                                l := coll.LengthInt()
+                                if l < blockS.MinItems {
+                                        return cty.UnknownVal(b.ImpliedType()), path.NewErrorf("insufficient items for attribute %q; must have at least %d", typeName, blockS.MinItems)
+                                }
+                                if l > blockS.MaxItems && blockS.MaxItems > 0 {
+                                        return cty.UnknownVal(b.ImpliedType()), path.NewErrorf("too many items for attribute %q; cannot have more than %d", typeName, blockS.MaxItems)
+                                }
+                                if l == 0 {
+                                        attrs[typeName] = cty.SetValEmpty(blockS.ImpliedType())
+                                        continue
+                                }
+                                elems := make([]cty.Value, 0, l)
+                                {
+                                        path = append(path, cty.GetAttrStep{Name: typeName})
+                                        for it := coll.ElementIterator(); it.Next(); {
+                                                var err error
+                                                idx, val := it.Element()
+                                                val, err = blockS.coerceValue(val, append(path, cty.IndexStep{Key: idx}))
+                                                if err != nil {
+                                                        return cty.UnknownVal(b.ImpliedType()), err
+                                                }
+                                                elems = append(elems, val)
+                                        }
+                                }
+                                attrs[typeName] = cty.SetVal(elems)
+                        case blockS.MinItems == 0:
+                                attrs[typeName] = cty.SetValEmpty(blockS.ImpliedType())
+                        default:
+                                return cty.UnknownVal(b.ImpliedType()), path.NewErrorf("attribute %q is required", typeName)
+                        }
+
+                case NestingMap:
+                        switch {
+                        case ty.HasAttribute(typeName):
+                                coll := in.GetAttr(typeName)
+
+                                switch {
+                                case coll.IsNull():
+                                        attrs[typeName] = cty.NullVal(cty.Map(blockS.ImpliedType()))
+                                        continue
+                                case !coll.IsKnown():
+                                        attrs[typeName] = cty.UnknownVal(cty.Map(blockS.ImpliedType()))
+                                        continue
+                                }
+
+                                if !coll.CanIterateElements() {
+                                        return cty.UnknownVal(b.ImpliedType()), path.NewErrorf("must be a map")
+                                }
+                                l := coll.LengthInt()
+                                if l == 0 {
+                                        attrs[typeName] = cty.MapValEmpty(blockS.ImpliedType())
+                                        continue
+                                }
+                                elems := make(map[string]cty.Value)
+                                {
+                                        path = append(path, cty.GetAttrStep{Name: typeName})
+                                        for it := coll.ElementIterator(); it.Next(); {
+                                                var err error
+                                                key, val := it.Element()
+                                                if key.Type() != cty.String || key.IsNull() || !key.IsKnown() {
+                                                        return cty.UnknownVal(b.ImpliedType()), path.NewErrorf("must be a map")
+                                                }
+                                                val, err = blockS.coerceValue(val, append(path, cty.IndexStep{Key: key}))
+                                                if err != nil {
+                                                        return cty.UnknownVal(b.ImpliedType()), err
+                                                }
+                                                elems[key.AsString()] = val
+                                        }
+                                }
+
+                                // If the attribute values here contain any DynamicPseudoTypes,
+                                // the concrete type must be an object.
+                                useObject := false
+                                switch {
+                                case coll.Type().IsObjectType():
+                                        useObject = true
+                                default:
+                                        // It's possible that we were given a map, and need to coerce it to an object
+                                        ety := coll.Type().ElementType()
+                                        for _, v := range elems {
+                                                if !v.Type().Equals(ety) {
+                                                        useObject = true
+                                                        break
+                                                }
+                                        }
+                                }
+
+                                if useObject {
+                                        attrs[typeName] = cty.ObjectVal(elems)
+                                } else {
+                                        attrs[typeName] = cty.MapVal(elems)
+                                }
+                        default:
+                                attrs[typeName] = cty.MapValEmpty(blockS.ImpliedType())
+                        }
+
+                default:
+                        // should never happen because above is exhaustive
+                        panic(fmt.Errorf("unsupported nesting mode %#v", blockS.Nesting))
+                }
+        }
+
+        return cty.ObjectVal(attrs), nil
+}
+
+func (a *Attribute) coerceValue(in cty.Value, path cty.Path) (cty.Value, error) {
+        val, err := convert.Convert(in, a.Type)
+        if err != nil {
+                return cty.UnknownVal(a.Type), path.NewError(err)
+        }
+        return val, nil
+}
diff --git a/vendor/github.com/hashicorp/terraform/configs/configschema/decoder_spec.go b/vendor/github.com/hashicorp/terraform/configs/configschema/decoder_spec.go
new file mode 100644
index 0000000..d8f41ea
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/configs/configschema/decoder_spec.go
@@ -0,0 +1,117 @@
+package configschema
+
+import (
+        "github.com/hashicorp/hcl2/hcldec"
+)
+
+var mapLabelNames = []string{"key"}
+
+// DecoderSpec returns a hcldec.Spec that can be used to decode a HCL Body
+// using the facilities in the hcldec package.
+//
+// The returned specification is guaranteed to return a value of the same type
+// returned by method ImpliedType, but it may contain null values if any of the
+// block attributes are defined as optional and/or computed respectively.
+func (b *Block) DecoderSpec() hcldec.Spec {
+        ret := hcldec.ObjectSpec{}
+        if b == nil {
+                return ret
+        }
+
+        for name, attrS := range b.Attributes {
+                ret[name] = attrS.decoderSpec(name)
+        }
+
+        for name, blockS := range b.BlockTypes {
+                if _, exists := ret[name]; exists {
+                        // This indicates an invalid schema, since it's not valid to
+                        // define both an attribute and a block type of the same name.
+                        // However, we don't raise this here since it's checked by
+                        // InternalValidate.
+                        continue
+                }
+
+                childSpec := blockS.Block.DecoderSpec()
+
+                switch blockS.Nesting {
+                case NestingSingle, NestingGroup:
+                        ret[name] = &hcldec.BlockSpec{
+                                TypeName: name,
+                                Nested:   childSpec,
+                                Required: blockS.MinItems == 1 && blockS.MaxItems >= 1,
+                        }
+                        if blockS.Nesting == NestingGroup {
+                                ret[name] = &hcldec.DefaultSpec{
+                                        Primary: ret[name],
+                                        Default: &hcldec.LiteralSpec{
+                                                Value: blockS.EmptyValue(),
+                                        },
+                                }
+                        }
+                case NestingList:
+                        // We prefer to use a list where possible, since it makes our
+                        // implied type more complete, but if there are any
+                        // dynamically-typed attributes inside we must use a tuple
+                        // instead, at the expense of our type then not being predictable.
+                        if blockS.Block.ImpliedType().HasDynamicTypes() {
+                                ret[name] = &hcldec.BlockTupleSpec{
+                                        TypeName: name,
+                                        Nested:   childSpec,
+                                        MinItems: blockS.MinItems,
+                                        MaxItems: blockS.MaxItems,
+                                }
+                        } else {
+                                ret[name] = &hcldec.BlockListSpec{
+                                        TypeName: name,
+                                        Nested:   childSpec,
+                                        MinItems: blockS.MinItems,
+                                        MaxItems: blockS.MaxItems,
+                                }
+                        }
+                case NestingSet:
+                        // We forbid dynamically-typed attributes inside NestingSet in
+                        // InternalValidate, so we don't do anything special to handle
+                        // that here. (There is no set analog to tuple and object types,
+                        // because cty's set implementation depends on knowing the static
+                        // type in order to properly compute its internal hashes.)
+                        ret[name] = &hcldec.BlockSetSpec{
+                                TypeName: name,
+                                Nested:   childSpec,
+                                MinItems: blockS.MinItems,
+                                MaxItems: blockS.MaxItems,
+                        }
+                case NestingMap:
+                        // We prefer to use a list where possible, since it makes our
+                        // implied type more complete, but if there are any
+                        // dynamically-typed attributes inside we must use a tuple
+                        // instead, at the expense of our type then not being predictable.
+                        if blockS.Block.ImpliedType().HasDynamicTypes() {
+                                ret[name] = &hcldec.BlockObjectSpec{
+                                        TypeName:   name,
+                                        Nested:     childSpec,
+                                        LabelNames: mapLabelNames,
+                                }
+                        } else {
+                                ret[name] = &hcldec.BlockMapSpec{
+                                        TypeName:   name,
+                                        Nested:     childSpec,
+                                        LabelNames: mapLabelNames,
+                                }
+                        }
+                default:
+                        // Invalid nesting type is just ignored. It's checked by
+                        // InternalValidate.
+                        continue
+                }
+        }
+
+        return ret
+}
+
+func (a *Attribute) decoderSpec(name string) hcldec.Spec {
+        return &hcldec.AttrSpec{
+                Name:     name,
+                Type:     a.Type,
+                Required: a.Required,
+        }
+}
diff --git a/vendor/github.com/hashicorp/terraform/configs/configschema/doc.go b/vendor/github.com/hashicorp/terraform/configs/configschema/doc.go
new file mode 100644
index 0000000..caf8d73
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/configs/configschema/doc.go
@@ -0,0 +1,14 @@
+// Package configschema contains types for describing the expected structure
+// of a configuration block whose shape is not known until runtime.
+//
+// For example, this is used to describe the expected contents of a resource
+// configuration block, which is defined by the corresponding provider plugin
+// and thus not compiled into Terraform core.
+//
+// A configschema primarily describes the shape of configuration, but it is
+// also suitable for use with other structures derived from the configuration,
+// such as the cached state of a resource or a resource diff.
+//
+// This package should not be confused with the package helper/schema, which
+// is the higher-level helper library used to implement providers themselves.
+package configschema
diff --git a/vendor/github.com/hashicorp/terraform/configs/configschema/empty_value.go b/vendor/github.com/hashicorp/terraform/configs/configschema/empty_value.go
new file mode 100644
index 0000000..005da56
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/configs/configschema/empty_value.go
@@ -0,0 +1,59 @@
+package configschema
+
+import (
+        "github.com/zclconf/go-cty/cty"
+)
+
+// EmptyValue returns the "empty value" for the recieving block, which for
+// a block type is a non-null object where all of the attribute values are
+// the empty values of the block's attributes and nested block types.
+//
+// In other words, it returns the value that would be returned if an empty
+// block were decoded against the recieving schema, assuming that no required
+// attribute or block constraints were honored.
+func (b *Block) EmptyValue() cty.Value {
+        vals := make(map[string]cty.Value)
+        for name, attrS := range b.Attributes {
+                vals[name] = attrS.EmptyValue()
+        }
+        for name, blockS := range b.BlockTypes {
+                vals[name] = blockS.EmptyValue()
+        }
+        return cty.ObjectVal(vals)
+}
+
+// EmptyValue returns the "empty value" for the receiving attribute, which is
+// the value that would be returned if there were no definition of the attribute
+// at all, ignoring any required constraint.
+func (a *Attribute) EmptyValue() cty.Value {
+        return cty.NullVal(a.Type)
+}
+
+// EmptyValue returns the "empty value" for when there are zero nested blocks
+// present of the receiving type.
+func (b *NestedBlock) EmptyValue() cty.Value {
+        switch b.Nesting {
+        case NestingSingle:
+                return cty.NullVal(b.Block.ImpliedType())
+        case NestingGroup:
+                return b.Block.EmptyValue()
+        case NestingList:
+                if ty := b.Block.ImpliedType(); ty.HasDynamicTypes() {
+                        return cty.EmptyTupleVal
+                } else {
+                        return cty.ListValEmpty(ty)
+                }
+        case NestingMap:
+                if ty := b.Block.ImpliedType(); ty.HasDynamicTypes() {
+                        return cty.EmptyObjectVal
+                } else {
+                        return cty.MapValEmpty(ty)
+                }
+        case NestingSet:
+                return cty.SetValEmpty(b.Block.ImpliedType())
+        default:
+                // Should never get here because the above is intended to be exhaustive,
+                // but we'll be robust and return a result nonetheless.
+                return cty.NullVal(cty.DynamicPseudoType)
+        }
+}
diff --git a/vendor/github.com/hashicorp/terraform/configs/configschema/implied_type.go b/vendor/github.com/hashicorp/terraform/configs/configschema/implied_type.go
new file mode 100644
index 0000000..c0ee841
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/configs/configschema/implied_type.go
@@ -0,0 +1,42 @@
+package configschema
+
+import (
+        "github.com/hashicorp/hcl2/hcldec"
+        "github.com/zclconf/go-cty/cty"
+)
+
+// ImpliedType returns the cty.Type that would result from decoding a
+// configuration block using the receiving block schema.
+//
+// ImpliedType always returns a result, even if the given schema is
+// inconsistent. Code that creates configschema.Block objects should be
+// tested using the InternalValidate method to detect any inconsistencies
+// that would cause this method to fall back on defaults and assumptions.
+func (b *Block) ImpliedType() cty.Type {
+        if b == nil {
+                return cty.EmptyObject
+        }
+
+        return hcldec.ImpliedType(b.DecoderSpec())
+}
+
+// ContainsSensitive returns true if any of the attributes of the receiving
+// block or any of its descendent blocks are marked as sensitive.
+//
+// Blocks themselves cannot be sensitive as a whole -- sensitivity is a
+// per-attribute idea -- but sometimes we want to include a whole object
+// decoded from a block in some UI output, and that is safe to do only if
+// none of the contained attributes are sensitive.
+func (b *Block) ContainsSensitive() bool {
+        for _, attrS := range b.Attributes {
+                if attrS.Sensitive {
+                        return true
+                }
+        }
+        for _, blockS := range b.BlockTypes {
+                if blockS.ContainsSensitive() {
+                        return true
+                }
+        }
+        return false
+}
diff --git a/vendor/github.com/hashicorp/terraform/configs/configschema/internal_validate.go b/vendor/github.com/hashicorp/terraform/configs/configschema/internal_validate.go
new file mode 100644
index 0000000..ebf1abb
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/configs/configschema/internal_validate.go
@@ -0,0 +1,105 @@
+package configschema
+
+import (
+        "fmt"
+        "regexp"
+
+        "github.com/zclconf/go-cty/cty"
+
+        multierror "github.com/hashicorp/go-multierror"
+)
+
+var validName = regexp.MustCompile(`^[a-z0-9_]+$`)
+
+// InternalValidate returns an error if the receiving block and its child
+// schema definitions have any consistencies with the documented rules for
+// valid schema.
+//
+// This is intended to be used within unit tests to detect when a given
+// schema is invalid.
+func (b *Block) InternalValidate() error {
+        if b == nil {
+                return fmt.Errorf("top-level block schema is nil")
+        }
+        return b.internalValidate("", nil)
+
+}
+
+func (b *Block) internalValidate(prefix string, err error) error {
+        for name, attrS := range b.Attributes {
+                if attrS == nil {
+                        err = multierror.Append(err, fmt.Errorf("%s%s: attribute schema is nil", prefix, name))
+                        continue
+                }
+                if !validName.MatchString(name) {
+                        err = multierror.Append(err, fmt.Errorf("%s%s: name may contain only lowercase letters, digits and underscores", prefix, name))
+                }
+                if attrS.Optional == false && attrS.Required == false && attrS.Computed == false {
+                        err = multierror.Append(err, fmt.Errorf("%s%s: must set Optional, Required or Computed", prefix, name))
+                }
+                if attrS.Optional && attrS.Required {
+                        err = multierror.Append(err, fmt.Errorf("%s%s: cannot set both Optional and Required", prefix, name))
+                }
+                if attrS.Computed && attrS.Required {
+                        err = multierror.Append(err, fmt.Errorf("%s%s: cannot set both Computed and Required", prefix, name))
+                }
+                if attrS.Type == cty.NilType {
+                        err = multierror.Append(err, fmt.Errorf("%s%s: Type must be set to something other than cty.NilType", prefix, name))
+                }
+        }
+
+        for name, blockS := range b.BlockTypes {
+                if blockS == nil {
+                        err = multierror.Append(err, fmt.Errorf("%s%s: block schema is nil", prefix, name))
+                        continue
+                }
+
+                if _, isAttr := b.Attributes[name]; isAttr {
+                        err = multierror.Append(err, fmt.Errorf("%s%s: name defined as both attribute and child block type", prefix, name))
+                } else if !validName.MatchString(name) {
+                        err = multierror.Append(err, fmt.Errorf("%s%s: name may contain only lowercase letters, digits and underscores", prefix, name))
+                }
+
+                if blockS.MinItems < 0 || blockS.MaxItems < 0 {
+                        err = multierror.Append(err, fmt.Errorf("%s%s: MinItems and MaxItems must both be greater than zero", prefix, name))
+                }
+
+                switch blockS.Nesting {
+                case NestingSingle:
+                        switch {
+                        case blockS.MinItems != blockS.MaxItems:
+                                err = multierror.Append(err, fmt.Errorf("%s%s: MinItems and MaxItems must match in NestingSingle mode", prefix, name))
+                        case blockS.MinItems < 0 || blockS.MinItems > 1:
+                                err = multierror.Append(err, fmt.Errorf("%s%s: MinItems and MaxItems must be set to either 0 or 1 in NestingSingle mode", prefix, name))
+                        }
+                case NestingGroup:
+                        if blockS.MinItems != 0 || blockS.MaxItems != 0 {
+                                err = multierror.Append(err, fmt.Errorf("%s%s: MinItems and MaxItems cannot be used in NestingGroup mode", prefix, name))
+                        }
+                case NestingList, NestingSet:
+                        if blockS.MinItems > blockS.MaxItems && blockS.MaxItems != 0 {
+                                err = multierror.Append(err, fmt.Errorf("%s%s: MinItems must be less than or equal to MaxItems in %s mode", prefix, name, blockS.Nesting))
+                        }
+                        if blockS.Nesting == NestingSet {
+                                ety := blockS.Block.ImpliedType()
+                                if ety.HasDynamicTypes() {
+                                        // This is not permitted because the HCL (cty) set implementation
+                                        // needs to know the exact type of set elements in order to
+                                        // properly hash them, and so can't support mixed types.
+                                        err = multierror.Append(err, fmt.Errorf("%s%s: NestingSet blocks may not contain attributes of cty.DynamicPseudoType", prefix, name))
+                                }
+                        }
+                case NestingMap:
+                        if blockS.MinItems != 0 || blockS.MaxItems != 0 {
+                                err = multierror.Append(err, fmt.Errorf("%s%s: MinItems and MaxItems must both be 0 in NestingMap mode", prefix, name))
+                        }
+                default:
+                        err = multierror.Append(err, fmt.Errorf("%s%s: invalid nesting mode %s", prefix, name, blockS.Nesting))
+                }
+
+                subPrefix := prefix + name + "."
+                err = blockS.Block.internalValidate(subPrefix, err)
+        }
+
+        return err
+}
diff --git a/vendor/github.com/hashicorp/terraform/configs/configschema/nestingmode_string.go b/vendor/github.com/hashicorp/terraform/configs/configschema/nestingmode_string.go
new file mode 100644
index 0000000..febe743
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/configs/configschema/nestingmode_string.go
@@ -0,0 +1,28 @@
+// Code generated by "stringer -type=NestingMode"; DO NOT EDIT.
+
+package configschema
+
+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[nestingModeInvalid-0]
+        _ = x[NestingSingle-1]
+        _ = x[NestingGroup-2]
+        _ = x[NestingList-3]
+        _ = x[NestingSet-4]
+        _ = x[NestingMap-5]
+}
+
+const _NestingMode_name = "nestingModeInvalidNestingSingleNestingGroupNestingListNestingSetNestingMap"
+
+var _NestingMode_index = [...]uint8{0, 18, 31, 43, 54, 64, 74}
+
+func (i NestingMode) String() string {
+        if i < 0 || i >= NestingMode(len(_NestingMode_index)-1) {
+                return "NestingMode(" + strconv.FormatInt(int64(i), 10) + ")"
+        }
+        return _NestingMode_name[_NestingMode_index[i]:_NestingMode_index[i+1]]
+}
diff --git a/vendor/github.com/hashicorp/terraform/configs/configschema/none_required.go b/vendor/github.com/hashicorp/terraform/configs/configschema/none_required.go
new file mode 100644
index 0000000..0be3b8f
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/configs/configschema/none_required.go
@@ -0,0 +1,38 @@
+package configschema
+
+// NoneRequired returns a deep copy of the receiver with any required
+// attributes translated to optional.
+func (b *Block) NoneRequired() *Block {
+        ret := &Block{}
+
+        if b.Attributes != nil {
+                ret.Attributes = make(map[string]*Attribute, len(b.Attributes))
+        }
+        for name, attrS := range b.Attributes {
+                ret.Attributes[name] = attrS.forceOptional()
+        }
+
+        if b.BlockTypes != nil {
+                ret.BlockTypes = make(map[string]*NestedBlock, len(b.BlockTypes))
+        }
+        for name, blockS := range b.BlockTypes {
+                ret.BlockTypes[name] = blockS.noneRequired()
+        }
+
+        return ret
+}
+
+func (b *NestedBlock) noneRequired() *NestedBlock {
+        ret := *b
+        ret.Block = *(ret.Block.NoneRequired())
+        ret.MinItems = 0
+        ret.MaxItems = 0
+        return &ret
+}
+
+func (a *Attribute) forceOptional() *Attribute {
+        ret := *a
+        ret.Optional = true
+        ret.Required = false
+        return &ret
+}
diff --git a/vendor/github.com/hashicorp/terraform/configs/configschema/schema.go b/vendor/github.com/hashicorp/terraform/configs/configschema/schema.go
new file mode 100644
index 0000000..5a67334
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/configs/configschema/schema.go
@@ -0,0 +1,130 @@
+package configschema
+
+import (
+        "github.com/zclconf/go-cty/cty"
+)
+
+// Block represents a configuration block.
+//
+// "Block" here is a logical grouping construct, though it happens to map
+// directly onto the physical block syntax of Terraform's native configuration
+// syntax. It may be a more a matter of convention in other syntaxes, such as
+// JSON.
+//
+// When converted to a value, a Block always becomes an instance of an object
+// type derived from its defined attributes and nested blocks
+type Block struct {
+        // Attributes describes any attributes that may appear directly inside
+        // the block.
+        Attributes map[string]*Attribute
+
+        // BlockTypes describes any nested block types that may appear directly
+        // inside the block.
+        BlockTypes map[string]*NestedBlock
+}
+
+// Attribute represents a configuration attribute, within a block.
+type Attribute struct {
+        // Type is a type specification that the attribute's value must conform to.
+        Type cty.Type
+
+        // Description is an English-language description of the purpose and
+        // usage of the attribute. A description should be concise and use only
+        // one or two sentences, leaving full definition to longer-form
+        // documentation defined elsewhere.
+        Description string
+
+        // Required, if set to true, specifies that an omitted or null value is
+        // not permitted.
+        Required bool
+
+        // Optional, if set to true, specifies that an omitted or null value is
+        // permitted. This field conflicts with Required.
+        Optional bool
+
+        // Computed, if set to true, specifies that the value comes from the
+        // provider rather than from configuration. If combined with Optional,
+        // then the config may optionally provide an overridden value.
+        Computed bool
+
+        // Sensitive, if set to true, indicates that an attribute may contain
+        // sensitive information.
+        //
+        // At present nothing is done with this information, but callers are
+        // encouraged to set it where appropriate so that it may be used in the
+        // future to help Terraform mask sensitive information. (Terraform
+        // currently achieves this in a limited sense via other mechanisms.)
+        Sensitive bool
+}
+
+// NestedBlock represents the embedding of one block within another.
+type NestedBlock struct {
+        // Block is the description of the block that's nested.
+        Block
+
+        // Nesting provides the nesting mode for the child block, which determines
+        // how many instances of the block are allowed, how many labels it expects,
+        // and how the resulting data will be converted into a data structure.
+        Nesting NestingMode
+
+        // MinItems and MaxItems set, for the NestingList and NestingSet nesting
+        // modes, lower and upper limits on the number of child blocks allowed
+        // of the given type. If both are left at zero, no limit is applied.
+        //
+        // As a special case, both values can be set to 1 for NestingSingle in
+        // order to indicate that a particular single block is required.
+        //
+        // These fields are ignored for other nesting modes and must both be left
+        // at zero.
+        MinItems, MaxItems int
+}
+
+// NestingMode is an enumeration of modes for nesting blocks inside other
+// blocks.
+type NestingMode int
+
+//go:generate stringer -type=NestingMode
+
+const (
+        nestingModeInvalid NestingMode = iota
+
+        // NestingSingle indicates that only a single instance of a given
+        // block type is permitted, with no labels, and its content should be
+        // provided directly as an object value.
+        NestingSingle
+
+        // NestingGroup is similar to NestingSingle in that it calls for only a
+        // single instance of a given block type with no labels, but it additonally
+        // guarantees that its result will never be null, even if the block is
+        // absent, and instead the nested attributes and blocks will be treated
+        // as absent in that case. (Any required attributes or blocks within the
+        // nested block are not enforced unless the block is explicitly present
+        // in the configuration, so they are all effectively optional when the
+        // block is not present.)
+        //
+        // This is useful for the situation where a remote API has a feature that
+        // is always enabled but has a group of settings related to that feature
+        // that themselves have default values. By using NestingGroup instead of
+        // NestingSingle in that case, generated plans will show the block as
+        // present even when not present in configuration, thus allowing any
+        // default values within to be displayed to the user.
+        NestingGroup
+
+        // NestingList indicates that multiple blocks of the given type are
+        // permitted, with no labels, and that their corresponding objects should
+        // be provided in a list.
+        NestingList
+
+        // NestingSet indicates that multiple blocks of the given type are
+        // permitted, with no labels, and that their corresponding objects should
+        // be provided in a set.
+        NestingSet
+
+        // NestingMap indicates that multiple blocks of the given type are
+        // permitted, each with a single label, and that their corresponding
+        // objects should be provided in a map whose keys are the labels.
+        //
+        // It's an error, therefore, to use the same label value on multiple
+        // blocks.
+        NestingMap
+)
diff --git a/vendor/github.com/hashicorp/terraform/configs/configschema/validate_traversal.go b/vendor/github.com/hashicorp/terraform/configs/configschema/validate_traversal.go
new file mode 100644
index 0000000..a41e930
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/configs/configschema/validate_traversal.go
@@ -0,0 +1,173 @@
+package configschema
+
+import (
+        "fmt"
+        "sort"
+
+        "github.com/hashicorp/hcl2/hcl"
+        "github.com/hashicorp/hcl2/hcl/hclsyntax"
+        "github.com/zclconf/go-cty/cty"
+
+        "github.com/hashicorp/terraform/helper/didyoumean"
+        "github.com/hashicorp/terraform/tfdiags"
+)
+
+// StaticValidateTraversal checks whether the given traversal (which must be
+// relative) refers to a construct in the receiving schema, returning error
+// diagnostics if any problems are found.
+//
+// This method is "optimistic" in that it will not return errors for possible
+// problems that cannot be detected statically. It is possible that an
+// traversal which passed static validation will still fail when evaluated.
+func (b *Block) StaticValidateTraversal(traversal hcl.Traversal) tfdiags.Diagnostics {
+        if !traversal.IsRelative() {
+                panic("StaticValidateTraversal on absolute traversal")
+        }
+        if len(traversal) == 0 {
+                return nil
+        }
+
+        var diags tfdiags.Diagnostics
+
+        next := traversal[0]
+        after := traversal[1:]
+
+        var name string
+        switch step := next.(type) {
+        case hcl.TraverseAttr:
+                name = step.Name
+        case hcl.TraverseIndex:
+                // No other traversal step types are allowed directly at a block.
+                // If it looks like the user was trying to use index syntax to
+                // access an attribute then we'll produce a specialized message.
+                key := step.Key
+                if key.Type() == cty.String && key.IsKnown() && !key.IsNull() {
+                        maybeName := key.AsString()
+                        if hclsyntax.ValidIdentifier(maybeName) {
+                                diags = diags.Append(&hcl.Diagnostic{
+                                        Severity: hcl.DiagError,
+                                        Summary:  `Invalid index operation`,
+                                        Detail:   fmt.Sprintf(`Only attribute access is allowed here. Did you mean to access attribute %q using the dot operator?`, maybeName),
+                                        Subject:  &step.SrcRange,
+                                })
+                                return diags
+                        }
+                }
+                // If it looks like some other kind of index then we'll use a generic error.
+                diags = diags.Append(&hcl.Diagnostic{
+                        Severity: hcl.DiagError,
+                        Summary:  `Invalid index operation`,
+                        Detail:   `Only attribute access is allowed here, using the dot operator.`,
+                        Subject:  &step.SrcRange,
+                })
+                return diags
+        default:
+                // No other traversal types should appear in a normal valid traversal,
+                // but we'll handle this with a generic error anyway to be robust.
+                diags = diags.Append(&hcl.Diagnostic{
+                        Severity: hcl.DiagError,
+                        Summary:  `Invalid operation`,
+                        Detail:   `Only attribute access is allowed here, using the dot operator.`,
+                        Subject:  next.SourceRange().Ptr(),
+                })
+                return diags
+        }
+
+        if attrS, exists := b.Attributes[name]; exists {
+                // For attribute validation we will just apply the rest of the
+                // traversal to an unknown value of the attribute type and pass
+                // through HCL's own errors, since we don't want to replicate all of
+                // HCL's type checking rules here.
+                val := cty.UnknownVal(attrS.Type)
+                _, hclDiags := after.TraverseRel(val)
+                diags = diags.Append(hclDiags)
+                return diags
+        }
+
+        if blockS, exists := b.BlockTypes[name]; exists {
+                moreDiags := blockS.staticValidateTraversal(name, after)
+                diags = diags.Append(moreDiags)
+                return diags
+        }
+
+        // If we get here then the name isn't valid at all. We'll collect up
+        // all of the names that _are_ valid to use as suggestions.
+        var suggestions []string
+        for name := range b.Attributes {
+                suggestions = append(suggestions, name)
+        }
+        for name := range b.BlockTypes {
+                suggestions = append(suggestions, name)
+        }
+        sort.Strings(suggestions)
+        suggestion := didyoumean.NameSuggestion(name, suggestions)
+        if suggestion != "" {
+                suggestion = fmt.Sprintf(" Did you mean %q?", suggestion)
+        }
+        diags = diags.Append(&hcl.Diagnostic{
+                Severity: hcl.DiagError,
+                Summary:  `Unsupported attribute`,
+                Detail:   fmt.Sprintf(`This object has no argument, nested block, or exported attribute named %q.%s`, name, suggestion),
+                Subject:  next.SourceRange().Ptr(),
+        })
+
+        return diags
+}
+
+func (b *NestedBlock) staticValidateTraversal(typeName string, traversal hcl.Traversal) tfdiags.Diagnostics {
+        if b.Nesting == NestingSingle || b.Nesting == NestingGroup {
+                // Single blocks are easy: just pass right through.
+                return b.Block.StaticValidateTraversal(traversal)
+        }
+
+        if len(traversal) == 0 {
+                // It's always valid to access a nested block's attribute directly.
+                return nil
+        }
+
+        var diags tfdiags.Diagnostics
+        next := traversal[0]
+        after := traversal[1:]
+
+        switch b.Nesting {
+
+        case NestingSet:
+                // Can't traverse into a set at all, since it does not have any keys
+                // to index with.
+                diags = diags.Append(&hcl.Diagnostic{
+                        Severity: hcl.DiagError,
+                        Summary:  `Cannot index a set value`,
+                        Detail:   fmt.Sprintf(`Block type %q is represented by a set of objects, and set elements do not have addressable keys. To find elements matching specific criteria, use a "for" expression with an "if" clause.`, typeName),
+                        Subject:  next.SourceRange().Ptr(),
+                })
+                return diags
+
+        case NestingList:
+                if _, ok := next.(hcl.TraverseIndex); ok {
+                        moreDiags := b.Block.StaticValidateTraversal(after)
+                        diags = diags.Append(moreDiags)
+                } else {
+                        diags = diags.Append(&hcl.Diagnostic{
+                                Severity: hcl.DiagError,
+                                Summary:  `Invalid operation`,
+                                Detail:   fmt.Sprintf(`Block type %q is represented by a list of objects, so it must be indexed using a numeric key, like .%s[0].`, typeName, typeName),
+                                Subject:  next.SourceRange().Ptr(),
+                        })
+                }
+                return diags
+
+        case NestingMap:
+                // Both attribute and index steps are valid for maps, so we'll just
+                // pass through here and let normal evaluation catch an
+                // incorrectly-typed index key later, if present.
+                moreDiags := b.Block.StaticValidateTraversal(after)
+                diags = diags.Append(moreDiags)
+                return diags
+
+        default:
+                // Invalid nesting type is just ignored. It's checked by
+                // InternalValidate. (Note that we handled NestingSingle separately
+                // back at the start of this function.)
+                return nil
+        }
+}
diff --git a/vendor/github.com/hashicorp/terraform/configs/depends_on.go b/vendor/github.com/hashicorp/terraform/configs/depends_on.go
new file mode 100644
index 0000000..b198476
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/configs/depends_on.go
@@ -0,0 +1,23 @@
+package configs
+
+import (
+        "github.com/hashicorp/hcl2/hcl"
+)
+
+func decodeDependsOn(attr *hcl.Attribute) ([]hcl.Traversal, hcl.Diagnostics) {
+        var ret []hcl.Traversal
+        exprs, diags := hcl.ExprList(attr.Expr)
+
+        for _, expr := range exprs {
+                expr, shimDiags := shimTraversalInString(expr, false)
+                diags = append(diags, shimDiags...)
+
+                traversal, travDiags := hcl.AbsTraversalForExpr(expr)
+                diags = append(diags, travDiags...)
+                if len(traversal) != 0 {
+                        ret = append(ret, traversal)
+                }
+        }
+
+        return ret, diags
+}
diff --git a/vendor/github.com/hashicorp/terraform/configs/doc.go b/vendor/github.com/hashicorp/terraform/configs/doc.go
new file mode 100644
index 0000000..f01eb79
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/configs/doc.go
@@ -0,0 +1,19 @@
+// Package configs contains types that represent Terraform configurations and
+// the different elements thereof.
+//
+// The functionality in this package can be used for some static analyses of
+// Terraform configurations, but this package generally exposes representations
+// of the configuration source code rather than the result of evaluating these
+// objects. The sibling package "lang" deals with evaluation of structures
+// and expressions in the configuration.
+//
+// Due to its close relationship with HCL, this package makes frequent use
+// of types from the HCL API, including raw HCL diagnostic messages. Such
+// diagnostics can be converted into Terraform-flavored diagnostics, if needed,
+// using functions in the sibling package tfdiags.
+//
+// The Parser type is the main entry-point into this package. The LoadConfigDir
+// method can be used to load a single module directory, and then a full
+// configuration (including any descendent modules) can be produced using
+// the top-level BuildConfig method.
+package configs
diff --git a/vendor/github.com/hashicorp/terraform/configs/module.go b/vendor/github.com/hashicorp/terraform/configs/module.go
new file mode 100644
index 0000000..250f9d3
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/configs/module.go
@@ -0,0 +1,404 @@
+package configs
+
+import (
+        "fmt"
+
+        "github.com/hashicorp/hcl2/hcl"
+
+        "github.com/hashicorp/terraform/addrs"
+)
+
+// Module is a container for a set of configuration constructs that are
+// evaluated within a common namespace.
+type Module struct {
+        // SourceDir is the filesystem directory that the module was loaded from.
+        //
+        // This is populated automatically only for configurations loaded with
+        // LoadConfigDir. If the parser is using a virtual filesystem then the
+        // path here will be in terms of that virtual filesystem.
+
+        // Any other caller that constructs a module directly with NewModule may
+        // assign a suitable value to this attribute before using it for other
+        // purposes. It should be treated as immutable by all consumers of Module
+        // values.
+        SourceDir string
+
+        CoreVersionConstraints []VersionConstraint
+
+        Backend              *Backend
+        ProviderConfigs      map[string]*Provider
+        ProviderRequirements map[string][]VersionConstraint
+
+        Variables map[string]*Variable
+        Locals    map[string]*Local
+        Outputs   map[string]*Output
+
+        ModuleCalls map[string]*ModuleCall
+
+        ManagedResources map[string]*Resource
+        DataResources    map[string]*Resource
+}
+
+// File describes the contents of a single configuration file.
+//
+// Individual files are not usually used alone, but rather combined together
+// with other files (conventionally, those in the same directory) to produce
+// a *Module, using NewModule.
+//
+// At the level of an individual file we represent directly the structural
+// elements present in the file, without any attempt to detect conflicting
+// declarations. A File object can therefore be used for some basic static
+// analysis of individual elements, but must be built into a Module to detect
+// duplicate declarations.
+type File struct {
+        CoreVersionConstraints []VersionConstraint
+
+        Backends             []*Backend
+        ProviderConfigs      []*Provider
+        ProviderRequirements []*ProviderRequirement
+
+        Variables []*Variable
+        Locals    []*Local
+        Outputs   []*Output
+
+        ModuleCalls []*ModuleCall
+
+        ManagedResources []*Resource
+        DataResources    []*Resource
+}
+
+// NewModule takes a list of primary files and a list of override files and
+// produces a *Module by combining the files together.
+//
+// If there are any conflicting declarations in the given files -- for example,
+// if the same variable name is defined twice -- then the resulting module
+// will be incomplete and error diagnostics will be returned. Careful static
+// analysis of the returned Module is still possible in this case, but the
+// module will probably not be semantically valid.
+func NewModule(primaryFiles, overrideFiles []*File) (*Module, hcl.Diagnostics) {
+        var diags hcl.Diagnostics
+        mod := &Module{
+                ProviderConfigs:      map[string]*Provider{},
+                ProviderRequirements: map[string][]VersionConstraint{},
+                Variables:            map[string]*Variable{},
+                Locals:               map[string]*Local{},
+                Outputs:              map[string]*Output{},
+                ModuleCalls:          map[string]*ModuleCall{},
+                ManagedResources:     map[string]*Resource{},
+                DataResources:        map[string]*Resource{},
+        }
+
+        for _, file := range primaryFiles {
+                fileDiags := mod.appendFile(file)
+                diags = append(diags, fileDiags...)
+        }
+
+        for _, file := range overrideFiles {
+                fileDiags := mod.mergeFile(file)
+                diags = append(diags, fileDiags...)
+        }
+
+        return mod, diags
+}
+
+// ResourceByAddr returns the configuration for the resource with the given
+// address, or nil if there is no such resource.
+func (m *Module) ResourceByAddr(addr addrs.Resource) *Resource {
+        key := addr.String()
+        switch addr.Mode {
+        case addrs.ManagedResourceMode:
+                return m.ManagedResources[key]
+        case addrs.DataResourceMode:
+                return m.DataResources[key]
+        default:
+                return nil
+        }
+}
+
+func (m *Module) appendFile(file *File) hcl.Diagnostics {
+        var diags hcl.Diagnostics
+
+        for _, constraint := range file.CoreVersionConstraints {
+                // If there are any conflicting requirements then we'll catch them
+                // when we actually check these constraints.
+                m.CoreVersionConstraints = append(m.CoreVersionConstraints, constraint)
+        }
+
+        for _, b := range file.Backends {
+                if m.Backend != nil {
+                        diags = append(diags, &hcl.Diagnostic{
+                                Severity: hcl.DiagError,
+                                Summary:  "Duplicate backend configuration",
+                                Detail:   fmt.Sprintf("A module may have only one backend configuration. The backend was previously configured at %s.", m.Backend.DeclRange),
+                                Subject:  &b.DeclRange,
+                        })
+                        continue
+                }
+                m.Backend = b
+        }
+
+        for _, pc := range file.ProviderConfigs {
+                key := pc.moduleUniqueKey()
+                if existing, exists := m.ProviderConfigs[key]; exists {
+                        if existing.Alias == "" {
+                                diags = append(diags, &hcl.Diagnostic{
+                                        Severity: hcl.DiagError,
+                                        Summary:  "Duplicate provider configuration",
+                                        Detail:   fmt.Sprintf("A default (non-aliased) provider configuration for %q was already given at %s. If multiple configurations are required, set the \"alias\" argument for alternative configurations.", existing.Name, existing.DeclRange),
+                                        Subject:  &pc.DeclRange,
+                                })
+                        } else {
+                                diags = append(diags, &hcl.Diagnostic{
+                                        Severity: hcl.DiagError,
+                                        Summary:  "Duplicate provider configuration",
+                                        Detail:   fmt.Sprintf("A provider configuration for %q with alias %q was already given at %s. Each configuration for the same provider must have a distinct alias.", existing.Name, existing.Alias, existing.DeclRange),
+                                        Subject:  &pc.DeclRange,
+                                })
+                        }
+                        continue
+                }
+                m.ProviderConfigs[key] = pc
+        }
+
+        for _, reqd := range file.ProviderRequirements {
+                m.ProviderRequirements[reqd.Name] = append(m.ProviderRequirements[reqd.Name], reqd.Requirement)
+        }
+
+        for _, v := range file.Variables {
+                if existing, exists := m.Variables[v.Name]; exists {
+                        diags = append(diags, &hcl.Diagnostic{
+                                Severity: hcl.DiagError,
+                                Summary:  "Duplicate variable declaration",
+                                Detail:   fmt.Sprintf("A variable named %q was already declared at %s. Variable names must be unique within a module.", existing.Name, existing.DeclRange),
+                                Subject:  &v.DeclRange,
+                        })
+                }
+                m.Variables[v.Name] = v
+        }
+
+        for _, l := range file.Locals {
+                if existing, exists := m.Locals[l.Name]; exists {
+                        diags = append(diags, &hcl.Diagnostic{
+                                Severity: hcl.DiagError,
+                                Summary:  "Duplicate local value definition",
+                                Detail:   fmt.Sprintf("A local value named %q was already defined at %s. Local value names must be unique within a module.", existing.Name, existing.DeclRange),
+                                Subject:  &l.DeclRange,
+                        })
+                }
+                m.Locals[l.Name] = l
+        }
+
+        for _, o := range file.Outputs {
+                if existing, exists := m.Outputs[o.Name]; exists {
+                        diags = append(diags, &hcl.Diagnostic{
+                                Severity: hcl.DiagError,
+                                Summary:  "Duplicate output definition",
+                                Detail:   fmt.Sprintf("An output named %q was already defined at %s. Output names must be unique within a module.", existing.Name, existing.DeclRange),
+                                Subject:  &o.DeclRange,
+                        })
+                }
+                m.Outputs[o.Name] = o
+        }
+
+        for _, mc := range file.ModuleCalls {
+                if existing, exists := m.ModuleCalls[mc.Name]; exists {
+                        diags = append(diags, &hcl.Diagnostic{
+                                Severity: hcl.DiagError,
+                                Summary:  "Duplicate module call",
+                                Detail:   fmt.Sprintf("An module call named %q was already defined at %s. Module calls must have unique names within a module.", existing.Name, existing.DeclRange),
+                                Subject:  &mc.DeclRange,
+                        })
+                }
+                m.ModuleCalls[mc.Name] = mc
+        }
+
+        for _, r := range file.ManagedResources {
+                key := r.moduleUniqueKey()
+                if existing, exists := m.ManagedResources[key]; exists {
+                        diags = append(diags, &hcl.Diagnostic{
+                                Severity: hcl.DiagError,
+                                Summary:  fmt.Sprintf("Duplicate resource %q configuration", existing.Type),
+                                Detail:   fmt.Sprintf("A %s resource named %q was already declared at %s. Resource names must be unique per type in each module.", existing.Type, existing.Name, existing.DeclRange),
+                                Subject:  &r.DeclRange,
+                        })
+                        continue
+                }
+                m.ManagedResources[key] = r
+        }
+
+        for _, r := range file.DataResources {
+                key := r.moduleUniqueKey()
+                if existing, exists := m.DataResources[key]; exists {
+                        diags = append(diags, &hcl.Diagnostic{
+                                Severity: hcl.DiagError,
+                                Summary:  fmt.Sprintf("Duplicate data %q configuration", existing.Type),
+                                Detail:   fmt.Sprintf("A %s data resource named %q was already declared at %s. Resource names must be unique per type in each module.", existing.Type, existing.Name, existing.DeclRange),
+                                Subject:  &r.DeclRange,
+                        })
+                        continue
+                }
+                m.DataResources[key] = r
+        }
+
+        return diags
+}
+
+func (m *Module) mergeFile(file *File) hcl.Diagnostics {
+        var diags hcl.Diagnostics
+
+        if len(file.CoreVersionConstraints) != 0 {
+                // This is a bit of a strange case for overriding since we normally
+                // would union together across multiple files anyway, but we'll
+                // allow it and have each override file clobber any existing list.
+                m.CoreVersionConstraints = nil
+                for _, constraint := range file.CoreVersionConstraints {
+                        m.CoreVersionConstraints = append(m.CoreVersionConstraints, constraint)
+                }
+        }
+
+        if len(file.Backends) != 0 {
+                switch len(file.Backends) {
+                case 1:
+                        m.Backend = file.Backends[0]
+                default:
+                        // An override file with multiple backends is still invalid, even
+                        // though it can override backends from _other_ files.
+                        diags = append(diags, &hcl.Diagnostic{
+                                Severity: hcl.DiagError,
+                                Summary:  "Duplicate backend configuration",
+                                Detail:   fmt.Sprintf("Each override file may have only one backend configuration. A backend was previously configured at %s.", file.Backends[0].DeclRange),
+                                Subject:  &file.Backends[1].DeclRange,
+                        })
+                }
+        }
+
+        for _, pc := range file.ProviderConfigs {
+                key := pc.moduleUniqueKey()
+                existing, exists := m.ProviderConfigs[key]
+                if pc.Alias == "" {
+                        // We allow overriding a non-existing _default_ provider configuration
+                        // because the user model is that an absent provider configuration
+                        // implies an empty provider configuration, which is what the user
+                        // is therefore overriding here.
+                        if exists {
+                                mergeDiags := existing.merge(pc)
+                                diags = append(diags, mergeDiags...)
+                        } else {
+                                m.ProviderConfigs[key] = pc
+                        }
+                } else {
+                        // For aliased providers, there must be a base configuration to
+                        // override. This allows us to detect and report alias typos
+                        // that might otherwise cause the override to not apply.
+                        if !exists {
+                                diags = append(diags, &hcl.Diagnostic{
+                                        Severity: hcl.DiagError,
+                                        Summary:  "Missing base provider configuration for override",
+                                        Detail:   fmt.Sprintf("There is no %s provider configuration with the alias %q. An override file can only override an aliased provider configuration that was already defined in a primary configuration file.", pc.Name, pc.Alias),
+                                        Subject:  &pc.DeclRange,
+                                })
+                                continue
+                        }
+                        mergeDiags := existing.merge(pc)
+                        diags = append(diags, mergeDiags...)
+                }
+        }
+
+        if len(file.ProviderRequirements) != 0 {
+                mergeProviderVersionConstraints(m.ProviderRequirements, file.ProviderRequirements)
+        }
+
+        for _, v := range file.Variables {
+                existing, exists := m.Variables[v.Name]
+                if !exists {
+                        diags = append(diags, &hcl.Diagnostic{
+                                Severity: hcl.DiagError,
+                                Summary:  "Missing base variable declaration to override",
+                                Detail:   fmt.Sprintf("There is no variable named %q. An override file can only override a variable that was already declared in a primary configuration file.", v.Name),
+                                Subject:  &v.DeclRange,
+                        })
+                        continue
+                }
+                mergeDiags := existing.merge(v)
+                diags = append(diags, mergeDiags...)
+        }
+
+        for _, l := range file.Locals {
+                existing, exists := m.Locals[l.Name]
+                if !exists {
+                        diags = append(diags, &hcl.Diagnostic{
+                                Severity: hcl.DiagError,
+                                Summary:  "Missing base local value definition to override",
+                                Detail:   fmt.Sprintf("There is no local value named %q. An override file can only override a local value that was already defined in a primary configuration file.", l.Name),
+                                Subject:  &l.DeclRange,
+                        })
+                        continue
+                }
+                mergeDiags := existing.merge(l)
+                diags = append(diags, mergeDiags...)
+        }
+
+        for _, o := range file.Outputs {
+                existing, exists := m.Outputs[o.Name]
+                if !exists {
+                        diags = append(diags, &hcl.Diagnostic{
+                                Severity: hcl.DiagError,
+                                Summary:  "Missing base output definition to override",
+                                Detail:   fmt.Sprintf("There is no output named %q. An override file can only override an output that was already defined in a primary configuration file.", o.Name),
+                                Subject:  &o.DeclRange,
+                        })
+                        continue
+                }
+                mergeDiags := existing.merge(o)
+                diags = append(diags, mergeDiags...)
+        }
+
+        for _, mc := range file.ModuleCalls {
+                existing, exists := m.ModuleCalls[mc.Name]
+                if !exists {
+                        diags = append(diags, &hcl.Diagnostic{
+                                Severity: hcl.DiagError,
+                                Summary:  "Missing module call to override",
+                                Detail:   fmt.Sprintf("There is no module call named %q. An override file can only override a module call that was defined in a primary configuration file.", mc.Name),
+                                Subject:  &mc.DeclRange,
+                        })
+                        continue
+                }
+                mergeDiags := existing.merge(mc)
+                diags = append(diags, mergeDiags...)
+        }
+
+        for _, r := range file.ManagedResources {
+                key := r.moduleUniqueKey()
+                existing, exists := m.ManagedResources[key]
+                if !exists {
+                        diags = append(diags, &hcl.Diagnostic{
+                                Severity: hcl.DiagError,
+                                Summary:  "Missing resource to override",
+                                Detail:   fmt.Sprintf("There is no %s resource named %q. An override file can only override a resource block defined in a primary configuration file.", r.Type, r.Name),
+                                Subject:  &r.DeclRange,
+                        })
+                        continue
+                }
+                mergeDiags := existing.merge(r)
+                diags = append(diags, mergeDiags...)
+        }
+
+        for _, r := range file.DataResources {
+                key := r.moduleUniqueKey()
+                existing, exists := m.DataResources[key]
+                if !exists {
+                        diags = append(diags, &hcl.Diagnostic{
+                                Severity: hcl.DiagError,
+                                Summary:  "Missing data resource to override",
+                                Detail:   fmt.Sprintf("There is no %s data resource named %q. An override file can only override a data block defined in a primary configuration file.", r.Type, r.Name),
+                                Subject:  &r.DeclRange,
+                        })
+                        continue
+                }
+                mergeDiags := existing.merge(r)
+                diags = append(diags, mergeDiags...)
+        }
+
+        return diags
+}
diff --git a/vendor/github.com/hashicorp/terraform/configs/module_call.go b/vendor/github.com/hashicorp/terraform/configs/module_call.go
new file mode 100644
index 0000000..8c3ba67
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/configs/module_call.go
@@ -0,0 +1,188 @@
+package configs
+
+import (
+        "fmt"
+
+        "github.com/hashicorp/hcl2/gohcl"
+        "github.com/hashicorp/hcl2/hcl"
+        "github.com/hashicorp/hcl2/hcl/hclsyntax"
+)
+
+// ModuleCall represents a "module" block in a module or file.
+type ModuleCall struct {
+        Name string
+
+        SourceAddr      string
+        SourceAddrRange hcl.Range
+        SourceSet       bool
+
+        Config hcl.Body
+
+        Version VersionConstraint
+
+        Count   hcl.Expression
+        ForEach hcl.Expression
+
+        Providers []PassedProviderConfig
+
+        DependsOn []hcl.Traversal
+
+        DeclRange hcl.Range
+}
+
+func decodeModuleBlock(block *hcl.Block, override bool) (*ModuleCall, hcl.Diagnostics) {
+        mc := &ModuleCall{
+                Name:      block.Labels[0],
+                DeclRange: block.DefRange,
+        }
+
+        schema := moduleBlockSchema
+        if override {
+                schema = schemaForOverrides(schema)
+        }
+
+        content, remain, diags := block.Body.PartialContent(schema)
+        mc.Config = remain
+
+        if !hclsyntax.ValidIdentifier(mc.Name) {
+                diags = append(diags, &hcl.Diagnostic{
+                        Severity: hcl.DiagError,
+                        Summary:  "Invalid module instance name",
+                        Detail:   badIdentifierDetail,
+                        Subject:  &block.LabelRanges[0],
+                })
+        }
+
+        if attr, exists := content.Attributes["source"]; exists {
+                valDiags := gohcl.DecodeExpression(attr.Expr, nil, &mc.SourceAddr)
+                diags = append(diags, valDiags...)
+                mc.SourceAddrRange = attr.Expr.Range()
+                mc.SourceSet = true
+        }
+
+        if attr, exists := content.Attributes["version"]; exists {
+                var versionDiags hcl.Diagnostics
+                mc.Version, versionDiags = decodeVersionConstraint(attr)
+                diags = append(diags, versionDiags...)
+        }
+
+        if attr, exists := content.Attributes["count"]; exists {
+                mc.Count = attr.Expr
+
+                // We currently parse this, but don't yet do anything with it.
+                diags = append(diags, &hcl.Diagnostic{
+                        Severity: hcl.DiagError,
+                        Summary:  "Reserved argument name in module block",
+                        Detail:   fmt.Sprintf("The name %q is reserved for use in a future version of Terraform.", attr.Name),
+                        Subject:  &attr.NameRange,
+                })
+        }
+
+        if attr, exists := content.Attributes["for_each"]; exists {
+                mc.ForEach = attr.Expr
+
+                // We currently parse this, but don't yet do anything with it.
+                diags = append(diags, &hcl.Diagnostic{
+                        Severity: hcl.DiagError,
+                        Summary:  "Reserved argument name in module block",
+                        Detail:   fmt.Sprintf("The name %q is reserved for use in a future version of Terraform.", attr.Name),
+                        Subject:  &attr.NameRange,
+                })
+        }
+
+        if attr, exists := content.Attributes["depends_on"]; exists {
+                deps, depsDiags := decodeDependsOn(attr)
+                diags = append(diags, depsDiags...)
+                mc.DependsOn = append(mc.DependsOn, deps...)
+
+                // We currently parse this, but don't yet do anything with it.
+                diags = append(diags, &hcl.Diagnostic{
+                        Severity: hcl.DiagError,
+                        Summary:  "Reserved argument name in module block",
+                        Detail:   fmt.Sprintf("The name %q is reserved for use in a future version of Terraform.", attr.Name),
+                        Subject:  &attr.NameRange,
+                })
+        }
+
+        if attr, exists := content.Attributes["providers"]; exists {
+                seen := make(map[string]hcl.Range)
+                pairs, pDiags := hcl.ExprMap(attr.Expr)
+                diags = append(diags, pDiags...)
+                for _, pair := range pairs {
+                        key, keyDiags := decodeProviderConfigRef(pair.Key, "providers")
+                        diags = append(diags, keyDiags...)
+                        value, valueDiags := decodeProviderConfigRef(pair.Value, "providers")
+                        diags = append(diags, valueDiags...)
+                        if keyDiags.HasErrors() || valueDiags.HasErrors() {
+                                continue
+                        }
+
+                        matchKey := key.String()
+                        if prev, exists := seen[matchKey]; exists {
+                                diags = append(diags, &hcl.Diagnostic{
+                                        Severity: hcl.DiagError,
+                                        Summary:  "Duplicate provider address",
+                                        Detail:   fmt.Sprintf("A provider configuration was already passed to %s at %s. Each child provider configuration can be assigned only once.", matchKey, prev),
+                                        Subject:  pair.Value.Range().Ptr(),
+                                })
+                                continue
+                        }
+
+                        rng := hcl.RangeBetween(pair.Key.Range(), pair.Value.Range())
+                        seen[matchKey] = rng
+                        mc.Providers = append(mc.Providers, PassedProviderConfig{
+                                InChild:  key,
+                                InParent: value,
+                        })
+                }
+        }
+
+        // Reserved block types (all of them)
+        for _, block := range content.Blocks {
+                diags = append(diags, &hcl.Diagnostic{
+                        Severity: hcl.DiagError,
+                        Summary:  "Reserved block type name in module block",
+                        Detail:   fmt.Sprintf("The block type name %q is reserved for use by Terraform in a future version.", block.Type),
+                        Subject:  &block.TypeRange,
+                })
+        }
+
+        return mc, diags
+}
+
+// PassedProviderConfig represents a provider config explicitly passed down to
+// a child module, possibly giving it a new local address in the process.
+type PassedProviderConfig struct {
+        InChild  *ProviderConfigRef
+        InParent *ProviderConfigRef
+}
+
+var moduleBlockSchema = &hcl.BodySchema{
+        Attributes: []hcl.AttributeSchema{
+                {
+                        Name:     "source",
+                        Required: true,
+                },
+                {
+                        Name: "version",
+                },
+                {
+                        Name: "count",
+                },
+                {
+                        Name: "for_each",
+                },
+                {
+                        Name: "depends_on",
+                },
+                {
+                        Name: "providers",
+                },
+        },
+        Blocks: []hcl.BlockHeaderSchema{
+                // These are all reserved for future use.
+                {Type: "lifecycle"},
+                {Type: "locals"},
+                {Type: "provider", LabelNames: []string{"type"}},
+        },
+}
diff --git a/vendor/github.com/hashicorp/terraform/configs/module_merge.go b/vendor/github.com/hashicorp/terraform/configs/module_merge.go
new file mode 100644
index 0000000..12614c1
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/configs/module_merge.go
@@ -0,0 +1,247 @@
+package configs
+
+import (
+        "fmt"
+
+        "github.com/hashicorp/terraform/addrs"
+
+        "github.com/hashicorp/hcl2/hcl"
+        "github.com/zclconf/go-cty/cty"
+        "github.com/zclconf/go-cty/cty/convert"
+)
+
+// The methods in this file are used by Module.mergeFile to apply overrides
+// to our different configuration elements. These methods all follow the
+// pattern of mutating the receiver to incorporate settings from the parameter,
+// returning error diagnostics if any aspect of the parameter cannot be merged
+// into the receiver for some reason.
+//
+// User expectation is that anything _explicitly_ set in the given object
+// should take precedence over the corresponding settings in the receiver,
+// but that anything omitted in the given object should be left unchanged.
+// In some cases it may be reasonable to do a "deep merge" of certain nested
+// features, if it is possible to unambiguously correlate the nested elements
+// and their behaviors are orthogonal to each other.
+
+func (p *Provider) merge(op *Provider) hcl.Diagnostics {
+        var diags hcl.Diagnostics
+
+        if op.Version.Required != nil {
+                p.Version = op.Version
+        }
+
+        p.Config = MergeBodies(p.Config, op.Config)
+
+        return diags
+}
+
+func mergeProviderVersionConstraints(recv map[string][]VersionConstraint, ovrd []*ProviderRequirement) {
+        // Any provider name that's mentioned in the override gets nilled out in
+        // our map so that we'll rebuild it below. Any provider not mentioned is
+        // left unchanged.
+        for _, reqd := range ovrd {
+                delete(recv, reqd.Name)
+        }
+        for _, reqd := range ovrd {
+                recv[reqd.Name] = append(recv[reqd.Name], reqd.Requirement)
+        }
+}
+
+func (v *Variable) merge(ov *Variable) hcl.Diagnostics {
+        var diags hcl.Diagnostics
+
+        if ov.DescriptionSet {
+                v.Description = ov.Description
+                v.DescriptionSet = ov.DescriptionSet
+        }
+        if ov.Default != cty.NilVal {
+                v.Default = ov.Default
+        }
+        if ov.Type != cty.NilType {
+                v.Type = ov.Type
+        }
+        if ov.ParsingMode != 0 {
+                v.ParsingMode = ov.ParsingMode
+        }
+
+        // If the override file overrode type without default or vice-versa then
+        // it may have created an invalid situation, which we'll catch now by
+        // attempting to re-convert the value.
+        //
+        // Note that here we may be re-converting an already-converted base value
+        // from the base config. This will be a no-op if the type was not changed,
+        // but in particular might be user-observable in the edge case where the
+        // literal value in config could've been converted to the overridden type
+        // constraint but the converted value cannot. In practice, this situation
+        // should be rare since most of our conversions are interchangable.
+        if v.Default != cty.NilVal {
+                val, err := convert.Convert(v.Default, v.Type)
+                if err != nil {
+                        // What exactly we'll say in the error message here depends on whether
+                        // it was Default or Type that was overridden here.
+                        switch {
+                        case ov.Type != cty.NilType && ov.Default == cty.NilVal:
+                                // If only the type was overridden
+                                diags = append(diags, &hcl.Diagnostic{
+                                        Severity: hcl.DiagError,
+                                        Summary:  "Invalid default value for variable",
+                                        Detail:   fmt.Sprintf("Overriding this variable's type constraint has made its default value invalid: %s.", err),
+                                        Subject:  &ov.DeclRange,
+                                })
+                        case ov.Type == cty.NilType && ov.Default != cty.NilVal:
+                                // Only the default was overridden
+                                diags = append(diags, &hcl.Diagnostic{
+                                        Severity: hcl.DiagError,
+                                        Summary:  "Invalid default value for variable",
+                                        Detail:   fmt.Sprintf("The overridden default value for this variable is not compatible with the variable's type constraint: %s.", err),
+                                        Subject:  &ov.DeclRange,
+                                })
+                        default:
+                                diags = append(diags, &hcl.Diagnostic{
+                                        Severity: hcl.DiagError,
+                                        Summary:  "Invalid default value for variable",
+                                        Detail:   fmt.Sprintf("This variable's default value is not compatible with its type constraint: %s.", err),
+                                        Subject:  &ov.DeclRange,
+                                })
+                        }
+                } else {
+                        v.Default = val
+                }
+        }
+
+        return diags
+}
+
+func (l *Local) merge(ol *Local) hcl.Diagnostics {
+        var diags hcl.Diagnostics
+
+        // Since a local is just a single expression in configuration, the
+        // override definition entirely replaces the base definition, including
+        // the source range so that we'll send the user to the right place if
+        // there is an error.
+        l.Expr = ol.Expr
+        l.DeclRange = ol.DeclRange
+
+        return diags
+}
+
+func (o *Output) merge(oo *Output) hcl.Diagnostics {
+        var diags hcl.Diagnostics
+
+        if oo.Description != "" {
+                o.Description = oo.Description
+        }
+        if oo.Expr != nil {
+                o.Expr = oo.Expr
+        }
+        if oo.SensitiveSet {
+                o.Sensitive = oo.Sensitive
+                o.SensitiveSet = oo.SensitiveSet
+        }
+
+        // We don't allow depends_on to be overridden because that is likely to
+        // cause confusing misbehavior.
+        if len(oo.DependsOn) != 0 {
+                diags = append(diags, &hcl.Diagnostic{
+                        Severity: hcl.DiagError,
+                        Summary:  "Unsupported override",
+                        Detail:   "The depends_on argument may not be overridden.",
+                        Subject:  oo.DependsOn[0].SourceRange().Ptr(), // the first item is the closest range we have
+                })
+        }
+
+        return diags
+}
+
+func (mc *ModuleCall) merge(omc *ModuleCall) hcl.Diagnostics {
+        var diags hcl.Diagnostics
+
+        if omc.SourceSet {
+                mc.SourceAddr = omc.SourceAddr
+                mc.SourceAddrRange = omc.SourceAddrRange
+                mc.SourceSet = omc.SourceSet
+        }
+
+        if omc.Count != nil {
+                mc.Count = omc.Count
+        }
+
+        if omc.ForEach != nil {
+                mc.ForEach = omc.ForEach
+        }
+
+        if len(omc.Version.Required) != 0 {
+                mc.Version = omc.Version
+        }
+
+        mc.Config = MergeBodies(mc.Config, omc.Config)
+
+        // We don't allow depends_on to be overridden because that is likely to
+        // cause confusing misbehavior.
+        if len(mc.DependsOn) != 0 {
+                diags = append(diags, &hcl.Diagnostic{
+                        Severity: hcl.DiagError,
+                        Summary:  "Unsupported override",
+                        Detail:   "The depends_on argument may not be overridden.",
+                        Subject:  mc.DependsOn[0].SourceRange().Ptr(), // the first item is the closest range we have
+                })
+        }
+
+        return diags
+}
+
+func (r *Resource) merge(or *Resource) hcl.Diagnostics {
+        var diags hcl.Diagnostics
+
+        if r.Mode != or.Mode {
+                // This is always a programming error, since managed and data resources
+                // are kept in separate maps in the configuration structures.
+                panic(fmt.Errorf("can't merge %s into %s", or.Mode, r.Mode))
+        }
+
+        if or.Count != nil {
+                r.Count = or.Count
+        }
+        if or.ForEach != nil {
+                r.ForEach = or.ForEach
+        }
+        if or.ProviderConfigRef != nil {
+                r.ProviderConfigRef = or.ProviderConfigRef
+        }
+        if r.Mode == addrs.ManagedResourceMode {
+                // or.Managed is always non-nil for managed resource mode
+
+                if or.Managed.Connection != nil {
+                        r.Managed.Connection = or.Managed.Connection
+                }
+                if or.Managed.CreateBeforeDestroySet {
+                        r.Managed.CreateBeforeDestroy = or.Managed.CreateBeforeDestroy
+                        r.Managed.CreateBeforeDestroySet = or.Managed.CreateBeforeDestroySet
+                }
+                if len(or.Managed.IgnoreChanges) != 0 {
+                        r.Managed.IgnoreChanges = or.Managed.IgnoreChanges
+                }
+                if or.Managed.PreventDestroySet {
+                        r.Managed.PreventDestroy = or.Managed.PreventDestroy
+                        r.Managed.PreventDestroySet = or.Managed.PreventDestroySet
+                }
+                if len(or.Managed.Provisioners) != 0 {
+                        r.Managed.Provisioners = or.Managed.Provisioners
+                }
+        }
+
+        r.Config = MergeBodies(r.Config, or.Config)
+
+        // We don't allow depends_on to be overridden because that is likely to
+        // cause confusing misbehavior.
+        if len(or.DependsOn) != 0 {
+                diags = append(diags, &hcl.Diagnostic{
+                        Severity: hcl.DiagError,
+                        Summary:  "Unsupported override",
+                        Detail:   "The depends_on argument may not be overridden.",
+                        Subject:  or.DependsOn[0].SourceRange().Ptr(), // the first item is the closest range we have
+                })
+        }
+
+        return diags
+}
diff --git a/vendor/github.com/hashicorp/terraform/configs/module_merge_body.go b/vendor/github.com/hashicorp/terraform/configs/module_merge_body.go
new file mode 100644
index 0000000..0ed561e
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/configs/module_merge_body.go
@@ -0,0 +1,143 @@
+package configs
+
+import (
+        "github.com/hashicorp/hcl2/hcl"
+)
+
+// MergeBodies creates a new HCL body that contains a combination of the
+// given base and override bodies. Attributes and blocks defined in the
+// override body take precedence over those of the same name defined in
+// the base body.
+//
+// If any block of a particular type appears in "override" then it will
+// replace _all_ of the blocks of the same type in "base" in the new
+// body.
+func MergeBodies(base, override hcl.Body) hcl.Body {
+        return mergeBody{
+                Base:     base,
+                Override: override,
+        }
+}
+
+// mergeBody is a hcl.Body implementation that wraps a pair of other bodies
+// and allows attributes and blocks within the override to take precedence
+// over those defined in the base body.
+//
+// This is used to deal with dynamically-processed bodies in Module.mergeFile.
+// It uses a shallow-only merging strategy where direct attributes defined
+// in Override will override attributes of the same name in Base, while any
+// blocks defined in Override will hide all blocks of the same type in Base.
+//
+// This cannot possibly "do the right thing" in all cases, because we don't
+// have enough information about user intent. However, this behavior is intended
+// to be reasonable for simple overriding use-cases.
+type mergeBody struct {
+        Base     hcl.Body
+        Override hcl.Body
+}
+
+var _ hcl.Body = mergeBody{}
+
+func (b mergeBody) Content(schema *hcl.BodySchema) (*hcl.BodyContent, hcl.Diagnostics) {
+        var diags hcl.Diagnostics
+        baseSchema := schemaWithDynamic(schema)
+        overrideSchema := schemaWithDynamic(schemaForOverrides(schema))
+
+        baseContent, _, cDiags := b.Base.PartialContent(baseSchema)
+        diags = append(diags, cDiags...)
+        overrideContent, _, cDiags := b.Override.PartialContent(overrideSchema)
+        diags = append(diags, cDiags...)
+
+        content := b.prepareContent(baseContent, overrideContent)
+
+        return content, diags
+}
+
+func (b mergeBody) PartialContent(schema *hcl.BodySchema) (*hcl.BodyContent, hcl.Body, hcl.Diagnostics) {
+        var diags hcl.Diagnostics
+        baseSchema := schemaWithDynamic(schema)
+        overrideSchema := schemaWithDynamic(schemaForOverrides(schema))
+
+        baseContent, baseRemain, cDiags := b.Base.PartialContent(baseSchema)
+        diags = append(diags, cDiags...)
+        overrideContent, overrideRemain, cDiags := b.Override.PartialContent(overrideSchema)
+        diags = append(diags, cDiags...)
+
+        content := b.prepareContent(baseContent, overrideContent)
+
+        remain := MergeBodies(baseRemain, overrideRemain)
+
+        return content, remain, diags
+}
+
+func (b mergeBody) prepareContent(base *hcl.BodyContent, override *hcl.BodyContent) *hcl.BodyContent {
+        content := &hcl.BodyContent{
+                Attributes: make(hcl.Attributes),
+        }
+
+        // For attributes we just assign from each map in turn and let the override
+        // map clobber any matching entries from base.
+        for k, a := range base.Attributes {
+                content.Attributes[k] = a
+        }
+        for k, a := range override.Attributes {
+                content.Attributes[k] = a
+        }
+
+        // Things are a little more interesting for blocks because they arrive
+        // as a flat list. Our merging semantics call for us to suppress blocks
+        // from base if at least one block of the same type appears in override.
+        // We explicitly do not try to correlate and deeply merge nested blocks,
+        // since we don't have enough context here to infer user intent.
+
+        overriddenBlockTypes := make(map[string]bool)
+        for _, block := range override.Blocks {
+                if block.Type == "dynamic" {
+                        overriddenBlockTypes[block.Labels[0]] = true
+                        continue
+                }
+                overriddenBlockTypes[block.Type] = true
+        }
+        for _, block := range base.Blocks {
+                // We skip over dynamic blocks whose type label is an overridden type
+                // but note that below we do still leave them as dynamic blocks in
+                // the result because expanding the dynamic blocks that are left is
+                // done much later during the core graph walks, where we can safely
+                // evaluate the expressions.
+                if block.Type == "dynamic" && overriddenBlockTypes[block.Labels[0]] {
+                        continue
+                }
+                if overriddenBlockTypes[block.Type] {
+                        continue
+                }
+                content.Blocks = append(content.Blocks, block)
+        }
+        for _, block := range override.Blocks {
+                content.Blocks = append(content.Blocks, block)
+        }
+
+        return content
+}
+
+func (b mergeBody) JustAttributes() (hcl.Attributes, hcl.Diagnostics) {
+        var diags hcl.Diagnostics
+        ret := make(hcl.Attributes)
+
+        baseAttrs, aDiags := b.Base.JustAttributes()
+        diags = append(diags, aDiags...)
+        overrideAttrs, aDiags := b.Override.JustAttributes()
+        diags = append(diags, aDiags...)
+
+        for k, a := range baseAttrs {
+                ret[k] = a
+        }
+        for k, a := range overrideAttrs {
+                ret[k] = a
+        }
+
+        return ret, diags
+}
+
+func (b mergeBody) MissingItemRange() hcl.Range {
+        return b.Base.MissingItemRange()
+}
diff --git a/vendor/github.com/hashicorp/terraform/configs/named_values.go b/vendor/github.com/hashicorp/terraform/configs/named_values.go
new file mode 100644
index 0000000..6f6b469
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/configs/named_values.go
@@ -0,0 +1,364 @@
+package configs
+
+import (
+        "fmt"
+
+        "github.com/hashicorp/hcl2/ext/typeexpr"
+        "github.com/hashicorp/hcl2/gohcl"
+        "github.com/hashicorp/hcl2/hcl"
+        "github.com/hashicorp/hcl2/hcl/hclsyntax"
+        "github.com/zclconf/go-cty/cty"
+        "github.com/zclconf/go-cty/cty/convert"
+
+        "github.com/hashicorp/terraform/addrs"
+)
+
+// A consistent detail message for all "not a valid identifier" diagnostics.
+const badIdentifierDetail = "A name must start with a letter and may contain only letters, digits, underscores, and dashes."
+
+// Variable represents a "variable" block in a module or file.
+type Variable struct {
+        Name        string
+        Description string
+        Default     cty.Value
+        Type        cty.Type
+        ParsingMode VariableParsingMode
+
+        DescriptionSet bool
+
+        DeclRange hcl.Range
+}
+
+func decodeVariableBlock(block *hcl.Block, override bool) (*Variable, hcl.Diagnostics) {
+        v := &Variable{
+                Name:      block.Labels[0],
+                DeclRange: block.DefRange,
+        }
+
+        // Unless we're building an override, we'll set some defaults
+        // which we might override with attributes below. We leave these
+        // as zero-value in the override case so we can recognize whether
+        // or not they are set when we merge.
+        if !override {
+                v.Type = cty.DynamicPseudoType
+                v.ParsingMode = VariableParseLiteral
+        }
+
+        content, diags := block.Body.Content(variableBlockSchema)
+
+        if !hclsyntax.ValidIdentifier(v.Name) {
+                diags = append(diags, &hcl.Diagnostic{
+                        Severity: hcl.DiagError,
+                        Summary:  "Invalid variable name",
+                        Detail:   badIdentifierDetail,
+                        Subject:  &block.LabelRanges[0],
+                })
+        }
+
+        // Don't allow declaration of variables that would conflict with the
+        // reserved attribute and block type names in a "module" block, since
+        // these won't be usable for child modules.
+        for _, attr := range moduleBlockSchema.Attributes {
+                if attr.Name == v.Name {
+                        diags = append(diags, &hcl.Diagnostic{
+                                Severity: hcl.DiagError,
+                                Summary:  "Invalid variable name",
+                                Detail:   fmt.Sprintf("The variable name %q is reserved due to its special meaning inside module blocks.", attr.Name),
+                                Subject:  &block.LabelRanges[0],
+                        })
+                }
+        }
+        for _, blockS := range moduleBlockSchema.Blocks {
+                if blockS.Type == v.Name {
+                        diags = append(diags, &hcl.Diagnostic{
+                                Severity: hcl.DiagError,
+                                Summary:  "Invalid variable name",
+                                Detail:   fmt.Sprintf("The variable name %q is reserved due to its special meaning inside module blocks.", blockS.Type),
+                                Subject:  &block.LabelRanges[0],
+                        })
+                }
+        }
+
+        if attr, exists := content.Attributes["description"]; exists {
+                valDiags := gohcl.DecodeExpression(attr.Expr, nil, &v.Description)
+                diags = append(diags, valDiags...)
+                v.DescriptionSet = true
+        }
+
+        if attr, exists := content.Attributes["type"]; exists {
+                ty, parseMode, tyDiags := decodeVariableType(attr.Expr)
+                diags = append(diags, tyDiags...)
+                v.Type = ty
+                v.ParsingMode = parseMode
+        }
+
+        if attr, exists := content.Attributes["default"]; exists {
+                val, valDiags := attr.Expr.Value(nil)
+                diags = append(diags, valDiags...)
+
+                // Convert the default to the expected type so we can catch invalid
+                // defaults early and allow later code to assume validity.
+                // Note that this depends on us having already processed any "type"
+                // attribute above.
+                // However, we can't do this if we're in an override file where
+                // the type might not be set; we'll catch that during merge.
+                if v.Type != cty.NilType {
+                        var err error
+                        val, err = convert.Convert(val, v.Type)
+                        if err != nil {
+                                diags = append(diags, &hcl.Diagnostic{
+                                        Severity: hcl.DiagError,
+                                        Summary:  "Invalid default value for variable",
+                                        Detail:   fmt.Sprintf("This default value is not compatible with the variable's type constraint: %s.", err),
+                                        Subject:  attr.Expr.Range().Ptr(),
+                                })
+                                val = cty.DynamicVal
+                        }
+                }
+
+                v.Default = val
+        }
+
+        return v, diags
+}
+
+func decodeVariableType(expr hcl.Expression) (cty.Type, VariableParsingMode, hcl.Diagnostics) {
+        if exprIsNativeQuotedString(expr) {
+                // Here we're accepting the pre-0.12 form of variable type argument where
+                // the string values "string", "list" and "map" are accepted has a hint
+                // about the type used primarily for deciding how to parse values
+                // given on the command line and in environment variables.
+                // Only the native syntax ends up in this codepath; we handle the
+                // JSON syntax (which is, of course, quoted even in the new format)
+                // in the normal codepath below.
+                val, diags := expr.Value(nil)
+                if diags.HasErrors() {
+                        return cty.DynamicPseudoType, VariableParseHCL, diags
+                }
+                str := val.AsString()
+                switch str {
+                case "string":
+                        return cty.String, VariableParseLiteral, diags
+                case "list":
+                        return cty.List(cty.DynamicPseudoType), VariableParseHCL, diags
+                case "map":
+                        return cty.Map(cty.DynamicPseudoType), VariableParseHCL, diags
+                default:
+                        return cty.DynamicPseudoType, VariableParseHCL, hcl.Diagnostics{{
+                                Severity: hcl.DiagError,
+                                Summary:  "Invalid legacy variable type hint",
+                                Detail:   `The legacy variable type hint form, using a quoted string, allows only the values "string", "list", and "map". To provide a full type expression, remove the surrounding quotes and give the type expression directly.`,
+                                Subject:  expr.Range().Ptr(),
+                        }}
+                }
+        }
+
+        // First we'll deal with some shorthand forms that the HCL-level type
+        // expression parser doesn't include. These both emulate pre-0.12 behavior
+        // of allowing a list or map of any element type as long as all of the
+        // elements are consistent. This is the same as list(any) or map(any).
+        switch hcl.ExprAsKeyword(expr) {
+        case "list":
+                return cty.List(cty.DynamicPseudoType), VariableParseHCL, nil
+        case "map":
+                return cty.Map(cty.DynamicPseudoType), VariableParseHCL, nil
+        }
+
+        ty, diags := typeexpr.TypeConstraint(expr)
+        if diags.HasErrors() {
+                return cty.DynamicPseudoType, VariableParseHCL, diags
+        }
+
+        switch {
+        case ty.IsPrimitiveType():
+                // Primitive types use literal parsing.
+                return ty, VariableParseLiteral, diags
+        default:
+                // Everything else uses HCL parsing
+                return ty, VariableParseHCL, diags
+        }
+}
+
+// VariableParsingMode defines how values of a particular variable given by
+// text-only mechanisms (command line arguments and environment variables)
+// should be parsed to produce the final value.
+type VariableParsingMode rune
+
+// VariableParseLiteral is a variable parsing mode that just takes the given
+// string directly as a cty.String value.
+const VariableParseLiteral VariableParsingMode = 'L'
+
+// VariableParseHCL is a variable parsing mode that attempts to parse the given
+// string as an HCL expression and returns the result.
+const VariableParseHCL VariableParsingMode = 'H'
+
+// Parse uses the receiving parsing mode to process the given variable value
+// string, returning the result along with any diagnostics.
+//
+// A VariableParsingMode does not know the expected type of the corresponding
+// variable, so it's the caller's responsibility to attempt to convert the
+// result to the appropriate type and return to the user any diagnostics that
+// conversion may produce.
+//
+// The given name is used to create a synthetic filename in case any diagnostics
+// must be generated about the given string value. This should be the name
+// of the root module variable whose value will be populated from the given
+// string.
+//
+// If the returned diagnostics has errors, the returned value may not be
+// valid.
+func (m VariableParsingMode) Parse(name, value string) (cty.Value, hcl.Diagnostics) {
+        switch m {
+        case VariableParseLiteral:
+                return cty.StringVal(value), nil
+        case VariableParseHCL:
+                fakeFilename := fmt.Sprintf("<value for var.%s>", name)
+                expr, diags := hclsyntax.ParseExpression([]byte(value), fakeFilename, hcl.Pos{Line: 1, Column: 1})
+                if diags.HasErrors() {
+                        return cty.DynamicVal, diags
+                }
+                val, valDiags := expr.Value(nil)
+                diags = append(diags, valDiags...)
+                return val, diags
+        default:
+                // Should never happen
+                panic(fmt.Errorf("Parse called on invalid VariableParsingMode %#v", m))
+        }
+}
+
+// Output represents an "output" block in a module or file.
+type Output struct {
+        Name        string
+        Description string
+        Expr        hcl.Expression
+        DependsOn   []hcl.Traversal
+        Sensitive   bool
+
+        DescriptionSet bool
+        SensitiveSet   bool
+
+        DeclRange hcl.Range
+}
+
+func decodeOutputBlock(block *hcl.Block, override bool) (*Output, hcl.Diagnostics) {
+        o := &Output{
+                Name:      block.Labels[0],
+                DeclRange: block.DefRange,
+        }
+
+        schema := outputBlockSchema
+        if override {
+                schema = schemaForOverrides(schema)
+        }
+
+        content, diags := block.Body.Content(schema)
+
+        if !hclsyntax.ValidIdentifier(o.Name) {
+                diags = append(diags, &hcl.Diagnostic{
+                        Severity: hcl.DiagError,
+                        Summary:  "Invalid output name",
+                        Detail:   badIdentifierDetail,
+                        Subject:  &block.LabelRanges[0],
+                })
+        }
+
+        if attr, exists := content.Attributes["description"]; exists {
+                valDiags := gohcl.DecodeExpression(attr.Expr, nil, &o.Description)
+                diags = append(diags, valDiags...)
+                o.DescriptionSet = true
+        }
+
+        if attr, exists := content.Attributes["value"]; exists {
+                o.Expr = attr.Expr
+        }
+
+        if attr, exists := content.Attributes["sensitive"]; exists {
+                valDiags := gohcl.DecodeExpression(attr.Expr, nil, &o.Sensitive)
+                diags = append(diags, valDiags...)
+                o.SensitiveSet = true
+        }
+
+        if attr, exists := content.Attributes["depends_on"]; exists {
+                deps, depsDiags := decodeDependsOn(attr)
+                diags = append(diags, depsDiags...)
+                o.DependsOn = append(o.DependsOn, deps...)
+        }
+
+        return o, diags
+}
+
+// Local represents a single entry from a "locals" block in a module or file.
+// The "locals" block itself is not represented, because it serves only to
+// provide context for us to interpret its contents.
+type Local struct {
+        Name string
+        Expr hcl.Expression
+
+        DeclRange hcl.Range
+}
+
+func decodeLocalsBlock(block *hcl.Block) ([]*Local, hcl.Diagnostics) {
+        attrs, diags := block.Body.JustAttributes()
+        if len(attrs) == 0 {
+                return nil, diags
+        }
+
+        locals := make([]*Local, 0, len(attrs))
+        for name, attr := range attrs {
+                if !hclsyntax.ValidIdentifier(name) {
+                        diags = append(diags, &hcl.Diagnostic{
+                                Severity: hcl.DiagError,
+                                Summary:  "Invalid local value name",
+                                Detail:   badIdentifierDetail,
+                                Subject:  &attr.NameRange,
+                        })
+                }
+
+                locals = append(locals, &Local{
+                        Name:      name,
+                        Expr:      attr.Expr,
+                        DeclRange: attr.Range,
+                })
+        }
+        return locals, diags
+}
+
+// Addr returns the address of the local value declared by the receiver,
+// relative to its containing module.
+func (l *Local) Addr() addrs.LocalValue {
+        return addrs.LocalValue{
+                Name: l.Name,
+        }
+}
+
+var variableBlockSchema = &hcl.BodySchema{
+        Attributes: []hcl.AttributeSchema{
+                {
+                        Name: "description",
+                },
+                {
+                        Name: "default",
+                },
+                {
+                        Name: "type",
+                },
+        },
+}
+
+var outputBlockSchema = &hcl.BodySchema{
+        Attributes: []hcl.AttributeSchema{
+                {
+                        Name: "description",
+                },
+                {
+                        Name:     "value",
+                        Required: true,
+                },
+                {
+                        Name: "depends_on",
+                },
+                {
+                        Name: "sensitive",
+                },
+        },
+}
diff --git a/vendor/github.com/hashicorp/terraform/configs/parser.go b/vendor/github.com/hashicorp/terraform/configs/parser.go
new file mode 100644
index 0000000..8176fa1
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/configs/parser.go
@@ -0,0 +1,100 @@
+package configs
+
+import (
+        "fmt"
+        "strings"
+
+        "github.com/hashicorp/hcl2/hcl"
+        "github.com/hashicorp/hcl2/hclparse"
+        "github.com/spf13/afero"
+)
+
+// Parser is the main interface to read configuration files and other related
+// files from disk.
+//
+// It retains a cache of all files that are loaded so that they can be used
+// to create source code snippets in diagnostics, etc.
+type Parser struct {
+        fs afero.Afero
+        p  *hclparse.Parser
+}
+
+// NewParser creates and returns a new Parser that reads files from the given
+// filesystem. If a nil filesystem is passed then the system's "real" filesystem
+// will be used, via afero.OsFs.
+func NewParser(fs afero.Fs) *Parser {
+        if fs == nil {
+                fs = afero.OsFs{}
+        }
+
+        return &Parser{
+                fs: afero.Afero{Fs: fs},
+                p:  hclparse.NewParser(),
+        }
+}
+
+// LoadHCLFile is a low-level method that reads the file at the given path,
+// parses it, and returns the hcl.Body representing its root. In many cases
+// it is better to use one of the other Load*File methods on this type,
+// which additionally decode the root body in some way and return a higher-level
+// construct.
+//
+// If the file cannot be read at all -- e.g. because it does not exist -- then
+// this method will return a nil body and error diagnostics. In this case
+// callers may wish to ignore the provided error diagnostics and produce
+// a more context-sensitive error instead.
+//
+// The file will be parsed using the HCL native syntax unless the filename
+// ends with ".json", in which case the HCL JSON syntax will be used.
+func (p *Parser) LoadHCLFile(path string) (hcl.Body, hcl.Diagnostics) {
+        src, err := p.fs.ReadFile(path)
+
+        if err != nil {
+                return nil, hcl.Diagnostics{
+                        {
+                                Severity: hcl.DiagError,
+                                Summary:  "Failed to read file",
+                                Detail:   fmt.Sprintf("The file %q could not be read.", path),
+                        },
+                }
+        }
+
+        var file *hcl.File
+        var diags hcl.Diagnostics
+        switch {
+        case strings.HasSuffix(path, ".json"):
+                file, diags = p.p.ParseJSON(src, path)
+        default:
+                file, diags = p.p.ParseHCL(src, path)
+        }
+
+        // If the returned file or body is nil, then we'll return a non-nil empty
+        // body so we'll meet our contract that nil means an error reading the file.
+        if file == nil || file.Body == nil {
+                return hcl.EmptyBody(), diags
+        }
+
+        return file.Body, diags
+}
+
+// Sources returns a map of the cached source buffers for all files that
+// have been loaded through this parser, with source filenames (as requested
+// when each file was opened) as the keys.
+func (p *Parser) Sources() map[string][]byte {
+        return p.p.Sources()
+}
+
+// ForceFileSource artificially adds source code to the cache of file sources,
+// as if it had been loaded from the given filename.
+//
+// This should be used only in special situations where configuration is loaded
+// some other way. Most callers should load configuration via methods of
+// Parser, which will update the sources cache automatically.
+func (p *Parser) ForceFileSource(filename string, src []byte) {
+        // We'll make a synthetic hcl.File here just so we can reuse the
+        // existing cache.
+        p.p.AddFile(filename, &hcl.File{
+                Body:  hcl.EmptyBody(),
+                Bytes: src,
+        })
+}
diff --git a/vendor/github.com/hashicorp/terraform/configs/parser_config.go b/vendor/github.com/hashicorp/terraform/configs/parser_config.go
new file mode 100644
index 0000000..7f2ff27
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/configs/parser_config.go
@@ -0,0 +1,247 @@
+package configs
+
+import (
+        "github.com/hashicorp/hcl2/hcl"
+)
+
+// LoadConfigFile reads the file at the given path and parses it as a config
+// file.
+//
+// If the file cannot be read -- for example, if it does not exist -- then
+// a nil *File will be returned along with error diagnostics. Callers may wish
+// to disregard the returned diagnostics in this case and instead generate
+// their own error message(s) with additional context.
+//
+// If the returned diagnostics has errors when a non-nil map is returned
+// then the map may be incomplete but should be valid enough for careful
+// static analysis.
+//
+// This method wraps LoadHCLFile, and so it inherits the syntax selection
+// behaviors documented for that method.
+func (p *Parser) LoadConfigFile(path string) (*File, hcl.Diagnostics) {
+        return p.loadConfigFile(path, false)
+}
+
+// LoadConfigFileOverride is the same as LoadConfigFile except that it relaxes
+// certain required attribute constraints in order to interpret the given
+// file as an overrides file.
+func (p *Parser) LoadConfigFileOverride(path string) (*File, hcl.Diagnostics) {
+        return p.loadConfigFile(path, true)
+}
+
+func (p *Parser) loadConfigFile(path string, override bool) (*File, hcl.Diagnostics) {
+
+        body, diags := p.LoadHCLFile(path)
+        if body == nil {
+                return nil, diags
+        }
+
+        file := &File{}
+
+        var reqDiags hcl.Diagnostics
+        file.CoreVersionConstraints, reqDiags = sniffCoreVersionRequirements(body)
+        diags = append(diags, reqDiags...)
+
+        content, contentDiags := body.Content(configFileSchema)
+        diags = append(diags, contentDiags...)
+
+        for _, block := range content.Blocks {
+                switch block.Type {
+
+                case "terraform":
+                        content, contentDiags := block.Body.Content(terraformBlockSchema)
+                        diags = append(diags, contentDiags...)
+
+                        // We ignore the "terraform_version" attribute here because
+                        // sniffCoreVersionRequirements already dealt with that above.
+
+                        for _, innerBlock := range content.Blocks {
+                                switch innerBlock.Type {
+
+                                case "backend":
+                                        backendCfg, cfgDiags := decodeBackendBlock(innerBlock)
+                                        diags = append(diags, cfgDiags...)
+                                        if backendCfg != nil {
+                                                file.Backends = append(file.Backends, backendCfg)
+                                        }
+
+                                case "required_providers":
+                                        reqs, reqsDiags := decodeRequiredProvidersBlock(innerBlock)
+                                        diags = append(diags, reqsDiags...)
+                                        file.ProviderRequirements = append(file.ProviderRequirements, reqs...)
+
+                                default:
+                                        // Should never happen because the above cases should be exhaustive
+                                        // for all block type names in our schema.
+                                        continue
+
+                                }
+                        }
+
+                case "provider":
+                        cfg, cfgDiags := decodeProviderBlock(block)
+                        diags = append(diags, cfgDiags...)
+                        if cfg != nil {
+                                file.ProviderConfigs = append(file.ProviderConfigs, cfg)
+                        }
+
+                case "variable":
+                        cfg, cfgDiags := decodeVariableBlock(block, override)
+                        diags = append(diags, cfgDiags...)
+                        if cfg != nil {
+                                file.Variables = append(file.Variables, cfg)
+                        }
+
+                case "locals":
+                        defs, defsDiags := decodeLocalsBlock(block)
+                        diags = append(diags, defsDiags...)
+                        file.Locals = append(file.Locals, defs...)
+
+                case "output":
+                        cfg, cfgDiags := decodeOutputBlock(block, override)
+                        diags = append(diags, cfgDiags...)
+                        if cfg != nil {
+                                file.Outputs = append(file.Outputs, cfg)
+                        }
+
+                case "module":
+                        cfg, cfgDiags := decodeModuleBlock(block, override)
+                        diags = append(diags, cfgDiags...)
+                        if cfg != nil {
+                                file.ModuleCalls = append(file.ModuleCalls, cfg)
+                        }
+
+                case "resource":
+                        cfg, cfgDiags := decodeResourceBlock(block)
+                        diags = append(diags, cfgDiags...)
+                        if cfg != nil {
+                                file.ManagedResources = append(file.ManagedResources, cfg)
+                        }
+
+                case "data":
+                        cfg, cfgDiags := decodeDataBlock(block)
+                        diags = append(diags, cfgDiags...)
+                        if cfg != nil {
+                                file.DataResources = append(file.DataResources, cfg)
+                        }
+
+                default:
+                        // Should never happen because the above cases should be exhaustive
+                        // for all block type names in our schema.
+                        continue
+
+                }
+        }
+
+        return file, diags
+}
+
+// sniffCoreVersionRequirements does minimal parsing of the given body for
+// "terraform" blocks with "required_version" attributes, returning the
+// requirements found.
+//
+// This is intended to maximize the chance that we'll be able to read the
+// requirements (syntax errors notwithstanding) even if the config file contains
+// constructs that might've been added in future Terraform versions
+//
+// This is a "best effort" sort of method which will return constraints it is
+// able to find, but may return no constraints at all if the given body is
+// so invalid that it cannot be decoded at all.
+func sniffCoreVersionRequirements(body hcl.Body) ([]VersionConstraint, hcl.Diagnostics) {
+        rootContent, _, diags := body.PartialContent(configFileVersionSniffRootSchema)
+
+        var constraints []VersionConstraint
+
+        for _, block := range rootContent.Blocks {
+                content, _, blockDiags := block.Body.PartialContent(configFileVersionSniffBlockSchema)
+                diags = append(diags, blockDiags...)
+
+                attr, exists := content.Attributes["required_version"]
+                if !exists {
+                        continue
+                }
+
+                constraint, constraintDiags := decodeVersionConstraint(attr)
+                diags = append(diags, constraintDiags...)
+                if !constraintDiags.HasErrors() {
+                        constraints = append(constraints, constraint)
+                }
+        }
+
+        return constraints, diags
+}
+
+// configFileSchema is the schema for the top-level of a config file. We use
+// the low-level HCL API for this level so we can easily deal with each
+// block type separately with its own decoding logic.
+var configFileSchema = &hcl.BodySchema{
+        Blocks: []hcl.BlockHeaderSchema{
+                {
+                        Type: "terraform",
+                },
+                {
+                        Type:       "provider",
+                        LabelNames: []string{"name"},
+                },
+                {
+                        Type:       "variable",
+                        LabelNames: []string{"name"},
+                },
+                {
+                        Type: "locals",
+                },
+                {
+                        Type:       "output",
+                        LabelNames: []string{"name"},
+                },
+                {
+                        Type:       "module",
+                        LabelNames: []string{"name"},
+                },
+                {
+                        Type:       "resource",
+                        LabelNames: []string{"type", "name"},
+                },
+                {
+                        Type:       "data",
+                        LabelNames: []string{"type", "name"},
+                },
+        },
+}
+
+// terraformBlockSchema is the schema for a top-level "terraform" block in
+// a configuration file.
+var terraformBlockSchema = &hcl.BodySchema{
+        Attributes: []hcl.AttributeSchema{
+                {
+                        Name: "required_version",
+                },
+        },
+        Blocks: []hcl.BlockHeaderSchema{
+                {
+                        Type:       "backend",
+                        LabelNames: []string{"type"},
+                },
+                {
+                        Type: "required_providers",
+                },
+        },
+}
+
+// configFileVersionSniffRootSchema is a schema for sniffCoreVersionRequirements
+var configFileVersionSniffRootSchema = &hcl.BodySchema{
+        Blocks: []hcl.BlockHeaderSchema{
+                {
+                        Type: "terraform",
+                },
+        },
+}
+
+// configFileVersionSniffBlockSchema is a schema for sniffCoreVersionRequirements
+var configFileVersionSniffBlockSchema = &hcl.BodySchema{
+        Attributes: []hcl.AttributeSchema{
+                {
+                        Name: "required_version",
+                },
+        },
+}
diff --git a/vendor/github.com/hashicorp/terraform/configs/parser_config_dir.go b/vendor/github.com/hashicorp/terraform/configs/parser_config_dir.go
new file mode 100644
index 0000000..3014cb4
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/configs/parser_config_dir.go
@@ -0,0 +1,142 @@
+package configs
+
+import (
+        "fmt"
+        "path/filepath"
+        "strings"
+
+        "github.com/hashicorp/hcl2/hcl"
+)
+
+// LoadConfigDir reads the .tf and .tf.json files in the given directory
+// as config files (using LoadConfigFile) and then combines these files into
+// a single Module.
+//
+// If this method returns nil, that indicates that the given directory does not
+// exist at all or could not be opened for some reason. Callers may wish to
+// detect this case and ignore the returned diagnostics so that they can
+// produce a more context-aware error message in that case.
+//
+// If this method returns a non-nil module while error diagnostics are returned
+// then the module may be incomplete but can be used carefully for static
+// analysis.
+//
+// This file does not consider a directory with no files to be an error, and
+// will simply return an empty module in that case. Callers should first call
+// Parser.IsConfigDir if they wish to recognize that situation.
+//
+// .tf files are parsed using the HCL native syntax while .tf.json files are
+// parsed using the HCL JSON syntax.
+func (p *Parser) LoadConfigDir(path string) (*Module, hcl.Diagnostics) {
+        primaryPaths, overridePaths, diags := p.dirFiles(path)
+        if diags.HasErrors() {
+                return nil, diags
+        }
+
+        primary, fDiags := p.loadFiles(primaryPaths, false)
+        diags = append(diags, fDiags...)
+        override, fDiags := p.loadFiles(overridePaths, true)
+        diags = append(diags, fDiags...)
+
+        mod, modDiags := NewModule(primary, override)
+        diags = append(diags, modDiags...)
+
+        mod.SourceDir = path
+
+        return mod, diags
+}
+
+// ConfigDirFiles returns lists of the primary and override files configuration
+// files in the given directory.
+//
+// If the given directory does not exist or cannot be read, error diagnostics
+// are returned. If errors are returned, the resulting lists may be incomplete.
+func (p Parser) ConfigDirFiles(dir string) (primary, override []string, diags hcl.Diagnostics) {
+        return p.dirFiles(dir)
+}
+
+// IsConfigDir determines whether the given path refers to a directory that
+// exists and contains at least one Terraform config file (with a .tf or
+// .tf.json extension.)
+func (p *Parser) IsConfigDir(path string) bool {
+        primaryPaths, overridePaths, _ := p.dirFiles(path)
+        return (len(primaryPaths) + len(overridePaths)) > 0
+}
+
+func (p *Parser) loadFiles(paths []string, override bool) ([]*File, hcl.Diagnostics) {
+        var files []*File
+        var diags hcl.Diagnostics
+
+        for _, path := range paths {
+                var f *File
+                var fDiags hcl.Diagnostics
+                if override {
+                        f, fDiags = p.LoadConfigFileOverride(path)
+                } else {
+                        f, fDiags = p.LoadConfigFile(path)
+                }
+                diags = append(diags, fDiags...)
+                if f != nil {
+                        files = append(files, f)
+                }
+        }
+
+        return files, diags
+}
+
+func (p *Parser) dirFiles(dir string) (primary, override []string, diags hcl.Diagnostics) {
+        infos, err := p.fs.ReadDir(dir)
+        if err != nil {
+                diags = append(diags, &hcl.Diagnostic{
+                        Severity: hcl.DiagError,
+                        Summary:  "Failed to read module directory",
+                        Detail:   fmt.Sprintf("Module directory %s does not exist or cannot be read.", dir),
+                })
+                return
+        }
+
+        for _, info := range infos {
+                if info.IsDir() {
+                        // We only care about files
+                        continue
+                }
+
+                name := info.Name()
+                ext := fileExt(name)
+                if ext == "" || IsIgnoredFile(name) {
+                        continue
+                }
+
+                baseName := name[:len(name)-len(ext)] // strip extension
+                isOverride := baseName == "override" || strings.HasSuffix(baseName, "_override")
+
+                fullPath := filepath.Join(dir, name)
+                if isOverride {
+                        override = append(override, fullPath)
+                } else {
+                        primary = append(primary, fullPath)
+                }
+        }
+
+        return
+}
+
+// fileExt returns the Terraform configuration extension of the given
+// path, or a blank string if it is not a recognized extension.
+func fileExt(path string) string {
+        if strings.HasSuffix(path, ".tf") {
+                return ".tf"
+        } else if strings.HasSuffix(path, ".tf.json") {
+                return ".tf.json"
+        } else {
+                return ""
+        }
+}
+
+// IsIgnoredFile returns true if the given filename (which must not have a
+// directory path ahead of it) should be ignored as e.g. an editor swap file.
+func IsIgnoredFile(name string) bool {
+        return strings.HasPrefix(name, ".") || // Unix-like hidden files
+                strings.HasSuffix(name, "~") || // vim
+                strings.HasPrefix(name, "#") && strings.HasSuffix(name, "#") // emacs
+}
diff --git a/vendor/github.com/hashicorp/terraform/configs/parser_values.go b/vendor/github.com/hashicorp/terraform/configs/parser_values.go
new file mode 100644
index 0000000..b7f1c1c
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/configs/parser_values.go
@@ -0,0 +1,43 @@
+package configs
+
+import (
+        "github.com/hashicorp/hcl2/hcl"
+        "github.com/zclconf/go-cty/cty"
+)
+
+// LoadValuesFile reads the file at the given path and parses it as a "values
+// file", which is an HCL config file whose top-level attributes are treated
+// as arbitrary key.value pairs.
+//
+// If the file cannot be read -- for example, if it does not exist -- then
+// a nil map will be returned along with error diagnostics. Callers may wish
+// to disregard the returned diagnostics in this case and instead generate
+// their own error message(s) with additional context.
+//
+// If the returned diagnostics has errors when a non-nil map is returned
+// then the map may be incomplete but should be valid enough for careful
+// static analysis.
+//
+// This method wraps LoadHCLFile, and so it inherits the syntax selection
+// behaviors documented for that method.
+func (p *Parser) LoadValuesFile(path string) (map[string]cty.Value, hcl.Diagnostics) {
+        body, diags := p.LoadHCLFile(path)
+        if body == nil {
+                return nil, diags
+        }
+
+        vals := make(map[string]cty.Value)
+        attrs, attrDiags := body.JustAttributes()
+        diags = append(diags, attrDiags...)
+        if attrs == nil {
+                return vals, diags
+        }
+
+        for name, attr := range attrs {
+                val, valDiags := attr.Expr.Value(nil)
+                diags = append(diags, valDiags...)
+                vals[name] = val
+        }
+
+        return vals, diags
+}
diff --git a/vendor/github.com/hashicorp/terraform/configs/provider.go b/vendor/github.com/hashicorp/terraform/configs/provider.go
new file mode 100644
index 0000000..d01d5cf
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/configs/provider.go
@@ -0,0 +1,144 @@
+package configs
+
+import (
+        "fmt"
+
+        "github.com/hashicorp/hcl2/gohcl"
+        "github.com/hashicorp/hcl2/hcl"
+        "github.com/hashicorp/hcl2/hcl/hclsyntax"
+
+        "github.com/hashicorp/terraform/addrs"
+)
+
+// Provider represents a "provider" block in a module or file. A provider
+// block is a provider configuration, and there can be zero or more
+// configurations for each actual provider.
+type Provider struct {
+        Name       string
+        NameRange  hcl.Range
+        Alias      string
+        AliasRange *hcl.Range // nil if no alias set
+
+        Version VersionConstraint
+
+        Config hcl.Body
+
+        DeclRange hcl.Range
+}
+
+func decodeProviderBlock(block *hcl.Block) (*Provider, hcl.Diagnostics) {
+        content, config, diags := block.Body.PartialContent(providerBlockSchema)
+
+        provider := &Provider{
+                Name:      block.Labels[0],
+                NameRange: block.LabelRanges[0],
+                Config:    config,
+                DeclRange: block.DefRange,
+        }
+
+        if attr, exists := content.Attributes["alias"]; exists {
+                valDiags := gohcl.DecodeExpression(attr.Expr, nil, &provider.Alias)
+                diags = append(diags, valDiags...)
+                provider.AliasRange = attr.Expr.Range().Ptr()
+
+                if !hclsyntax.ValidIdentifier(provider.Alias) {
+                        diags = append(diags, &hcl.Diagnostic{
+                                Severity: hcl.DiagError,
+                                Summary:  "Invalid provider configuration alias",
+                                Detail:   fmt.Sprintf("An alias must be a valid name. %s", badIdentifierDetail),
+                        })
+                }
+        }
+
+        if attr, exists := content.Attributes["version"]; exists {
+                var versionDiags hcl.Diagnostics
+                provider.Version, versionDiags = decodeVersionConstraint(attr)
+                diags = append(diags, versionDiags...)
+        }
+
+        // Reserved attribute names
+        for _, name := range []string{"count", "depends_on", "for_each", "source"} {
+                if attr, exists := content.Attributes[name]; exists {
+                        diags = append(diags, &hcl.Diagnostic{
+                                Severity: hcl.DiagError,
+                                Summary:  "Reserved argument name in provider block",
+                                Detail:   fmt.Sprintf("The provider argument name %q is reserved for use by Terraform in a future version.", name),
+                                Subject:  &attr.NameRange,
+                        })
+                }
+        }
+
+        // Reserved block types (all of them)
+        for _, block := range content.Blocks {
+                diags = append(diags, &hcl.Diagnostic{
+                        Severity: hcl.DiagError,
+                        Summary:  "Reserved block type name in provider block",
+                        Detail:   fmt.Sprintf("The block type name %q is reserved for use by Terraform in a future version.", block.Type),
+                        Subject:  &block.TypeRange,
+                })
+        }
+
+        return provider, diags
+}
+
+// Addr returns the address of the receiving provider configuration, relative
+// to its containing module.
+func (p *Provider) Addr() addrs.ProviderConfig {
+        return addrs.ProviderConfig{
+                Type:  p.Name,
+                Alias: p.Alias,
+        }
+}
+
+func (p *Provider) moduleUniqueKey() string {
+        if p.Alias != "" {
+                return fmt.Sprintf("%s.%s", p.Name, p.Alias)
+        }
+        return p.Name
+}
+
+// ProviderRequirement represents a declaration of a dependency on a particular
+// provider version without actually configuring that provider. This is used in
+// child modules that expect a provider to be passed in from their parent.
+type ProviderRequirement struct {
+        Name        string
+        Requirement VersionConstraint
+}
+
+func decodeRequiredProvidersBlock(block *hcl.Block) ([]*ProviderRequirement, hcl.Diagnostics) {
+        attrs, diags := block.Body.JustAttributes()
+        var reqs []*ProviderRequirement
+        for name, attr := range attrs {
+                req, reqDiags := decodeVersionConstraint(attr)
+                diags = append(diags, reqDiags...)
+                if !diags.HasErrors() {
+                        reqs = append(reqs, &ProviderRequirement{
+                                Name:        name,
+                                Requirement: req,
+                        })
+                }
+        }
+        return reqs, diags
+}
+
+var providerBlockSchema = &hcl.BodySchema{
+        Attributes: []hcl.AttributeSchema{
+                {
+                        Name: "alias",
+                },
+                {
+                        Name: "version",
+                },
+
+                // Attribute names reserved for future expansion.
+                {Name: "count"},
+                {Name: "depends_on"},
+                {Name: "for_each"},
+                {Name: "source"},
+        },
+        Blocks: []hcl.BlockHeaderSchema{
+                // _All_ of these are reserved for future expansion.
+                {Type: "lifecycle"},
+                {Type: "locals"},
+        },
+}
diff --git a/vendor/github.com/hashicorp/terraform/configs/provisioner.go b/vendor/github.com/hashicorp/terraform/configs/provisioner.go
new file mode 100644
index 0000000..b031dd0
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/configs/provisioner.go
@@ -0,0 +1,150 @@
+package configs
+
+import (
+        "fmt"
+
+        "github.com/hashicorp/hcl2/hcl"
+)
+
+// Provisioner represents a "provisioner" block when used within a
+// "resource" block in a module or file.
+type Provisioner struct {
+        Type       string
+        Config     hcl.Body
+        Connection *Connection
+        When       ProvisionerWhen
+        OnFailure  ProvisionerOnFailure
+
+        DeclRange hcl.Range
+        TypeRange hcl.Range
+}
+
+func decodeProvisionerBlock(block *hcl.Block) (*Provisioner, hcl.Diagnostics) {
+        pv := &Provisioner{
+                Type:      block.Labels[0],
+                TypeRange: block.LabelRanges[0],
+                DeclRange: block.DefRange,
+                When:      ProvisionerWhenCreate,
+                OnFailure: ProvisionerOnFailureFail,
+        }
+
+        content, config, diags := block.Body.PartialContent(provisionerBlockSchema)
+        pv.Config = config
+
+        if attr, exists := content.Attributes["when"]; exists {
+                expr, shimDiags := shimTraversalInString(attr.Expr, true)
+                diags = append(diags, shimDiags...)
+
+                switch hcl.ExprAsKeyword(expr) {
+                case "create":
+                        pv.When = ProvisionerWhenCreate
+                case "destroy":
+                        pv.When = ProvisionerWhenDestroy
+                default:
+                        diags = append(diags, &hcl.Diagnostic{
+                                Severity: hcl.DiagError,
+                                Summary:  "Invalid \"when\" keyword",
+                                Detail:   "The \"when\" argument requires one of the following keywords: create or destroy.",
+                                Subject:  expr.Range().Ptr(),
+                        })
+                }
+        }
+
+        if attr, exists := content.Attributes["on_failure"]; exists {
+                expr, shimDiags := shimTraversalInString(attr.Expr, true)
+                diags = append(diags, shimDiags...)
+
+                switch hcl.ExprAsKeyword(expr) {
+                case "continue":
+                        pv.OnFailure = ProvisionerOnFailureContinue
+                case "fail":
+                        pv.OnFailure = ProvisionerOnFailureFail
+                default:
+                        diags = append(diags, &hcl.Diagnostic{
+                                Severity: hcl.DiagError,
+                                Summary:  "Invalid \"on_failure\" keyword",
+                                Detail:   "The \"on_failure\" argument requires one of the following keywords: continue or fail.",
+                                Subject:  attr.Expr.Range().Ptr(),
+                        })
+                }
+        }
+
+        var seenConnection *hcl.Block
+        for _, block := range content.Blocks {
+                switch block.Type {
+
+                case "connection":
+                        if seenConnection != nil {
+                                diags = append(diags, &hcl.Diagnostic{
+                                        Severity: hcl.DiagError,
+                                        Summary:  "Duplicate connection block",
+                                        Detail:   fmt.Sprintf("This provisioner already has a connection block at %s.", seenConnection.DefRange),
+                                        Subject:  &block.DefRange,
+                                })
+                                continue
+                        }
+                        seenConnection = block
+
+                        //conn, connDiags := decodeConnectionBlock(block)
+                        //diags = append(diags, connDiags...)
+                        pv.Connection = &Connection{
+                                Config:    block.Body,
+                                DeclRange: block.DefRange,
+                        }
+
+                default:
+                        // Any other block types are ones we've reserved for future use,
+                        // so they get a generic message.
+                        diags = append(diags, &hcl.Diagnostic{
+                                Severity: hcl.DiagError,
+                                Summary:  "Reserved block type name in provisioner block",
+                                Detail:   fmt.Sprintf("The block type name %q is reserved for use by Terraform in a future version.", block.Type),
+                                Subject:  &block.TypeRange,
+                        })
+                }
+        }
+
+        return pv, diags
+}
+
+// Connection represents a "connection" block when used within either a
+// "resource" or "provisioner" block in a module or file.
+type Connection struct {
+        Config hcl.Body
+
+        DeclRange hcl.Range
+}
+
+// ProvisionerWhen is an enum for valid values for when to run provisioners.
+type ProvisionerWhen int
+
+//go:generate stringer -type ProvisionerWhen
+
+const (
+        ProvisionerWhenInvalid ProvisionerWhen = iota
+        ProvisionerWhenCreate
+        ProvisionerWhenDestroy
+)
+
+// ProvisionerOnFailure is an enum for valid values for on_failure options
+// for provisioners.
+type ProvisionerOnFailure int
+
+//go:generate stringer -type ProvisionerOnFailure
+
+const (
+        ProvisionerOnFailureInvalid ProvisionerOnFailure = iota
+        ProvisionerOnFailureContinue
+        ProvisionerOnFailureFail
+)
+
+var provisionerBlockSchema = &hcl.BodySchema{
+        Attributes: []hcl.AttributeSchema{
+                {Name: "when"},
+                {Name: "on_failure"},
+        },
+        Blocks: []hcl.BlockHeaderSchema{
+                {Type: "connection"},
+                {Type: "lifecycle"}, // reserved for future use
+        },
+}
diff --git a/vendor/github.com/hashicorp/terraform/configs/provisioneronfailure_string.go b/vendor/github.com/hashicorp/terraform/configs/provisioneronfailure_string.go
new file mode 100644
index 0000000..7ff5a6e
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/configs/provisioneronfailure_string.go
@@ -0,0 +1,25 @@
+// Code generated by "stringer -type ProvisionerOnFailure"; DO NOT EDIT.
+
+package configs
+
+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[ProvisionerOnFailureInvalid-0]
+        _ = x[ProvisionerOnFailureContinue-1]
+        _ = x[ProvisionerOnFailureFail-2]
+}
+
+const _ProvisionerOnFailure_name = "ProvisionerOnFailureInvalidProvisionerOnFailureContinueProvisionerOnFailureFail"
+
+var _ProvisionerOnFailure_index = [...]uint8{0, 27, 55, 79}
+
+func (i ProvisionerOnFailure) String() string {
+        if i < 0 || i >= ProvisionerOnFailure(len(_ProvisionerOnFailure_index)-1) {
+                return "ProvisionerOnFailure(" + strconv.FormatInt(int64(i), 10) + ")"
+        }
+        return _ProvisionerOnFailure_name[_ProvisionerOnFailure_index[i]:_ProvisionerOnFailure_index[i+1]]
+}
diff --git a/vendor/github.com/hashicorp/terraform/configs/provisionerwhen_string.go b/vendor/github.com/hashicorp/terraform/configs/provisionerwhen_string.go
new file mode 100644
index 0000000..9f21b3a
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/configs/provisionerwhen_string.go
@@ -0,0 +1,25 @@
+// Code generated by "stringer -type ProvisionerWhen"; DO NOT EDIT.
+
+package configs
+
+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[ProvisionerWhenInvalid-0]
+        _ = x[ProvisionerWhenCreate-1]
+        _ = x[ProvisionerWhenDestroy-2]
+}
+
+const _ProvisionerWhen_name = "ProvisionerWhenInvalidProvisionerWhenCreateProvisionerWhenDestroy"
+
+var _ProvisionerWhen_index = [...]uint8{0, 22, 43, 65}
+
+func (i ProvisionerWhen) String() string {
+        if i < 0 || i >= ProvisionerWhen(len(_ProvisionerWhen_index)-1) {
+                return "ProvisionerWhen(" + strconv.FormatInt(int64(i), 10) + ")"
+        }
+        return _ProvisionerWhen_name[_ProvisionerWhen_index[i]:_ProvisionerWhen_index[i+1]]
+}
diff --git a/vendor/github.com/hashicorp/terraform/configs/resource.go b/vendor/github.com/hashicorp/terraform/configs/resource.go
new file mode 100644
index 0000000..de1a343
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/configs/resource.go
@@ -0,0 +1,486 @@
+package configs
+
+import (
+        "fmt"
+
+        "github.com/hashicorp/hcl2/gohcl"
+        "github.com/hashicorp/hcl2/hcl"
+        "github.com/hashicorp/hcl2/hcl/hclsyntax"
+
+        "github.com/hashicorp/terraform/addrs"
+)
+
+// Resource represents a "resource" or "data" block in a module or file.
+type Resource struct {
+        Mode    addrs.ResourceMode
+        Name    string
+        Type    string
+        Config  hcl.Body
+        Count   hcl.Expression
+        ForEach hcl.Expression
+
+        ProviderConfigRef *ProviderConfigRef
+
+        DependsOn []hcl.Traversal
+
+        // Managed is populated only for Mode = addrs.ManagedResourceMode,
+        // containing the additional fields that apply to managed resources.
+        // For all other resource modes, this field is nil.
+        Managed *ManagedResource
+
+        DeclRange hcl.Range
+        TypeRange hcl.Range
+}
+
+// ManagedResource represents a "resource" block in a module or file.
+type ManagedResource struct {
+        Connection   *Connection
+        Provisioners []*Provisioner
+
+        CreateBeforeDestroy bool
+        PreventDestroy      bool
+        IgnoreChanges       []hcl.Traversal
+        IgnoreAllChanges    bool
+
+        CreateBeforeDestroySet bool
+        PreventDestroySet      bool
+}
+
+func (r *Resource) moduleUniqueKey() string {
+        return r.Addr().String()
+}
+
+// Addr returns a resource address for the receiver that is relative to the
+// resource's containing module.
+func (r *Resource) Addr() addrs.Resource {
+        return addrs.Resource{
+                Mode: r.Mode,
+                Type: r.Type,
+                Name: r.Name,
+        }
+}
+
+// ProviderConfigAddr returns the address for the provider configuration
+// that should be used for this resource. This function implements the
+// default behavior of extracting the type from the resource type name if
+// an explicit "provider" argument was not provided.
+func (r *Resource) ProviderConfigAddr() addrs.ProviderConfig {
+        if r.ProviderConfigRef == nil {
+                return r.Addr().DefaultProviderConfig()
+        }
+
+        return addrs.ProviderConfig{
+                Type:  r.ProviderConfigRef.Name,
+                Alias: r.ProviderConfigRef.Alias,
+        }
+}
+
+func decodeResourceBlock(block *hcl.Block) (*Resource, hcl.Diagnostics) {
+        r := &Resource{
+                Mode:      addrs.ManagedResourceMode,
+                Type:      block.Labels[0],
+                Name:      block.Labels[1],
+                DeclRange: block.DefRange,
+                TypeRange: block.LabelRanges[0],
+                Managed:   &ManagedResource{},
+        }
+
+        content, remain, diags := block.Body.PartialContent(resourceBlockSchema)
+        r.Config = remain
+
+        if !hclsyntax.ValidIdentifier(r.Type) {
+                diags = append(diags, &hcl.Diagnostic{
+                        Severity: hcl.DiagError,
+                        Summary:  "Invalid resource type name",
+                        Detail:   badIdentifierDetail,
+                        Subject:  &block.LabelRanges[0],
+                })
+        }
+        if !hclsyntax.ValidIdentifier(r.Name) {
+                diags = append(diags, &hcl.Diagnostic{
+                        Severity: hcl.DiagError,
+                        Summary:  "Invalid resource name",
+                        Detail:   badIdentifierDetail,
+                        Subject:  &block.LabelRanges[1],
+                })
+        }
+
+        if attr, exists := content.Attributes["count"]; exists {
+                r.Count = attr.Expr
+        }
+
+        if attr, exists := content.Attributes["for_each"]; exists {
+                r.ForEach = attr.Expr
+                // We currently parse this, but don't yet do anything with it.
+                diags = append(diags, &hcl.Diagnostic{
+                        Severity: hcl.DiagError,
+                        Summary:  "Reserved argument name in resource block",
+                        Detail:   fmt.Sprintf("The name %q is reserved for use in a future version of Terraform.", attr.Name),
+                        Subject:  &attr.NameRange,
+                })
+        }
+
+        if attr, exists := content.Attributes["provider"]; exists {
+                var providerDiags hcl.Diagnostics
+                r.ProviderConfigRef, providerDiags = decodeProviderConfigRef(attr.Expr, "provider")
+                diags = append(diags, providerDiags...)
+        }
+
+        if attr, exists := content.Attributes["depends_on"]; exists {
+                deps, depsDiags := decodeDependsOn(attr)
+                diags = append(diags, depsDiags...)
+                r.DependsOn = append(r.DependsOn, deps...)
+        }
+
+        var seenLifecycle *hcl.Block
+        var seenConnection *hcl.Block
+        for _, block := range content.Blocks {
+                switch block.Type {
+                case "lifecycle":
+                        if seenLifecycle != nil {
+                                diags = append(diags, &hcl.Diagnostic{
+                                        Severity: hcl.DiagError,
+                                        Summary:  "Duplicate lifecycle block",
+                                        Detail:   fmt.Sprintf("This resource already has a lifecycle block at %s.", seenLifecycle.DefRange),
+                                        Subject:  &block.DefRange,
+                                })
+                                continue
+                        }
+                        seenLifecycle = block
+
+                        lcContent, lcDiags := block.Body.Content(resourceLifecycleBlockSchema)
+                        diags = append(diags, lcDiags...)
+
+                        if attr, exists := lcContent.Attributes["create_before_destroy"]; exists {
+                                valDiags := gohcl.DecodeExpression(attr.Expr, nil, &r.Managed.CreateBeforeDestroy)
+                                diags = append(diags, valDiags...)
+                                r.Managed.CreateBeforeDestroySet = true
+                        }
+
+                        if attr, exists := lcContent.Attributes["prevent_destroy"]; exists {
+                                valDiags := gohcl.DecodeExpression(attr.Expr, nil, &r.Managed.PreventDestroy)
+                                diags = append(diags, valDiags...)
+                                r.Managed.PreventDestroySet = true
+                        }
+
+                        if attr, exists := lcContent.Attributes["ignore_changes"]; exists {
+
+                                // ignore_changes can either be a list of relative traversals
+                                // or it can be just the keyword "all" to ignore changes to this
+                                // resource entirely.
+                                //   ignore_changes = [ami, instance_type]
+                                //   ignore_changes = all
+                                // We also allow two legacy forms for compatibility with earlier
+                                // versions:
+                                //   ignore_changes = ["ami", "instance_type"]
+                                //   ignore_changes = ["*"]
+
+                                kw := hcl.ExprAsKeyword(attr.Expr)
+
+                                switch {
+                                case kw == "all":
+                                        r.Managed.IgnoreAllChanges = true
+                                default:
+                                        exprs, listDiags := hcl.ExprList(attr.Expr)
+                                        diags = append(diags, listDiags...)
+
+                                        var ignoreAllRange hcl.Range
+
+                                        for _, expr := range exprs {
+
+                                                // our expr might be the literal string "*", which
+                                                // we accept as a deprecated way of saying "all".
+                                                if shimIsIgnoreChangesStar(expr) {
+                                                        r.Managed.IgnoreAllChanges = true
+                                                        ignoreAllRange = expr.Range()
+                                                        diags = append(diags, &hcl.Diagnostic{
+                                                                Severity: hcl.DiagWarning,
+                                                                Summary:  "Deprecated ignore_changes wildcard",
+                                                                Detail:   "The [\"*\"] form of ignore_changes wildcard is deprecated. Use \"ignore_changes = all\" to ignore changes to all attributes.",
+                                                                Subject:  attr.Expr.Range().Ptr(),
+                                                        })
+                                                        continue
+                                                }
+
+                                                expr, shimDiags := shimTraversalInString(expr, false)
+                                                diags = append(diags, shimDiags...)
+
+                                                traversal, travDiags := hcl.RelTraversalForExpr(expr)
+                                                diags = append(diags, travDiags...)
+                                                if len(traversal) != 0 {
+                                                        r.Managed.IgnoreChanges = append(r.Managed.IgnoreChanges, traversal)
+                                                }
+                                        }
+
+                                        if r.Managed.IgnoreAllChanges && len(r.Managed.IgnoreChanges) != 0 {
+                                                diags = append(diags, &hcl.Diagnostic{
+                                                        Severity: hcl.DiagError,
+                                                        Summary:  "Invalid ignore_changes ruleset",
+                                                        Detail:   "Cannot mix wildcard string \"*\" with non-wildcard references.",
+                                                        Subject:  &ignoreAllRange,
+                                                        Context:  attr.Expr.Range().Ptr(),
+                                                })
+                                        }
+
+                                }
+
+                        }
+
+                case "connection":
+                        if seenConnection != nil {
+                                diags = append(diags, &hcl.Diagnostic{
+                                        Severity: hcl.DiagError,
+                                        Summary:  "Duplicate connection block",
+                                        Detail:   fmt.Sprintf("This resource already has a connection block at %s.", seenConnection.DefRange),
+                                        Subject:  &block.DefRange,
+                                })
+                                continue
+                        }
+                        seenConnection = block
+
+                        r.Managed.Connection = &Connection{
+                                Config:    block.Body,
+                                DeclRange: block.DefRange,
+                        }
+
+                case "provisioner":
+                        pv, pvDiags := decodeProvisionerBlock(block)
+                        diags = append(diags, pvDiags...)
+                        if pv != nil {
+                                r.Managed.Provisioners = append(r.Managed.Provisioners, pv)
+                        }
+
+                default:
+                        // Any other block types are ones we've reserved for future use,
+                        // so they get a generic message.
+                        diags = append(diags, &hcl.Diagnostic{
+                                Severity: hcl.DiagError,
+                                Summary:  "Reserved block type name in resource block",
+                                Detail:   fmt.Sprintf("The block type name %q is reserved for use by Terraform in a future version.", block.Type),
+                                Subject:  &block.TypeRange,
+                        })
+                }
+        }
+
+        return r, diags
+}
+
+func decodeDataBlock(block *hcl.Block) (*Resource, hcl.Diagnostics) {
+        r := &Resource{
+                Mode:      addrs.DataResourceMode,
+                Type:      block.Labels[0],
+                Name:      block.Labels[1],
+                DeclRange: block.DefRange,
+                TypeRange: block.LabelRanges[0],
+        }
+
+        content, remain, diags := block.Body.PartialContent(dataBlockSchema)
+        r.Config = remain
+
+        if !hclsyntax.ValidIdentifier(r.Type) {
+                diags = append(diags, &hcl.Diagnostic{
+                        Severity: hcl.DiagError,
+                        Summary:  "Invalid data source name",
+                        Detail:   badIdentifierDetail,
+                        Subject:  &block.LabelRanges[0],
+                })
+        }
+        if !hclsyntax.ValidIdentifier(r.Name) {
+                diags = append(diags, &hcl.Diagnostic{
+                        Severity: hcl.DiagError,
+                        Summary:  "Invalid data resource name",
+                        Detail:   badIdentifierDetail,
+                        Subject:  &block.LabelRanges[1],
+                })
+        }
+
+        if attr, exists := content.Attributes["count"]; exists {
+                r.Count = attr.Expr
+        }
+
+        if attr, exists := content.Attributes["for_each"]; exists {
+                r.ForEach = attr.Expr
+                // We currently parse this, but don't yet do anything with it.
+                diags = append(diags, &hcl.Diagnostic{
+                        Severity: hcl.DiagError,
+                        Summary:  "Reserved argument name in module block",
+                        Detail:   fmt.Sprintf("The name %q is reserved for use in a future version of Terraform.", attr.Name),
+                        Subject:  &attr.NameRange,
+                })
+        }
+
+        if attr, exists := content.Attributes["provider"]; exists {
+                var providerDiags hcl.Diagnostics
+                r.ProviderConfigRef, providerDiags = decodeProviderConfigRef(attr.Expr, "provider")
+                diags = append(diags, providerDiags...)
+        }
+
+        if attr, exists := content.Attributes["depends_on"]; exists {
+                deps, depsDiags := decodeDependsOn(attr)
+                diags = append(diags, depsDiags...)
+                r.DependsOn = append(r.DependsOn, deps...)
+        }
+
+        for _, block := range content.Blocks {
+                // All of the block types we accept are just reserved for future use, but some get a specialized error message.
+                switch block.Type {
+                case "lifecycle":
+                        diags = append(diags, &hcl.Diagnostic{
+                                Severity: hcl.DiagError,
+                                Summary:  "Unsupported lifecycle block",
+                                Detail:   "Data resources do not have lifecycle settings, so a lifecycle block is not allowed.",
+                                Subject:  &block.DefRange,
+                        })
+                default:
+                        diags = append(diags, &hcl.Diagnostic{
+                                Severity: hcl.DiagError,
+                                Summary:  "Reserved block type name in data block",
+                                Detail:   fmt.Sprintf("The block type name %q is reserved for use by Terraform in a future version.", block.Type),
+                                Subject:  &block.TypeRange,
+                        })
+                }
+        }
+
+        return r, diags
+}
+
+type ProviderConfigRef struct {
+        Name       string
+        NameRange  hcl.Range
+        Alias      string
+        AliasRange *hcl.Range // nil if alias not set
+}
+
+func decodeProviderConfigRef(expr hcl.Expression, argName string) (*ProviderConfigRef, hcl.Diagnostics) {
+        var diags hcl.Diagnostics
+
+        var shimDiags hcl.Diagnostics
+        expr, shimDiags = shimTraversalInString(expr, false)
+        diags = append(diags, shimDiags...)
+
+        traversal, travDiags := hcl.AbsTraversalForExpr(expr)
+
+        // AbsTraversalForExpr produces only generic errors, so we'll discard
+        // the errors given and produce our own with extra context. If we didn't
+        // get any errors then we might still have warnings, though.
+        if !travDiags.HasErrors() {
+                diags = append(diags, travDiags...)
+        }
+
+        if len(traversal) < 1 || len(traversal) > 2 {
+                // A provider reference was given as a string literal in the legacy
+                // configuration language and there are lots of examples out there
+                // showing that usage, so we'll sniff for that situation here and
+                // produce a specialized error message for it to help users find
+                // the new correct form.
+                if exprIsNativeQuotedString(expr) {
+                        diags = append(diags, &hcl.Diagnostic{
+                                Severity: hcl.DiagError,
+                                Summary:  "Invalid provider configuration reference",
+                                Detail:   "A provider configuration reference must not be given in quotes.",
+                                Subject:  expr.Range().Ptr(),
+                        })
+                        return nil, diags
+                }
+
+                diags = append(diags, &hcl.Diagnostic{
+                        Severity: hcl.DiagError,
+                        Summary:  "Invalid provider configuration reference",
+                        Detail:   fmt.Sprintf("The %s argument requires a provider type name, optionally followed by a period and then a configuration alias.", argName),
+                        Subject:  expr.Range().Ptr(),
+                })
+                return nil, diags
+        }
+
+        ret := &ProviderConfigRef{
+                Name:      traversal.RootName(),
+                NameRange: traversal[0].SourceRange(),
+        }
+
+        if len(traversal) > 1 {
+                aliasStep, ok := traversal[1].(hcl.TraverseAttr)
+                if !ok {
+                        diags = append(diags, &hcl.Diagnostic{
+                                Severity: hcl.DiagError,
+                                Summary:  "Invalid provider configuration reference",
+                                Detail:   "Provider name must either stand alone or be followed by a period and then a configuration alias.",
+                                Subject:  traversal[1].SourceRange().Ptr(),
+                        })
+                        return ret, diags
+                }
+
+                ret.Alias = aliasStep.Name
+                ret.AliasRange = aliasStep.SourceRange().Ptr()
+        }
+
+        return ret, diags
+}
+
+// Addr returns the provider config address corresponding to the receiving
+// config reference.
+//
+// This is a trivial conversion, essentially just discarding the source
+// location information and keeping just the addressing information.
+func (r *ProviderConfigRef) Addr() addrs.ProviderConfig {
+        return addrs.ProviderConfig{
+                Type:  r.Name,
+                Alias: r.Alias,
+        }
+}
+
+func (r *ProviderConfigRef) String() string {
+        if r == nil {
+                return "<nil>"
+        }
+        if r.Alias != "" {
+                return fmt.Sprintf("%s.%s", r.Name, r.Alias)
+        }
+        return r.Name
+}
+
+var commonResourceAttributes = []hcl.AttributeSchema{
+        {
+                Name: "count",
+        },
+        {
+                Name: "for_each",
+        },
+        {
+                Name: "provider",
+        },
+        {
+                Name: "depends_on",
+        },
+}
+
+var resourceBlockSchema = &hcl.BodySchema{
+        Attributes: commonResourceAttributes,
+        Blocks: []hcl.BlockHeaderSchema{
+                {Type: "locals"}, // reserved for future use
+                {Type: "lifecycle"},
+                {Type: "connection"},
+                {Type: "provisioner", LabelNames: []string{"type"}},
+        },
+}
+
+var dataBlockSchema = &hcl.BodySchema{
+        Attributes: commonResourceAttributes,
+        Blocks: []hcl.BlockHeaderSchema{
+                {Type: "lifecycle"}, // reserved for future use
+                {Type: "locals"},    // reserved for future use
+        },
+}
+
+var resourceLifecycleBlockSchema = &hcl.BodySchema{
+        Attributes: []hcl.AttributeSchema{
+                {
+                        Name: "create_before_destroy",
+                },
+                {
+                        Name: "prevent_destroy",
+                },
+                {
+                        Name: "ignore_changes",
+                },
+        },
+}
diff --git a/vendor/github.com/hashicorp/terraform/configs/synth_body.go b/vendor/github.com/hashicorp/terraform/configs/synth_body.go
new file mode 100644
index 0000000..3ae1bff
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/configs/synth_body.go
@@ -0,0 +1,118 @@
+package configs
+
+import (
+        "fmt"
+
+        "github.com/hashicorp/hcl2/hcl"
+        "github.com/hashicorp/hcl2/hcl/hclsyntax"
+        "github.com/zclconf/go-cty/cty"
+)
+
+// SynthBody produces a synthetic hcl.Body that behaves as if it had attributes
+// corresponding to the elements given in the values map.
+//
+// This is useful in situations where, for example, values provided on the
+// command line can override values given in configuration, using MergeBodies.
+//
+// The given filename is used in case any diagnostics are returned. Since
+// the created body is synthetic, it is likely that this will not be a "real"
+// filename. For example, if from a command line argument it could be
+// a representation of that argument's name, such as "-var=...".
+func SynthBody(filename string, values map[string]cty.Value) hcl.Body {
+        return synthBody{
+                Filename: filename,
+                Values:   values,
+        }
+}
+
+type synthBody struct {
+        Filename string
+        Values   map[string]cty.Value
+}
+
+func (b synthBody) Content(schema *hcl.BodySchema) (*hcl.BodyContent, hcl.Diagnostics) {
+        content, remain, diags := b.PartialContent(schema)
+        remainS := remain.(synthBody)
+        for name := range remainS.Values {
+                diags = append(diags, &hcl.Diagnostic{
+                        Severity: hcl.DiagError,
+                        Summary:  "Unsupported attribute",
+                        Detail:   fmt.Sprintf("An attribute named %q is not expected here.", name),
+                        Subject:  b.synthRange().Ptr(),
+                })
+        }
+        return content, diags
+}
+
+func (b synthBody) PartialContent(schema *hcl.BodySchema) (*hcl.BodyContent, hcl.Body, hcl.Diagnostics) {
+        var diags hcl.Diagnostics
+        content := &hcl.BodyContent{
+                Attributes:       make(hcl.Attributes),
+                MissingItemRange: b.synthRange(),
+        }
+
+        remainValues := make(map[string]cty.Value)
+        for attrName, val := range b.Values {
+                remainValues[attrName] = val
+        }
+
+        for _, attrS := range schema.Attributes {
+                delete(remainValues, attrS.Name)
+                val, defined := b.Values[attrS.Name]
+                if !defined {
+                        if attrS.Required {
+                                diags = append(diags, &hcl.Diagnostic{
+                                        Severity: hcl.DiagError,
+                                        Summary:  "Missing required attribute",
+                                        Detail:   fmt.Sprintf("The attribute %q is required, but no definition was found.", attrS.Name),
+                                        Subject:  b.synthRange().Ptr(),
+                                })
+                        }
+                        continue
+                }
+                content.Attributes[attrS.Name] = b.synthAttribute(attrS.Name, val)
+        }
+
+        // We just ignore blocks altogether, because this body type never has
+        // nested blocks.
+
+        remain := synthBody{
+                Filename: b.Filename,
+                Values:   remainValues,
+        }
+
+        return content, remain, diags
+}
+
+func (b synthBody) JustAttributes() (hcl.Attributes, hcl.Diagnostics) {
+        ret := make(hcl.Attributes)
+        for name, val := range b.Values {
+                ret[name] = b.synthAttribute(name, val)
+        }
+        return ret, nil
+}
+
+func (b synthBody) MissingItemRange() hcl.Range {
+        return b.synthRange()
+}
+
+func (b synthBody) synthAttribute(name string, val cty.Value) *hcl.Attribute {
+        rng := b.synthRange()
+        return &hcl.Attribute{
+                Name: name,
+                Expr: &hclsyntax.LiteralValueExpr{
+                        Val:      val,
+                        SrcRange: rng,
+                },
+                NameRange: rng,
+                Range:     rng,
+        }
+}
+
+func (b synthBody) synthRange() hcl.Range {
+        return hcl.Range{
+                Filename: b.Filename,
+                Start:    hcl.Pos{Line: 1, Column: 1},
+                End:      hcl.Pos{Line: 1, Column: 1},
+        }
+}
diff --git a/vendor/github.com/hashicorp/terraform/configs/util.go b/vendor/github.com/hashicorp/terraform/configs/util.go
new file mode 100644
index 0000000..5fbde43
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/configs/util.go
@@ -0,0 +1,63 @@
+package configs
+
+import (
+        "github.com/hashicorp/hcl2/hcl"
+        "github.com/hashicorp/hcl2/hcl/hclsyntax"
+)
+
+// exprIsNativeQuotedString determines whether the given expression looks like
+// it's a quoted string in the HCL native syntax.
+//
+// This should be used sparingly only for situations where our legacy HCL
+// decoding would've expected a keyword or reference in quotes but our new
+// decoding expects the keyword or reference to be provided directly as
+// an identifier-based expression.
+func exprIsNativeQuotedString(expr hcl.Expression) bool {
+        _, ok := expr.(*hclsyntax.TemplateExpr)
+        return ok
+}
+
+// schemaForOverrides takes a *hcl.BodySchema and produces a new one that is
+// equivalent except that any required attributes are forced to not be required.
+//
+// This is useful for dealing with "override" config files, which are allowed
+// to omit things that they don't wish to override from the main configuration.
+//
+// The returned schema may have some pointers in common with the given schema,
+// so neither the given schema nor the returned schema should be modified after
+// using this function in order to avoid confusion.
+//
+// Overrides are rarely used, so it's recommended to just create the override
+// schema on the fly only when it's needed, rather than storing it in a global
+// variable as we tend to do for a primary schema.
+func schemaForOverrides(schema *hcl.BodySchema) *hcl.BodySchema {
+        ret := &hcl.BodySchema{
+                Attributes: make([]hcl.AttributeSchema, len(schema.Attributes)),
+                Blocks:     schema.Blocks,
+        }
+
+        for i, attrS := range schema.Attributes {
+                ret.Attributes[i] = attrS
+                ret.Attributes[i].Required = false
+        }
+
+        return ret
+}
+
+// schemaWithDynamic takes a *hcl.BodySchema and produces a new one that
+// is equivalent except that it accepts an additional block type "dynamic" with
+// a single label, used to recognize usage of the HCL dynamic block extension.
+func schemaWithDynamic(schema *hcl.BodySchema) *hcl.BodySchema {
+        ret := &hcl.BodySchema{
+                Attributes: schema.Attributes,
+                Blocks:     make([]hcl.BlockHeaderSchema, len(schema.Blocks), len(schema.Blocks)+1),
+        }
+
+        copy(ret.Blocks, schema.Blocks)
+        ret.Blocks = append(ret.Blocks, hcl.BlockHeaderSchema{
+                Type:       "dynamic",
+                LabelNames: []string{"type"},
+        })
+
+        return ret
+}
diff --git a/vendor/github.com/hashicorp/terraform/configs/variable_type_hint.go b/vendor/github.com/hashicorp/terraform/configs/variable_type_hint.go
new file mode 100644
index 0000000..204efd1
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/configs/variable_type_hint.go
@@ -0,0 +1,45 @@
+package configs
+
+// VariableTypeHint is an enumeration used for the Variable.TypeHint field,
+// which is an incompletely-specified type for the variable which is used
+// as a hint for whether a value provided in an ambiguous context (on the
+// command line or in an environment variable) should be taken literally as a
+// string or parsed as an HCL expression to produce a data structure.
+//
+// The type hint is applied to runtime values as well, but since it does not
+// accurately describe a precise type it is not fully-sufficient to infer
+// the dynamic type of a value passed through a variable.
+//
+// These hints use inaccurate terminology for historical reasons. Full details
+// are in the documentation for each constant in this enumeration, but in
+// summary:
+//
+//     TypeHintString requires a primitive type
+//     TypeHintList requires a type that could be converted to a tuple
+//     TypeHintMap requires a type that could be converted to an object
+type VariableTypeHint rune
+
+//go:generate stringer -type VariableTypeHint
+
+// TypeHintNone indicates the absense of a type hint. Values specified in
+// ambiguous contexts will be treated as literal strings, as if TypeHintString
+// were selected, but no runtime value checks will be applied. This is reasonable
+// type hint for a module that is never intended to be used at the top-level
+// of a configuration, since descendent modules never recieve values from
+// ambiguous contexts.
+const TypeHintNone VariableTypeHint = 0
+
+// TypeHintString spec indicates that a value provided in an ambiguous context
+// should be treated as a literal string, and additionally requires that the
+// runtime value for the variable is of a primitive type (string, number, bool).
+const TypeHintString VariableTypeHint = 'S'
+
+// TypeHintList indicates that a value provided in an ambiguous context should
+// be treated as an HCL expression, and additionally requires that the
+// runtime value for the variable is of an tuple, list, or set type.
+const TypeHintList VariableTypeHint = 'L'
+
+// TypeHintMap indicates that a value provided in an ambiguous context should
+// be treated as an HCL expression, and additionally requires that the
+// runtime value for the variable is of an object or map type.
+const TypeHintMap VariableTypeHint = 'M'
diff --git a/vendor/github.com/hashicorp/terraform/configs/variabletypehint_string.go b/vendor/github.com/hashicorp/terraform/configs/variabletypehint_string.go
new file mode 100644
index 0000000..2b50428
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/configs/variabletypehint_string.go
@@ -0,0 +1,39 @@
+// Code generated by "stringer -type VariableTypeHint"; DO NOT EDIT.
+
+package configs
+
+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[TypeHintNone-0]
+        _ = x[TypeHintString-83]
+        _ = x[TypeHintList-76]
+        _ = x[TypeHintMap-77]
+}
+
+const (
+        _VariableTypeHint_name_0 = "TypeHintNone"
+        _VariableTypeHint_name_1 = "TypeHintListTypeHintMap"
+        _VariableTypeHint_name_2 = "TypeHintString"
+)
+
+var (
+        _VariableTypeHint_index_1 = [...]uint8{0, 12, 23}
+)
+
+func (i VariableTypeHint) String() string {
+        switch {
+        case i == 0:
+                return _VariableTypeHint_name_0
+        case 76 <= i && i <= 77:
+                i -= 76
+                return _VariableTypeHint_name_1[_VariableTypeHint_index_1[i]:_VariableTypeHint_index_1[i+1]]
+        case i == 83:
+                return _VariableTypeHint_name_2
+        default:
+                return "VariableTypeHint(" + strconv.FormatInt(int64(i), 10) + ")"
+        }
+}
diff --git a/vendor/github.com/hashicorp/terraform/configs/version_constraint.go b/vendor/github.com/hashicorp/terraform/configs/version_constraint.go
new file mode 100644
index 0000000..7aa19ef
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/configs/version_constraint.go
@@ -0,0 +1,64 @@
+package configs
+
+import (
+        "fmt"
+
+        version "github.com/hashicorp/go-version"
+        "github.com/hashicorp/hcl2/hcl"
+        "github.com/zclconf/go-cty/cty"
+        "github.com/zclconf/go-cty/cty/convert"
+)
+
+// VersionConstraint represents a version constraint on some resource
+// (e.g. Terraform Core, a provider, a module, ...) that carries with it
+// a source range so that a helpful diagnostic can be printed in the event
+// that a particular constraint does not match.
+type VersionConstraint struct {
+        Required  version.Constraints
+        DeclRange hcl.Range
+}
+
+func decodeVersionConstraint(attr *hcl.Attribute) (VersionConstraint, hcl.Diagnostics) {
+        ret := VersionConstraint{
+                DeclRange: attr.Range,
+        }
+
+        val, diags := attr.Expr.Value(nil)
+        if diags.HasErrors() {
+                return ret, diags
+        }
+        var err error
+        val, err = convert.Convert(val, cty.String)
+        if err != nil {
+                diags = append(diags, &hcl.Diagnostic{
+                        Severity: hcl.DiagError,
+                        Summary:  "Invalid version constraint",
+                        Detail:   fmt.Sprintf("A string value is required for %s.", attr.Name),
+                        Subject:  attr.Expr.Range().Ptr(),
+                })
+                return ret, diags
+        }
+
+        if val.IsNull() {
+                // A null version constraint is strange, but we'll just treat it
+                // like an empty constraint set.
+                return ret, diags
+        }
+
+        constraintStr := val.AsString()
+        constraints, err := version.NewConstraint(constraintStr)
+        if err != nil {
+                // NewConstraint doesn't return user-friendly errors, so we'll just
+                // ignore the provided error and produce our own generic one.
+                diags = append(diags, &hcl.Diagnostic{
+                        Severity: hcl.DiagError,
+                        Summary:  "Invalid version constraint",
+                        Detail:   "This string does not use correct version constraint syntax.", // Not very actionable :(
+                        Subject:  attr.Expr.Range().Ptr(),
+                })
+                return ret, diags
+        }
+
+        ret.Required = constraints
+        return ret, diags
+}