all: fix spelling errors found by misspell

Change-Id: Icedd0c3d49259d5aee249ecb33374e9b78e0c275
Reviewed-on: https://go-review.googlesource.com/c/go/+/373376
Reviewed-by: Robert Findley <rfindley@google.com>
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Gopher Robot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>

diff --git a/src/cmd/compile/internal/types2/assignments.go b/src/cmd/compile/internal/types2/assignments.go
index 668eeac00ef28df24798f5265ba0be7d89ee8256..936930f0b108327d4c5e9f4c438544507377237a 100644 (file)
--- a/src/cmd/compile/internal/types2/assignments.go
+++ b/src/cmd/compile/internal/types2/assignments.go
@@ -268,7 +268,7 @@ func (check *Checker) typesSummary(list []Type, variadic bool) string {
                var s string
                switch {
                case t == nil:
-                       fallthrough // should not happend but be cautious
+                       fallthrough // should not happen but be cautious
                case t == Typ[Invalid]:
                        s = "<T>"
                case isUntyped(t):

diff --git a/src/cmd/compile/internal/types2/decl.go b/src/cmd/compile/internal/types2/decl.go
index a4bc3969c0de1e2ffd44663c8d088c888252ed8f..d5495304fa3d581138b0e9413e685f5d78666264 100644 (file)
--- a/src/cmd/compile/internal/types2/decl.go
+++ b/src/cmd/compile/internal/types2/decl.go
@@ -351,7 +351,7 @@ func (check *Checker) validType(typ Type, path []Object) typeInfo {
                // Instantiating such a type would lead to an infinite sequence of instantiations.
                // In general, we need "type flow analysis" to recognize those cases.
                // Example: type A[T any] struct{ x A[*T] } (issue #48951)
-               // In this algorithm we always only consider the orginal, uninstantiated type.
+               // In this algorithm we always only consider the original, uninstantiated type.
                // This won't recognize some invalid cases with parameterized types, but it
                // will terminate.
                t = t.orig

diff --git a/src/cmd/compile/internal/types2/typeterm_test.go b/src/cmd/compile/internal/types2/typeterm_test.go
index 5a5c1fa4477d9e0da4a5a4d72a4505bce65856e1..6d9c8db0348ecffea365522fef9ee1b66ad00483 100644 (file)
--- a/src/cmd/compile/internal/types2/typeterm_test.go
+++ b/src/cmd/compile/internal/types2/typeterm_test.go
@@ -99,7 +99,7 @@ func TestTermUnion(t *testing.T) {
                "~int ~string ~int ~string",
                "~int myInt ~int ∅",
 
-               // union is symmetric, but the result order isn't - repeat symmetric cases explictly
+               // union is symmetric, but the result order isn't - repeat symmetric cases explicitly
                "𝓤 ∅ 𝓤 ∅",
                "int ∅ int ∅",
                "~int ∅ ~int ∅",

diff --git a/src/cmd/internal/obj/ppc64/asm_test.go b/src/cmd/internal/obj/ppc64/asm_test.go
index ee2e5962f753ea43fdf6e5500858d911a73fd513..1de6e76b09168726efdb8d8429062c4173c0ee70 100644 (file)
--- a/src/cmd/internal/obj/ppc64/asm_test.go
+++ b/src/cmd/internal/obj/ppc64/asm_test.go
@@ -300,7 +300,7 @@ func TestLarge(t *testing.T) {
                                t.Fatal(err)
                        }
                        if !matched {
-                               t.Errorf("Failed to detect long foward BC fixup in (%v):%s\n", platenv, out)
+                               t.Errorf("Failed to detect long forward BC fixup in (%v):%s\n", platenv, out)
                        }
                        matched, err = regexp.MatchString(strings.Join(test.backpattern, "\n\t*"), string(out))
                        if err != nil {

diff --git a/src/go/types/assignments.go b/src/go/types/assignments.go
index fa05a1092024ba09d3dd47be6f1a73bdb85218b6..f75b8b6f6b65cd244c0f74d640109b7adf287188 100644 (file)
--- a/src/go/types/assignments.go
+++ b/src/go/types/assignments.go
@@ -264,7 +264,7 @@ func (check *Checker) typesSummary(list []Type, variadic bool) string {
                var s string
                switch {
                case t == nil:
-                       fallthrough // should not happend but be cautious
+                       fallthrough // should not happen but be cautious
                case t == Typ[Invalid]:
                        s = "<T>"
                case isUntyped(t):

diff --git a/src/go/types/decl.go b/src/go/types/decl.go
index 2c51329be93b04bae5a017354428e3e45241ef87..db29f11920a630b5bcd257c914d9223c06373885 100644 (file)
--- a/src/go/types/decl.go
+++ b/src/go/types/decl.go
@@ -350,7 +350,7 @@ func (check *Checker) validType(typ Type, path []Object) typeInfo {
                // Instantiating such a type would lead to an infinite sequence of instantiations.
                // In general, we need "type flow analysis" to recognize those cases.
                // Example: type A[T any] struct{ x A[*T] } (issue #48951)
-               // In this algorithm we always only consider the orginal, uninstantiated type.
+               // In this algorithm we always only consider the original, uninstantiated type.
                // This won't recognize some invalid cases with parameterized types, but it
                // will terminate.
                t = t.orig

diff --git a/src/go/types/typeterm_test.go b/src/go/types/typeterm_test.go
index 27f132a1d249a2df23599acbd51123680399d2fa..24a14102d0a0cb29d7308d1b3f2b09215205adc3 100644 (file)
--- a/src/go/types/typeterm_test.go
+++ b/src/go/types/typeterm_test.go
@@ -100,7 +100,7 @@ func TestTermUnion(t *testing.T) {
                "~int ~string ~int ~string",
                "~int myInt ~int ∅",
 
-               // union is symmetric, but the result order isn't - repeat symmetric cases explictly
+               // union is symmetric, but the result order isn't - repeat symmetric cases explicitly
                "𝓤 ∅ 𝓤 ∅",
                "int ∅ int ∅",
                "~int ∅ ~int ∅",

diff --git a/src/internal/fuzz/fuzz.go b/src/internal/fuzz/fuzz.go
index b3f1381dbbf58aaf61aaaf068b94e3a83ed691e1..37b6d2b391e6bfef99781021193dbc3451260336 100644 (file)
--- a/src/internal/fuzz/fuzz.go
+++ b/src/internal/fuzz/fuzz.go
@@ -323,7 +323,7 @@ func CoordinateFuzzing(ctx context.Context, opts CoordinateFuzzingOpts) (err err
                                                        // flakiness in the coverage counters). In order to prevent adding
                                                        // duplicate entries to the corpus (and re-writing the file on
                                                        // disk), skip it if the on disk file already exists.
-                                                       // TOOD(roland): this check is limited in that it will only be
+                                                       // TODO(roland): this check is limited in that it will only be
                                                        // applied if we are using the CacheDir. Another option would be
                                                        // to iterate through the corpus and check if it is already present,
                                                        // which would catch cases where we are not caching entries.

diff --git a/src/testing/fuzz.go b/src/testing/fuzz.go
index 17a8753ae6a654df10219f7f7dc24b8edf3dc217..efb59b3e57ad01dc2f01fd6ae535a384fcabf7d6 100644 (file)
--- a/src/testing/fuzz.go
+++ b/src/testing/fuzz.go
@@ -199,7 +199,7 @@ var supportedTypes = map[reflect.Type]bool{
 // the corresponding *T method instead. The only *F methods that are allowed in
 // the (*F).Fuzz function are (*F).Failed and (*F).Name.
 //
-// This function sould be fast and deterministic, and its behavior should not
+// This function should be fast and deterministic, and its behavior should not
 // depend on shared state. No mutatable input arguments, or pointers to them,
 // should be retained between executions of the fuzz function, as the memory
 // backing them may be mutated during a subsequent invocation. ff must not