Some cleanups.

runtime/vm/flow_graph_allocator.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 VM_FLOW_GRAPH_ALLOCATOR_H_
 #define VM_FLOW_GRAPH_ALLOCATOR_H_
 
 #include "vm/growable_array.h"
 #include "vm/intermediate_language.h"
 
@@ skipping 183 matching lines @@
   bool blocked_cpu_regs_[kNumberOfCpuRegisters];
 
   DISALLOW_COPY_AND_ASSIGN(FlowGraphAllocator);
 };
 
 
 // UsePosition represents a single use of an SSA value by some instruction.
 // It points to a location slot which either tells register allocator
 // where instruction expects the value (if slot contains a fixed location) or
 // asks register allocator to allocate storage (register or spill slot) for
-// this use with certain properties (if slot contain an unallocated location).
+// this use with certain properties (if slot contains an unallocated location).
 class UsePosition : public ZoneAllocated {
  public:
-  UsePosition(intptr_t pos,
-              UsePosition* next,
-              Location* location_slot)
-      : pos_(pos),
-        location_slot_(location_slot),
-        next_(next) {
-  }
+  UsePosition(intptr_t pos, UsePosition* next, Location* location_slot)
+      : pos_(pos), location_slot_(location_slot), next_(next) { }
 
   Location* location_slot() const { return location_slot_; }
   void set_location_slot(Location* location_slot) {
     location_slot_ = location_slot;
   }
 
   void set_next(UsePosition* next) { next_ = next; }
   UsePosition* next() const { return next_; }
 
   intptr_t pos() const { return pos_; }
@@ skipping 53 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(UseInterval);
 };
 
 
 // AllocationFinger is used to keep track of currently active position
 // for the register allocator and cache lookup results.
 class AllocationFinger : public ValueObject {
  public:
   AllocationFinger()
-    : first_pending_use_interval_(NULL),
-      first_register_use_(NULL),
-      first_register_beneficial_use_(NULL),
-      first_hinted_use_(NULL) {
+      : first_pending_use_interval_(NULL),
+        first_register_use_(NULL),
+        first_register_beneficial_use_(NULL),
+        first_hinted_use_(NULL) {
   }
 
   void Initialize(LiveRange* range);
   bool Advance(intptr_t start);
 
   UseInterval* first_pending_use_interval() const {
     return first_pending_use_interval_;
   }
 
   Location FirstHint();
   UsePosition* FirstRegisterUse(intptr_t after_pos);
   UsePosition* FirstRegisterBeneficialUse(intptr_t after_pos);
 
  private:
   UseInterval* first_pending_use_interval_;
   UsePosition* first_register_use_;
   UsePosition* first_register_beneficial_use_;
   UsePosition* first_hinted_use_;
 
   DISALLOW_COPY_AND_ASSIGN(AllocationFinger);
 };
 
 
 // LiveRange represents a sequence of UseIntervals for a given SSA value.
 class LiveRange : public ZoneAllocated {
  public:
   explicit LiveRange(intptr_t vreg)
     : vreg_(vreg),
+      assigned_location_(),
       uses_(NULL),
       first_use_interval_(NULL),
       last_use_interval_(NULL),
       next_sibling_(NULL),
-      finger_() {
-  }
+      finger_() {}

[hausner, 2012/07/24 23:53:47]

I actually like the old formatting better, but it's a matter of taste.

[srdjan, 2012/07/24 23:57:16]

Changed it to old formatting.

 
   static LiveRange* MakeTemp(intptr_t pos, Location* location_slot);
 
   intptr_t vreg() const { return vreg_; }
   LiveRange* next_sibling() const { return next_sibling_; }
   UsePosition* first_use() const { return uses_; }
   void set_first_use(UsePosition* use) { uses_ = use; }
   UseInterval* first_use_interval() const { return first_use_interval_; }
   UseInterval* last_use_interval() const { return last_use_interval_; }
   Location assigned_location() const { return assigned_location_; }
@@ skipping 21 matching lines @@
     return (Start() <= pos) && (pos < End());
   }
 
  private:
   LiveRange(intptr_t vreg,
             UsePosition* uses,
             UseInterval* first_use_interval,
             UseInterval* last_use_interval,
             LiveRange* next_sibling)
     : vreg_(vreg),
+      assigned_location_(),
       uses_(uses),
       first_use_interval_(first_use_interval),
       last_use_interval_(last_use_interval),
       next_sibling_(next_sibling),
       finger_() {
   }
 
   const intptr_t vreg_;
   Location assigned_location_;
 
   UsePosition* uses_;
   UseInterval* first_use_interval_;
   UseInterval* last_use_interval_;
 
   LiveRange* next_sibling_;
 
   AllocationFinger finger_;
 
   DISALLOW_COPY_AND_ASSIGN(LiveRange);
 };
 
 
 }  // namespace dart
 
 #endif  // VM_FLOW_GRAPH_ALLOCATOR_H_