Fix typos.

Author: practicalswift

Diff for: include/swift/AST/ASTPrinter.h

@@ -105,7 +105,7 @@ class ASTPrinter {
     PendingDeclLocCallback = D;
   }
 
-  /// To sanitize a malformatted utf8 string to a well-formatted one.
+  /// To sanitize a malformed utf8 string to a well-formed one.
   static std::string sanitizeUtf8(StringRef Text);
   static bool printTypeInterface(Type Ty, DeclContext *DC, std::string &Result);
   static bool printTypeInterface(Type Ty, DeclContext *DC, llvm::raw_ostream &Out);

Diff for: include/swift/AST/Availability.h

@@ -117,7 +117,7 @@ class VersionRange {
   }
 
   /// Mutates this range to be the union of itself and Other. This is the
-  /// join operator (least upper bound) in the veresion range lattice.
+  /// join operator (least upper bound) in the version range lattice.
   void unionWith(const VersionRange &Other) {
     // With the existing lattice this operation is precise. If the lattice
     // is ever extended it is important that this operation be an

Diff for: include/swift/AST/Decl.h

@@ -209,7 +209,7 @@ enum class CircularityCheck {
   Checked
 };
 
-/// Keeps track of whrther a given class inherits initializers from its
+/// Keeps track of whether a given class inherits initializers from its
 /// superclass.
 enum class StoredInheritsSuperclassInits {
   /// We have not yet checked.

Diff for: include/swift/AST/Types.h

@@ -425,7 +425,7 @@ class alignas(1 << TypeAlignInBits) TypeBase {
     return getRecursiveProperties().hasOpenedExistential();
   }
 
-  /// Determine whether the type involves the given opend existential
+  /// Determine whether the type involves the given opened existential
   /// archetype.
   bool hasOpenedExistential(ArchetypeType *opened);
 

Diff for: include/swift/SIL/SILInstruction.h

@@ -3816,7 +3816,7 @@ class CondBranchInst : public TermInst {
     ConditionIdx
   };
   enum {
-    // Map branch targets to block sucessor indices.
+    // Map branch targets to block successor indices.
     TrueIdx,
     FalseIdx
   };
@@ -4252,7 +4252,7 @@ class CheckedCastAddrBranchInst : public TermInst {
 class TryApplyInstBase : public TermInst {
 public:
   enum {
-    // Map branch targets to block sucessor indices.
+    // Map branch targets to block successor indices.
     NormalIdx,
     ErrorIdx
   };

Diff for: include/swift/SIL/SILValueProjection.h

@@ -370,7 +370,7 @@ class LSValue : public SILValueProjection {
   /// we only need a map between the projection tree of a SILType and the value
   /// each leaf node takes. This will be implemented once ProjectionPath memory
   /// cost is reduced and made copyable (its copy constructor is deleted at the
-  /// momemt). 
+  /// moment).
   static SILValue reduce(LSLocation &Base, SILModule *Mod,
                          LSLocationValueMap &LocAndVal,
                          SILInstruction *InsertPt,

Diff for: include/swift/SILOptimizer/Analysis/EscapeAnalysis.h

@@ -118,7 +118,7 @@ class EscapeAnalysis : public BottomUpIPAnalysis {
   /// pointer points to (see NodeType).
   class CGNode {
 
-    /// The associated value in the functino. It is only used for debug printing.
+    /// The associated value in the function. It is only used for debug printing.
     /// There may be multiple nodes associated to the same value, e.g. a Content
     /// node has the same V as its points-to predecessor.
     ValueBase *V;
@@ -341,7 +341,7 @@ class EscapeAnalysis : public BottomUpIPAnalysis {
   /// 2) A node can only have a single outgoing points-to edge (is enforced by
   ///    CGNode::pointsTo being a single pointer and not a vector).
   /// 3) The target of a points-to edge must be a Content node.
-  /// 4) For any node N, all pathes starting at N which consist of only
+  /// 4) For any node N, all paths starting at N which consist of only
   ///    defer-edges and a single trailing points-to edge must lead to the same
   ///    Content node.
   class ConnectionGraph {
@@ -679,7 +679,7 @@ class EscapeAnalysis : public BottomUpIPAnalysis {
   /// Sets all operands and results of \p I as global escaping.
   void setAllEscaping(SILInstruction *I, ConnectionGraph *ConGraph);
 
-  /// Recomputes the connection grpah for the function \p Initial and
+  /// Recomputes the connection graph for the function \p Initial and
   /// all called functions, up to a recursion depth of MaxRecursionDepth.
   void recompute(FunctionInfo *Initial);
 
@@ -725,7 +725,7 @@ class EscapeAnalysis : public BottomUpIPAnalysis {
 
   /// Returns true if the value \p V or its content can escape to the
   /// function call \p FAS.
-  /// This is the same as above, execpt that it returns true if an address of
+  /// This is the same as above, except that it returns true if an address of
   /// a contained property escapes.
   bool canObjectOrContentEscapeTo(SILValue V, FullApplySite FAS);
 

Diff for: include/swift/SILOptimizer/Analysis/LoopRegionAnalysis.h

@@ -61,7 +61,7 @@
 ///
 /// Then we perform a postorder DFS of the loop nest. The postorder provides the
 /// inductive rule that all loops will be visited after all of their subloops
-/// hae been visited. If a Loop has no subloops (i.e. all subregions are
+/// have been visited. If a Loop has no subloops (i.e. all subregions are
 /// blocks), we do nothing. Otherwise, if the loop does have subloops, we visit
 /// each subloop and do the following:
 ///

Diff for: include/swift/SILOptimizer/Analysis/SideEffectAnalysis.h

@@ -181,7 +181,7 @@ class SideEffectAnalysis : public BottomUpIPAnalysis {
     /// release instructions, e.g. isUnique?
     bool ReadsRC = false;
 
-    /// Returns the effecs for an address or reference. This might be a
+    /// Returns the effects for an address or reference. This might be a
     /// parameter, the LocalEffects or, if the value cannot be associated to one
     /// of them, the GlobalEffects.
     Effects *getEffectsOn(SILValue Addr);

Diff for: lib/AST/ASTPrinter.cpp

@@ -121,7 +121,7 @@ std::string ASTPrinter::sanitizeUtf8(StringRef Text) {
       Builder.append(Data, Data + Step);
     } else {
 
-      // If malformatted, add replacement characters.
+      // If malformed, add replacement characters.
       Builder.append(Replacement);
     }
     Data += Step;

Diff for: lib/AST/Decl.cpp

@@ -1183,7 +1183,7 @@ ValueDecl::getAccessSemanticsFromContext(const DeclContext *UseDC) const {
 
     // "StoredWithTrivialAccessors" are generally always accessed indirectly,
     // but if we know that the trivial accessor will always produce the same
-    // thing as the getter/setter (i.e., it can't be overriden), then just do a
+    // thing as the getter/setter (i.e., it can't be overridden), then just do a
     // direct access.
     //
     // This is true in structs and for final properties.

Diff for: lib/AST/LookupVisibleDecls.cpp

@@ -588,7 +588,7 @@ class OverrideFilteringConsumer : public VisibleDeclConsumer {
     }
     auto &PossiblyConflicting = FoundDecls[VD->getName()];
 
-    // Check all overriden decls.
+    // Check all overridden decls.
     {
       auto *CurrentVD = VD->getOverriddenDecl();
       while (CurrentVD) {

Diff for: lib/AST/NameLookup.cpp

@@ -698,7 +698,7 @@ class swift::MemberLookupTable {
   /// Update a lookup table with members from newly-added extensions.
   void updateLookupTable(NominalTypeDecl *nominal);
 
-  /// \brief Add the given member to the lookup tabke.
+  /// \brief Add the given member to the lookup table.
   void addMember(Decl *members);
 
   /// \brief Add the given members to the lookup table.

Diff for: lib/AST/Verifier.cpp

@@ -674,7 +674,7 @@ struct ASTNodeBase {};
 
       if (auto Overridden = D->getOverriddenDecl()) {
         if (D->getDeclContext() == Overridden->getDeclContext()) {
-          PrettyStackTraceDecl debugStack("verifying overriden", D);
+          PrettyStackTraceDecl debugStack("verifying overridden", D);
           Out << "cannot override a decl in the same DeclContext";
           D->dump(Out);
           Overridden->dump(Out);

Diff for: lib/ClangImporter/ClangImporter.cpp

@@ -4145,7 +4145,7 @@ ClangImporter::Implementation::createExtensionWriter(clang::ASTWriter &writer) {
       auto named = dyn_cast<clang::NamedDecl>(decl);
       if (!named) continue;
 
-      // Add this entry to the lookup tabke.
+      // Add this entry to the lookup table.
       addEntryToLookupTable(sema, table, named);
     }
 

Diff for: lib/ClangImporter/ImporterImpl.h

@@ -421,7 +421,7 @@ class LLVM_LIBRARY_VISIBILITY ClangImporter::Implementation
   /// \brief Check if the declaration is one of the specially handled
   /// accessibility APIs.
   ///
-  /// These appaer as both properties and methods in ObjC and should be
+  /// These appear as both properties and methods in ObjC and should be
   /// imported as methods into Swift.
   static bool isAccessibilityDecl(const clang::Decl *objCMethodOrProp);
 

Diff for: lib/SILGen/SILGen.h

@@ -227,7 +227,7 @@ class LLVM_LIBRARY_VISIBILITY SILGenModule : public ASTVisitor<SILGenModule> {
   void emitFunction(FuncDecl *fd);
 
   /// \brief Generates code for the given closure expression and adds the
-  /// SILFunction to the current SILModule under the nane SILDeclRef(ce).
+  /// SILFunction to the current SILModule under the name SILDeclRef(ce).
   SILFunction *emitClosure(AbstractClosureExpr *ce);
   /// Generates code for the given ConstructorDecl and adds
   /// the SILFunction to the current SILModule under the name SILDeclRef(decl).

Diff for: lib/SILGen/SILGenPoly.cpp

@@ -49,7 +49,7 @@
 // parameter of the base with a concrete type, the derived class can override
 // methods in the base that involved generic types. In the derived class, a
 // method override that involves substituted types will have a different
-// SIL lowering than the base method. In this case, the overriden vtable entry
+// SIL lowering than the base method. In this case, the overridden vtable entry
 // will point to a thunk which transforms parameters and results and invokes
 // the derived method.
 //
@@ -1310,7 +1310,7 @@ static SILValue getThunkResult(SILGenFunction &gen,
 /// \param inputOrigType Abstraction pattern of function value being thunked
 /// \param inputSubstType Formal AST type of function value being thunked
 /// \param outputOrigType Abstraction pattern of the thunk
-/// \param outputSubstType Formal AST type of the thuk
+/// \param outputSubstType Formal AST type of the thunk
 static void buildThunkBody(SILGenFunction &gen, SILLocation loc,
                            AbstractionPattern inputOrigType,
                            CanAnyFunctionType inputSubstType,

Diff for: lib/SILOptimizer/ARC/ARCRegionState.h

@@ -34,7 +34,7 @@ class ARCRegionState {
   /// The region that this ARCRegionState summarizes information for.
   ///
   /// The only time that the pointer is null is during initialization. Using
-  /// NullablePtr is just a convient way to make sure that we assert if we
+  /// NullablePtr is just a convenient way to make sure that we assert if we
   /// attempt to use Region during initialization before the pointer is set.
   NullablePtr<LoopRegion> Region;
 

Diff for: lib/SILOptimizer/ARC/GlobalARCPairingAnalysis.h

@@ -95,7 +95,7 @@ class CodeMotionOrDeleteCallback {
   bool madeChange() const { return Changed; }
 };
 
-/// A wrapper around the results of the bottomup/topdown dataflow that knows how
+/// A wrapper around the results of the bottom-up/top-down dataflow that knows how
 /// to pair the retains/releases in those results.
 struct ARCPairingContext {
   SILFunction &F;

Diff for: lib/SILOptimizer/Analysis/EscapeAnalysis.cpp

@@ -297,7 +297,7 @@ updatePointsTo(CGNode *InitialNode, CGNode *pointsTo) {
     }
   }
   if (isInitialSet) {
-    // Here we handle a special case: all defer-edge pathes must eventually end
+    // Here we handle a special case: all defer-edge paths must eventually end
     // in a points-to edge to pointsTo. We ensure this by setting the edge on
     // nodes which have no defer-successors (see above). But this does not cover
     // the case where there is a terminating cyle in the defer-edge path,
@@ -1547,7 +1547,7 @@ bool EscapeAnalysis::canEscapeToUsePoint(SILValue V, ValueBase *UsePoint,
   if (!Node)
     return true;
 
-  // First check if there are escape pathes which we don't explicitly see
+  // First check if there are escape paths which we don't explicitly see
   // in the graph.
   if (Node->escapesInsideFunction(isNotAliasingArgument(V)))
     return true;
@@ -1574,7 +1574,7 @@ bool EscapeAnalysis::canObjectOrContentEscapeTo(SILValue V, FullApplySite FAS) {
   if (!Node)
     return true;
 
-  // First check if there are escape pathes which we don't explicitly see
+  // First check if there are escape paths which we don't explicitly see
   // in the graph.
   if (Node->escapesInsideFunction(isNotAliasingArgument(V)))
     return true;

Diff for: lib/SILOptimizer/IPO/CapturePromotion.cpp

@@ -391,7 +391,7 @@ static llvm::SmallString<64> getSpecializedName(SILFunction *F,
 
 /// \brief Create the function corresponding to the clone of the original
 /// closure with the signature modified to reflect promotable captures (which
-/// are givien by PromotableIndices, such that each entry in the set is the
+/// are given by PromotableIndices, such that each entry in the set is the
 /// index of the box containing the variable in the closure's argument list, and
 /// the address of the box's contents is the argument immediately following each
 /// box argument); does not actually clone the body of the function

Diff for: lib/SILOptimizer/IPO/DeadFunctionElimination.cpp

@@ -87,7 +87,7 @@ class FunctionLivenessComputation {
 
   /// Gets or creates the MethodInfo for a vtable or witness table method.
   /// \p decl The method declaration. In case of a vtable method this is always
-  ///         the most overriden method.
+  ///         the most overridden method.
   MethodInfo *getMethodInfo(AbstractFunctionDecl *decl) {
     MethodInfo *&entry = MethodInfos[decl];
     if (entry == nullptr) {

Diff for: lib/SILOptimizer/IPO/GlobalPropertyOpt.cpp

@@ -35,7 +35,7 @@ namespace {
 /// The GlobalPropertyOpt performs an analysis on the whole module to determine
 /// the values of high-level properties.
 ///
-/// Currently only one property is handled and thats the isNativeTypeChecked
+/// Currently only one property is handled and that's the isNativeTypeChecked
 /// property for arrays. If the property can be proved to be true, the
 /// corresponding semantics-call is replaced by a true-literal.
 class GlobalPropertyOpt {

Diff for: lib/SILOptimizer/Mandatory/DefiniteInitialization.cpp

@@ -2161,7 +2161,7 @@ computePredsLiveOut(SILBasicBlock *BB) {
   DEBUG(llvm::dbgs() << "  Get liveness for block " << BB->getDebugID() << "\n");
 
   // Collect blocks for which we have to calculate the out-availability.
-  // These are the pathes from blocks with known out-availability to the BB.
+  // These are the paths from blocks with known out-availability to the BB.
   WorkListType WorkList;
   for (auto Pred : BB->getPreds()) {
     putIntoWorkList(Pred, WorkList);

Diff for: lib/SILOptimizer/Mandatory/DiagnoseUnreachable.cpp

@@ -66,7 +66,7 @@ struct UnreachableInfo {
 /// it possible.
 class UnreachableUserCodeReportingState {
 public:
-  /// \brief The set of top-level blocks that became immediately unreachbale due
+  /// \brief The set of top-level blocks that became immediately unreachable due
   /// to conditional branch folding, etc.
   ///
   /// This is a SetVector since several blocks may lead to the same error
@@ -200,7 +200,7 @@ static bool constantFoldTerminator(SILBasicBlock &BB,
       SILBuilderWithScope B(&BB, CBI);
 
       // Determine which of the successors is unreachable and create a new
-      // terminator that only branches to the reachable sucessor.
+      // terminator that only branches to the reachable successor.
       SILBasicBlock *UnreachableBlock = nullptr;
       bool CondIsTrue = false;
       if (ConstCond->getValue() == APInt(1, /*value*/ 0, false)) {
@@ -645,7 +645,7 @@ static bool diagnoseUnreachableBlock(const SILBasicBlock &B,
         HasReachablePred = true;
     }
 
-    // If all of the predecessors of this sucessor are unreachable, check if
+    // If all of the predecessors of this successor are unreachable, check if
     // it contains user code.
     if (!HasReachablePred && diagnoseUnreachableBlock(*SB, M, Reachable,
                                                     State, TopLevelB, Visited))

Diff for: lib/SILOptimizer/Transforms/DeadCodeElimination.cpp

@@ -197,7 +197,7 @@ void DCE::markValueLive(ValueBase *V) {
 }
 
 /// Gets the producing instruction of a cond_fail condition. Currently these
-/// are overflow builtints but may be extended to other instructions in the
+/// are overflow builtins but may be extended to other instructions in the
 /// future.
 static SILInstruction *getProducer(CondFailInst *CFI) {
   // Check for the pattern:

Diff for: lib/SILOptimizer/Transforms/MergeCondFail.cpp

@@ -37,7 +37,7 @@ namespace {
 ///
 /// We can merge cond_fail instructions if there is no side-effect or memory
 /// write in between them.
-/// This pass merges cond_fail instructions by building the disconjunction of
+/// This pass merges cond_fail instructions by building the disjunction of
 /// their operands.
 class MergeCondFailInsts : public SILFunctionTransform {
 public:

Diff for: lib/SILOptimizer/Transforms/RedundantLoadElimination.cpp

@@ -20,7 +20,7 @@
 /// In this case, one can replace the load instruction with the previous
 /// results.
 ///
-/// Redudant Load Elimination (RLE) eliminates such loads by:
+/// Redundant Load Elimination (RLE) eliminates such loads by:
 ///
 /// 1. Introducing a notion of a LSLocation that is used to model object
 /// fields. (See below for more details).
@@ -337,7 +337,7 @@ namespace {
 
 using BBValueMap = llvm::DenseMap<SILBasicBlock *, SILValue>;
 
-/// This class stores global state that we use when computing redudant load and
+/// This class stores global state that we use when computing redundant load and
 /// their replacement in each basic block.
 class RLEContext {
   /// Function currently processing.

Diff for: lib/SILOptimizer/Transforms/SILCodeMotion.cpp

@@ -981,7 +981,7 @@ static bool hoistDecrementsToPredecessors(SILBasicBlock *BB, AliasAnalysis *AA,
 
   return HoistedDecrement;
 }
-/// Try sink a retain as far as possible.  This is either to sucessor BBs,
+/// Try sink a retain as far as possible.  This is either to successor BBs,
 /// or as far down the current BB as possible
 static bool sinkRefCountIncrement(SILBasicBlock *BB, AliasAnalysis *AA,
                                   RCIdentityFunctionInfo *RCIA) {

Diff for: lib/SILOptimizer/Transforms/SimplifyCFG.cpp

@@ -2001,7 +2001,7 @@ bool RemoveUnreachable::run() {
 }
 
 /// Checks if the block contains a cond_fail as first side-effect instruction
-/// and trys to move it to the predecessors (if beneficial). A sequence
+/// and tries to move it to the predecessors (if beneficial). A sequence
 ///
 ///     bb1:
 ///       br bb3(%c)

Diff for: lib/SILOptimizer/Transforms/StackPromotion.cpp

@@ -306,7 +306,7 @@ bool StackPromoter::canPromoteAlloc(SILInstruction *AI,
   int NumUsePointsToFind = ConGraph->getNumUsePoints(Node);
   if (NumUsePointsToFind == 0) {
     // There should always be at least one release for an allocated object.
-    // But in case all pathes from this block end in unreachable then the
+    // But in case all paths from this block end in unreachable then the
     // final release of the object may be optimized away. We bail out in this
     // case.
     return false;

Diff for: lib/SILOptimizer/Utils/Local.cpp

@@ -2301,7 +2301,7 @@ swift::analyzeStaticInitializer(SILValue V,
 
 /// Replace load sequence which may contain
 /// a chain of struct_element_addr followed by a load.
-/// The sequence is travered inside out, i.e.
+/// The sequence is traversed inside out, i.e.
 /// starting with the innermost struct_element_addr
 /// Move into utils.
 void swift::replaceLoadSequence(SILInstruction *I,

Diff for: stdlib/public/core/ArrayBuffer.swift

@@ -49,7 +49,7 @@ public struct _ArrayBuffer<Element> : _ArrayBufferType {
   var deferredTypeCheckMask : Int { return 1 }
 
   /// Returns an `_ArrayBuffer<U>` containing the same elements,
-  /// deffering checking each element's `U`-ness until it is accessed.
+  /// deferring checking each element's `U`-ness until it is accessed.
   ///
   /// - Requires: `U` is a class or `@objc` existential derived from `Element`.
   @warn_unused_result