Improve the casing of Stackmap and Stacktrace.

runtime/vm/code_descriptors.h

 // 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.
 
 #ifndef RUNTIME_VM_CODE_DESCRIPTORS_H_
 #define RUNTIME_VM_CODE_DESCRIPTORS_H_
 
 #include "vm/ast.h"
 #include "vm/code_generator.h"
 #include "vm/globals.h"
@@ skipping 45 matching lines @@
  private:
   GrowableArray<uint8_t> encoded_data_;
 
   intptr_t prev_pc_offset;
   intptr_t prev_token_pos;
 
   DISALLOW_COPY_AND_ASSIGN(CodeSourceMapBuilder);
 };
 
 
-class StackmapTableBuilder : public ZoneAllocated {
+class StackMapTableBuilder : public ZoneAllocated {
  public:
-  StackmapTableBuilder()
-      : stack_map_(Stackmap::ZoneHandle()),
+  StackMapTableBuilder()
+      : stack_map_(StackMap::ZoneHandle()),
         list_(GrowableObjectArray::ZoneHandle(
             GrowableObjectArray::New(Heap::kOld))) {}
-  ~StackmapTableBuilder() {}
+  ~StackMapTableBuilder() {}
 
   void AddEntry(intptr_t pc_offset,
                 BitmapBuilder* bitmap,
                 intptr_t register_bit_count);
 
   bool Verify();
 
-  RawArray* FinalizeStackmaps(const Code& code);
+  RawArray* FinalizeStackMaps(const Code& code);
 
  private:
   intptr_t Length() const { return list_.Length(); }
-  RawStackmap* MapAt(intptr_t index) const;
+  RawStackMap* MapAt(intptr_t index) const;
 
-  Stackmap& stack_map_;
+  StackMap& stack_map_;
   GrowableObjectArray& list_;
-  DISALLOW_COPY_AND_ASSIGN(StackmapTableBuilder);
+  DISALLOW_COPY_AND_ASSIGN(StackMapTableBuilder);
 };
 
 
 class ExceptionHandlerList : public ZoneAllocated {
  public:
   struct HandlerDesc {
     intptr_t outer_try_index;    // Try block in which this try block is nested.
     intptr_t pc_offset;          // Handler PC offset value.
     const Array* handler_types;  // Catch clause guards.
     bool needs_stacktrace;
@@ skipping 24 matching lines @@
     list_[try_index].outer_try_index = outer_try_index;
     ASSERT(list_[try_index].pc_offset == ExceptionHandlers::kInvalidPcOffset);
     list_[try_index].pc_offset = pc_offset;
     ASSERT(handler_types.IsZoneHandle());
     list_[try_index].handler_types = &handler_types;
     list_[try_index].needs_stacktrace |= needs_stacktrace;
   }
 
 
   // Called by rethrows, to mark their enclosing handlers.
-  void SetNeedsStacktrace(intptr_t try_index) {
+  void SetNeedsStackTrace(intptr_t try_index) {
     // Rethrows can be generated outside a try by the compiler.
     if (try_index == CatchClauseNode::kInvalidTryIndex) {
       return;
     }
     ASSERT(try_index >= 0);
     while (Length() <= try_index) {
       AddPlaceHolder();
     }
     list_[try_index].needs_stacktrace = true;
   }
@@ skipping 11 matching lines @@
   RawExceptionHandlers* FinalizeExceptionHandlers(uword entry_point) const;
 
  private:
   GrowableArray<struct HandlerDesc> list_;
   DISALLOW_COPY_AND_ASSIGN(ExceptionHandlerList);
 };
 
 }  // namespace dart
 
 #endif  // RUNTIME_VM_CODE_DESCRIPTORS_H_