Fixed some typos

Author: nickolas-pohilets

include/swift/AST/Decl.h

@@ -8762,7 +8762,7 @@ class DestructorDecl : public AbstractFunctionDecl {
   /// Retrieve the Objective-C selector for destructors.
   ObjCSelector getObjCSelector() const;
 
-  /// Retrives destructor decl from the superclass, or nil if there is no
+  /// Retrieves destructor decl from the superclass, or nil if there is no
   /// superclass
   DestructorDecl *getSuperDeinit() const;
 

lib/SILGen/SILGenDestructor.cpp

@@ -299,9 +299,9 @@ bool Lowering::needsIsolatingDestructor(DestructorDecl *dd) {
     firstIsolated = next;
   }
 
-  // If isolation was intoduced in ObjC code, then we assume that ObjC code also
-  // overrides retain/release to make sure that dealloc is called on the correct
-  // executor in the first place.
+  // If isolation was introduced in ObjC code, then we assume that ObjC code
+  // also overrides retain/release to make sure that dealloc is called on the
+  // correct executor in the first place.
   return firstIsolated->getClangNode().isNull();
 }
 

lib/Sema/TypeCheckConcurrency.cpp

@@ -122,7 +122,8 @@ bool swift::usesFlowSensitiveIsolation(AbstractFunctionDecl const *fn) {
   if (!fn)
     return false;
 
-  // Only designated constructors use this kind of isolation.
+  // Only designated constructors or nonisolated destructors use this kind of
+  // isolation.
   if (auto const* ctor = dyn_cast<ConstructorDecl>(fn)) {
     if (!ctor->isDesignatedInit())
       return false;
@@ -4955,7 +4956,7 @@ static OverrideIsolationResult validOverrideIsolation(
 
   // Normally we are checking if overriding declaration can be called by calling
   // overriden declaration. But in case of destructors, overriden declaration is
-  // always callable by definition and we are checking that subclas deinit can
+  // always callable by definition and we are checking that subclass deinit can
   // call super deinit.
   bool isDtor = isa<DestructorDecl>(value);
 
@@ -5095,7 +5096,7 @@ ActorIsolation ActorIsolationRequest::evaluate(
       }
 
       if (hasIsolatedSelf && isolation.isUnspecified()) {
-        // Don't use 'unspecified' for actors, use 'nonisolated' instead
+        // Don't use 'unspecified' for actors, use 'nonisolated' instead.
         // To force generation of the 'nonisolated' attribute in SIL and
         // .swiftmodule
         isolation = ActorIsolation::forNonisolated(false);
@@ -5113,7 +5114,7 @@ ActorIsolation ActorIsolationRequest::evaluate(
     assert(actor && "could not find the actor that 'self' is isolated to");
 
     // Bootstrapping hack: force _Concurrency.MainActor.deinit() to be
-    // non-isolated even when importing from SDK's swiftmodule without
+    // non-isolated even when importing from host SDK's swiftmodule without
     // `nonisolated` attribute.
     if (isa<DestructorDecl>(value) && actor->getName().is("MainActor") &&
         actor->getDeclContext()->isModuleScopeContext() &&

stdlib/public/Concurrency/Task.cpp

@@ -1710,7 +1710,7 @@ static void swift_task_performOnExecutorImpl(void *context,
   // we can just immediately continue running with the resume function
   // we were passed in.
   //
-  // Note that swift_task_isCurrentExecutor() return true for @MainActor
+  // Note that swift_task_isCurrentExecutor() returns true for @MainActor
   // when running on the main thread without any executor
   if (swift_task_isCurrentExecutor(newExecutor)) {
     return work(context); // 'return' forces tail call