Spelling ide

include/swift/IDE/CancellableResult.h

@@ -147,7 +147,7 @@ class CancellableResult {
   /// \p Handle with either the transformed value or the failure or cancelled
   /// result.
   /// The \c async part of the map means that the transform might happen
-  /// asyncronously. This function does not introduce asynchronicity by itself.
+  /// asynchronously. This function does not introduce asynchronicity by itself.
   /// \p Transform might also invoke the callback synchronously.
   template <typename NewResultType>
   void

include/swift/IDE/CodeCompletionResult.h

@@ -219,7 +219,7 @@ enum class CompletionKind : uint8_t {
   ForEachInKw,
   AfterPoundExpr,
   AfterPoundDirective,
-  PlatformConditon,
+  PlatformCondition,
   AfterIfStmtElse,
   GenericRequirement,
   PrecedenceGroup,
@@ -265,7 +265,7 @@ enum class NotRecommendedReason : uint8_t {
 };
 
 /// TODO: We consider deprecation warnings as context free although they don't
-/// produce deprecation warnings insdide context that have the same or a
+/// produce deprecation warnings inside context that have the same or a
 /// stronger deprecation attribute.
 /// E.g.
 /// In SDK:
@@ -361,9 +361,9 @@ class ContextFreeCodeCompletionResult {
   /// Memberwise initializer. \p AssociatedKInd is opaque and will be
   /// interpreted based on \p Kind. If \p KnownOperatorKind is \c None and the
   /// completion item is an operator, it will be determined based on the
-  /// compleiton string.
+  /// completion string.
   ///
-  /// \note The caller must ensure that the \p CompleitonString and all the
+  /// \note The caller must ensure that the \p CompletionString and all the
   /// \c Ref types outlive this result, typically by storing them in the same
   /// \c CodeCompletionResultSink as the result itself.
   ContextFreeCodeCompletionResult(

include/swift/IDE/CodeCompletionResultSink.h

@@ -38,7 +38,7 @@ struct CodeCompletionResultSink {
   /// position.
   bool addInitsToTopLevel = false;
 
-  /// Whether to perform "call pettern heuristics".
+  /// Whether to perform "call pattern heuristics".
   bool enableCallPatternHeuristics = false;
 
   /// Whether to include an item without any default arguments.

include/swift/IDE/CodeCompletionResultType.h

@@ -160,13 +160,13 @@ class USRBasedTypeContext {
   class ContextualType {
     /// The types that the result type must be identical/convertible to to
     /// compute the type relation. Needs to be a vector because for the
-    /// conextual type `some MyProto & MyOtherProto`, the return type must be
+    /// contextual type `some MyProto & MyOtherProto`, the return type must be
     /// convertible to both \c MyProto and \c MyOtherProto to be considered
     /// convertible.
     llvm::SmallVector<const USRBasedType *, 1> Types;
 
   public:
-    /// Compute the type relation of \p ResultType to this conextual type.
+    /// Compute the type relation of \p ResultType to this contextual type.
     CodeCompletionResultTypeRelation
     typeRelation(const USRBasedType *ResultType,
                  const USRBasedType *VoidType) const;
@@ -227,7 +227,7 @@ class USRBasedType {
       : USR(USR), Supertypes(Supertypes),
         CustomAttributeKinds(CustomAttributeKinds) {}
 
-  /// Implementation of \c typeRelation. \p VisistedTypes keeps track which
+  /// Implementation of \c typeRelation. \p VisitedTypes keeps track which
   /// types have already been visited.
   CodeCompletionResultTypeRelation
   typeRelationImpl(const USRBasedType *ResultType, const USRBasedType *VoidType,
@@ -286,7 +286,7 @@ class CodeCompletionResultType {
   ///    It would be nice if we could use a SmallVector to store those types
   ///    instead but \c CodeCompletionResultType is allocated in a bump
   ///    allocator and freeing the bump allocator does not call the
-  ///    SmallVecotor's destructor, leaking potential heap memory. Since we only
+  ///    SmallVector's destructor, leaking potential heap memory. Since we only
   ///    need two result types at the moment, I decided to implement it in a
   ///    hacky way with two pointers.
   /// The \c getResultTypes and \c isApplicable methods mask away this

include/swift/IDE/CodeCompletionStringPrinter.h

@@ -66,12 +66,12 @@ class CodeCompletionStringPrinter : public ASTPrinter {
 
   /// Start \c AttributeAndModifierListBegin group. This must be called before
   /// any attributes/modifiers printed to the output when printing an override
-  /// compleion.
+  /// completion.
   void startPreamble();
 
   /// End the current \c AttributeAndModifierListBegin group if it's still open.
   /// This is automatically called before the main part of the signature.
-  void endPremable();
+  void endPreamble();
 
   /// Implement \c ASTPrinter .
 public:

include/swift/IDE/CompletionLookup.h

@@ -44,7 +44,7 @@ bool KeyPathFilter(ValueDecl *decl, DeclVisibilityKind,
                    DynamicLookupInfo dynamicLookupInfo);
 
 /// Returns \c true only if the completion is happening for top-level
-/// declrarations. i.e.:
+/// declarations. i.e.:
 ///
 ///     if condition {
 ///       #false#
@@ -604,7 +604,7 @@ class CompletionLookup final : public swift::VisibleDeclConsumer {
 
   void getPoundAvailablePlatformCompletions();
 
-  /// \p Loc is the location of the code completin token.
+  /// \p Loc is the location of the code completion token.
   /// \p isForDeclResult determines if were are spelling out the result type
   /// of a declaration.
   void getSelfTypeCompletionInDeclContext(SourceLoc Loc, bool isForDeclResult);

include/swift/IDE/IDERequestIDZone.def

@@ -16,7 +16,7 @@
 //===----------------------------------------------------------------------===//
 
 SWIFT_REQUEST(IDE, CollectOverriddenDeclsRequest,
-              ArrayRef<ValueDecl *>(OverridenDeclsOwner), Cached,
+              ArrayRef<ValueDecl *>(OverriddenDeclsOwner), Cached,
               NoLocationInfo)
 SWIFT_REQUEST(IDE, CursorInfoRequest, ide::ResolvedCursorInfo(CursorInfoOwner),
               Cached, NoLocationInfo)

include/swift/IDE/IDERequests.h

@@ -25,7 +25,7 @@
 
 namespace swift {
 //----------------------------------------------------------------------------//
-// Cusor info
+// Cursor info
 //----------------------------------------------------------------------------//
 
 // Input for CursorInfoRequest.
@@ -171,36 +171,36 @@ class ProvideDefaultImplForRequest:
 //----------------------------------------------------------------------------//
 // CollectOverriddenDeclsRequest
 //----------------------------------------------------------------------------//
-struct OverridenDeclsOwner {
+struct OverriddenDeclsOwner {
   ValueDecl *VD;
   bool IncludeProtocolRequirements;
   bool Transitive;
 
-  OverridenDeclsOwner(ValueDecl *VD, bool IncludeProtocolRequirements,
+  OverriddenDeclsOwner(ValueDecl *VD, bool IncludeProtocolRequirements,
     bool Transitive): VD(VD),
       IncludeProtocolRequirements(IncludeProtocolRequirements),
       Transitive(Transitive) {}
 
-  friend llvm::hash_code hash_value(const OverridenDeclsOwner &CI) {
+  friend llvm::hash_code hash_value(const OverriddenDeclsOwner &CI) {
     return llvm::hash_combine(CI.VD,
                               CI.IncludeProtocolRequirements,
                               CI.Transitive);
   }
 
-  friend bool operator==(const OverridenDeclsOwner &lhs,
-                         const OverridenDeclsOwner &rhs) {
+  friend bool operator==(const OverriddenDeclsOwner &lhs,
+                         const OverriddenDeclsOwner &rhs) {
     return lhs.VD == rhs.VD &&
       lhs.IncludeProtocolRequirements == rhs.IncludeProtocolRequirements &&
       lhs.Transitive == rhs.Transitive;
   }
 
-  friend bool operator!=(const OverridenDeclsOwner &lhs,
-                         const OverridenDeclsOwner &rhs) {
+  friend bool operator!=(const OverriddenDeclsOwner &lhs,
+                         const OverriddenDeclsOwner &rhs) {
     return !(lhs == rhs);
   }
 
   friend void simple_display(llvm::raw_ostream &out,
-                             const OverridenDeclsOwner &owner) {
+                             const OverriddenDeclsOwner &owner) {
     simple_display(out, owner.VD);
   }
 };
@@ -210,7 +210,7 @@ struct OverridenDeclsOwner {
 ///   requirements it satisfies in a conforming class
 class CollectOverriddenDeclsRequest:
     public SimpleRequest<CollectOverriddenDeclsRequest,
-                         ArrayRef<ValueDecl*>(OverridenDeclsOwner),
+                         ArrayRef<ValueDecl*>(OverriddenDeclsOwner),
                          RequestFlags::Cached> {
 public:
   using SimpleRequest::SimpleRequest;
@@ -220,7 +220,7 @@ class CollectOverriddenDeclsRequest:
 
   // Evaluation.
   ArrayRef<ValueDecl*> evaluate(Evaluator &evaluator,
-                                OverridenDeclsOwner Owner) const;
+                                OverriddenDeclsOwner Owner) const;
 
 public:
   // Caching

include/swift/IDE/Utils.h

@@ -371,7 +371,7 @@ struct ResolvedRangeInfo {
                       CommonExprParent(CommonExprParent) {}
   ResolvedRangeInfo(ArrayRef<Token> TokensInRange) :
   ResolvedRangeInfo(RangeKind::Invalid, {nullptr, ExitState::Unsure},
-                    TokensInRange, nullptr, /*Commom Expr Parent*/nullptr,
+                    TokensInRange, nullptr, /*Common Expr Parent*/nullptr,
                     /*Single entry*/true, /*UnhandledEffects*/{},
                     OrphanKind::None, {}, {}, {}) {}
   ResolvedRangeInfo(): ResolvedRangeInfo(ArrayRef<Token>()) {}
@@ -602,7 +602,7 @@ bool isDeclOverridable(ValueDecl *D);
 
 /// Given a reference to a member \p D and its \p Base expression, return
 /// whether that declaration could be dynamic, ie. may resolve to some other
-/// declaration. Note that while the decl itself itself may be overridable, a
+/// declaration. Note that while the decl itself may be overridable, a
 /// reference to it is not necessarily "dynamic". Furthermore,  is *not* the
 /// `dynamic` keyword.
 ///

include/swift/IDETool/CompileInstance.h

@@ -71,7 +71,7 @@ class CompileInstance {
         DiagnosticDocumentationPath(DiagnosticDocumentationPath),
         CachedCIInvalidated(false), CachedReuseCount(0) {}
 
-  /// NOTE: \p Args is only used for checking the equaity of the invocation.
+  /// NOTE: \p Args is only used for checking the equality of the invocation.
   /// Since this function assumes that it is already normalized, exact the same
   /// arguments including their order is considered as the same invocation.
   bool

include/swift/IDETool/CompletionInstance.h

@@ -117,7 +117,7 @@ class CompletionInstance {
           Callback);
 
   /// Calls \p Callback with new \c CompilerInstance for the completion
-  /// request. The \c CompilerInstace passed to the callback already performed
+  /// request. The \c CompilerInstance passed to the callback already performed
   /// the first pass.
   /// Returns \c false if it fails to setup the \c CompilerInstance.
   void performNewOperation(
@@ -131,7 +131,7 @@ class CompletionInstance {
           Callback);
 
   /// Calls \p Callback with a \c CompilerInstance which is prepared for the
-  /// second pass. \p Callback is resposible to perform the second pass on it.
+  /// second pass. \p Callback is responsible to perform the second pass on it.
   /// The \c CompilerInstance may be reused from the previous completions,
   /// and may be cached for the next completion.
   /// In case of failure or cancellation, the callback receives the
@@ -145,7 +145,7 @@ class CompletionInstance {
   /// interpreting the results, since invalid results may be returned in case
   /// of cancellation.
   ///
-  /// NOTE: \p Args is only used for checking the equaity of the invocation.
+  /// NOTE: \p Args is only used for checking the equality of the invocation.
   /// Since this function assumes that it is already normalized, exact the same
   /// arguments including their order is considered as the same invocation.
   void performOperation(

include/swift/Refactoring/RefactoringKinds.def

@@ -26,11 +26,11 @@ REFACTORING(GlobalRename, "Global Rename", rename.global)
 /// (syntactically).
 REFACTORING(FindGlobalRenameRanges, "Find Global Rename Ranges", rename.global.find-ranges)
 
-/// Find and categorize all occurences of the file-local symbol at a given
+/// Find and categorize all occurrences of the file-local symbol at a given
 /// location.
 REFACTORING(FindLocalRenameRanges, "Find Local Rename Ranges", rename.local.find-ranges)
 
-/// Find and rename all occurences of the file-local symbol at a given
+/// Find and rename all occurrences of the file-local symbol at a given
 /// location.
 CURSOR_REFACTORING(LocalRename, "Local Rename", rename.local)
 

lib/IDE/CodeCompletion.cpp

@@ -124,7 +124,7 @@ class CodeCompletionCallbacksImpl : public CodeCompletionCallbacks {
   /// In situations when \c SyntaxKind hints or determines
   /// completions, i.e. a precedence group attribute, this
   /// can be set and used to control the code completion scenario.
-  SyntaxKind SyntxKind;
+  SyntaxKind SyntaxKind_;
 
   int AttrParamIndex;
   bool IsInSil = false;
@@ -470,7 +470,7 @@ void CodeCompletionCallbacksImpl::completeDeclAttrBeginning(
 void CodeCompletionCallbacksImpl::completeInPrecedenceGroup(SyntaxKind SK) {
   assert(P.Tok.is(tok::code_complete));
 
-  SyntxKind = SK;
+  SyntaxKind_ = SK;
   Kind = CompletionKind::PrecedenceGroup;
   CurDeclContext = P.CurDeclContext;
 }
@@ -597,7 +597,7 @@ void CodeCompletionCallbacksImpl::completeAfterPoundDirective() {
 
 void CodeCompletionCallbacksImpl::completePlatformCondition() {
   CurDeclContext = P.CurDeclContext;
-  Kind = CompletionKind::PlatformConditon;
+  Kind = CompletionKind::PlatformCondition;
 }
 
 void CodeCompletionCallbacksImpl::completeAfterIfStmtElse() {
@@ -945,7 +945,7 @@ void CodeCompletionCallbacksImpl::addKeywords(CodeCompletionResultSink &Sink,
   case CompletionKind::LabeledTrailingClosure:
   case CompletionKind::AfterPoundExpr:
   case CompletionKind::AfterPoundDirective:
-  case CompletionKind::PlatformConditon:
+  case CompletionKind::PlatformCondition:
   case CompletionKind::GenericRequirement:
   case CompletionKind::KeyPathExprObjC:
   case CompletionKind::KeyPathExprSwift:
@@ -964,7 +964,7 @@ void CodeCompletionCallbacksImpl::addKeywords(CodeCompletionResultSink &Sink,
   }
 
   case CompletionKind::AccessorBeginning: {
-    // TODO: Omit already declared or mutally exclusive accessors.
+    // TODO: Omit already declared or mutually exclusive accessors.
     //       E.g. If 'get' is already declared, emit 'set' only.
     addAccessorKeywords(Sink);
 
@@ -1258,23 +1258,23 @@ void swift::ide::deliverCompletionResults(
   llvm::SmallPtrSet<Identifier, 8> seenModuleNames;
   std::vector<RequestedCachedModule> RequestedModules;
 
-  SmallPtrSet<ModuleDecl *, 4> explictlyImportedModules;
+  SmallPtrSet<ModuleDecl *, 4> explicitlyImportedModules;
   {
     // Collect modules directly imported in this SourceFile.
     SmallVector<ImportedModule, 4> directImport;
     SF.getImportedModules(directImport,
                           {ModuleDecl::ImportFilterKind::Default,
                            ModuleDecl::ImportFilterKind::ImplementationOnly});
     for (auto import : directImport)
-      explictlyImportedModules.insert(import.importedModule);
+      explicitlyImportedModules.insert(import.importedModule);
 
     // Exclude modules implicitly imported in the current module.
     auto implicitImports = SF.getParentModule()->getImplicitImports();
     for (auto import : implicitImports.imports)
-      explictlyImportedModules.erase(import.module.importedModule);
+      explicitlyImportedModules.erase(import.module.importedModule);
 
     // Consider the current module "explicit".
-    explictlyImportedModules.insert(SF.getParentModule());
+    explicitlyImportedModules.insert(SF.getParentModule());
   }
 
   for (auto &Request: Lookup.RequestedCachedResults) {
@@ -1338,7 +1338,7 @@ void swift::ide::deliverCompletionResults(
         auto TheModuleName = TheModule->getName();
         if (Request.IncludeModuleQualifier &&
             (!Lookup.isHiddenModuleName(TheModuleName) ||
-             explictlyImportedModules.contains(TheModule)) &&
+             explicitlyImportedModules.contains(TheModule)) &&
             seenModuleNames.insert(TheModuleName).second)
           Lookup.addModuleName(TheModule);
       }
@@ -1654,7 +1654,7 @@ void CodeCompletionCallbacksImpl::doneParsing() {
     /// We set the type of ParsedExpr explicitly above. But we don't want an
     /// unresolved type in our AST when we type check again for operator
     /// completions. Remove the type of the ParsedExpr and see if we can come up
-    /// with something more useful based on the the full sequence expression.
+    /// with something more useful based on the full sequence expression.
     if (ParsedExpr->getType()->is<UnresolvedType>()) {
       ParsedExpr->setType(nullptr);
     }
@@ -1945,7 +1945,7 @@ void CodeCompletionCallbacksImpl::doneParsing() {
     break;
   }
 
-  case CompletionKind::PlatformConditon: {
+  case CompletionKind::PlatformCondition: {
     addPlatformConditions(CompletionContext.getResultSink());
     addConditionalCompilationFlags(CurDeclContext->getASTContext(),
                                    CompletionContext.getResultSink());
@@ -1958,7 +1958,7 @@ void CodeCompletionCallbacksImpl::doneParsing() {
     break;
   }
   case CompletionKind::PrecedenceGroup:
-    Lookup.getPrecedenceGroupCompletions(SyntxKind);
+    Lookup.getPrecedenceGroupCompletions(SyntaxKind_);
     break;
   case CompletionKind::StmtLabel: {
     SourceLoc Loc = P.Context.SourceMgr.getCodeCompletionLoc();