Explicitly set TypeSets of nested objects (#2660)

google/resource_compute_firewall.go

@@ -36,7 +36,7 @@ func resourceComputeFirewallRuleHash(v interface{}) int {
 
 	// We need to make sure to sort the strings below so that we always
 	// generate the same hash code no matter what is in the set.
-	if v, ok := m["ports"]; ok {
+	if v, ok := m["ports"]; ok && v != nil {
 		s := convertStringArr(v.([]interface{}))
 		sort.Strings(s)
 
@@ -81,44 +81,16 @@ func resourceComputeFirewall() *schema.Resource {
 				DiffSuppressFunc: compareSelfLinkOrResourceName,
 			},
 			"allow": {
-				Type:     schema.TypeSet,
+				Type:          schema.TypeSet,
-				Optional: true,
+				Optional:      true,
-				Elem: &schema.Resource{
+				Elem:          computeFirewallAllowSchema(),
-					Schema: map[string]*schema.Schema{
-						"protocol": {
-							Type:     schema.TypeString,
-							Required: true,
-						},
-						"ports": {
-							Type:     schema.TypeList,
-							Optional: true,
-							Elem: &schema.Schema{
-								Type: schema.TypeString,
-							},
-						},
-					},
-				},
 				Set:           resourceComputeFirewallRuleHash,
 				ConflictsWith: []string{"deny"},
 			},
 			"deny": {
-				Type:     schema.TypeSet,
+				Type:          schema.TypeSet,
-				Optional: true,
+				Optional:      true,
-				Elem: &schema.Resource{
+				Elem:          computeFirewallDenySchema(),
-					Schema: map[string]*schema.Schema{
-						"protocol": {
-							Type:     schema.TypeString,
-							Required: true,
-						},
-						"ports": {
-							Type:     schema.TypeList,
-							Optional: true,
-							Elem: &schema.Schema{
-								Type: schema.TypeString,
-							},
-						},
-					},
-				},
 				Set:           resourceComputeFirewallRuleHash,
 				ConflictsWith: []string{"allow"},
 			},
@@ -218,6 +190,42 @@ func resourceComputeFirewall() *schema.Resource {
 	}
 }
 
+func computeFirewallAllowSchema() *schema.Resource {
+	return &schema.Resource{
+		Schema: map[string]*schema.Schema{
+			"protocol": {
+				Type:     schema.TypeString,
+				Required: true,
+			},
+			"ports": {
+				Type:     schema.TypeList,
+				Optional: true,
+				Elem: &schema.Schema{
+					Type: schema.TypeString,
+				},
+			},
+		},
+	}
+}
+
+func computeFirewallDenySchema() *schema.Resource {
+	return &schema.Resource{
+		Schema: map[string]*schema.Schema{
+			"protocol": {
+				Type:     schema.TypeString,
+				Required: true,
+			},
+			"ports": {
+				Type:     schema.TypeList,
+				Optional: true,
+				Elem: &schema.Schema{
+					Type: schema.TypeString,
+				},
+			},
+		},
+	}
+}
+
 func resourceComputeFirewallCreate(d *schema.ResourceData, meta interface{}) error {
 	config := meta.(*Config)
 
@@ -595,14 +603,14 @@ func flattenComputeFirewallAllow(v interface{}, d *schema.ResourceData) interfac
 		return v
 	}
 	l := v.([]interface{})
-	transformed := make([]interface{}, 0, len(l))
+	transformed := schema.NewSet(resourceComputeFirewallRuleHash, []interface{}{})
 	for _, raw := range l {
 		original := raw.(map[string]interface{})
 		if len(original) < 1 {
 			// Do not include empty json objects coming back from the api
 			continue
 		}
-		transformed = append(transformed, map[string]interface{}{
+		transformed.Add(map[string]interface{}{
 			"protocol": flattenComputeFirewallAllowProtocol(original["IPProtocol"], d),
 			"ports":    flattenComputeFirewallAllowPorts(original["ports"], d),
 		})
@@ -626,14 +634,14 @@ func flattenComputeFirewallDeny(v interface{}, d *schema.ResourceData) interface
 		return v
 	}
 	l := v.([]interface{})
-	transformed := make([]interface{}, 0, len(l))
+	transformed := schema.NewSet(resourceComputeFirewallRuleHash, []interface{}{})
 	for _, raw := range l {
 		original := raw.(map[string]interface{})
 		if len(original) < 1 {
 			// Do not include empty json objects coming back from the api
 			continue
 		}
-		transformed = append(transformed, map[string]interface{}{
+		transformed.Add(map[string]interface{}{
 			"protocol": flattenComputeFirewallDenyProtocol(original["IPProtocol"], d),
 			"ports":    flattenComputeFirewallDenyPorts(original["ports"], d),
 		})

google/resource_compute_subnetwork.go

@@ -159,6 +159,7 @@ func resourceComputeSubnetwork() *schema.Resource {
 		},
 	}
 }
+
 func resourceComputeSubnetworkSecondaryIpRangeSetStyleDiff(diff *schema.ResourceDiff, meta interface{}) error {
 	keys := diff.GetChangedKeysPrefix("secondary_ip_range")
 	if len(keys) == 0 {

google/resource_compute_url_map.go

@@ -60,26 +60,7 @@ func resourceComputeUrlMap() *schema.Resource {
 			"host_rule": {
 				Type:     schema.TypeSet,
 				Optional: true,
-				Elem: &schema.Resource{
+				Elem:     computeUrlMapHostRuleSchema(),
-					Schema: map[string]*schema.Schema{
-						"hosts": {
-							Type:     schema.TypeSet,
-							Required: true,
-							Elem: &schema.Schema{
-								Type: schema.TypeString,
-							},
-							Set: schema.HashString,
-						},
-						"path_matcher": {
-							Type:     schema.TypeString,
-							Required: true,
-						},
-						"description": {
-							Type:     schema.TypeString,
-							Optional: true,
-						},
-					},
-				},
 				// Default schema.HashSchema is used.
 			},
 			"path_matcher": {
@@ -175,6 +156,29 @@ func resourceComputeUrlMap() *schema.Resource {
 	}
 }
 
+func computeUrlMapHostRuleSchema() *schema.Resource {
+	return &schema.Resource{
+		Schema: map[string]*schema.Schema{
+			"hosts": {
+				Type:     schema.TypeSet,
+				Required: true,
+				Elem: &schema.Schema{
+					Type: schema.TypeString,
+				},
+				Set: schema.HashString,
+			},
+			"path_matcher": {
+				Type:     schema.TypeString,
+				Required: true,
+			},
+			"description": {
+				Type:     schema.TypeString,
+				Optional: true,
+			},
+		},
+	}
+}
+
 func resourceComputeUrlMapCreate(d *schema.ResourceData, meta interface{}) error {
 	config := meta.(*Config)
 
@@ -471,14 +475,14 @@ func flattenComputeUrlMapHost_rule(v interface{}, d *schema.ResourceData) interf
 		return v
 	}
 	l := v.([]interface{})
-	transformed := make([]interface{}, 0, len(l))
+	transformed := schema.NewSet(schema.HashResource(computeUrlMapHostRuleSchema()), []interface{}{})
 	for _, raw := range l {
 		original := raw.(map[string]interface{})
 		if len(original) < 1 {
 			// Do not include empty json objects coming back from the api
 			continue
 		}
-		transformed = append(transformed, map[string]interface{}{
+		transformed.Add(map[string]interface{}{
 			"description":  flattenComputeUrlMapHost_ruleDescription(original["description"], d),
 			"hosts":        flattenComputeUrlMapHost_ruleHosts(original["hosts"], d),
 			"path_matcher": flattenComputeUrlMapHost_rulePathMatcher(original["pathMatcher"], d),