Improve the casing of Stackmap and Stacktrace.

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 6357 matching lines @@
     // to load the stack trace object (:stack_trace_var) into the stack
     // trace variable specified in this block.
     current_block_->statements->Add(new (Z) StoreLocalNode(
         TokenPosition::kNoSource, stack_trace_param.var,
         new (Z) LoadLocalNode(TokenPosition::kNoSource, stack_trace_var)));
   }
   LocalVariable* saved_exception_var =
       try_scope->LocalLookupVariable(Symbols::SavedExceptionVar());
   LocalVariable* saved_stack_trace_var =
       try_scope->LocalLookupVariable(Symbols::SavedStackTraceVar());
-  SaveExceptionAndStacktrace(current_block_->statements, exception_var,
+  SaveExceptionAndStackTrace(current_block_->statements, exception_var,
                              stack_trace_var, saved_exception_var,
                              saved_stack_trace_var);
 
   // Catch block: add the error to the stream.
   // :controller.AddError(:exception, :stack_trace);
   // return;  // The finally block will close the stream.
   LocalVariable* controller =
       current_block_->scope->LookupVariable(Symbols::Controller(), false);
   ASSERT(controller != NULL);
   ArgumentListNode* args = new (Z) ArgumentListNode(TokenPosition::kNoSource);
@@ skipping 127 matching lines @@
     // trace variable specified in this block.
     ASSERT(stack_trace_var != NULL);
     current_block_->statements->Add(new (Z) StoreLocalNode(
         TokenPosition::kNoSource, stack_trace_param.var,
         new (Z) LoadLocalNode(TokenPosition::kNoSource, stack_trace_var)));
   }
   LocalVariable* saved_exception_var =
       try_scope->LocalLookupVariable(Symbols::SavedExceptionVar());
   LocalVariable* saved_stack_trace_var =
       try_scope->LocalLookupVariable(Symbols::SavedStackTraceVar());
-  SaveExceptionAndStacktrace(current_block_->statements, exception_var,
+  SaveExceptionAndStackTrace(current_block_->statements, exception_var,
                              stack_trace_var, saved_exception_var,
                              saved_stack_trace_var);
 
   // Complete the async future with an error. This catch block executes
   // unconditionally, there is no need to generate a type check for.
   LocalVariable* async_completer =
       current_block_->scope->LookupVariable(Symbols::AsyncCompleter(), false);
   ASSERT(async_completer != NULL);
   ArgumentListNode* completer_args =
       new (Z) ArgumentListNode(TokenPosition::kNoSource);
@@ skipping 2683 matching lines @@
     }
     stack_trace_param->var = var;
   }
 }
 
 
 // Generate code to load the exception object (:exception_var) into
 // the saved exception variable (:saved_exception_var) used to rethrow.
 // Generate code to load the stack trace object (:stack_trace_var) into
 // the saved stacktrace variable (:saved_stack_trace_var) used to rethrow.
-void Parser::SaveExceptionAndStacktrace(SequenceNode* statements,
+void Parser::SaveExceptionAndStackTrace(SequenceNode* statements,
                                         LocalVariable* exception_var,
                                         LocalVariable* stack_trace_var,
                                         LocalVariable* saved_exception_var,
                                         LocalVariable* saved_stack_trace_var) {
   ASSERT(innermost_function().IsAsyncClosure() ||
          innermost_function().IsAsyncFunction() ||
          innermost_function().IsSyncGenClosure() ||
          innermost_function().IsSyncGenerator() ||
          innermost_function().IsAsyncGenClosure() ||
          innermost_function().IsAsyncGenerator());
@@ skipping 52 matching lines @@
         current_block_->statements->Add(new (Z) StoreLocalNode(
             TokenPosition::kNoSource, saved_try_ctx,
             new (Z)
                 LoadLocalNode(TokenPosition::kNoSource, async_saved_try_ctx)));
       }
     }
     // We need to save the exception variables as in catch clauses, whether
     // there is an outer try or not. Note that this is only necessary if the
     // finally clause contains an await or yield.
     // TODO(hausner): Optimize.
-    SaveExceptionAndStacktrace(current_block_->statements, exception_var,
+    SaveExceptionAndStackTrace(current_block_->statements, exception_var,
                                stack_trace_var, rethrow_exception_var,
                                rethrow_stack_trace_var);
   }
 
   if (parse) {
     ParseStatementSequence();
     ExpectToken(Token::kRBRACE);
   }
   SequenceNode* finally_clause = CloseBlock();
   if (try_stack_ != NULL) {
@@ skipping 260 matching lines @@
         LocalVariable* saved_try_ctx =
             LookupSavedTryContextVar(scope->parent());
         LocalVariable* async_saved_try_ctx = LookupAsyncSavedTryContextVar(
             T, async_temp_scope_, try_block->try_index());
         async_code->Add(new (Z) StoreLocalNode(
             TokenPosition::kNoSource, saved_try_ctx,
             new (Z)
                 LoadLocalNode(TokenPosition::kNoSource, async_saved_try_ctx)));
       }
     }
-    SaveExceptionAndStacktrace(async_code, exception_var, stack_trace_var,
+    SaveExceptionAndStackTrace(async_code, exception_var, stack_trace_var,
                                rethrow_exception_var, rethrow_stack_trace_var);
     // The async_code node sequence contains code to restore the context (if
     // an outer try block is present) and code to save the exception and
     // stack trace variables.
     // This async code is inserted before the current node sequence containing
     // the chain of if/then/else handling all catch clauses.
     async_code->Add(current);
     current = async_code;
   }
   return current;
@@ skipping 4889 matching lines @@
     const ArgumentListNode& function_args,
     const LocalVariable* temp_for_last_arg,
     bool is_super_invocation) {
   UNREACHABLE();
   return NULL;
 }
 
 }  // namespace dart
 
 #endif  // DART_PRECOMPILED_RUNTIME