deps: github.com/hashicorp/terraform@sdk-v0.11-with-go-modules

Updated via: go get github.com/hashicorp/terraform@sdk-v0.11-with-go-modules and go mod tidy

1 files changed, 261 insertions, 135 deletions

diff --git a/vendor/github.com/hashicorp/terraform/config/config.go b/vendor/github.com/hashicorp/terraform/config/config.go
index 3f756dc..1772fd7 100644
--- a/vendor/github.com/hashicorp/terraform/config/config.go
+++ b/vendor/github.com/hashicorp/terraform/config/config.go
@@ -8,11 +8,11 @@ import (
         "strconv"
         "strings"
 
-        "github.com/hashicorp/go-multierror"
-        "github.com/hashicorp/hil"
+        hcl2 "github.com/hashicorp/hcl2/hcl"
         "github.com/hashicorp/hil/ast"
         "github.com/hashicorp/terraform/helper/hilmapstructure"
         "github.com/hashicorp/terraform/plugin/discovery"
+        "github.com/hashicorp/terraform/tfdiags"
         "github.com/mitchellh/reflectwalk"
 )
 
@@ -34,6 +34,7 @@ type Config struct {
         ProviderConfigs []*ProviderConfig
         Resources       []*Resource
         Variables       []*Variable
+        Locals          []*Local
         Outputs         []*Output
 
         // The fields below can be filled in by loaders for validation
@@ -55,6 +56,8 @@ type AtlasConfig struct {
 type Module struct {
         Name      string
         Source    string
+        Version   string
+        Providers map[string]string
         RawConfig *RawConfig
 }
 
@@ -147,7 +150,7 @@ func (p *Provisioner) Copy() *Provisioner {
         }
 }
 
-// Variable is a variable defined within the configuration.
+// Variable is a module argument defined within the configuration.
 type Variable struct {
         Name         string
         DeclaredType string `mapstructure:"type"`
@@ -155,6 +158,12 @@ type Variable struct {
         Description  string
 }
 
+// Local is a local value defined within the configuration.
+type Local struct {
+        Name      string
+        RawConfig *RawConfig
+}
+
 // Output is an output defined within the configuration. An output is
 // resulting data that is highlighted by Terraform when finished. An
 // output marked Sensitive will be output in a masked form following
@@ -222,7 +231,10 @@ func (r *Resource) Count() (int, error) {
 
         v, err := strconv.ParseInt(count, 0, 0)
         if err != nil {
-                return 0, err
+                return 0, fmt.Errorf(
+                        "cannot parse %q as an integer",
+                        count,
+                )
         }
 
         return int(v), nil
@@ -253,7 +265,9 @@ func (r *Resource) ProviderFullName() string {
 // the provider name is inferred from the resource type name.
 func ResourceProviderFullName(resourceType, explicitProvider string) string {
         if explicitProvider != "" {
-                return explicitProvider
+                // check for an explicit provider name, or return the original
+                parts := strings.SplitAfter(explicitProvider, "provider.")
+                return parts[len(parts)-1]
         }
 
         idx := strings.IndexRune(resourceType, '_')
@@ -268,30 +282,35 @@ func ResourceProviderFullName(resourceType, explicitProvider string) string {
 }
 
 // Validate does some basic semantic checking of the configuration.
-func (c *Config) Validate() error {
+func (c *Config) Validate() tfdiags.Diagnostics {
         if c == nil {
                 return nil
         }
 
-        var errs []error
+        var diags tfdiags.Diagnostics
 
         for _, k := range c.unknownKeys {
-                errs = append(errs, fmt.Errorf(
-                        "Unknown root level key: %s", k))
+                diags = diags.Append(
+                        fmt.Errorf("Unknown root level key: %s", k),
+                )
         }
 
         // Validate the Terraform config
         if tf := c.Terraform; tf != nil {
-                errs = append(errs, c.Terraform.Validate()...)
+                errs := c.Terraform.Validate()
+                for _, err := range errs {
+                        diags = diags.Append(err)
+                }
         }
 
         vars := c.InterpolatedVariables()
         varMap := make(map[string]*Variable)
         for _, v := range c.Variables {
                 if _, ok := varMap[v.Name]; ok {
-                        errs = append(errs, fmt.Errorf(
+                        diags = diags.Append(fmt.Errorf(
                                 "Variable '%s': duplicate found. Variable names must be unique.",
-                                v.Name))
+                                v.Name,
+                        ))
                 }
 
                 varMap[v.Name] = v
@@ -299,17 +318,19 @@ func (c *Config) Validate() error {
 
         for k, _ := range varMap {
                 if !NameRegexp.MatchString(k) {
-                        errs = append(errs, fmt.Errorf(
-                                "variable %q: variable name must match regular expresion %s",
-                                k, NameRegexp))
+                        diags = diags.Append(fmt.Errorf(
+                                "variable %q: variable name must match regular expression %s",
+                                k, NameRegexp,
+                        ))
                 }
         }
 
         for _, v := range c.Variables {
                 if v.Type() == VariableTypeUnknown {
-                        errs = append(errs, fmt.Errorf(
+                        diags = diags.Append(fmt.Errorf(
                                 "Variable '%s': must be a string or a map",
-                                v.Name))
+                                v.Name,
+                        ))
                         continue
                 }
 
@@ -330,9 +351,10 @@ func (c *Config) Validate() error {
                 if v.Default != nil {
                         if err := reflectwalk.Walk(v.Default, w); err == nil {
                                 if interp {
-                                        errs = append(errs, fmt.Errorf(
-                                                "Variable '%s': cannot contain interpolations",
-                                                v.Name))
+                                        diags = diags.Append(fmt.Errorf(
+                                                "variable %q: default may not contain interpolations",
+                                                v.Name,
+                                        ))
                                 }
                         }
                 }
@@ -348,10 +370,11 @@ func (c *Config) Validate() error {
                         }
 
                         if _, ok := varMap[uv.Name]; !ok {
-                                errs = append(errs, fmt.Errorf(
-                                        "%s: unknown variable referenced: '%s'. define it with 'variable' blocks",
+                                diags = diags.Append(fmt.Errorf(
+                                        "%s: unknown variable referenced: '%s'; define it with a 'variable' block",
                                         source,
-                                        uv.Name))
+                                        uv.Name,
+                                ))
                         }
                 }
         }
@@ -362,17 +385,19 @@ func (c *Config) Validate() error {
                         switch v := rawV.(type) {
                         case *CountVariable:
                                 if v.Type == CountValueInvalid {
-                                        errs = append(errs, fmt.Errorf(
+                                        diags = diags.Append(fmt.Errorf(
                                                 "%s: invalid count variable: %s",
                                                 source,
-                                                v.FullKey()))
+                                                v.FullKey(),
+                                        ))
                                 }
                         case *PathVariable:
                                 if v.Type == PathValueInvalid {
-                                        errs = append(errs, fmt.Errorf(
+                                        diags = diags.Append(fmt.Errorf(
                                                 "%s: invalid path variable: %s",
                                                 source,
-                                                v.FullKey()))
+                                                v.FullKey(),
+                                        ))
                                 }
                         }
                 }
@@ -380,27 +405,35 @@ func (c *Config) Validate() error {
 
         // Check that providers aren't declared multiple times and that their
         // version constraints, where present, are syntactically valid.
-        providerSet := make(map[string]struct{})
+        providerSet := make(map[string]bool)
         for _, p := range c.ProviderConfigs {
                 name := p.FullName()
                 if _, ok := providerSet[name]; ok {
-                        errs = append(errs, fmt.Errorf(
-                                "provider.%s: declared multiple times, you can only declare a provider once",
-                                name))
+                        diags = diags.Append(fmt.Errorf(
+                                "provider.%s: multiple configurations present; only one configuration is allowed per provider",
+                                name,
+                        ))
                         continue
                 }
 
                 if p.Version != "" {
                         _, err := discovery.ConstraintStr(p.Version).Parse()
                         if err != nil {
-                                errs = append(errs, fmt.Errorf(
-                                        "provider.%s: invalid version constraint %q: %s",
-                                        name, p.Version, err,
-                                ))
+                                diags = diags.Append(&hcl2.Diagnostic{
+                                        Severity: hcl2.DiagError,
+                                        Summary:  "Invalid provider version constraint",
+                                        Detail: fmt.Sprintf(
+                                                "The value %q given for provider.%s is not a valid version constraint.",
+                                                p.Version, name,
+                                        ),
+                                        // TODO: include a "Subject" source reference in here,
+                                        // once the config loader is able to retain source
+                                        // location information.
+                                })
                         }
                 }
 
-                providerSet[name] = struct{}{}
+                providerSet[name] = true
         }
 
         // Check that all references to modules are valid
@@ -412,9 +445,10 @@ func (c *Config) Validate() error {
                         if _, ok := dupped[m.Id()]; !ok {
                                 dupped[m.Id()] = struct{}{}
 
-                                errs = append(errs, fmt.Errorf(
-                                        "%s: module repeated multiple times",
-                                        m.Id()))
+                                diags = diags.Append(fmt.Errorf(
+                                        "module %q: module repeated multiple times",
+                                        m.Id(),
+                                ))
                         }
 
                         // Already seen this module, just skip it
@@ -428,21 +462,23 @@ func (c *Config) Validate() error {
                         "root": m.Source,
                 })
                 if err != nil {
-                        errs = append(errs, fmt.Errorf(
-                                "%s: module source error: %s",
-                                m.Id(), err))
+                        diags = diags.Append(fmt.Errorf(
+                                "module %q: module source error: %s",
+                                m.Id(), err,
+                        ))
                 } else if len(rc.Interpolations) > 0 {
-                        errs = append(errs, fmt.Errorf(
-                                "%s: module source cannot contain interpolations",
-                                m.Id()))
+                        diags = diags.Append(fmt.Errorf(
+                                "module %q: module source cannot contain interpolations",
+                                m.Id(),
+                        ))
                 }
 
                 // Check that the name matches our regexp
                 if !NameRegexp.Match([]byte(m.Name)) {
-                        errs = append(errs, fmt.Errorf(
-                                "%s: module name can only contain letters, numbers, "+
-                                        "dashes, and underscores",
-                                m.Id()))
+                        diags = diags.Append(fmt.Errorf(
+                                "module %q: module name must be a letter or underscore followed by only letters, numbers, dashes, and underscores",
+                                m.Id(),
+                        ))
                 }
 
                 // Check that the configuration can all be strings, lists or maps
@@ -466,30 +502,47 @@ func (c *Config) Validate() error {
                                 continue
                         }
 
-                        errs = append(errs, fmt.Errorf(
-                                "%s: variable %s must be a string, list or map value",
-                                m.Id(), k))
+                        diags = diags.Append(fmt.Errorf(
+                                "module %q: argument %s must have a string, list, or map value",
+                                m.Id(), k,
+                        ))
                 }
 
                 // Check for invalid count variables
                 for _, v := range m.RawConfig.Variables {
                         switch v.(type) {
                         case *CountVariable:
-                                errs = append(errs, fmt.Errorf(
-                                        "%s: count variables are only valid within resources", m.Name))
+                                diags = diags.Append(fmt.Errorf(
+                                        "module %q: count variables are only valid within resources",
+                                        m.Name,
+                                ))
                         case *SelfVariable:
-                                errs = append(errs, fmt.Errorf(
-                                        "%s: self variables are only valid within resources", m.Name))
+                                diags = diags.Append(fmt.Errorf(
+                                        "module %q: self variables are only valid within resources",
+                                        m.Name,
+                                ))
                         }
                 }
 
                 // Update the raw configuration to only contain the string values
                 m.RawConfig, err = NewRawConfig(raw)
                 if err != nil {
-                        errs = append(errs, fmt.Errorf(
+                        diags = diags.Append(fmt.Errorf(
                                 "%s: can't initialize configuration: %s",
-                                m.Id(), err))
+                                m.Id(), err,
+                        ))
                 }
+
+                // check that all named providers actually exist
+                for _, p := range m.Providers {
+                        if !providerSet[p] {
+                                diags = diags.Append(fmt.Errorf(
+                                        "module %q: cannot pass non-existent provider %q",
+                                        m.Name, p,
+                                ))
+                        }
+                }
+
         }
         dupped = nil
 
@@ -503,10 +556,10 @@ func (c *Config) Validate() error {
                         }
 
                         if _, ok := modules[mv.Name]; !ok {
-                                errs = append(errs, fmt.Errorf(
+                                diags = diags.Append(fmt.Errorf(
                                         "%s: unknown module referenced: %s",
-                                        source,
-                                        mv.Name))
+                                        source, mv.Name,
+                                ))
                         }
                 }
         }
@@ -519,9 +572,10 @@ func (c *Config) Validate() error {
                         if _, ok := dupped[r.Id()]; !ok {
                                 dupped[r.Id()] = struct{}{}
 
-                                errs = append(errs, fmt.Errorf(
+                                diags = diags.Append(fmt.Errorf(
                                         "%s: resource repeated multiple times",
-                                        r.Id()))
+                                        r.Id(),
+                                ))
                         }
                 }
 
@@ -535,53 +589,42 @@ func (c *Config) Validate() error {
                 for _, v := range r.RawCount.Variables {
                         switch v.(type) {
                         case *CountVariable:
-                                errs = append(errs, fmt.Errorf(
+                                diags = diags.Append(fmt.Errorf(
                                         "%s: resource count can't reference count variable: %s",
-                                        n,
-                                        v.FullKey()))
+                                        n, v.FullKey(),
+                                ))
                         case *SimpleVariable:
-                                errs = append(errs, fmt.Errorf(
+                                diags = diags.Append(fmt.Errorf(
                                         "%s: resource count can't reference variable: %s",
-                                        n,
-                                        v.FullKey()))
+                                        n, v.FullKey(),
+                                ))
 
                         // Good
                         case *ModuleVariable:
                         case *ResourceVariable:
                         case *TerraformVariable:
                         case *UserVariable:
+                        case *LocalVariable:
 
                         default:
-                                errs = append(errs, fmt.Errorf(
+                                diags = diags.Append(fmt.Errorf(
                                         "Internal error. Unknown type in count var in %s: %T",
-                                        n, v))
+                                        n, v,
+                                ))
                         }
                 }
 
-                // Interpolate with a fixed number to verify that its a number.
-                r.RawCount.interpolate(func(root ast.Node) (interface{}, error) {
-                        // Execute the node but transform the AST so that it returns
-                        // a fixed value of "5" for all interpolations.
-                        result, err := hil.Eval(
-                                hil.FixedValueTransform(
-                                        root, &ast.LiteralNode{Value: "5", Typex: ast.TypeString}),
-                                nil)
-                        if err != nil {
-                                return "", err
-                        }
-
-                        return result.Value, nil
-                })
-                _, err := strconv.ParseInt(r.RawCount.Value().(string), 0, 0)
-                if err != nil {
-                        errs = append(errs, fmt.Errorf(
-                                "%s: resource count must be an integer",
-                                n))
+                if !r.RawCount.couldBeInteger() {
+                        diags = diags.Append(fmt.Errorf(
+                                "%s: resource count must be an integer", n,
+                        ))
                 }
                 r.RawCount.init()
 
                 // Validate DependsOn
-                errs = append(errs, c.validateDependsOn(n, r.DependsOn, resources, modules)...)
+                for _, err := range c.validateDependsOn(n, r.DependsOn, resources, modules) {
+                        diags = diags.Append(err)
+                }
 
                 // Verify provisioners
                 for _, p := range r.Provisioners {
@@ -595,9 +638,10 @@ func (c *Config) Validate() error {
                                 }
 
                                 if rv.Multi && rv.Index == -1 && rv.Type == r.Type && rv.Name == r.Name {
-                                        errs = append(errs, fmt.Errorf(
-                                                "%s: connection info cannot contain splat variable "+
-                                                        "referencing itself", n))
+                                        diags = diags.Append(fmt.Errorf(
+                                                "%s: connection info cannot contain splat variable referencing itself",
+                                                n,
+                                        ))
                                         break
                                 }
                         }
@@ -609,9 +653,10 @@ func (c *Config) Validate() error {
                                 }
 
                                 if rv.Multi && rv.Index == -1 && rv.Type == r.Type && rv.Name == r.Name {
-                                        errs = append(errs, fmt.Errorf(
-                                                "%s: connection info cannot contain splat variable "+
-                                                        "referencing itself", n))
+                                        diags = diags.Append(fmt.Errorf(
+                                                "%s: connection info cannot contain splat variable referencing itself",
+                                                n,
+                                        ))
                                         break
                                 }
                         }
@@ -619,21 +664,24 @@ func (c *Config) Validate() error {
                         // Check for invalid when/onFailure values, though this should be
                         // picked up by the loader we check here just in case.
                         if p.When == ProvisionerWhenInvalid {
-                                errs = append(errs, fmt.Errorf(
-                                        "%s: provisioner 'when' value is invalid", n))
+                                diags = diags.Append(fmt.Errorf(
+                                        "%s: provisioner 'when' value is invalid", n,
+                                ))
                         }
                         if p.OnFailure == ProvisionerOnFailureInvalid {
-                                errs = append(errs, fmt.Errorf(
-                                        "%s: provisioner 'on_failure' value is invalid", n))
+                                diags = diags.Append(fmt.Errorf(
+                                        "%s: provisioner 'on_failure' value is invalid", n,
+                                ))
                         }
                 }
 
                 // Verify ignore_changes contains valid entries
                 for _, v := range r.Lifecycle.IgnoreChanges {
                         if strings.Contains(v, "*") && v != "*" {
-                                errs = append(errs, fmt.Errorf(
-                                        "%s: ignore_changes does not support using a partial string "+
-                                                "together with a wildcard: %s", n, v))
+                                diags = diags.Append(fmt.Errorf(
+                                        "%s: ignore_changes does not support using a partial string together with a wildcard: %s",
+                                        n, v,
+                                ))
                         }
                 }
 
@@ -642,21 +690,24 @@ func (c *Config) Validate() error {
                         "root": r.Lifecycle.IgnoreChanges,
                 })
                 if err != nil {
-                        errs = append(errs, fmt.Errorf(
+                        diags = diags.Append(fmt.Errorf(
                                 "%s: lifecycle ignore_changes error: %s",
-                                n, err))
+                                n, err,
+                        ))
                 } else if len(rc.Interpolations) > 0 {
-                        errs = append(errs, fmt.Errorf(
+                        diags = diags.Append(fmt.Errorf(
                                 "%s: lifecycle ignore_changes cannot contain interpolations",
-                                n))
+                                n,
+                        ))
                 }
 
                 // If it is a data source then it can't have provisioners
                 if r.Mode == DataResourceMode {
                         if _, ok := r.RawConfig.Raw["provisioner"]; ok {
-                                errs = append(errs, fmt.Errorf(
+                                diags = diags.Append(fmt.Errorf(
                                         "%s: data sources cannot have provisioners",
-                                        n))
+                                        n,
+                                ))
                         }
                 }
         }
@@ -670,25 +721,50 @@ func (c *Config) Validate() error {
 
                         id := rv.ResourceId()
                         if _, ok := resources[id]; !ok {
-                                errs = append(errs, fmt.Errorf(
+                                diags = diags.Append(fmt.Errorf(
                                         "%s: unknown resource '%s' referenced in variable %s",
                                         source,
                                         id,
-                                        rv.FullKey()))
+                                        rv.FullKey(),
+                                ))
                                 continue
                         }
                 }
         }
 
+        // Check that all locals are valid
+        {
+                found := make(map[string]struct{})
+                for _, l := range c.Locals {
+                        if _, ok := found[l.Name]; ok {
+                                diags = diags.Append(fmt.Errorf(
+                                        "%s: duplicate local. local value names must be unique",
+                                        l.Name,
+                                ))
+                                continue
+                        }
+                        found[l.Name] = struct{}{}
+
+                        for _, v := range l.RawConfig.Variables {
+                                if _, ok := v.(*CountVariable); ok {
+                                        diags = diags.Append(fmt.Errorf(
+                                                "local %s: count variables are only valid within resources", l.Name,
+                                        ))
+                                }
+                        }
+                }
+        }
+
         // Check that all outputs are valid
         {
                 found := make(map[string]struct{})
                 for _, o := range c.Outputs {
                         // Verify the output is new
                         if _, ok := found[o.Name]; ok {
-                                errs = append(errs, fmt.Errorf(
-                                        "%s: duplicate output. output names must be unique.",
-                                        o.Name))
+                                diags = diags.Append(fmt.Errorf(
+                                        "output %q: an output of this name was already defined",
+                                        o.Name,
+                                ))
                                 continue
                         }
                         found[o.Name] = struct{}{}
@@ -708,9 +784,10 @@ func (c *Config) Validate() error {
                                                 continue
                                         }
 
-                                        errs = append(errs, fmt.Errorf(
-                                                "%s: value for 'sensitive' must be boolean",
-                                                o.Name))
+                                        diags = diags.Append(fmt.Errorf(
+                                                "output %q: value for 'sensitive' must be boolean",
+                                                o.Name,
+                                        ))
                                         continue
                                 }
                                 if k == "description" {
@@ -719,27 +796,78 @@ func (c *Config) Validate() error {
                                                 continue
                                         }
 
-                                        errs = append(errs, fmt.Errorf(
-                                                "%s: value for 'description' must be string",
-                                                o.Name))
+                                        diags = diags.Append(fmt.Errorf(
+                                                "output %q: value for 'description' must be string",
+                                                o.Name,
+                                        ))
                                         continue
                                 }
                                 invalidKeys = append(invalidKeys, k)
                         }
                         if len(invalidKeys) > 0 {
-                                errs = append(errs, fmt.Errorf(
-                                        "%s: output has invalid keys: %s",
-                                        o.Name, strings.Join(invalidKeys, ", ")))
+                                diags = diags.Append(fmt.Errorf(
+                                        "output %q: invalid keys: %s",
+                                        o.Name, strings.Join(invalidKeys, ", "),
+                                ))
                         }
                         if !valueKeyFound {
-                                errs = append(errs, fmt.Errorf(
-                                        "%s: output is missing required 'value' key", o.Name))
+                                diags = diags.Append(fmt.Errorf(
+                                        "output %q: missing required 'value' argument", o.Name,
+                                ))
                         }
 
                         for _, v := range o.RawConfig.Variables {
                                 if _, ok := v.(*CountVariable); ok {
-                                        errs = append(errs, fmt.Errorf(
-                                                "%s: count variables are only valid within resources", o.Name))
+                                        diags = diags.Append(fmt.Errorf(
+                                                "output %q: count variables are only valid within resources",
+                                                o.Name,
+                                        ))
+                                }
+                        }
+
+                        // Detect a common mistake of using a "count"ed resource in
+                        // an output value without using the splat or index form.
+                        // Prior to 0.11 this error was silently ignored, but outputs
+                        // now have their errors checked like all other contexts.
+                        //
+                        // TODO: Remove this in 0.12.
+                        for _, v := range o.RawConfig.Variables {
+                                rv, ok := v.(*ResourceVariable)
+                                if !ok {
+                                        continue
+                                }
+
+                                // If the variable seems to be treating the referenced
+                                // resource as a singleton (no count specified) then
+                                // we'll check to make sure it is indeed a singleton.
+                                // It's a warning if not.
+
+                                if rv.Multi || rv.Index != 0 {
+                                        // This reference is treating the resource as a
+                                        // multi-resource, so the warning doesn't apply.
+                                        continue
+                                }
+
+                                for _, r := range c.Resources {
+                                        if r.Id() != rv.ResourceId() {
+                                                continue
+                                        }
+
+                                        // We test specifically for the raw string "1" here
+                                        // because we _do_ want to generate this warning if
+                                        // the user has provided an expression that happens
+                                        // to return 1 right now, to catch situations where
+                                        // a count might dynamically be set to something
+                                        // other than 1 and thus splat syntax is still needed
+                                        // to be safe.
+                                        if r.RawCount != nil && r.RawCount.Raw != nil && r.RawCount.Raw["count"] != "1" && rv.Field != "count" {
+                                                diags = diags.Append(tfdiags.SimpleWarning(fmt.Sprintf(
+                                                        "output %q: must use splat syntax to access %s attribute %q, because it has \"count\" set; use %s.*.%s to obtain a list of the attributes across all instances",
+                                                        o.Name,
+                                                        r.Id(), rv.Field,
+                                                        r.Id(), rv.Field,
+                                                )))
+                                        }
                                 }
                         }
                 }
@@ -755,17 +883,15 @@ func (c *Config) Validate() error {
 
                 for _, v := range rc.Variables {
                         if _, ok := v.(*SelfVariable); ok {
-                                errs = append(errs, fmt.Errorf(
-                                        "%s: cannot contain self-reference %s", source, v.FullKey()))
+                                diags = diags.Append(fmt.Errorf(
+                                        "%s: cannot contain self-reference %s",
+                                        source, v.FullKey(),
+                                ))
                         }
                 }
         }
 
-        if len(errs) > 0 {
-                return &multierror.Error{Errors: errs}
-        }
-
-        return nil
+        return diags
 }
 
 // InterpolatedVariables is a helper that returns a mapping of all the interpolated