Import block expansion with for_each

internal/command/import.go

@@ -12,7 +12,6 @@ import (
 
 	"github.com/hashicorp/hcl/v2"
 	"github.com/hashicorp/hcl/v2/hclsyntax"
-	"github.com/zclconf/go-cty/cty"
 
 	"github.com/hashicorp/terraform/internal/addrs"
 	"github.com/hashicorp/terraform/internal/backend"
@@ -236,11 +235,8 @@ func (c *ImportCommand) Run(args []string) int {
 	newState, importDiags := lr.Core.Import(lr.Config, lr.InputState, &terraform.ImportOpts{
 		Targets: []*terraform.ImportTarget{
 			{
-				Addr: addr,
-
-				// In the import block, the ID can be an arbitrary hcl.Expression,
-				// but here it's always interpreted as a literal string.
-				ID: hcl.StaticExpr(cty.StringVal(args[1]), configs.SynthBody("import", nil).MissingItemRange()),
+				LegacyAddr: addr,
+				IDString:   args[1],
 			},
 		},
 

internal/command/testdata/validate-invalid/duplicate_import_targets/output.json

@@ -11,22 +11,22 @@
       "range": {
         "filename": "testdata/validate-invalid/duplicate_import_targets/main.tf",
         "start": {
-          "line": 9,
-          "column": 1,
-          "byte": 85
+          "line": 10,
+          "column": 8,
+          "byte": 101
         },
         "end": {
-          "line": 9,
-          "column": 7,
-          "byte": 91
+          "line": 10,
+          "column": 24,
+          "byte": 117
         }
       },
       "snippet": {
-        "context": null,
-        "code": "import {",
-        "start_line": 9,
-        "highlight_start_offset": 0,
-        "highlight_end_offset": 6,
+        "context": "import",
+        "code": "  to = aws_instance.web",
+        "start_line": 10,
+        "highlight_start_offset": 7,
+        "highlight_end_offset": 23,
         "values": []
       }
     }

internal/configs/config.go

@@ -430,8 +430,10 @@ func (c *Config) addProviderRequirements(reqs getproviders.Requirements, recurse
 		reqs[fqn] = nil
 	}
 	for _, i := range c.Module.Import {
-		implied, err := addrs.ParseProviderPart(i.To.Resource.Resource.ImpliedProvider())
+		implied, err := addrs.ParseProviderPart(i.ToResource.Resource.ImpliedProvider())
 		if err == nil {
+			// FIXME: this will not resolve correctly if the target module uses
+			// a different local name from the root module.
 			provider := c.Module.ImpliedProviderForUnqualifiedType(implied)
 			if _, exists := reqs[provider]; exists {
 				// Explicit dependency already present
@@ -452,14 +454,14 @@ func (c *Config) addProviderRequirements(reqs getproviders.Requirements, recurse
 	// this will be because the user has written explicit provider arguments
 	// that don't agree and we'll get them to fix it.
 	for _, i := range c.Module.Import {
-		if len(i.To.Module) > 0 {
+		if len(i.ToResource.Module) > 0 {
 			// All provider information for imports into modules should come
 			// from the module block, so we don't need to load anything for
 			// import targets within modules.
 			continue
 		}
 
-		if target, exists := c.Module.ManagedResources[i.To.String()]; exists {
+		if target, exists := c.Module.ManagedResources[i.ToResource.Resource.String()]; exists {
 			// This means the information about the provider for this import
 			// should come from the resource block itself and not the import
 			// block.

internal/configs/import.go

@@ -5,12 +5,23 @@ package configs
 
 import (
 	"github.com/hashicorp/hcl/v2"
+	"github.com/hashicorp/hcl/v2/hclsyntax"
+	hcljson "github.com/hashicorp/hcl/v2/json"
 	"github.com/hashicorp/terraform/internal/addrs"
+	"github.com/hashicorp/terraform/internal/tfdiags"
+	"github.com/zclconf/go-cty/cty"
 )
 
 type Import struct {
 	ID hcl.Expression
-	To addrs.AbsResourceInstance
+
+	To hcl.Expression
+	// The To address may not be resolvable immediately if it contains dynamic
+	// index expressions, so we will extract the ConfigResource address and
+	// store it here for reference.
+	ToResource addrs.ConfigResource
+
+	ForEach hcl.Expression
 
 	ProviderConfigRef *ProviderConfigRef
 	Provider          addrs.Provider
@@ -33,17 +44,25 @@ func decodeImportBlock(block *hcl.Block) (*Import, hcl.Diagnostics) {
 	}
 
 	if attr, exists := content.Attributes["to"]; exists {
-		traversal, traversalDiags := hcl.AbsTraversalForExpr(attr.Expr)
-		diags = append(diags, traversalDiags...)
-		if !traversalDiags.HasErrors() {
-			to, toDiags := addrs.ParseAbsResourceInstance(traversal)
-			diags = append(diags, toDiags.ToHCL()...)
-			imp.To = to
+		toExpr, jsDiags := unwrapJSONRefExpr(attr.Expr)
+		diags = diags.Extend(jsDiags)
+		if diags.HasErrors() {
+			return imp, diags
 		}
+
+		imp.To = toExpr
+
+		addr, toDiags := parseConfigResourceFromExpression(imp.To)
+		diags = diags.Extend(toDiags.ToHCL())
+		imp.ToResource = addr
+	}
+
+	if attr, exists := content.Attributes["for_each"]; exists {
+		imp.ForEach = attr.Expr
 	}
 
 	if attr, exists := content.Attributes["provider"]; exists {
-		if len(imp.To.Module) > 0 {
+		if len(imp.ToResource.Module) > 0 {
 			diags = append(diags, &hcl.Diagnostic{
 				Severity: hcl.DiagError,
 				Summary:  "Invalid import provider argument",
@@ -66,6 +85,9 @@ var importBlockSchema = &hcl.BodySchema{
 		{
 			Name: "provider",
 		},
+		{
+			Name: "for_each",
+		},
 		{
 			Name:     "id",
 			Required: true,
@@ -76,3 +98,117 @@ var importBlockSchema = &hcl.BodySchema{
 		},
 	},
 }
+
+// parseResourceInstanceFromExpression takes an arbitrary expression
+// representing a resource instance, and parses out the static ConfigResource
+// skipping an variable index expressions. This is used to connect an import
+// block's "to" to the configuration address before the full instance
+// expressions are evaluated.
+func parseConfigResourceFromExpression(expr hcl.Expression) (addrs.ConfigResource, tfdiags.Diagnostics) {
+	traversal, hcdiags := exprToResourceTraversal(expr)
+	if hcdiags.HasErrors() {
+		return addrs.ConfigResource{}, tfdiags.Diagnostics(nil).Append(hcdiags)
+	}
+
+	addr, diags := addrs.ParseAbsResourceInstance(traversal)
+	if diags.HasErrors() {
+		return addrs.ConfigResource{}, diags
+	}
+
+	return addr.ConfigResource(), diags
+}
+
+// unwrapJSONRefExpr takes a string expression from a JSON configuration,
+// and re-evaluates the string as HCL. If the expression is not JSON, the
+// original expression is returned directly.
+func unwrapJSONRefExpr(expr hcl.Expression) (hcl.Expression, hcl.Diagnostics) {
+	if !hcljson.IsJSONExpression(expr) {
+		return expr, nil
+	}
+
+	// We can abuse the hcl json api and rely on the fact that calling
+	// Value on a json expression with no EvalContext will return the
+	// raw string. We can then parse that as normal hcl syntax, and
+	// continue with the decoding.
+	v, diags := expr.Value(nil)
+	if diags.HasErrors() {
+		return nil, diags
+	}
+
+	// the JSON representation can only be a string
+	if v.Type() != cty.String {
+		diags = diags.Append(&hcl.Diagnostic{
+			Severity: hcl.DiagError,
+			Summary:  "Invalid reference expression",
+			Detail:   "A single reference string is required.",
+			Subject:  expr.Range().Ptr(),
+		})
+
+		return nil, diags
+	}
+
+	rng := expr.Range()
+	expr, ds := hclsyntax.ParseExpression([]byte(v.AsString()), rng.Filename, rng.Start)
+	diags = diags.Extend(ds)
+	return expr, diags
+}
+
+// exprToResourceTraversal is used to parse the import block's to expression,
+// which must be a resource instance, but may contain limited variables with
+// index expressions. Since we only need the ConfigResource to connect the
+// import to the configuration, we skip any index expressions.
+func exprToResourceTraversal(expr hcl.Expression) (hcl.Traversal, hcl.Diagnostics) {
+	var trav hcl.Traversal
+	var diags hcl.Diagnostics
+
+	switch e := expr.(type) {
+	case *hclsyntax.RelativeTraversalExpr:
+		t, d := exprToResourceTraversal(e.Source)
+		diags = diags.Extend(d)
+		trav = append(trav, t...)
+		trav = append(trav, e.Traversal...)
+
+	case *hclsyntax.ScopeTraversalExpr:
+		// a static reference, we can just append the traversal
+		trav = append(trav, e.Traversal...)
+
+	case *hclsyntax.IndexExpr:
+		// Get the collection from the index expression, we don't need the
+		// index for a ConfigResource
+		t, d := exprToResourceTraversal(e.Collection)
+		diags = diags.Extend(d)
+		if diags.HasErrors() {
+			return nil, diags
+		}
+		trav = append(trav, t...)
+
+	default:
+		// if we don't recognise the expression type (which means we are likely
+		// dealing with a test mock), try and interpret this as an absolute
+		// traversal
+		t, d := hcl.AbsTraversalForExpr(e)
+		diags = diags.Extend(d)
+		trav = append(trav, t...)
+	}
+
+	return trav, diags
+}
+
+// parseImportToStatic attempts to parse the To address of an import block
+// statically to get the resource address. This returns false when the address
+// cannot be parsed, which is usually a result of dynamic index expressions
+// using for_each.
+func parseImportToStatic(expr hcl.Expression) (addrs.AbsResourceInstance, bool) {
+	// we may have a nil expression in some error cases, which we can just
+	// false to avoid the parsing
+	if expr == nil {
+		return addrs.AbsResourceInstance{}, false
+	}
+
+	var toDiags tfdiags.Diagnostics
+	traversal, hd := hcl.AbsTraversalForExpr(expr)
+	toDiags = toDiags.Append(hd)
+	to, td := addrs.ParseAbsResourceInstance(traversal)
+	toDiags = toDiags.Append(td)
+	return to, !toDiags.HasErrors()
+}