[WIP]: Add failing test for missing computed map entries

config/interpolate.go

@@ -149,6 +149,10 @@ func (v *ModuleVariable) FullKey() string {
 	return v.key
 }
 
+func (v *ModuleVariable) GoString() string {
+	return fmt.Sprintf("*%#v", *v)
+}
+
 func NewPathVariable(key string) (*PathVariable, error) {
 	var fieldType PathValueType
 	parts := strings.SplitN(key, ".", 2)

config/interpolate_test.go

@@ -240,6 +240,22 @@ func TestDetectVariables(t *testing.T) {
 				},
 			},
 		},
+
+		{
+			`foo ${module.foo.output["key"]}`,
+			[]InterpolatedVariable{
+				&ModuleVariable{
+					Name:  "foo",
+					Field: "output",
+					key:   "module.foo.output",
+				},
+				&ModuleVariable{
+					Name:  "foo",
+					Field: "output",
+					key:   "module.foo.output",
+				},
+			},
+		},
 	}
 
 	for _, tc := range cases {

config/interpolate_walk.go

@@ -176,8 +176,7 @@ func (w *interpolationWalker) Primitive(v reflect.Value) error {
 		}
 
 		if remove {
-			w.removeCurrent()
-			return nil
+			w.unknownKeys = append(w.unknownKeys, strings.Join(w.key, "."))
 		}
 
 		resultVal := reflect.ValueOf(replaceVal)
@@ -209,27 +208,6 @@ func (w *interpolationWalker) Primitive(v reflect.Value) error {
 	return nil
 }
 
-func (w *interpolationWalker) removeCurrent() {
-	// Append the key to the unknown keys
-	w.unknownKeys = append(w.unknownKeys, strings.Join(w.key, "."))
-
-	for i := 1; i <= len(w.cs); i++ {
-		c := w.cs[len(w.cs)-i]
-		switch c.Kind() {
-		case reflect.Map:
-			// Zero value so that we delete the map key
-			var val reflect.Value
-
-			// Get the key and delete it
-			k := w.csData.(reflect.Value)
-			c.SetMapIndex(k, val)
-			return
-		}
-	}
-
-	panic("No container found for removeCurrent")
-}
-
 func (w *interpolationWalker) replaceCurrent(v reflect.Value) {
 	c := w.cs[len(w.cs)-2]
 	switch c.Kind() {

config/interpolate_walk_test.go

@@ -169,8 +169,14 @@ func TestInterpolationWalker_replace(t *testing.T) {
 					"bing",
 				},
 			},
-			Output: map[string]interface{}{},
-			Value:  []interface{}{UnknownVariableValue, "baz"},
+			Output: map[string]interface{}{
+				"foo": []interface{}{
+					UnknownVariableValue,
+					"baz",
+					"bing",
+				},
+			},
+			Value: []interface{}{UnknownVariableValue, "baz"},
 		},
 	}
 

config/raw_config.go

@@ -127,27 +127,6 @@ func (r *RawConfig) Interpolate(vs map[string]ast.Variable) error {
 
 	config := langEvalConfig(vs)
 	return r.interpolate(func(root ast.Node) (interface{}, error) {
-		// We detect the variables again and check if the value of any
-		// of the variables is the computed value. If it is, then we
-		// treat this entire value as computed.
-		//
-		// We have to do this here before the `lang.Eval` because
-		// if any of the variables it depends on are computed, then
-		// the interpolation can fail at runtime for other reasons. Example:
-		// `${count.index+1}`: in a world where `count.index` is computed,
-		// this would fail a type check since the computed placeholder is
-		// a string, but realistically the whole value is just computed.
-		vars, err := DetectVariables(root)
-		if err != nil {
-			return "", err
-		}
-		for _, v := range vars {
-			varVal, ok := vs[v.FullKey()]
-			if ok && varVal.Value == UnknownVariableValue {
-				return UnknownVariableValue, nil
-			}
-		}
-
 		// None of the variables we need are computed, meaning we should
 		// be able to properly evaluate.
 		result, err := hil.Eval(root, config)

config/raw_config_test.go

@@ -191,7 +191,7 @@ func TestRawConfig_merge(t *testing.T) {
 			},
 			"var.baz": ast.Variable{
 				Value: UnknownVariableValue,
-				Type:  ast.TypeString,
+				Type:  ast.TypeUnknown,
 			},
 		}
 		if err := rc2.Interpolate(vars); err != nil {
@@ -216,6 +216,7 @@ func TestRawConfig_merge(t *testing.T) {
 	expected := map[string]interface{}{
 		"foo": "foovalue",
 		"bar": "barvalue",
+		"baz": UnknownVariableValue,
 	}
 	if !reflect.DeepEqual(actual, expected) {
 		t.Fatalf("bad: %#v", actual)
@@ -250,15 +251,15 @@ func TestRawConfig_unknown(t *testing.T) {
 	vars := map[string]ast.Variable{
 		"var.bar": ast.Variable{
 			Value: UnknownVariableValue,
-			Type:  ast.TypeString,
+			Type:  ast.TypeUnknown,
 		},
 	}
 	if err := rc.Interpolate(vars); err != nil {
 		t.Fatalf("err: %s", err)
 	}
 
 	actual := rc.Config()
-	expected := map[string]interface{}{}
+	expected := map[string]interface{}{"foo": UnknownVariableValue}
 
 	if !reflect.DeepEqual(actual, expected) {
 		t.Fatalf("bad: %#v", actual)
@@ -283,15 +284,50 @@ func TestRawConfig_unknownPartial(t *testing.T) {
 	vars := map[string]ast.Variable{
 		"var.bar": ast.Variable{
 			Value: UnknownVariableValue,
-			Type:  ast.TypeString,
+			Type:  ast.TypeUnknown,
+		},
+	}
+	if err := rc.Interpolate(vars); err != nil {
+		t.Fatalf("err: %s", err)
+	}
+
+	actual := rc.Config()
+	expected := map[string]interface{}{"foo": UnknownVariableValue}
+
+	if !reflect.DeepEqual(actual, expected) {
+		t.Fatalf("bad: %#v", actual)
+	}
+
+	expectedKeys := []string{"foo"}
+	if !reflect.DeepEqual(rc.UnknownKeys(), expectedKeys) {
+		t.Fatalf("bad: %#v", rc.UnknownKeys())
+	}
+}
+
+func TestRawConfig_unknownPartialList(t *testing.T) {
+	raw := map[string]interface{}{
+		"foo": []interface{}{
+			"${var.bar}/32",
+		},
+	}
+
+	rc, err := NewRawConfig(raw)
+	if err != nil {
+		t.Fatalf("err: %s", err)
+	}
+
+	vars := map[string]ast.Variable{
+		"var.bar": ast.Variable{
+			Value: UnknownVariableValue,
+			Type:  ast.TypeUnknown,
 		},
 	}
 	if err := rc.Interpolate(vars); err != nil {
 		t.Fatalf("err: %s", err)
 	}
 
 	actual := rc.Config()
-	expected := map[string]interface{}{}
+	expected := map[string]interface{}{"foo": []interface{}{UnknownVariableValue}}
 
 	if !reflect.DeepEqual(actual, expected) {
 		t.Fatalf("bad: %#v", actual)

helper/diff/resource_builder.go

@@ -3,6 +3,7 @@ package diff
 import (
 	"strings"
 
+	"github.com/hashicorp/terraform/config"
 	"github.com/hashicorp/terraform/flatmap"
 	"github.com/hashicorp/terraform/terraform"
 )
@@ -94,7 +95,7 @@ func (b *ResourceBuilder) Diff(
 
 			// If this key is in the cleaned config, then use that value
 			// because it'll have its variables properly interpolated
-			if cleanV, ok := flatConfig[k]; ok {
+			if cleanV, ok := flatConfig[k]; ok && cleanV != config.UnknownVariableValue {
 				v = cleanV
 				originalV = v
 

helper/schema/field_reader_config_test.go

@@ -344,7 +344,7 @@ func TestConfigFieldReader_ComputedSet(t *testing.T) {
 			}, map[string]ast.Variable{
 				"var.foo": ast.Variable{
 					Value: config.UnknownVariableValue,
-					Type:  ast.TypeString,
+					Type:  ast.TypeUnknown,
 				},
 			}),
 			false,
@@ -362,7 +362,7 @@ func TestConfigFieldReader_ComputedSet(t *testing.T) {
 			}, map[string]ast.Variable{
 				"var.foo": ast.Variable{
 					Value: config.UnknownVariableValue,
-					Type:  ast.TypeString,
+					Type:  ast.TypeUnknown,
 				},
 			}),
 			false,