Fix typo (a --> an, an --> a)

docs/Generics.rst

@@ -594,7 +594,7 @@ lets us describe an iteration of values of some given value type::
     func next() -> Element
   }
 
-Now, we want to express the notion of an enumerable collection, which provides a
+Now, we want to express the notion of an enumerable collection, which provides
 iteration, which we do by adding requirements into the protocol::
 
   protocol EnumerableCollection : Collection {

docs/Pattern Matching.rst

@@ -354,7 +354,7 @@ imperative language — in contrast to, say, a functional language where
 you're in an expression and you need to produce a value — there's a
 colorable argument that non-exhaustive matches should be okay.  I
 dislike this, however, and propose that it should be an error to
-make an non-exhaustive switch; people who want non-exhaustive matches
+make a non-exhaustive switch; people who want non-exhaustive matches
 can explicitly put in default cases.
 Exhaustiveness actually isn't that difficult to check, at least over
 ADTs.  It's also really the behavior that I would expect from the
@@ -689,13 +689,13 @@ interpreted according to what is found:
   value must match the named type (according to the rules below for
   'is' patterns).  It is okay for this to be trivially true.
 
-  In addition, there must be an non-empty arguments clause, and each
+  In addition, there must be a non-empty arguments clause, and each
   element in the clause must have an identifier.  For each element,
   the identifier must correspond to a known property of the named
   type, and the value of that property must satisfy the element
   pattern.
 
-- If the name resolves to a enum element, then the dynamic type
+- If the name resolves to an enum element, then the dynamic type
   of the matched value must match the enum type as discussed above,
   and the value must be of the specified element.  There must be
   an arguments clause if and only if the element has a value type.

docs/SIL.rst

@@ -4058,7 +4058,7 @@ select_value
   // %r1, %r2, %r3, etc. must have type $T
   // %n has type $T
 
-Selects one of the "case" or "default" operands based on the case of an
+Selects one of the "case" or "default" operands based on the case of a
 value. This is equivalent to a trivial `switch_value`_ branch sequence::
 
   entry:

docs/Testing.rst

@@ -355,7 +355,7 @@ CPU=i386_or_x86_64`` to ``REQUIRES: CPU=x86_64``.
 ``swift_test_mode_optimize[_unchecked|none]_<CPUNAME>`` to specify a test mode
 plus cpu configuration.
 
-``optimized_stdlib_<CPUNAME>``` to specify a optimized stdlib plus cpu
+``optimized_stdlib_<CPUNAME>``` to specify an optimized stdlib plus cpu
 configuration.
 
 Feature ``REQUIRES: executable_test``

docs/doxygen.cfg.in

@@ -1063,7 +1063,7 @@ PERL_PATH              =
 #---------------------------------------------------------------------------
 
 # If the CLASS_DIAGRAMS tag is set to YES (the default) Doxygen will 
-# generate a inheritance diagram (in HTML, RTF and LaTeX) for classes with base 
+# generate an inheritance diagram (in HTML, RTF and LaTeX) for classes with base 
 # or super classes. Setting the tag to NO turns the diagrams off. Note that 
 # this option is superseded by the HAVE_DOT option below. This is only a 
 # fallback. It is recommended to install and use dot, since it yields more 

docs/proposals/Accessors.rst

@@ -704,7 +704,7 @@ that was technically copied beforehand.  For example::
   var oldArray : [Int] = []
 
   // This function copies array before modifying it, but because that
-  // copy is of an value undergoing modification, the copy will use
+  // copy is of a value undergoing modification, the copy will use
   // the same buffer and therefore observe updates to the element.
   func foo(inout element: Int) {
     oldArray = array

docs/proposals/Enums.rst

@@ -281,7 +281,7 @@ circumstances:
   StringLiteralConvertible.
 - None of the cases of the enum may have non-void payloads.
 
-If an enum declares an raw type, then its cases may declare raw
+If an enum declares a raw type, then its cases may declare raw
 values. raw values must be integer, float, character, or string
 literals, and must be unique within the enum. If the raw type is
 IntegerLiteralConvertible, then the raw values default to

docs/proposals/InitializerInheritance.rst

@@ -378,7 +378,7 @@ a trivial ``NSDocument``::
 
 In Swift, there would be no way to create an object of type
 ``MyDocument``. However, the frameworks will allocate an instance of
-``MyDocument`` and then send an message such as
+``MyDocument`` and then send a message such as
 ``initWithContentsOfURL:ofType:error:`` to the object. This will find
 ``-[NSDocument initWithContentsOfURL:ofType:error:]``, which delegates
 to ``-[NSDocument init]``, leaving ``MyDocument``'s stored properties

docs/proposals/OptimizerEffects.rst

@@ -795,7 +795,7 @@ Store (1) and load (2) do not alias and (3) is defined as ``readnone``. So (1)
 could be moved over (3).
 
 Currently inlining is prevented in high-level SIL for all functions which
-have an semantics or effect attribute. Therefore we could say that the
+have a semantics or effect attribute. Therefore we could say that the
 implementor of a pure value type has to define effects on all member functions
 which eventually can access or modify the storage.
 

stdlib/public/core/Arrays.swift.gyb

@@ -19,7 +19,7 @@
 //    contiguous sequence of `Element`s.
 //
 //  - `Array<Element>` is like `ContiguousArray<Element>` when `Element` is not
-//    an reference type or an Objective-C existential.  Otherwise, it may use
+//    a reference type or an Objective-C existential.  Otherwise, it may use
 //    an `NSArray` bridged from Cocoa for storage.
 //
 //===----------------------------------------------------------------------===//

stdlib/public/core/AssertCommon.swift

@@ -179,7 +179,7 @@ func _fatalErrorMessage(prefix: StaticString, _ message: StaticString,
   Builtin.int_trap()
 }
 
-/// Prints a fatal error message when a unimplemented initializer gets
+/// Prints a fatal error message when an unimplemented initializer gets
 /// called by the Objective-C runtime.
 @_transparent @noreturn
 public // COMPILER_INTRINSIC

stdlib/public/core/StaticString.swift

@@ -17,7 +17,7 @@
 // are involved in its construction.  This feature is crucial for
 // preventing infinite recursion even in non-asserting cases.
 
-/// An simple string designed to represent text that is "knowable at
+/// A simple string designed to represent text that is "knowable at
 /// compile-time".
 ///
 /// Logically speaking, each instance looks something like this:

stdlib/public/core/UnicodeScalar.swift

@@ -159,7 +159,7 @@ public struct UnicodeScalar :
     return (self >= "A" && self <= "Z") || (self >= "a" && self <= "z")
   }
 
-  // FIXME: Is there an similar term of art in Unicode?
+  // FIXME: Is there a similar term of art in Unicode?
   @warn_unused_result
   public func _isASCIIDigit() -> Bool {
     return self >= "0" && self <= "9"

stdlib/public/runtime/ExistentialMetadataImpl.h

@@ -325,7 +325,7 @@ struct LLVM_LIBRARY_VISIBILITY ClassExistentialBox
   static constexpr size_t isBitwiseTakable = true;
 };
 
-/// A non-fixed box implementation class for an class existential
+/// A non-fixed box implementation class for a class existential
 /// type with a dynamic number of witness tables.
 struct LLVM_LIBRARY_VISIBILITY NonFixedClassExistentialBox
     : ClassExistentialBoxBase {

stdlib/public/runtime/HeapObject.cpp

@@ -105,7 +105,7 @@ extern "C" HeapObject* swift_bufferAllocate(
 }
 
 /// \brief Another entrypoint for swift_bufferAllocate.
-/// It is generated by the compiler in some corner cases, e.g. if an serialized
+/// It is generated by the compiler in some corner cases, e.g. if a serialized
 /// optimzed module is imported into a non-optimized main module.
 /// TODO: This is only a workaround. Remove this function as soon as we can
 /// get rid of the llvm SwiftStackPromotion pass.
@@ -116,7 +116,7 @@ extern "C" HeapObject* swift_bufferAllocateOnStack(
 
 /// \brief Called at the end of the lifetime of an object returned by
 /// swift_bufferAllocateOnStack.
-/// It is generated by the compiler in some corner cases, e.g. if an serialized
+/// It is generated by the compiler in some corner cases, e.g. if a serialized
 /// optimzed module is imported into a non-optimized main module.
 /// TODO: This is only a workaround. Remove this function as soon as we can
 /// get rid of the llvm SwiftStackPromotion pass.

stdlib/public/runtime/UnicodeNormalization.cpp

@@ -78,7 +78,7 @@ class ASCIICollation {
     return &collation;
   }
 
-  /// Maps an ASCII character to an collation element priority as would be
+  /// Maps an ASCII character to a collation element priority as would be
   /// returned by a call to ucol_next().
   int32_t map(unsigned char c) const {
     return CollationTable[c];
@@ -287,7 +287,7 @@ int32_t _swift_stdlib_unicode_strToUpper(uint16_t *Destination,
 /// Convert the unicode string to lowercase. This function will return the
 /// required buffer length as a result. If this length does not match the
 /// 'DestinationCapacity' this function must be called again with a buffer of
-/// the required length to get an lowercase version of the string.
+/// the required length to get a lowercase version of the string.
 extern "C"
 int32_t _swift_stdlib_unicode_strToLower(uint16_t *Destination,
                                          int32_t DestinationCapacity,