Merge pull request #2359 from practicalswift/typo-fixes-20160501

[gardening] Fix recently introduced typos: "adavances" → "advances", etc. (10 typos)

Author: practicalswift

include/swift/Runtime/Metadata.h

@@ -1773,7 +1773,7 @@ using ClassMetadata = TargetClassMetadata<InProcess>;
 ///   captures (these aren't in the DATA segment, however).
 /// - a list of GenericMetadataSource objects - each element is a pair of:
 ///   - MangledTypeName (for a GenericTypeParameterTypeRef)
-///   - EncodededMetadataSource (an encoded string like TypeRefs, but describe
+///   - EncodedMetadataSource (an encoded string like TypeRefs, but describe
 ///     the method of crawling to the metadata for that generic type parameter.
 struct CaptureDescriptor {
 public:

include/swift/Runtime/Mutex.h

@@ -23,7 +23,7 @@
 #if (defined(__APPLE__) || defined(__linux__) || defined(__CYGWIN__) || defined(__FreeBSD__))
 #include "swift/Runtime/MutexPThread.h"
 #else
-#error "Implement equvalent of MutexPThread.h/cpp for your platform."
+#error "Implement equivalent of MutexPThread.h/cpp for your platform."
 #endif
 
 namespace swift {
@@ -718,23 +718,23 @@ static_assert(std::is_literal_type<StaticMutex>::value,
 static_assert(std::is_literal_type<StaticUnsafeMutex>::value,
               "StaticUnsafeMutex must be literal type");
 #else
-// Your platform doesn't currently support staticly allocated Mutex
+// Your platform doesn't currently support statically allocated Mutex
 // you will possibly see global-constructors warnings
 #endif
 
 #if CONDITION_SUPPORTS_CONSTEXPR
 static_assert(std::is_literal_type<StaticConditionVariable>::value,
               "StaticConditionVariable must be literal type");
 #else
-// Your platform doesn't currently support staticly allocated ConditionVar
+// Your platform doesn't currently support statically allocated ConditionVar
 // you will possibly see global-constructors warnings
 #endif
 
 #if READWRITELOCK_SUPPORTS_CONSTEXPR
 static_assert(std::is_literal_type<StaticReadWriteLock>::value,
               "StaticReadWriteLock must be literal type");
 #else
-// Your platform doesn't currently support staticly allocated ReadWriteLocks
+// Your platform doesn't currently support statically allocated ReadWriteLocks
 // you will possibly see global-constructors warnings
 #endif
 }

lib/Parse/ParseExpr.cpp

@@ -2411,7 +2411,7 @@ bool Parser::isCollectionLiteralStartingWithLSquareLit() {
    BacktrackingScope backtracking(*this);
    (void)consumeToken(tok::l_square_lit);
    switch (Tok.getKind()) {
-     // Handle both dengerate '#' and '# identifier'.
+     // Handle both degenerate '#' and '# identifier'.
      case tok::pound:
       (void) consumeToken();
       if (Tok.is(tok::identifier)) skipSingle();

lib/SILOptimizer/Transforms/UnsafeGuaranteedPeephole.cpp

@@ -82,10 +82,10 @@ getSingleUnsafeGuaranteedValueResult(BuiltinInst *BI) {
   return std::make_pair(GuaranteedValue, Token);
 }
 
-static bool hasUnsafeGuarantedOperand(SILValue UnsafeGuaranteedValue,
-                                      SILValue UnsafeGuaranteedValueOperand,
-                                      RCIdentityFunctionInfo &RCII,
-                                      SILBasicBlock::iterator ReleaseIt) {
+static bool hasUnsafeGuaranteedOperand(SILValue UnsafeGuaranteedValue,
+                                       SILValue UnsafeGuaranteedValueOperand,
+                                       RCIdentityFunctionInfo &RCII,
+                                       SILBasicBlock::iterator ReleaseIt) {
   assert(isa<StrongReleaseInst>(ReleaseIt) ||
          isa<ReleaseValueInst>(ReleaseIt) && "Expecting a release");
 
@@ -125,27 +125,27 @@ static SILBasicBlock::iterator findReleaseToMatchUnsafeGuaranteedValue(
   while (LastReleaseIt != BB.begin() &&
          (((isa<StrongReleaseInst>(*LastReleaseIt) ||
             isa<ReleaseValueInst>(*LastReleaseIt)) &&
-           !hasUnsafeGuarantedOperand(UnsafeGuaranteedRoot,
-                                      UnsafeGuaranteedOpdRoot, RCIA,
-                                      LastReleaseIt)) ||
+           !hasUnsafeGuaranteedOperand(UnsafeGuaranteedRoot,
+                                       UnsafeGuaranteedOpdRoot, RCIA,
+                                       LastReleaseIt)) ||
           !LastReleaseIt->mayHaveSideEffects() ||
           isa<DebugValueInst>(*LastReleaseIt) ||
           isa<DebugValueInst>(*LastReleaseIt)))
     --LastReleaseIt;
   if ((isa<StrongReleaseInst>(*LastReleaseIt) ||
        isa<ReleaseValueInst>(*LastReleaseIt)) &&
-      hasUnsafeGuarantedOperand(UnsafeGuaranteedRoot, UnsafeGuaranteedOpdRoot,
-                                RCIA, LastReleaseIt))
+      hasUnsafeGuaranteedOperand(UnsafeGuaranteedRoot, UnsafeGuaranteedOpdRoot,
+                                 RCIA, LastReleaseIt))
     return LastReleaseIt;
 
   // Otherwise, try finding it after the "unsafeGuaranteedEnd".
   LastReleaseIt = std::next(SILBasicBlock::iterator(UnsafeGuaranteedEndI));
   while (LastReleaseIt != BB.end() &&
          (((isa<StrongReleaseInst>(*LastReleaseIt) ||
             isa<ReleaseValueInst>(*LastReleaseIt)) &&
-           !hasUnsafeGuarantedOperand(UnsafeGuaranteedRoot,
-                                      UnsafeGuaranteedOpdRoot, RCIA,
-                                      LastReleaseIt)) ||
+           !hasUnsafeGuaranteedOperand(UnsafeGuaranteedRoot,
+                                       UnsafeGuaranteedOpdRoot, RCIA,
+                                       LastReleaseIt)) ||
           !LastReleaseIt->mayHaveSideEffects() ||
           isa<DebugValueInst>(*LastReleaseIt) ||
           isa<DebugValueInst>(*LastReleaseIt)))
@@ -154,8 +154,8 @@ static SILBasicBlock::iterator findReleaseToMatchUnsafeGuaranteedValue(
     return LastReleaseIt;
   if ((!isa<StrongReleaseInst>(*LastReleaseIt) &&
        !isa<ReleaseValueInst>(*LastReleaseIt)) ||
-      !hasUnsafeGuarantedOperand(UnsafeGuaranteedRoot, UnsafeGuaranteedOpdRoot,
-                                 RCIA, LastReleaseIt))
+      !hasUnsafeGuaranteedOperand(UnsafeGuaranteedRoot, UnsafeGuaranteedOpdRoot,
+                                  RCIA, LastReleaseIt))
     return BB.end();
 
   return LastReleaseIt;

lib/Sema/TypeCheckDecl.cpp

@@ -2292,7 +2292,7 @@ static void inferObjCName(TypeChecker &tc, ValueDecl *decl) {
   auto attr = decl->getAttrs().getAttribute<ObjCAttr>();
   if (attr && attr->hasName()) return;
 
-  // When no overridde determined the Objective-C name, look for
+  // When no override determined the Objective-C name, look for
   // requirements for which this declaration is a witness.
   Optional<ObjCSelector> requirementObjCName;
   for (auto req : tc.findWitnessedObjCRequirements(decl,

stdlib/public/core/Collection.swift

@@ -1112,7 +1112,7 @@ extension Collection {
   ///
   /// - Parameter n: The number of elements to drop from the beginning of
   ///   the sequence. `n` must be greater than or equal to zero.
-  /// - Returns: A subsquence starting after the specified number of
+  /// - Returns: A subsequence starting after the specified number of
   ///   elements.
   ///
   /// - Complexity: O(*n*), where *n* is the number of elements to drop from

stdlib/public/core/Sequence.swift

@@ -244,7 +244,7 @@ public protocol IteratorProtocol {
 ///
 /// The `Sequence` protocol provides default implementations for many common
 /// operations that depend on sequential access to a sequence's values. For
-/// clearer, more consise code, the example above could use the array's
+/// clearer, more concise code, the example above could use the array's
 /// `contains(_:)` method, which every sequence inherits from `Sequence`,
 /// instead of iterating manually:
 ///
@@ -445,7 +445,7 @@ public protocol Sequence {
   ///
   /// - Parameter n: The number of elements to drop from the beginning of
   ///   the sequence. `n` must be greater than or equal to zero.
-  /// - Returns: A subsquence starting after the specified number of
+  /// - Returns: A subsequence starting after the specified number of
   ///   elements.
   ///
   /// - Complexity: O(*n*), where *n* is the number of elements to drop from
@@ -1039,7 +1039,7 @@ extension Sequence where
   ///
   /// - Parameter n: The number of elements to drop from the beginning of
   ///   the sequence. `n` must be greater than or equal to zero.
-  /// - Returns: A subsquence starting after the specified number of
+  /// - Returns: A subsequence starting after the specified number of
   ///   elements.
   ///
   /// - Complexity: O(*n*), where *n* is the number of elements to drop from

stdlib/public/core/SetAlgebra.swift

@@ -18,7 +18,7 @@
 ///
 /// You use types that conform to the `SetAlgebra` protocol when you need
 /// efficient membership tests or mathematical set operations such as
-/// intersection, union, and substraction. In the standard library, you can
+/// intersection, union, and subtraction. In the standard library, you can
 /// use the `Set` type with elements of any hashable type, or you can easily
 /// create bit masks with `SetAlgebra` conformance using the `OptionSet`
 /// protocol. See those types for more information.

utils/swift-mode.el

@@ -182,7 +182,7 @@ Use `M-x hs-show-all' to show them again."
     s))
 
 (defun swift-skip-comments-and-space ()
-  "Skip comments and whiltespace, returning t"
+  "Skip comments and whitespace, returning t"
   (while (forward-comment 1))
   t)
 

utils/swift_build_support/tests/test_cmake.py

@@ -104,7 +104,7 @@ def test_common_options_asan_ubsan(self):
              "-DCMAKE_C_COMPILER:PATH=/path/to/clang",
              "-DCMAKE_CXX_COMPILER:PATH=/path/to/clang++"])
 
-    def test_common_options_export_compie_commands(self):
+    def test_common_options_export_compile_commands(self):
         args = self.default_args()
         args.export_compile_commands = True
         cmake = self.cmake(args)