Review comments

src/Compilers/CSharp/Portable/Lowering/AsyncRewriter/AsyncExceptionHandlerRewriter.cs

@@ -46,7 +46,7 @@ internal sealed class AsyncExceptionHandlerRewriter : BoundTreeRewriter
         /// Lower a block of code by performing local rewritings. 
         /// The goal is to not have exception handlers that contain awaits in them.
         /// 
-        /// 1) Await containing finallies:
+        /// 1) Await containing finally blocks:
         ///     The general strategy is to rewrite await containing handlers into synthetic handlers.
         ///     Synthetic handlers are not handlers in IL sense so it is ok to have awaits in them.
         ///     Since synthetic handlers are just blocks, we have to deal with pending exception/branch/return manually
@@ -692,7 +692,7 @@ private void PopFrame()
         }
 
         /// <summary>
-        /// Analyses method body for Try blocks with awaits in finallies 
+        /// Analyses method body for Try blocks with awaits in finally blocks 
         /// Also collects labels that such blocks contain.
         /// </summary>
         private sealed class AwaitInFinallyAnalysis : LabelCollector

src/Compilers/CSharp/Portable/Lowering/IteratorRewriter/IteratorMethodToStateMachineRewriter.cs

@@ -228,7 +228,7 @@ private BoundStatement HandleReturn(BoundStatement newBody)
         ///             break;
         ///             
         ///         case state5:
-        ///             ... another dispatch of nested states to their finallies ...
+        ///             ... another dispatch of nested states to their finally blocks ...
         ///             break;
         ///     }
         /// }

src/Compilers/Core/Portable/CodeGen/ILBuilder.cs

@@ -323,7 +323,7 @@ private static void MarkReachableFromBranch(ArrayBuilder<BasicBlock> reachableBl
             {
                 // if branch is blocked by a finally, then should branch to corresponding 
                 // BlockedBranchDestination instead. Original label may not be reachable.
-                // if there are no blocking finallies, then BlockedBranchDestination returns null
+                // if there are no blocking finally blocks, then BlockedBranchDestination returns null
                 // and we just visit the target.
                 var blockedDest = BlockedBranchDestination(block, branchBlock);
                 if (blockedDest == null)
@@ -377,9 +377,9 @@ private static object BlockedBranchDestinationSlow(ExceptionHandlerScope destHan
                 destHandlerScope = destHandler.ContainingExceptionScope;
             }
 
-            // go from the source out until we no longer crossing any finallies 
+            // go from the source out until no longer crossing any finally blocks
             // between source and destination
-            // if any finallies found in the process, check if they are blocking
+            // if any finally blocks found in the process, check if they are blocking
             while (srcHandler != destHandler)
             {
                 // branches within same ContainingExceptionScope do not go through finally.

src/Compilers/Core/Portable/DiagnosticAnalyzer/CompilerDiagnosticAnalyzer.CompilationAnalyzer.cs

@@ -82,7 +82,7 @@ public CompilerDiagnostic(Diagnostic original, ImmutableDictionary<string, strin
                     _properties = properties;
                 }
 
-#pragma warning disable RS0013 // we are delegating to delegate so it is okay here
+#pragma warning disable RS0013 // we are delegating so it is okay here
                 public override DiagnosticDescriptor Descriptor => _original.Descriptor;
 #pragma warning restore RS0013