Fix typos

becuase -> because
preceeds -> precedes
initalizer -> initializer
intialize -> initialize
libary -> library
notfication -> notification
reciever -> receiver
collecton -> collection
exlcusive -> exclusive
techincal -> technical
compatability -> compatibility
setps -> steps
accomodate -> accommodate
brakcet -> bracket
fraciton -> fraction
programm -> program
concequently -> consequently
ecoding -> encoding
timeIntervalforSelfEnd -> timeIntervalForSelfEnd

Author: Matt Zanchelli

lib/AST/Attr.cpp

@@ -721,7 +721,7 @@ bool DeclAttribute::printImpl(ASTPrinter &Printer, const PrintOptions &Options,
     // if the overriden decl is invisible from the interface. Otherwise, an error
     // will occur while building the Swift module because the overriding decl
     // doesn't override anything.
-    // We couldn't skip every `override` keywords becuase they change the
+    // We couldn't skip every `override` keywords because they change the
     // ABI if the overriden decl is also publically visible.
     // For public-override-internal case, having `override` doesn't have ABI
     // implication. Thus we can skip them.

stdlib/public/Darwin/Foundation/Data.swift

@@ -183,7 +183,7 @@ internal final class __DataStorage {
     @inlinable // This is inlinable as trivially computable.
     var isExternallyOwned: Bool {
         // all __DataStorages will have some sort of capacity, because empty cases hit the .empty enum _Representation
-        // anything with 0 capacity means that we have not allocated this pointer and concequently mutation is not ours to make.
+        // anything with 0 capacity means that we have not allocated this pointer and consequently mutation is not ours to make.
         return _capacity == 0
     }
 

stdlib/public/Darwin/Foundation/DateInterval.swift

@@ -145,8 +145,8 @@ public struct DateInterval : ReferenceConvertible, Comparable, Hashable, Codable
     public func contains(_ date: Date) -> Bool {
         let timeIntervalForGivenDate = date.timeIntervalSinceReferenceDate
         let timeIntervalForSelfStart = start.timeIntervalSinceReferenceDate
-        let timeIntervalforSelfEnd = end.timeIntervalSinceReferenceDate
-        if (timeIntervalForGivenDate >= timeIntervalForSelfStart) && (timeIntervalForGivenDate <= timeIntervalforSelfEnd) {
+        let timeIntervalForSelfEnd = end.timeIntervalSinceReferenceDate
+        if (timeIntervalForGivenDate >= timeIntervalForSelfStart) && (timeIntervalForGivenDate <= timeIntervalForSelfEnd) {
             return true
         }
         return false

stdlib/public/Darwin/Foundation/NSStringAPI.swift

@@ -205,7 +205,7 @@ extension String {
   ///
   /// - Parameters:
   ///   - bytes: A sequence of bytes to interpret using `encoding`.
-  ///   - encoding: The ecoding to use to interpret `bytes`.
+  ///   - encoding: The encoding to use to interpret `bytes`.
   public init?<S: Sequence>(bytes: __shared S, encoding: Encoding)
   where S.Iterator.Element == UInt8 {
     let byteArray = Array(bytes)

stdlib/public/Darwin/Foundation/Publishers+NotificationCenter.swift

@@ -22,7 +22,7 @@ extension NotificationCenter {
     ///
     /// - Parameters:
     ///   - name: The name of the notification to publish.
-    ///   - object: The object posting the named notfication. If `nil`, the publisher emits elements for any object producing a notification with the given name.
+    ///   - object: The object posting the named notification. If `nil`, the publisher emits elements for any object producing a notification with the given name.
     /// - Returns: A publisher that emits events when broadcasting notifications.
     public func publisher(
         for name: Notification.Name,
@@ -43,15 +43,15 @@ extension NotificationCenter {
         public let center: NotificationCenter
         /// The name of notifications published by this publisher.
         public let name: Notification.Name
-        /// The object posting the named notfication.
+        /// The object posting the named notification.
         public let object: AnyObject?
 
         /// Creates a publisher that emits events when broadcasting notifications.
         ///
         /// - Parameters:
         ///   - center: The notification center to publish notifications for.
         ///   - name: The name of the notification to publish.
-        ///   - object: The object posting the named notfication. If `nil`, the publisher emits elements for any object producing a notification with the given name.
+        ///   - object: The object posting the named notification. If `nil`, the publisher emits elements for any object producing a notification with the given name.
         public init(center: NotificationCenter, name: Notification.Name, object: AnyObject? = nil) {
             self.center = center
             self.name = name

stdlib/public/SwiftOnoneSupport/SwiftOnoneSupport.swift

@@ -15,7 +15,7 @@ import Swift
 
 // =============================================================================
 // Definitions of proxy functions that mimic a generic function signature in the
-// standard library and are annotated with the standard libary's
+// standard library and are annotated with the standard library's
 // actual generic function name. The "prespecialize" annotation forces
 // the actual generic function to be specialized based on the argument
 // types passed to the proxy function.

stdlib/public/core/Array.swift

@@ -1111,7 +1111,7 @@ extension Array: RangeReplaceableCollection {
   internal mutating func _reserveCapacityAssumingUniqueBuffer(oldCount: Int) {
     // Due to make_mutable hoisting the situation can arise where we hoist
     // _makeMutableAndUnique out of loop and use it to replace
-    // _makeUniqueAndReserveCapacityIfNotUnique that preceeds this call. If the
+    // _makeUniqueAndReserveCapacityIfNotUnique that precedes this call. If the
     // array was empty _makeMutableAndUnique does not replace the empty array
     // buffer by a unique buffer (it just replaces it by the empty array
     // singleton).

stdlib/public/core/ArraySlice.swift

@@ -867,7 +867,7 @@ extension ArraySlice: RangeReplaceableCollection {
   internal mutating func _reserveCapacityAssumingUniqueBuffer(oldCount: Int) {
     // Due to make_mutable hoisting the situation can arise where we hoist
     // _makeMutableAndUnique out of loop and use it to replace
-    // _makeUniqueAndReserveCapacityIfNotUnique that preceeds this call. If the
+    // _makeUniqueAndReserveCapacityIfNotUnique that precedes this call. If the
     // array was empty _makeMutableAndUnique does not replace the empty array
     // buffer by a unique buffer (it just replaces it by the empty array
     // singleton).

stdlib/public/core/Character.swift

@@ -145,7 +145,7 @@ extension Character :
 
   /// Creates a character with the specified value.
   ///
-  /// Do not call this initalizer directly. It is used by the compiler when
+  /// Do not call this initializer directly. It is used by the compiler when
   /// you use a string literal to initialize a `Character` instance. For
   /// example:
   ///

stdlib/public/core/ContiguousArray.swift

@@ -746,7 +746,7 @@ extension ContiguousArray: RangeReplaceableCollection {
   internal mutating func _reserveCapacityAssumingUniqueBuffer(oldCount: Int) {
     // Due to make_mutable hoisting the situation can arise where we hoist
     // _makeMutableAndUnique out of loop and use it to replace
-    // _makeUniqueAndReserveCapacityIfNotUnique that preceeds this call. If the
+    // _makeUniqueAndReserveCapacityIfNotUnique that precedes this call. If the
     // array was empty _makeMutableAndUnique does not replace the empty array
     // buffer by a unique buffer (it just replaces it by the empty array
     // singleton).

stdlib/public/core/DictionaryBuilder.swift

@@ -49,7 +49,7 @@ extension Dictionary {
   ///
   /// Foundation uses this initializer to bridge the contents of an NSDictionary
   /// instance without allocating a pair of intermediary buffers.  Pass the
-  /// required capacity and a closure that can intialize the dictionary's
+  /// required capacity and a closure that can initialize the dictionary's
   /// elements. The closure must return `c`, the number of initialized elements
   /// in both buffers, such that the elements in the range `0..<c` are
   /// initialized and the elements in the range `c..<capacity` are

stdlib/public/core/Diffing.swift

@@ -136,7 +136,7 @@ extension BidirectionalCollection {
   ///   - areEquivalent: A closure that returns a Boolean value indicating
   ///     whether two elements are equivalent.
   ///
-  /// - Returns: The difference needed to produce the reciever's state from
+  /// - Returns: The difference needed to produce the receiver's state from
   ///   the parameter's state.
   ///
   /// - Complexity: Worst case performance is O(*n* * *m*), where *n* is the

stdlib/public/core/EitherSequence.swift

@@ -107,15 +107,15 @@ extension _EitherCollection: Collection {
     switch (self,position) {
     case let (.left(s),.left(i)): return s[i]
     case let (.right(s),.right(i)): return s[i]
-    default: fatalError("_EitherCollecton: Sequence used with other index type")
+    default: fatalError("_EitherCollection: Sequence used with other index type")
     }
   }
 
   internal func index(after i: Index) -> Index {
     switch (self,i) {
     case let (.left(s),.left(i)): return .left(s.index(after: i))
     case let (.right(s),.right(i)): return .right(s.index(after: i))
-    default: fatalError("_EitherCollecton: wrong type of index used")
+    default: fatalError("_EitherCollection: wrong type of index used")
     }
   }
 
@@ -129,15 +129,15 @@ extension _EitherCollection: Collection {
       return s.index(i, offsetBy: distance, limitedBy: limit).map { .left($0) }
     case let (.right(s),.right(i),.right(limit)):
       return s.index(i, offsetBy: distance, limitedBy: limit).map { .right($0) }
-    default: fatalError("_EitherCollecton: wrong type of index used")
+    default: fatalError("_EitherCollection: wrong type of index used")
     }
   }
 
   internal func index(_ i: Index, offsetBy distance: Int) -> Index {
     switch (self,i) {
     case let (.left(s),.left(i)): return .left(s.index(i, offsetBy: distance))
     case let (.right(s),.right(i)): return .right(s.index(i, offsetBy: distance))
-    default: fatalError("_EitherCollecton: wrong type of index used")
+    default: fatalError("_EitherCollection: wrong type of index used")
     }
   }
 
@@ -147,7 +147,7 @@ extension _EitherCollection: Collection {
       return s.distance(from: i, to: j)
     case let (.right(s),.right(i),.right(j)):
       return s.distance(from: i, to: j)
-    default: fatalError("_EitherCollecton: wrong type of index used")
+    default: fatalError("_EitherCollection: wrong type of index used")
     }
   }
 }
@@ -161,7 +161,7 @@ extension _EitherBidirectionalCollection: BidirectionalCollection {
     switch (self,i) {
     case let (.left(s),.left(i)): return .left(s.index(before: i))
     case let (.right(s),.right(i)): return .right(s.index(before: i))
-    default: fatalError("_EitherCollecton: wrong type of index used")
+    default: fatalError("_EitherCollection: wrong type of index used")
     }
   }
 }

stdlib/public/core/Filter.swift

@@ -187,7 +187,7 @@ extension LazyFilterCollection: Collection {
   internal func _ensureBidirectional(step: Int) {
     // FIXME: This seems to be the best way of checking whether _base is
     // forward only without adding an extra protocol requirement.
-    // index(_:offsetBy:limitedBy:) is chosen becuase it is supposed to return
+    // index(_:offsetBy:limitedBy:) is chosen because it is supposed to return
     // nil when the resulting index lands outside the collection boundaries,
     // and therefore likely does not trap in these cases.
     if step < 0 {

stdlib/public/core/Flatten.swift

@@ -328,7 +328,7 @@ extension FlattenCollection: Collection {
   internal func _ensureBidirectional(step: Int) {
     // FIXME: This seems to be the best way of checking whether _base is
     // forward only without adding an extra protocol requirement.
-    // index(_:offsetBy:limitedBy:) is chosen becuase it is supposed to return
+    // index(_:offsetBy:limitedBy:) is chosen because it is supposed to return
     // nil when the resulting index lands outside the collection boundaries,
     // and therefore likely does not trap in these cases.
     if step < 0 {

stdlib/public/core/KeyPath.swift

@@ -748,7 +748,7 @@ internal enum KeyPathComponent: Hashable {
 internal final class ClassHolder<ProjectionType> {
 
   /// The type of the scratch record passed to the runtime to record
-  /// accesses to guarantee exlcusive access.
+  /// accesses to guarantee exclusive access.
   internal typealias AccessRecord = Builtin.UnsafeValueBuffer
 
   internal var previous: AnyObject?

stdlib/public/core/LegacyABI.swift

@@ -82,7 +82,7 @@ extension String {
 
 extension String.UTF16View {
   // Swift 5.x: This was accidentally shipped as inlinable, but was never used
-  // from an inlinable context. The definition is kept around for techincal ABI
+  // from an inlinable context. The definition is kept around for technical ABI
   // compatibility (even though it shouldn't matter), but is unused.
   @inlinable @inline(__always)
   internal var _shortHeuristic: Int { return 32 }

stdlib/public/core/Sequence.swift

@@ -1159,7 +1159,7 @@ extension IteratorSequence: IteratorProtocol, Sequence {
   }
 }
 
-/* FIXME: ideally for compatability we would declare
+/* FIXME: ideally for compatibility we would declare
 extension Sequence {
   @available(swift, deprecated: 5, message: "")
   public typealias SubSequence = AnySequence<Element>

stdlib/public/core/Slice.swift

@@ -31,7 +31,7 @@
 ///
 /// You're tasked with finding the day with the most absences in the second
 /// half of the session. To find the index of the day in question, follow
-/// these setps:
+/// these steps:
 ///
 /// 1) Create a slice of the `absences` array that holds the second half of the
 ///    days.

stdlib/public/core/StringGutsRangeReplaceable.swift

@@ -71,15 +71,15 @@ extension _StringGuts {
     self.grow(n) // TODO: no factor should be applied
   }
 
-  // Grow to accomodate at least `n` code units
+  // Grow to accommodate at least `n` code units
   @usableFromInline
   internal mutating func grow(_ n: Int) {
     defer { self._invariantCheck() }
 
     _internalInvariant(
       self.uniqueNativeCapacity == nil || self.uniqueNativeCapacity! < n)
 
-    // TODO: Dont' do this! Growth should only happen for append...
+    // TODO: Don't do this! Growth should only happen for append...
     let growthTarget = Swift.max(n, (self.uniqueNativeCapacity ?? 0) * 2)
 
     if _fastPath(isFastUTF8) {
@@ -122,7 +122,7 @@ extension _StringGuts {
         "growth should produce enough capacity")
     }
 
-    // See if we can accomodate without growing or copying. If we have
+    // See if we can accommodate without growing or copying. If we have
     // sufficient capacity, we do not need to grow, and we can skip the copy if
     // unique. Otherwise, growth is required.
     let sufficientCapacity: Bool

stdlib/public/core/StringRangeReplaceableCollection.swift

@@ -31,7 +31,7 @@ extension String: RangeReplaceableCollection {
     self.init(repeating: repeatedValue._str, count: count)
   }
 
-  // This initializer disambiguates between the following intitializers, now
+  // This initializer disambiguates between the following initializers, now
   // that String conforms to Collection:
   // - init<T>(_ value: T) where T: LosslessStringConvertible
   // - init<S>(_ characters: S) where S: Sequence, S.Element == Character

stdlib/public/core/UnicodeScalarProperties.swift

@@ -1156,7 +1156,7 @@ extension Unicode.Scalar.Properties {
   /// The name of a scalar is immutable and never changed in future versions of
   /// the Unicode Standard. The `nameAlias` property is provided to issue
   /// corrections if a name was issued erroneously. For example, the `name` of
-  /// U+FE18 is "PRESENTATION FORM FOR VERTICAL RIGHT WHITE LENTICULAR BRAKCET"
+  /// U+FE18 is "PRESENTATION FORM FOR VERTICAL RIGHT WHITE LENTICULAR BRACKET"
   /// (note that "BRACKET" is misspelled). The `nameAlias` property then
   /// contains the corrected name.
   ///
@@ -1356,7 +1356,7 @@ extension Unicode {
     /// type or a non-digit numeric value.
     ///
     /// This numeric type includes fractions such as "⅕" (U+2155 VULGAR
-    /// FRACITON ONE FIFTH), numerical CJK ideographs like "兆" (U+5146 CJK
+    /// FRACTION ONE FIFTH), numerical CJK ideographs like "兆" (U+5146 CJK
     /// UNIFIED IDEOGRAPH-5146), and other scalars that are not decimal digits
     /// used positionally in the writing of base-10 numbers.
     ///

stdlib/public/core/Unmanaged.swift

@@ -124,7 +124,7 @@ public struct Unmanaged<Instance: AnyObject> {
   /// Violation of this will incur undefined behavior.
   ///
   /// A lifetime of a reference 'the instance' is fixed over a point in the
-  /// programm if:
+  /// program if:
   ///
   /// * There exists a global variable that references 'the instance'.
   ///

tools/swift-api-digester/ModuleAnalyzerNodes.h

@@ -105,7 +105,7 @@ enum class NodeMatchReason: uint8_t {
   // The second node is missing.
   Removed,
 
-  // The nodes are considered a pair becuase they have same/similar name.
+  // The nodes are considered a pair because they have same/similar name.
   Name,
 
   // The nodes are matched because they're in the same order, e.g. ith child of