fix: correct spelling errors in comments and documentation

_tools/customlint/testdata/shadow/shadow.go

@@ -268,7 +268,7 @@ func F17(read func() (v any, err error), sendError func(error) error) error {
 		v, err := read()
 		if err != nil {
 			if err == errSome {
-				// OK: use after asignnent above; switching to = below would not be observable.
+				// OK: use after assignment above; switching to = below would not be observable.
 				if err := sendError(err); err != nil {
 					return err
 				}
@@ -287,7 +287,7 @@ func F17b(read func() (v any, err error), sendError func(error) error) error {
 			return err
 		}
 		if v == "bad value" {
-			// OK: use after asignnent above; switching to = below would not be observable.
+			// OK: use after assignment above; switching to = below would not be observable.
 			if err := sendError(err); err != nil {
 				return err
 			}
@@ -302,7 +302,7 @@ func F18(index int) int {
 		}
 
 		if index == 1 {
-			// Dubuious; did this mean to keep the value for another execution?
+			// Dubious; did this mean to keep the value for another execution?
 			index := 2
 			println(index)
 			return index

internal/ast/precedence.go

@@ -58,7 +58,7 @@ const (
 	OperatorPrecedenceLogicalOR
 	// LogicalANDExpression:
 	//     BitwiseORExpression
-	//     LogicalANDExprerssion `&&` BitwiseORExpression
+	//     LogicalANDExpression `&&` BitwiseORExpression
 	OperatorPrecedenceLogicalAND
 	// BitwiseORExpression:
 	//     BitwiseXORExpression

internal/ast/symbolflags.go

@@ -59,7 +59,7 @@ const (
 	SymbolFlagsPropertyExcludes                    = SymbolFlagsValue & ^SymbolFlagsProperty
 	SymbolFlagsEnumMemberExcludes                  = SymbolFlagsValue | SymbolFlagsType
 	SymbolFlagsFunctionExcludes                    = SymbolFlagsValue & ^(SymbolFlagsFunction | SymbolFlagsValueModule | SymbolFlagsClass)
-	SymbolFlagsClassExcludes                       = (SymbolFlagsValue | SymbolFlagsType) & ^(SymbolFlagsValueModule | SymbolFlagsInterface | SymbolFlagsFunction) // class-interface mergability done in checker.ts
+	SymbolFlagsClassExcludes                       = (SymbolFlagsValue | SymbolFlagsType) & ^(SymbolFlagsValueModule | SymbolFlagsInterface | SymbolFlagsFunction) // class-interface mergeability done in checker.ts
 	SymbolFlagsInterfaceExcludes                   = SymbolFlagsType & ^(SymbolFlagsInterface | SymbolFlagsClass)
 	SymbolFlagsRegularEnumExcludes                 = (SymbolFlagsValue | SymbolFlagsType) & ^(SymbolFlagsRegularEnum | SymbolFlagsValueModule) // regular enums merge only with regular enums and modules
 	SymbolFlagsConstEnumExcludes                   = (SymbolFlagsValue | SymbolFlagsType) & ^SymbolFlagsConstEnum                              // const enums merge only with const enums

internal/ast/utilities.go

@@ -454,7 +454,7 @@ func IsCommaExpression(node *Node) bool {
 
 func IsCommaSequence(node *Node) bool {
 	// !!!
-	// New compiler just has binary expressinons.
+	// New compiler just has binary expressions.
 	// Maybe this should consider KindCommaListExpression even though we don't generate them.
 	return IsCommaExpression(node)
 }

internal/checker/emitresolver.go

@@ -97,7 +97,7 @@ func (r *emitResolver) isAliasResolvedToValue(symbol *ast.Symbol, excludeTypeOnl
 		if container := ast.GetSourceFileOfNode(symbol.ValueDeclaration); container != nil {
 			fileSymbol := c.getSymbolOfDeclaration(container.AsNode())
 			// Ensures cjs export assignment is setup, since this symbol may point at, and merge with, the file itself.
-			// If we don't, the merge may not have yet occured, and the flags check below will be missing flags that
+			// If we don't, the merge may not have yet occurred, and the flags check below will be missing flags that
 			// are added as a result of the merge.
 			c.resolveExternalModuleSymbol(fileSymbol, false /*dontResolveAlias*/)
 		}

internal/checker/inference.go

@@ -198,7 +198,7 @@ func (c *Checker) inferFromTypes(n *InferenceState, source *Type, target *Type)
 		} else if target.flags&TypeFlagsIndexedAccess != 0 {
 			indexType := c.getSimplifiedType(target.AsIndexedAccessType().indexType, false /*writing*/)
 			// Generally simplifications of instantiable indexes are avoided to keep relationship checking correct, however if our target is an access, we can consider
-			// that key of that access to be "instantiated", since we're looking to find the infernce goal in any way we can.
+			// that key of that access to be "instantiated", since we're looking to find the inference goal in any way we can.
 			if indexType.flags&TypeFlagsInstantiable != 0 {
 				simplified := c.distributeIndexOverObjectType(c.getSimplifiedType(target.AsIndexedAccessType().objectType, false /*writing*/), indexType, false /*writing*/)
 				if simplified != nil && simplified != target {

internal/checker/relater.go

@@ -2680,7 +2680,7 @@ func (r *Relater) hasExcessProperties(source *Type, target *Type, reportErrors b
 					}
 					if ast.IsJsxAttributes(r.errorNode) || isJsxOpeningLikeElement(r.errorNode) || isJsxOpeningLikeElement(r.errorNode.Parent) {
 						// !!!
-						// // JsxAttributes has an object-literal flag and undergo same type-assignablity check as normal object-literal.
+						// // JsxAttributes has an object-literal flag and undergo same type-assignability check as normal object-literal.
 						// // However, using an object-literal error message will be very confusing to the users so we give different a message.
 						// if prop.valueDeclaration && isJsxAttribute(prop.valueDeclaration) && ast.GetSourceFileOfNode(errorNode) == ast.GetSourceFileOfNode(prop.valueDeclaration.name) {
 						// 	// Note that extraneous children (as in `<NoChild>extra</NoChild>`) don't pass this check,