VM: Re-format to use at most one newline between functions

runtime/vm/flow_graph_range_analysis.h

 // Copyright (c) 2014, 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_FLOW_GRAPH_RANGE_ANALYSIS_H_
 #define RUNTIME_VM_FLOW_GRAPH_RANGE_ANALYSIS_H_
 
 #include "vm/flow_graph.h"
 #include "vm/intermediate_language.h"
 
@@ skipping 84 matching lines @@
         return FromConstant(Smi::kMaxValue);
       case kRangeBoundaryInt32:
         return FromConstant(kMaxInt32);
       case kRangeBoundaryInt64:
         return FromConstant(kMaxInt64);
     }
     UNREACHABLE();
     return FromConstant(kMaxInt64);
   }
 
-
   // Given two boundaries a and b, select one of them as c so that
   //
   //   inf {[a, ...) ^ [b, ...)} >= inf {c}
   //
   static RangeBoundary IntersectionMin(RangeBoundary a, RangeBoundary b);
 
   // Given two boundaries a and b, select one of them as c so that
   //
   //   sup {(..., a] ^ (..., b]} <= sup {c}
   //
@@ skipping 163 matching lines @@
 
  private:
   RangeBoundary(Kind kind, int64_t value, int64_t offset)
       : kind_(kind), value_(value), offset_(offset) {}
 
   Kind kind_;
   int64_t value_;
   int64_t offset_;
 };
 
-
 class Range : public ZoneAllocated {
  public:
   Range() : min_(), max_() {}
   Range(RangeBoundary min, RangeBoundary max) : min_(min), max_(max) {
     ASSERT(min_.IsUnknown() == max_.IsUnknown());
   }
 
   Range(const Range& other)
       : ZoneAllocated(), min_(other.min_), max_(other.max_) {}
 
@@ skipping 56 matching lines @@
   }
 
   static RangeBoundary ConstantMax(const Range* range,
                                    RangeBoundary::RangeSize size) {
     if (range == NULL) {
       return RangeBoundary::MaxConstant(size);
     }
     return range->max().UpperBound().Clamp(size);
   }
 
-
   // [0, +inf]
   bool IsPositive() const;
 
   // [-inf, val].
   bool OnlyLessThanOrEqualTo(int64_t val) const;
 
   // [val, +inf].
   bool OnlyGreaterThanOrEqualTo(int64_t val) const;
 
   // Inclusive.
@@ skipping 74 matching lines @@
                        const Range* left_range,
                        const Range* right_range,
                        Definition* left_defn,
                        Range* result);
 
  private:
   RangeBoundary min_;
   RangeBoundary max_;
 };
 
-
 class RangeUtils : public AllStatic {
  public:
   static bool Fits(Range* range, RangeBoundary::RangeSize size) {
     return !Range::IsUnknown(range) && range->Fits(size);
   }
 
   static bool IsWithin(Range* range, int64_t min, int64_t max) {
     return !Range::IsUnknown(range) && range->IsWithin(min, max);
   }
 
   static bool IsPositive(Range* range) {
     return !Range::IsUnknown(range) && range->IsPositive();
   }
 
   static bool Overlaps(Range* range, intptr_t min, intptr_t max) {
     return Range::IsUnknown(range) || range->Overlaps(min, max);
   }
 
   static bool CanBeZero(Range* range) { return Overlaps(range, 0, 0); }
 
   static bool OnlyLessThanOrEqualTo(Range* range, intptr_t value) {
     return !Range::IsUnknown(range) && range->OnlyLessThanOrEqualTo(value);
   }
 };
 
-
 // Range analysis for integer values.
 class RangeAnalysis : public ValueObject {
  public:
   explicit RangeAnalysis(FlowGraph* flow_graph)
       : flow_graph_(flow_graph),
         smi_range_(Range::Full(RangeBoundary::kRangeBoundarySmi)),
         int64_range_(Range::Full(RangeBoundary::kRangeBoundaryInt64)) {}
 
   // Infer ranges for all values and remove overflow checks from binary smi
   // operations when proven redundant.
@@ skipping 43 matching lines @@
 
   bool ConstrainValueAfterBranch(Value* use, Definition* defn);
   void ConstrainValueAfterCheckArrayBound(Value* use, Definition* defn);
 
   // Replace uses of the definition def that are dominated by instruction dom
   // with uses of other definition.
   void RenameDominatedUses(Definition* def,
                            Instruction* dom,
                            Definition* other);
 
-
   // Infer ranges for integer (smi or mint) definitions.
   void InferRanges();
 
   // Collect integer definition in the reverse postorder.
   void CollectDefinitions(BitVector* set);
 
   // Recompute ranges of all definitions until they stop changing.
   // Apply the given JoinOperator when computing Phi ranges.
   void Iterate(JoinOperator op, intptr_t max_iterations);
   bool InferRange(JoinOperator op, Definition* defn, intptr_t iteration);
@@ skipping 39 matching lines @@
   // as smi values.
   GrowableArray<ConstraintInstr*> constraints_;
 
   // List of integer (smi or mint) definitions including constraints sorted
   // in the reverse postorder.
   GrowableArray<Definition*> definitions_;
 
   DISALLOW_COPY_AND_ASSIGN(RangeAnalysis);
 };
 
-
 // Replaces Mint IL instructions with Uint32 IL instructions
 // when possible. Uses output of RangeAnalysis.
 class IntegerInstructionSelector : public ValueObject {
  public:
   explicit IntegerInstructionSelector(FlowGraph* flow_graph);
 
   void Select();
 
  private:
   bool IsPotentialUint32Definition(Definition* def);
   void FindPotentialUint32Definitions();
   bool IsUint32NarrowingDefinition(Definition* def);
   void FindUint32NarrowingDefinitions();
   bool AllUsesAreUint32Narrowing(Value* list_head);
   bool CanBecomeUint32(Definition* def);
   void Propagate();
   Definition* ConstructReplacementFor(Definition* def);
   void ReplaceInstructions();
 
   Zone* zone() const { return zone_; }
 
   GrowableArray<Definition*> potential_uint32_defs_;
   BitVector* selected_uint32_defs_;
 
   FlowGraph* flow_graph_;
   Zone* zone_;
 };
 
-
 }  // namespace dart
 
 #endif  // RUNTIME_VM_FLOW_GRAPH_RANGE_ANALYSIS_H_