core: Support native lists in Terraform configuration

config/config.go

@@ -158,6 +158,7 @@ type VariableType byte
 const (
 	VariableTypeUnknown VariableType = iota
 	VariableTypeString
+	VariableTypeList
 	VariableTypeMap
 )
 
@@ -167,6 +168,8 @@ func (v VariableType) Printable() string {
 		return "string"
 	case VariableTypeMap:
 		return "map"
+	case VariableTypeList:
+		return "list"
 	default:
 		return "unknown"
 	}
@@ -348,16 +351,30 @@ func (c *Config) Validate() error {
 				m.Id()))
 		}
 
-		// Check that the configuration can all be strings
+		// Check that the configuration can all be strings, lists or maps
 		raw := make(map[string]interface{})
 		for k, v := range m.RawConfig.Raw {
 			var strVal string
-			if err := mapstructure.WeakDecode(v, &strVal); err != nil {
-				errs = append(errs, fmt.Errorf(
-					"%s: variable %s must be a string value",
-					m.Id(), k))
+			if err := mapstructure.WeakDecode(v, &strVal); err == nil {
+				raw[k] = strVal
+				continue
+			}
+
+			var mapVal map[string]interface{}
+			if err := mapstructure.WeakDecode(v, &mapVal); err == nil {
+				raw[k] = mapVal
+				continue
+			}
+
+			var sliceVal []interface{}
+			if err := mapstructure.WeakDecode(v, &sliceVal); err == nil {
+				raw[k] = sliceVal
+				continue
 			}
-			raw[k] = strVal
+
+			errs = append(errs, fmt.Errorf(
+				"%s: variable %s must be a string, list or map value",
+				m.Id(), k))
 		}
 
 		// Check for invalid count variables
@@ -705,7 +722,8 @@ func (c *Config) validateVarContextFn(
 
 			if rv.Multi && rv.Index == -1 {
 				*errs = append(*errs, fmt.Errorf(
-					"%s: multi-variable must be in a slice", source))
+					"%s: use of the splat ('*') operator must be wrapped in a list declaration",
+					source))
 			}
 		}
 	}
@@ -813,6 +831,7 @@ func (v *Variable) Merge(v2 *Variable) *Variable {
 var typeStringMap = map[string]VariableType{
 	"string": VariableTypeString,
 	"map":    VariableTypeMap,
+	"list":   VariableTypeList,
 }
 
 // Type returns the type of variable this is.
@@ -872,9 +891,9 @@ func (v *Variable) inferTypeFromDefault() VariableType {
 		return VariableTypeString
 	}
 
-	var strVal string
-	if err := mapstructure.WeakDecode(v.Default, &strVal); err == nil {
-		v.Default = strVal
+	var s string
+	if err := mapstructure.WeakDecode(v.Default, &s); err == nil {
+		v.Default = s
 		return VariableTypeString
 	}
 
@@ -884,5 +903,11 @@ func (v *Variable) inferTypeFromDefault() VariableType {
 		return VariableTypeMap
 	}
 
+	var l []string
+	if err := mapstructure.WeakDecode(v.Default, &l); err == nil {
+		v.Default = l
+		return VariableTypeList
+	}
+
 	return VariableTypeUnknown
 }

config/config_test.go

@@ -215,8 +215,15 @@ func TestConfigValidate_moduleVarInt(t *testing.T) {
 
 func TestConfigValidate_moduleVarMap(t *testing.T) {
 	c := testConfig(t, "validate-module-var-map")
-	if err := c.Validate(); err == nil {
-		t.Fatal("should be invalid")
+	if err := c.Validate(); err != nil {
+		t.Fatalf("should be valid: %s", err)
+	}
+}
+
+func TestConfigValidate_moduleVarList(t *testing.T) {
+	c := testConfig(t, "validate-module-var-list")
+	if err := c.Validate(); err != nil {
+		t.Fatalf("should be valid: %s", err)
 	}
 }
 
@@ -367,10 +374,10 @@ func TestConfigValidate_varDefault(t *testing.T) {
 	}
 }
 
-func TestConfigValidate_varDefaultBadType(t *testing.T) {
-	c := testConfig(t, "validate-var-default-bad-type")
-	if err := c.Validate(); err == nil {
-		t.Fatal("should not be valid")
+func TestConfigValidate_varDefaultListType(t *testing.T) {
+	c := testConfig(t, "validate-var-default-list-type")
+	if err := c.Validate(); err != nil {
+		t.Fatal("should be valid: %s", err)
 	}
 }
 

config/interpolate.go

@@ -284,18 +284,35 @@ func DetectVariables(root ast.Node) ([]InterpolatedVariable, error) {
 			return n
 		}
 
-		vn, ok := n.(*ast.VariableAccess)
-		if !ok {
-			return n
-		}
-
-		v, err := NewInterpolatedVariable(vn.Name)
-		if err != nil {
-			resultErr = err
+		switch vn := n.(type) {
+		case *ast.VariableAccess:
+			v, err := NewInterpolatedVariable(vn.Name)
+			if err != nil {
+				resultErr = err
+				return n
+			}
+			result = append(result, v)
+		case *ast.Index:
+			if va, ok := vn.Target.(*ast.VariableAccess); ok {
+				v, err := NewInterpolatedVariable(va.Name)
+				if err != nil {
+					resultErr = err
+					return n
+				}
+				result = append(result, v)
+			}
+			if va, ok := vn.Key.(*ast.VariableAccess); ok {
+				v, err := NewInterpolatedVariable(va.Name)
+				if err != nil {
+					resultErr = err
+					return n
+				}
+				result = append(result, v)
+			}
+		default:
 			return n
 		}
 
-		result = append(result, v)
 		return n
 	}