Enable gosimple linter and fix issues (#880)

bflad · web-flow · commit 74c4eeb6c319 · 2022-02-04T13:36:13.000-05:00
Reference: #865 Previously: ```text helper/validation/float_test.go:66:17: S1007: should use raw string (`...`) with regexp.MustCompile to avoid having to escape twice (gosimple) expectedErr: regexp.MustCompile("expected [\\w]+ to be at least \\(2\\.5\\d*\\), got 1\\.5\\d*"), ^ helper/validation/float_test.go:71:17: S1007: should use raw string (`...`) with regexp.MustCompile to avoid having to escape twice (gosimple) expectedErr: regexp.MustCompile("expected type of [\\w]+ to be float"), ^ helper/validation/float_test.go:89:17: S1007: should use raw string (`...`) with regexp.MustCompile to avoid having to escape twice (gosimple) expectedErr: regexp.MustCompile("expected [\\w]+ to be at most \\(1\\.5\\d*\\), got 2\\.5\\d*"), ^ helper/validation/float_test.go:94:17: S1007: should use raw string (`...`) with regexp.MustCompile to avoid having to escape twice (gosimple) expectedErr: regexp.MustCompile("expected type of [\\w]+ to be float"), ^ helper/validation/int_test.go:21:17: S1007: should use raw string (`...`) with regexp.MustCompile to avoid having to escape twice (gosimple) expectedErr: regexp.MustCompile("expected [\\w]+ to be in the range \\(2 - 3\\), got 1"), ^ helper/validation/int_test.go:26:17: S1007: should use raw string (`...`) with regexp.MustCompile to avoid having to escape twice (gosimple) expectedErr: regexp.MustCompile("expected type of [\\w]+ to be integer"), ^ helper/validation/int_test.go:44:17: S1007: should use raw string (`...`) with regexp.MustCompile to avoid having to escape twice (gosimple) expectedErr: regexp.MustCompile("expected [\\w]+ to be at least \\(2\\), got 1"), ^ helper/validation/int_test.go:49:17: S1007: should use raw string (`...`) with regexp.MustCompile to avoid having to escape twice (gosimple) expectedErr: regexp.MustCompile("expected type of [\\w]+ to be integer"), ^ helper/validation/int_test.go:67:17: S1007: should use raw string (`...`) with regexp.MustCompile to avoid having to escape twice (gosimple) expectedErr: regexp.MustCompile("expected [\\w]+ to be at most \\(0\\), got 1"), ^ helper/validation/int_test.go:72:17: S1007: should use raw string (`...`) with regexp.MustCompile to avoid having to escape twice (gosimple) expectedErr: regexp.MustCompile("expected type of [\\w]+ to be integer"), ^ helper/validation/int_test.go:122:17: S1007: should use raw string (`...`) with regexp.MustCompile to avoid having to escape twice (gosimple) expectedErr: regexp.MustCompile("expected [\\w]+ to be one of \\[10 20\\], got 42"), ^ helper/validation/int_test.go:127:17: S1007: should use raw string (`...`) with regexp.MustCompile to avoid having to escape twice (gosimple) expectedErr: regexp.MustCompile("expected type of [\\w]+ to be integer"), ^ helper/validation/meta_test.go:55:17: S1007: should use raw string (`...`) with regexp.MustCompile to avoid having to escape twice (gosimple) expectedErr: regexp.MustCompile("expected length of [\\w]+ to be in the range \\(5 - 42\\), got foo"), ^ helper/validation/meta_test.go:90:17: S1007: should use raw string (`...`) with regexp.MustCompile to avoid having to escape twice (gosimple) expectedErr: regexp.MustCompile("expected [\\w]+ to be at least \\(42\\), got 7"), ^ helper/validation/meta_test.go:98:17: S1007: should use raw string (`...`) with regexp.MustCompile to avoid having to escape twice (gosimple) expectedErr: regexp.MustCompile("expected [\\w]+ to be at most \\(5\\), got 7"), ^ helper/validation/meta_test.go:125:17: S1007: should use raw string (`...`) with regexp.MustCompile to avoid having to escape twice (gosimple) expectedErr: regexp.MustCompile("expected [\\w]+ to be at least \\(42\\), got 7"), ^ helper/validation/meta_test.go:133:17: S1007: should use raw string (`...`) with regexp.MustCompile to avoid having to escape twice (gosimple) expectedErr: regexp.MustCompile("expected [\\w]+ to be at most \\(5\\), got 7"), ^ helper/validation/strings_test.go:293:17: S1007: should use raw string (`...`) with regexp.MustCompile to avoid having to escape twice (gosimple) expectedErr: regexp.MustCompile("expected [\\w]+ to be one of \\[ValidValue AnotherValidValue\\], got VALIDVALUE"), ^ helper/validation/strings_test.go:298:17: S1007: should use raw string (`...`) with regexp.MustCompile to avoid having to escape twice (gosimple) expectedErr: regexp.MustCompile("expected [\\w]+ to be one of \\[ValidValue AnotherValidValue\\], got InvalidValue"), ^ helper/validation/strings_test.go:303:17: S1007: should use raw string (`...`) with regexp.MustCompile to avoid having to escape twice (gosimple) expectedErr: regexp.MustCompile("expected type of [\\w]+ to be string"), ^ helper/validation/strings_test.go:322:17: S1007: should use raw string (`...`) with regexp.MustCompile to avoid having to escape twice (gosimple) expectedErr: regexp.MustCompile("expected [\\w]+ to not be any of \\[InvalidValue AnotherInvalidValue\\], got AnotherInvalidValue"), ^ helper/validation/strings_test.go:328:17: S1007: should use raw string (`...`) with regexp.MustCompile to avoid having to escape twice (gosimple) expectedErr: regexp.MustCompile("expected [\\w]+ to not be any of \\[InvalidValue AnotherInvalidValue\\], got INVALIDVALUE"), ^ helper/validation/strings_test.go:333:17: S1007: should use raw string (`...`) with regexp.MustCompile to avoid having to escape twice (gosimple) expectedErr: regexp.MustCompile("expected type of [\\w]+ to be string"), ^ helper/validation/strings_test.go:352:17: S1007: should use raw string (`...`) with regexp.MustCompile to avoid having to escape twice (gosimple) expectedErr: regexp.MustCompile("invalid value for [\\w]+ \\(value must contain foo\\)"), ^ helper/validation/strings_test.go:371:17: S1007: should use raw string (`...`) with regexp.MustCompile to avoid having to escape twice (gosimple) expectedErr: regexp.MustCompile("invalid value for [\\w]+ \\(value must not contain foo\\)"), ^ internal/plugin/convert/diagnostics.go:96:10: S1034: assigning the result of this type assertion to a variable (switch step := step.(type)) could eliminate type assertions in switch cases (gosimple) switch step.(type) { ^ internal/plugin/convert/diagnostics.go:98:25: S1034(related information): could eliminate this type assertion (gosimple) p = p.GetAttr(string(step.(tftypes.AttributeName))) ^ internal/plugin/convert/diagnostics.go:100:37: S1034(related information): could eliminate this type assertion (gosimple) p = p.Index(cty.StringVal(string(step.(tftypes.ElementKeyString)))) ^ internal/plugin/convert/diagnostics.go:102:39: S1034(related information): could eliminate this type assertion (gosimple) p = p.Index(cty.NumberIntVal(int64(step.(tftypes.ElementKeyInt)))) ^ internal/addrs/module_instance.go:95:4: S1023: redundant break statement (gosimple) break ^ internal/addrs/module_instance.go:125:4: S1023: redundant break statement (gosimple) break ^ helper/resource/testing.go:129:14: S1012: should use `time.Since` instead of `time.Now().Sub` (gosimple) elapsed := time.Now().Sub(start) ^ helper/resource/testing.go:242:13: S1012: should use `time.Since` instead of `time.Now().Sub` (gosimple) elapsed := time.Now().Sub(start) ^ helper/schema/set.go:241:2: S1032: should use sort.Strings(...) instead of sort.Sort(sort.StringSlice(...)) (gosimple) sort.Sort(sort.StringSlice(keys)) ^ helper/schema/resource.go:847:5: S1002: should omit comparison to bool constant, can be simplified to `!s.Computed` (gosimple) if s.Computed != true { ^ helper/schema/field_reader_map.go:162:3: S1008: should use 'return len(countActual) < countExpected' instead of 'if len(countActual) >= countExpected { return false }; return true' (gosimple) if len(countActual) >= countExpected { ^ terraform/state.go:1026:20: S1039: unnecessary use of fmt.Sprintf (gosimple) buf.WriteString(fmt.Sprintf("\n Dependencies:\n")) ^ terraform/state.go:1240:2: S1008: should use 'return s.Primary.Equal(other.Primary)' instead of 'if !s.Primary.Equal(other.Primary) { return false }; return true' (gosimple) if !s.Primary.Equal(other.Primary) { ```
diff --git a/.golangci.yml b/.golangci.yml
@@ -14,7 +14,7 @@ linters:
     - errcheck
     - exportloopref
     - gofmt
-    # - gosimple # TODO: https://github.com/hashicorp/terraform-plugin-sdk/issues/865
+    - gosimple
     # - ineffassign # TODO: https://github.com/hashicorp/terraform-plugin-sdk/issues/865
     # - makezero # TODO: https://github.com/hashicorp/terraform-plugin-sdk/issues/865
     - nilerr
diff --git a/helper/resource/testing.go b/helper/resource/testing.go
@@ -126,7 +126,7 @@ func runSweepers(regions []string, sweepers map[string]*Sweeper, allowFailures b
 				return sweeperRunList, fmt.Errorf("sweeper (%s) for region (%s) failed: %s", sweeper.Name, region, err)
 			}
 		}
-		elapsed := time.Now().Sub(start)
+		elapsed := time.Since(start)
 		log.Printf("Completed Sweepers for region (%s) in %s", region, elapsed)
 
 		log.Printf("Sweeper Tests for region (%s) ran successfully:\n", region)
@@ -239,7 +239,7 @@ func runSweeperWithRegion(region string, s *Sweeper, sweepers map[string]*Sweepe
 
 	start := time.Now()
 	runE := s.F(region)
-	elapsed := time.Now().Sub(start)
+	elapsed := time.Since(start)
 
 	log.Printf("[DEBUG] Completed Sweeper (%s) in region (%s) in %s", s.Name, region, elapsed)
 
diff --git a/helper/schema/field_reader_map.go b/helper/schema/field_reader_map.go
@@ -159,11 +159,8 @@ func (r *MapFieldReader) readSet(
 		// "ports.1", but the "state" map might have those plus "ports.2".
 		// We don't want "ports.2"
 		countActual[idx] = struct{}{}
-		if len(countActual) >= countExpected {
-			return false
-		}
 
-		return true
+		return len(countActual) < countExpected
 	})
 	if !completed && err != nil {
 		return FieldReadResult{}, err
diff --git a/helper/schema/resource.go b/helper/schema/resource.go
@@ -844,7 +844,7 @@ func validateResourceID(s *Schema) error {
 
 	// ID should at least be computed. If unspecified it will be set to Computed and Optional,
 	// but Optional is unnecessary if undesired.
-	if s.Computed != true {
+	if !s.Computed {
 		return fmt.Errorf(`the "id" attribute must be marked Computed`)
 	}
 	return nil
diff --git a/helper/schema/set.go b/helper/schema/set.go
@@ -3,12 +3,12 @@ package schema
 import (
 	"bytes"
 	"fmt"
-	"github.com/google/go-cmp/cmp"
 	"reflect"
 	"sort"
 	"strconv"
 	"sync"
 
+	"github.com/google/go-cmp/cmp"
 	"github.com/hashicorp/terraform-plugin-sdk/v2/internal/helper/hashcode"
 )
 
@@ -238,6 +238,6 @@ func (s *Set) listCode() []string {
 	for k := range s.m {
 		keys = append(keys, k)
 	}
-	sort.Sort(sort.StringSlice(keys))
+	sort.Strings(keys)
 	return keys
 }
diff --git a/helper/validation/float_test.go b/helper/validation/float_test.go
@@ -63,12 +63,12 @@ func TestValidateFloatAtLeast(t *testing.T) {
 		{
 			val:         1.5,
 			f:           FloatAtLeast(2.5),
-			expectedErr: regexp.MustCompile("expected [\\w]+ to be at least \\(2\\.5\\d*\\), got 1\\.5\\d*"),
+			expectedErr: regexp.MustCompile(`expected [\w]+ to be at least \(2\.5\d*\), got 1\.5\d*`),
 		},
 		{
 			val:         "2.5",
 			f:           FloatAtLeast(1.5),
-			expectedErr: regexp.MustCompile("expected type of [\\w]+ to be float"),
+			expectedErr: regexp.MustCompile(`expected type of [\w]+ to be float`),
 		},
 	})
 }
@@ -86,12 +86,12 @@ func TestValidateFloatAtMost(t *testing.T) {
 		{
 			val:         2.5,
 			f:           FloatAtMost(1.5),
-			expectedErr: regexp.MustCompile("expected [\\w]+ to be at most \\(1\\.5\\d*\\), got 2\\.5\\d*"),
+			expectedErr: regexp.MustCompile(`expected [\w]+ to be at most \(1\.5\d*\), got 2\.5\d*`),
 		},
 		{
 			val:         "2.5",
 			f:           FloatAtMost(3.5),
-			expectedErr: regexp.MustCompile("expected type of [\\w]+ to be float"),
+			expectedErr: regexp.MustCompile(`expected type of [\w]+ to be float`),
 		},
 	})
 }
diff --git a/helper/validation/int_test.go b/helper/validation/int_test.go
@@ -18,12 +18,12 @@ func TestValidationIntBetween(t *testing.T) {
 		{
 			val:         1,
 			f:           IntBetween(2, 3),
-			expectedErr: regexp.MustCompile("expected [\\w]+ to be in the range \\(2 - 3\\), got 1"),
+			expectedErr: regexp.MustCompile(`expected [\w]+ to be in the range \(2 - 3\), got 1`),
 		},
 		{
 			val:         "1",
 			f:           IntBetween(2, 3),
-			expectedErr: regexp.MustCompile("expected type of [\\w]+ to be integer"),
+			expectedErr: regexp.MustCompile(`expected type of [\w]+ to be integer`),
 		},
 	})
 }
@@ -41,12 +41,12 @@ func TestValidationIntAtLeast(t *testing.T) {
 		{
 			val:         1,
 			f:           IntAtLeast(2),
-			expectedErr: regexp.MustCompile("expected [\\w]+ to be at least \\(2\\), got 1"),
+			expectedErr: regexp.MustCompile(`expected [\w]+ to be at least \(2\), got 1`),
 		},
 		{
 			val:         "1",
 			f:           IntAtLeast(2),
-			expectedErr: regexp.MustCompile("expected type of [\\w]+ to be integer"),
+			expectedErr: regexp.MustCompile(`expected type of [\w]+ to be integer`),
 		},
 	})
 }
@@ -64,12 +64,12 @@ func TestValidationIntAtMost(t *testing.T) {
 		{
 			val:         1,
 			f:           IntAtMost(0),
-			expectedErr: regexp.MustCompile("expected [\\w]+ to be at most \\(0\\), got 1"),
+			expectedErr: regexp.MustCompile(`expected [\w]+ to be at most \(0\), got 1`),
 		},
 		{
 			val:         "1",
 			f:           IntAtMost(0),
-			expectedErr: regexp.MustCompile("expected type of [\\w]+ to be integer"),
+			expectedErr: regexp.MustCompile(`expected type of [\w]+ to be integer`),
 		},
 	})
 }
@@ -119,12 +119,12 @@ func TestValidationIntInSlice(t *testing.T) {
 		{
 			val:         42,
 			f:           IntInSlice([]int{10, 20}),
-			expectedErr: regexp.MustCompile("expected [\\w]+ to be one of \\[10 20\\], got 42"),
+			expectedErr: regexp.MustCompile(`expected [\w]+ to be one of \[10 20\], got 42`),
 		},
 		{
 			val:         "InvalidValue",
 			f:           IntInSlice([]int{10, 20}),
-			expectedErr: regexp.MustCompile("expected type of [\\w]+ to be integer"),
+			expectedErr: regexp.MustCompile(`expected type of [\w]+ to be integer`),
 		},
 	})
 }
diff --git a/helper/validation/meta_test.go b/helper/validation/meta_test.go
@@ -52,7 +52,7 @@ func TestValidationAll(t *testing.T) {
 				StringLenBetween(5, 42),
 				StringMatch(regexp.MustCompile(`[a-zA-Z0-9]+`), "value must be alphanumeric"),
 			),
-			expectedErr: regexp.MustCompile("expected length of [\\w]+ to be in the range \\(5 - 42\\), got foo"),
+			expectedErr: regexp.MustCompile(`expected length of [\w]+ to be in the range \(5 - 42\), got foo`),
 		},
 		{
 			val: "!!!!!",
@@ -87,15 +87,15 @@ func TestValidationAny(t *testing.T) {
 				IntAtLeast(42),
 				IntAtMost(5),
 			),
-			expectedErr: regexp.MustCompile("expected [\\w]+ to be at least \\(42\\), got 7"),
+			expectedErr: regexp.MustCompile(`expected [\w]+ to be at least \(42\), got 7`),
 		},
 		{
 			val: 7,
 			f: Any(
 				IntAtLeast(42),
 				IntAtMost(5),
 			),
-			expectedErr: regexp.MustCompile("expected [\\w]+ to be at most \\(5\\), got 7"),
+			expectedErr: regexp.MustCompile(`expected [\w]+ to be at most \(5\), got 7`),
 		},
 	})
 }
@@ -122,15 +122,15 @@ func TestToDiagFunc(t *testing.T) {
 				IntAtLeast(42),
 				IntAtMost(5),
 			)),
-			expectedErr: regexp.MustCompile("expected [\\w]+ to be at least \\(42\\), got 7"),
+			expectedErr: regexp.MustCompile(`expected [\w]+ to be at least \(42\), got 7`),
 		},
 		{
 			val: 7,
 			f: ToDiagFunc(Any(
 				IntAtLeast(42),
 				IntAtMost(5),
 			)),
-			expectedErr: regexp.MustCompile("expected [\\w]+ to be at most \\(5\\), got 7"),
+			expectedErr: regexp.MustCompile(`expected [\w]+ to be at most \(5\), got 7`),
 		},
 	})
 }
diff --git a/helper/validation/strings_test.go b/helper/validation/strings_test.go
@@ -290,17 +290,17 @@ func TestValidationStringInSlice(t *testing.T) {
 		{
 			val:         "VALIDVALUE",
 			f:           StringInSlice([]string{"ValidValue", "AnotherValidValue"}, false),
-			expectedErr: regexp.MustCompile("expected [\\w]+ to be one of \\[ValidValue AnotherValidValue\\], got VALIDVALUE"),
+			expectedErr: regexp.MustCompile(`expected [\w]+ to be one of \[ValidValue AnotherValidValue\], got VALIDVALUE`),
 		},
 		{
 			val:         "InvalidValue",
 			f:           StringInSlice([]string{"ValidValue", "AnotherValidValue"}, false),
-			expectedErr: regexp.MustCompile("expected [\\w]+ to be one of \\[ValidValue AnotherValidValue\\], got InvalidValue"),
+			expectedErr: regexp.MustCompile(`expected [\w]+ to be one of \[ValidValue AnotherValidValue\], got InvalidValue`),
 		},
 		{
 			val:         1,
 			f:           StringInSlice([]string{"ValidValue", "AnotherValidValue"}, false),
-			expectedErr: regexp.MustCompile("expected type of [\\w]+ to be string"),
+			expectedErr: regexp.MustCompile(`expected type of [\w]+ to be string`),
 		},
 	})
 }
@@ -319,18 +319,18 @@ func TestValidationStringNotInSlice(t *testing.T) {
 		{
 			val:         "AnotherInvalidValue",
 			f:           StringNotInSlice([]string{"InvalidValue", "AnotherInvalidValue"}, false),
-			expectedErr: regexp.MustCompile("expected [\\w]+ to not be any of \\[InvalidValue AnotherInvalidValue\\], got AnotherInvalidValue"),
+			expectedErr: regexp.MustCompile(`expected [\w]+ to not be any of \[InvalidValue AnotherInvalidValue\], got AnotherInvalidValue`),
 		},
 		// ignore case
 		{
 			val:         "INVALIDVALUE",
 			f:           StringNotInSlice([]string{"InvalidValue", "AnotherInvalidValue"}, true),
-			expectedErr: regexp.MustCompile("expected [\\w]+ to not be any of \\[InvalidValue AnotherInvalidValue\\], got INVALIDVALUE"),
+			expectedErr: regexp.MustCompile(`expected [\w]+ to not be any of \[InvalidValue AnotherInvalidValue\], got INVALIDVALUE`),
 		},
 		{
 			val:         1,
 			f:           StringNotInSlice([]string{"InvalidValue", "AnotherInvalidValue"}, false),
-			expectedErr: regexp.MustCompile("expected type of [\\w]+ to be string"),
+			expectedErr: regexp.MustCompile(`expected type of [\w]+ to be string`),
 		},
 	})
 }
@@ -344,12 +344,12 @@ func TestValidationStringMatch(t *testing.T) {
 		{
 			val:         "bar",
 			f:           StringMatch(regexp.MustCompile(".*foo.*"), ""),
-			expectedErr: regexp.MustCompile("expected value of [\\w]+ to match regular expression " + regexp.QuoteMeta(`".*foo.*"`)),
+			expectedErr: regexp.MustCompile(`expected value of [\w]+ to match regular expression ` + regexp.QuoteMeta(`".*foo.*"`)),
 		},
 		{
 			val:         "bar",
 			f:           StringMatch(regexp.MustCompile(".*foo.*"), "value must contain foo"),
-			expectedErr: regexp.MustCompile("invalid value for [\\w]+ \\(value must contain foo\\)"),
+			expectedErr: regexp.MustCompile(`invalid value for [\w]+ \(value must contain foo\)`),
 		},
 	})
 }
@@ -363,12 +363,12 @@ func TestValidationStringDoesNotMatch(t *testing.T) {
 		{
 			val:         "bar",
 			f:           StringDoesNotMatch(regexp.MustCompile(".*bar.*"), ""),
-			expectedErr: regexp.MustCompile("expected value of [\\w]+ to not match regular expression " + regexp.QuoteMeta(`".*bar.*"`)),
+			expectedErr: regexp.MustCompile(`expected value of [\w]+ to not match regular expression ` + regexp.QuoteMeta(`".*bar.*"`)),
 		},
 		{
 			val:         "bar",
 			f:           StringDoesNotMatch(regexp.MustCompile(".*bar.*"), "value must not contain foo"),
-			expectedErr: regexp.MustCompile("invalid value for [\\w]+ \\(value must not contain foo\\)"),
+			expectedErr: regexp.MustCompile(`invalid value for [\w]+ \(value must not contain foo\)`),
 		},
 	})
 }
diff --git a/internal/addrs/module_instance.go b/internal/addrs/module_instance.go
@@ -92,7 +92,6 @@ func parseModuleInstancePrefix(traversal hcl.Traversal) (ModuleInstance, hcl.Tra
 				"Invalid address operator",
 				"Module address prefix must be followed by dot and then a name.",
 			))
-			break
 		}
 
 		if next != "module" {
@@ -122,7 +121,6 @@ func parseModuleInstancePrefix(traversal hcl.Traversal) (ModuleInstance, hcl.Tra
 				"Invalid address operator",
 				"Prefix \"module.\" must be followed by a module name.",
 			))
-			break
 		}
 		remain = remain[1:]
 		step := ModuleInstanceStep{
diff --git a/internal/plugin/convert/diagnostics.go b/internal/plugin/convert/diagnostics.go
@@ -93,13 +93,13 @@ func AttributePathToPath(ap *tftypes.AttributePath) cty.Path {
 		return p
 	}
 	for _, step := range ap.Steps() {
-		switch step.(type) {
+		switch step := step.(type) {
 		case tftypes.AttributeName:
-			p = p.GetAttr(string(step.(tftypes.AttributeName)))
+			p = p.GetAttr(string(step))
 		case tftypes.ElementKeyString:
-			p = p.Index(cty.StringVal(string(step.(tftypes.ElementKeyString))))
+			p = p.Index(cty.StringVal(string(step)))
 		case tftypes.ElementKeyInt:
-			p = p.Index(cty.NumberIntVal(int64(step.(tftypes.ElementKeyInt))))
+			p = p.Index(cty.NumberIntVal(int64(step)))
 		}
 	}
 	return p
diff --git a/terraform/state.go b/terraform/state.go
@@ -1023,7 +1023,7 @@ func (m *ModuleState) String() string {
 		}
 
 		if len(rs.Dependencies) > 0 {
-			buf.WriteString(fmt.Sprintf("\n  Dependencies:\n"))
+			buf.WriteString("\n  Dependencies:\n")
 			for _, dep := range rs.Dependencies {
 				buf.WriteString(fmt.Sprintf("    %s\n", dep))
 			}
@@ -1237,11 +1237,7 @@ func (s *ResourceState) Equal(other *ResourceState) bool {
 	}
 
 	// States must be equal
-	if !s.Primary.Equal(other.Primary) {
-		return false
-	}
-
-	return true
+	return s.Primary.Equal(other.Primary)
 }
 
 // Taint marks a resource as tainted.

Original file line number	Diff line number	Diff line change
`@@ -126,7 +126,7 @@ func runSweepers(regions []string, sweepers map[string]*Sweeper, allowFailures b`
`126`	`126`	`return sweeperRunList, fmt.Errorf("sweeper (%s) for region (%s) failed: %s", sweeper.Name, region, err)`
`127`	`127`	`}`
`128`	`128`	`}`
`129`		`- elapsed := time.Now().Sub(start)`
	`129`	`+ elapsed := time.Since(start)`
`130`	`130`	`log.Printf("Completed Sweepers for region (%s) in %s", region, elapsed)`
`131`	`131`
`132`	`132`	`log.Printf("Sweeper Tests for region (%s) ran successfully:\n", region)`
`@@ -239,7 +239,7 @@ func runSweeperWithRegion(region string, s Sweeper, sweepers map[string]Sweepe`
`239`	`239`
`240`	`240`	`start := time.Now()`
`241`	`241`	`runE := s.F(region)`
`242`		`- elapsed := time.Now().Sub(start)`
	`242`	`+ elapsed := time.Since(start)`
`243`	`243`
`244`	`244`	`log.Printf("[DEBUG] Completed Sweeper (%s) in region (%s) in %s", s.Name, region, elapsed)`
`245`	`245`
Original file line number	Diff line number	Diff line change
`@@ -844,7 +844,7 @@ func validateResourceID(s *Schema) error {`
`844`	`844`
`845`	`845`	`// ID should at least be computed. If unspecified it will be set to Computed and Optional,`
`846`	`846`	`// but Optional is unnecessary if undesired.`
`847`		`- if s.Computed != true {`
	`847`	`+ if !s.Computed {`
`848`	`848`	return fmt.Errorf(`the "id" attribute must be marked Computed`)
`849`	`849`	`}`
`850`	`850`	`return nil`
Original file line number	Diff line number	Diff line change
`@@ -3,12 +3,12 @@ package schema`
`3`	`3`	`import (`
`4`	`4`	`"bytes"`
`5`	`5`	`"fmt"`
`6`		`- "github.com/google/go-cmp/cmp"`
`7`	`6`	`"reflect"`
`8`	`7`	`"sort"`
`9`	`8`	`"strconv"`
`10`	`9`	`"sync"`
`11`	`10`
	`11`	`+ "github.com/google/go-cmp/cmp"`
`12`	`12`	`"github.com/hashicorp/terraform-plugin-sdk/v2/internal/helper/hashcode"`
`13`	`13`	`)`
`14`	`14`
`@@ -238,6 +238,6 @@ func (s *Set) listCode() []string {`
`238`	`238`	`for k := range s.m {`
`239`	`239`	`keys = append(keys, k)`
`240`	`240`	`}`
`241`		`- sort.Sort(sort.StringSlice(keys))`
	`241`	`+ sort.Strings(keys)`
`242`	`242`	`return keys`
`243`	`243`	`}`
Original file line number	Diff line number	Diff line change
`@@ -63,12 +63,12 @@ func TestValidateFloatAtLeast(t *testing.T) {`
`63`	`63`	`{`
`64`	`64`	`val: 1.5,`
`65`	`65`	`f: FloatAtLeast(2.5),`
`66`		`- expectedErr: regexp.MustCompile("expected [\\w]+ to be at least \\(2\\.5\\d\\), got 1\\.5\\d"),`
	`66`	+ expectedErr: regexp.MustCompile(`expected [\w]+ to be at least \(2\.5\d\), got 1\.5\d`),
`67`	`67`	`},`
`68`	`68`	`{`
`69`	`69`	`val: "2.5",`
`70`	`70`	`f: FloatAtLeast(1.5),`
`71`		`- expectedErr: regexp.MustCompile("expected type of [\\w]+ to be float"),`
	`71`	+ expectedErr: regexp.MustCompile(`expected type of [\w]+ to be float`),
`72`	`72`	`},`
`73`	`73`	`})`
`74`	`74`	`}`
`@@ -86,12 +86,12 @@ func TestValidateFloatAtMost(t *testing.T) {`
`86`	`86`	`{`
`87`	`87`	`val: 2.5,`
`88`	`88`	`f: FloatAtMost(1.5),`
`89`		`- expectedErr: regexp.MustCompile("expected [\\w]+ to be at most \\(1\\.5\\d\\), got 2\\.5\\d"),`
	`89`	+ expectedErr: regexp.MustCompile(`expected [\w]+ to be at most \(1\.5\d\), got 2\.5\d`),
`90`	`90`	`},`
`91`	`91`	`{`
`92`	`92`	`val: "2.5",`
`93`	`93`	`f: FloatAtMost(3.5),`
`94`		`- expectedErr: regexp.MustCompile("expected type of [\\w]+ to be float"),`
	`94`	+ expectedErr: regexp.MustCompile(`expected type of [\w]+ to be float`),
`95`	`95`	`},`
`96`	`96`	`})`
`97`	`97`	`}`
Original file line number	Diff line number	Diff line change
`@@ -18,12 +18,12 @@ func TestValidationIntBetween(t *testing.T) {`
`18`	`18`	`{`
`19`	`19`	`val: 1,`
`20`	`20`	`f: IntBetween(2, 3),`
`21`		`- expectedErr: regexp.MustCompile("expected [\\w]+ to be in the range \\(2 - 3\\), got 1"),`
	`21`	+ expectedErr: regexp.MustCompile(`expected [\w]+ to be in the range \(2 - 3\), got 1`),
`22`	`22`	`},`
`23`	`23`	`{`
`24`	`24`	`val: "1",`
`25`	`25`	`f: IntBetween(2, 3),`
`26`		`- expectedErr: regexp.MustCompile("expected type of [\\w]+ to be integer"),`
	`26`	+ expectedErr: regexp.MustCompile(`expected type of [\w]+ to be integer`),
`27`	`27`	`},`
`28`	`28`	`})`
`29`	`29`	`}`
`@@ -41,12 +41,12 @@ func TestValidationIntAtLeast(t *testing.T) {`
`41`	`41`	`{`
`42`	`42`	`val: 1,`
`43`	`43`	`f: IntAtLeast(2),`
`44`		`- expectedErr: regexp.MustCompile("expected [\\w]+ to be at least \\(2\\), got 1"),`
	`44`	+ expectedErr: regexp.MustCompile(`expected [\w]+ to be at least \(2\), got 1`),
`45`	`45`	`},`
`46`	`46`	`{`
`47`	`47`	`val: "1",`
`48`	`48`	`f: IntAtLeast(2),`
`49`		`- expectedErr: regexp.MustCompile("expected type of [\\w]+ to be integer"),`
	`49`	+ expectedErr: regexp.MustCompile(`expected type of [\w]+ to be integer`),
`50`	`50`	`},`
`51`	`51`	`})`
`52`	`52`	`}`
`@@ -64,12 +64,12 @@ func TestValidationIntAtMost(t *testing.T) {`
`64`	`64`	`{`
`65`	`65`	`val: 1,`
`66`	`66`	`f: IntAtMost(0),`
`67`		`- expectedErr: regexp.MustCompile("expected [\\w]+ to be at most \\(0\\), got 1"),`
	`67`	+ expectedErr: regexp.MustCompile(`expected [\w]+ to be at most \(0\), got 1`),
`68`	`68`	`},`
`69`	`69`	`{`
`70`	`70`	`val: "1",`
`71`	`71`	`f: IntAtMost(0),`
`72`		`- expectedErr: regexp.MustCompile("expected type of [\\w]+ to be integer"),`
	`72`	+ expectedErr: regexp.MustCompile(`expected type of [\w]+ to be integer`),
`73`	`73`	`},`
`74`	`74`	`})`
`75`	`75`	`}`
`@@ -119,12 +119,12 @@ func TestValidationIntInSlice(t *testing.T) {`
`119`	`119`	`{`
`120`	`120`	`val: 42,`
`121`	`121`	`f: IntInSlice([]int{10, 20}),`
`122`		`- expectedErr: regexp.MustCompile("expected [\\w]+ to be one of \\[10 20\\], got 42"),`
	`122`	+ expectedErr: regexp.MustCompile(`expected [\w]+ to be one of \[10 20\], got 42`),
`123`	`123`	`},`
`124`	`124`	`{`
`125`	`125`	`val: "InvalidValue",`
`126`	`126`	`f: IntInSlice([]int{10, 20}),`
`127`		`- expectedErr: regexp.MustCompile("expected type of [\\w]+ to be integer"),`
	`127`	+ expectedErr: regexp.MustCompile(`expected type of [\w]+ to be integer`),
`128`	`128`	`},`
`129`	`129`	`})`
`130`	`130`	`}`
Original file line number	Diff line number	Diff line change
`@@ -290,17 +290,17 @@ func TestValidationStringInSlice(t *testing.T) {`
`290`	`290`	`{`
`291`	`291`	`val: "VALIDVALUE",`
`292`	`292`	`f: StringInSlice([]string{"ValidValue", "AnotherValidValue"}, false),`
`293`		`- expectedErr: regexp.MustCompile("expected [\\w]+ to be one of \\[ValidValue AnotherValidValue\\], got VALIDVALUE"),`
	`293`	+ expectedErr: regexp.MustCompile(`expected [\w]+ to be one of \[ValidValue AnotherValidValue\], got VALIDVALUE`),
`294`	`294`	`},`
`295`	`295`	`{`
`296`	`296`	`val: "InvalidValue",`
`297`	`297`	`f: StringInSlice([]string{"ValidValue", "AnotherValidValue"}, false),`
`298`		`- expectedErr: regexp.MustCompile("expected [\\w]+ to be one of \\[ValidValue AnotherValidValue\\], got InvalidValue"),`
	`298`	+ expectedErr: regexp.MustCompile(`expected [\w]+ to be one of \[ValidValue AnotherValidValue\], got InvalidValue`),
`299`	`299`	`},`
`300`	`300`	`{`
`301`	`301`	`val: 1,`
`302`	`302`	`f: StringInSlice([]string{"ValidValue", "AnotherValidValue"}, false),`
`303`		`- expectedErr: regexp.MustCompile("expected type of [\\w]+ to be string"),`
	`303`	+ expectedErr: regexp.MustCompile(`expected type of [\w]+ to be string`),
`304`	`304`	`},`
`305`	`305`	`})`
`306`	`306`	`}`
`@@ -319,18 +319,18 @@ func TestValidationStringNotInSlice(t *testing.T) {`
`319`	`319`	`{`
`320`	`320`	`val: "AnotherInvalidValue",`
`321`	`321`	`f: StringNotInSlice([]string{"InvalidValue", "AnotherInvalidValue"}, false),`
`322`		`- expectedErr: regexp.MustCompile("expected [\\w]+ to not be any of \\[InvalidValue AnotherInvalidValue\\], got AnotherInvalidValue"),`
	`322`	+ expectedErr: regexp.MustCompile(`expected [\w]+ to not be any of \[InvalidValue AnotherInvalidValue\], got AnotherInvalidValue`),
`323`	`323`	`},`
`324`	`324`	`// ignore case`
`325`	`325`	`{`
`326`	`326`	`val: "INVALIDVALUE",`
`327`	`327`	`f: StringNotInSlice([]string{"InvalidValue", "AnotherInvalidValue"}, true),`
`328`		`- expectedErr: regexp.MustCompile("expected [\\w]+ to not be any of \\[InvalidValue AnotherInvalidValue\\], got INVALIDVALUE"),`
	`328`	+ expectedErr: regexp.MustCompile(`expected [\w]+ to not be any of \[InvalidValue AnotherInvalidValue\], got INVALIDVALUE`),
`329`	`329`	`},`
`330`	`330`	`{`
`331`	`331`	`val: 1,`
`332`	`332`	`f: StringNotInSlice([]string{"InvalidValue", "AnotherInvalidValue"}, false),`
`333`		`- expectedErr: regexp.MustCompile("expected type of [\\w]+ to be string"),`
	`333`	+ expectedErr: regexp.MustCompile(`expected type of [\w]+ to be string`),
`334`	`334`	`},`
`335`	`335`	`})`
`336`	`336`	`}`
`@@ -344,12 +344,12 @@ func TestValidationStringMatch(t *testing.T) {`
`344`	`344`	`{`
`345`	`345`	`val: "bar",`
`346`	`346`	`f: StringMatch(regexp.MustCompile(".foo."), ""),`
`347`		- expectedErr: regexp.MustCompile("expected value of [\\w]+ to match regular expression " + regexp.QuoteMeta(`".foo."`)),
	`347`	+ expectedErr: regexp.MustCompile(`expected value of [\w]+ to match regular expression ` + regexp.QuoteMeta(`".foo."`)),
`348`	`348`	`},`
`349`	`349`	`{`
`350`	`350`	`val: "bar",`
`351`	`351`	`f: StringMatch(regexp.MustCompile(".foo."), "value must contain foo"),`
`352`		`- expectedErr: regexp.MustCompile("invalid value for [\\w]+ \\(value must contain foo\\)"),`
	`352`	+ expectedErr: regexp.MustCompile(`invalid value for [\w]+ \(value must contain foo\)`),
`353`	`353`	`},`
`354`	`354`	`})`
`355`	`355`	`}`
`@@ -363,12 +363,12 @@ func TestValidationStringDoesNotMatch(t *testing.T) {`
`363`	`363`	`{`
`364`	`364`	`val: "bar",`
`365`	`365`	`f: StringDoesNotMatch(regexp.MustCompile(".bar."), ""),`
`366`		- expectedErr: regexp.MustCompile("expected value of [\\w]+ to not match regular expression " + regexp.QuoteMeta(`".bar."`)),
	`366`	+ expectedErr: regexp.MustCompile(`expected value of [\w]+ to not match regular expression ` + regexp.QuoteMeta(`".bar."`)),
`367`	`367`	`},`
`368`	`368`	`{`
`369`	`369`	`val: "bar",`
`370`	`370`	`f: StringDoesNotMatch(regexp.MustCompile(".bar."), "value must not contain foo"),`
`371`		`- expectedErr: regexp.MustCompile("invalid value for [\\w]+ \\(value must not contain foo\\)"),`
	`371`	+ expectedErr: regexp.MustCompile(`invalid value for [\w]+ \(value must not contain foo\)`),
`372`	`372`	`},`
`373`	`373`	`})`
`374`	`374`	`}`
Original file line number	Diff line number	Diff line change
`@@ -92,7 +92,6 @@ func parseModuleInstancePrefix(traversal hcl.Traversal) (ModuleInstance, hcl.Tra`
`92`	`92`	`"Invalid address operator",`
`93`	`93`	`"Module address prefix must be followed by dot and then a name.",`
`94`	`94`	`))`
`95`		`- break`
`96`	`95`	`}`
`97`	`96`
`98`	`97`	`if next != "module" {`
`@@ -122,7 +121,6 @@ func parseModuleInstancePrefix(traversal hcl.Traversal) (ModuleInstance, hcl.Tra`
`122`	`121`	`"Invalid address operator",`
`123`	`122`	`"Prefix \"module.\" must be followed by a module name.",`
`124`	`123`	`))`
`125`		`- break`
`126`	`124`	`}`
`127`	`125`	`remain = remain[1:]`
`128`	`126`	`step := ModuleInstanceStep{`