Spelling fixes e to i.

runtime/vm/parser.cc

 // Copyright (c) 2012, 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 "vm/parser.h"
 #include "vm/flags.h"
 
 #ifndef DART_PRECOMPILED_RUNTIME
 
 #include "lib/invocation_mirror.h"
@@ skipping 7357 matching lines @@
 //   :controller = new _AsyncStarStreamController(:async_op);
 //   var :controller_stream = :controller.stream;
 //   return :controller_stream;
 // }
 SequenceNode* Parser::CloseAsyncGeneratorFunction(const Function& closure_func,
                                                   SequenceNode* closure_body) {
   TRACE_PARSER("CloseAsyncGeneratorFunction");
   ASSERT(!closure_func.IsNull());
   ASSERT(closure_body != NULL);
 
-  // Explicitly reference variables of the async genenerator function from the
+  // Explicitly reference variables of the async generator function from the
   // closure body in order to mark them as captured.
   LocalVariable* existing_var =
       closure_body->scope()->LookupVariable(Symbols::AwaitJumpVar(), false);
   ASSERT((existing_var != NULL) && existing_var->is_captured());
   existing_var =
       closure_body->scope()->LookupVariable(Symbols::AwaitContextVar(), false);
   ASSERT((existing_var != NULL) && existing_var->is_captured());
   existing_var =
       closure_body->scope()->LookupVariable(Symbols::ColonController(), false);
   ASSERT((existing_var != NULL) && existing_var->is_captured());
@@ skipping 602 matching lines @@
                   ident.ToCString());
 
     } else {
       intptr_t line_number;
       script_.GetTokenLocation(previous_pos, &line_number, NULL);
       ReportError(ident_pos, "identifier '%s' previously used in line %" Pd "",
                   ident.ToCString(), line_number);
     }
   }
 
-  // Add variable to scope after parsing the initalizer expression.
+  // Add variable to scope after parsing the initializer expression.
   // The expression must not be able to refer to the variable.
   if (!current_block_->scope->AddVariable(variable)) {
     LocalVariable* existing_var =
         current_block_->scope->LookupVariable(variable->name(), true);
     ASSERT(existing_var != NULL);
     // Use before define cases have already been detected and reported above.
     ASSERT(existing_var->owner() == current_block_->scope);
     ReportError(ident_pos, "identifier '%s' already defined",
                 variable->name().ToCString());
   }
@@ skipping 1817 matching lines @@
   }
   arguments->Add(message);
   AstNode* assert_throw = MakeStaticCall(
       Symbols::AssertionError(),
       Library::PrivateCoreLibName(Symbols::ThrowNew()), arguments);
 
   AstNode* assertion_check = NULL;
   if (parsed_function()->have_seen_await()) {
     // The await transformation must be done manually because assertions
     // are parsed as statements, not expressions. Thus, we need to check
-    // explicitely whether the arguments contain await operators. (Note that
+    // explicitly whether the arguments contain await operators. (Note that
     // we must not parse the arguments with ParseAwaitableExpr(). In the
     // corner case of assert(await a, await b), this would create two
     // sibling scopes containing the temporary values for a and b. Both
     // values would be allocated in the same internal context variable.)
     //
     // Build !condition ? _AsertionError._throwNew(...) : null;
     // We need to use a conditional expression because the await transformer
     // cannot transform if statements.
     assertion_check = new (Z) ConditionalExprNode(
         condition_pos, not_condition, assert_throw,
@@ skipping 349 matching lines @@
 
   // Build the if/then/else nest from the inside out.  Keep the AST simple
   // for the case of a single generic catch clause.  The initial value of
   // current is the last (innermost) else block if there were any catch
   // clauses.
   SequenceNode* current = NULL;
   if (!generic_catch_seen) {
     // There isn't a generic catch clause so create a clause body that
     // rethrows the exception.  This includes the case that there were no
     // catch clauses.
-    // An await cannot possibly be executed inbetween the catch entry and here,
+    // An await cannot possibly be executed in between the catch entry and here,
     // therefore, it is safe to rethrow the stack-based :exception_var instead
     // of the captured copy :saved_exception_var.
     current = new (Z) SequenceNode(handler_pos, NULL);
     current->Add(new (Z) ThrowNode(
         handler_pos, new (Z) LoadLocalNode(handler_pos, exception_var),
         new (Z) LoadLocalNode(handler_pos, stack_trace_var)));
   } else if (type_tests.Last()->IsLiteralNode()) {
     ASSERT(type_tests.Last()->AsLiteralNode()->literal().raw() ==
            Bool::True().raw());
     // The last body is entered unconditionally.  Start building the
@@ skipping 611 matching lines @@
     statement = ParseJump(label_name);
     AddNodeForFinallyInlining(statement);
     ExpectSemicolon();
   } else if (token == Token::kSEMICOLON) {
     // Empty statement, nothing to do.
     ConsumeToken();
   } else if (token == Token::kRETHROW) {
     // Rethrow of current exception.
     ConsumeToken();
     ExpectSemicolon();
-    // Check if it is ok to do a rethrow. Find the inntermost enclosing
+    // Check if it is ok to do a rethrow. Find the innermost enclosing
     // catch block.
     TryStack* try_statement = try_stack_;
     while ((try_statement != NULL) && !try_statement->inside_catch()) {
       try_statement = try_statement->outer_try();
     }
     if (try_statement == NULL) {
       ReportError(statement_pos, "rethrow of an exception is not valid here");
     }
 
     // If in async code, use :saved_exception_var and :saved_stack_trace_var
@@ skipping 3895 matching lines @@
         GrowableHandlePtrArray<const String> pieces(Z, 3);
         pieces.Add(String::Handle(Z, prefix.name()));
         pieces.Add(Symbols::Dot());
         pieces.Add(ident);
         const String& qualified_name =
             String::ZoneHandle(Z, Symbols::FromConcatAll(T, pieces));
         InvocationMirror::Type call_type = CurrentToken() == Token::kLPAREN
                                                ? InvocationMirror::kMethod
                                                : InvocationMirror::kGetter;
         // Note: Adding a statement to current block is a hack, parsing an
-        // espression should have no side-effect.
+        // expression should have no side-effect.
         current_block_->statements->Add(ThrowNoSuchMethodError(
             qual_ident_pos, current_class(), qualified_name,
             NULL,  // No arguments.
             InvocationMirror::kTopLevel, call_type,
             NULL,  // No existing function.
             &prefix));
       }
     }
     ASSERT(primary != NULL);
   } else if (token == Token::kTHIS) {
@@ skipping 628 matching lines @@
                                                 TokenPosition* start,
                                                 TokenPosition* end) {
   UNREACHABLE();
   return false;
 }
 
 
 }  // namespace dart
 
 #endif  // DART_PRECOMPILED_RUNTIME