Dart SDK Spelling b, c, and d.

runtime/vm/kernel_to_il.cc

 // Copyright (c) 2016, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include <set>
 #include <string>
 
 #include "vm/kernel_to_il.h"
 
 #include "vm/compiler.h"
@@ skipping 3534 matching lines @@
         // :current_context_var from :await_ctx_var.
         // Note: after this point context_depth_ does not match current context
         // depth so we should not access any local variables anymore.
         dispatch += LoadLocal(scopes_->yield_context_variable);
         dispatch += StoreLocal(TokenPosition::kNoSource,
                                parsed_function_->current_context_var());
         dispatch += Drop();
       }
       if (i == (yield_continuations_.length() - 1)) {
         // We reached the last possility, no need to build more ifs.
-        // Coninue to the last continuation.
+        // Continue to the last continuation.
         // Note: continuations start with nop DropTemps instruction
         // which acts like an anchor, so we need to skip it.
         block->set_try_index(yield_continuations_[i].try_index);
         dispatch <<= yield_continuations_[i].entry->next();
         break;
       }
 
       // Build comparison:
       //
       //   if (:await_ctx_var == i) {
@@ skipping 45 matching lines @@
 
     // Call _asyncSetThreadStackTrace
     instructions += StaticCall(TokenPosition::kNoSource, target, 1);
     instructions += Drop();
 
     body = instructions + body;
     context_depth_ = current_context_depth;
   }
 
   if (NeedsDebugStepCheck(dart_function, function->position())) {
-    // If a switch was added above: Start the switch by injecting a debugable
+    // If a switch was added above: Start the switch by injecting a debuggable
     // safepoint so stepping over an await works.
-    // If not, still start the body with a debugable safepoint to ensure
+    // If not, still start the body with a debuggable safepoint to ensure
     // breaking on a method always happens, even if there are no
     // assignments/calls/runtimecalls in the first basic block.
     // Place this check at the last parameter to ensure parameters
     // are in scope in the debugger at method entry.
     const int num_params = dart_function.NumParameters();
     TokenPosition check_pos = TokenPosition::kNoSource;
     if (num_params > 0) {
       LocalScope* scope = parsed_function_->node_sequence()->scope();
       const LocalVariable& parameter = *scope->VariableAt(num_params - 1);
       check_pos = parameter.token_pos();
@@ skipping 3189 matching lines @@
     thread->clear_sticky_error();
     return error.raw();
   }
 }
 
 
 }  // namespace kernel
 }  // namespace dart
 
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)