Refactor RangeBoundary +/- infinity to be distinct RangeBoundary kinds.

runtime/vm/intermediate_language.h

 // Copyright (c) 2013, 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_INTERMEDIATE_LANGUAGE_H_
 #define VM_INTERMEDIATE_LANGUAGE_H_
 
 #include "vm/allocation.h"
 #include "vm/ast.h"
 #include "vm/growable_array.h"
@@ skipping 2466 matching lines @@
 
   virtual bool MayThrow() const { return false; }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(RedefinitionInstr);
 };
 
 
 class RangeBoundary : public ValueObject {
  public:
-  enum Kind { kUnknown, kSymbol, kConstant };
+  enum Kind {
+    kUnknown,
+    kNegativeInfinity,
+    kPositiveInfinity,
+    kSymbol,
+    kConstant,
+  };
 
   RangeBoundary() : kind_(kUnknown), value_(0), offset_(0) { }
 
   RangeBoundary(const RangeBoundary& other)
       : ValueObject(),
         kind_(other.kind_),
         value_(other.value_),
         offset_(other.offset_) { }
 
   RangeBoundary& operator=(const RangeBoundary& other) {
     kind_ = other.kind_;
     value_ = other.value_;
     offset_ = other.offset_;
     return *this;
   }
 
   static RangeBoundary FromConstant(intptr_t val) {
     return RangeBoundary(kConstant, val, 0);
   }
 
+  static RangeBoundary NegativeInfinity() {
+    return RangeBoundary(kNegativeInfinity, 0, 0);
+  }
+
+  static RangeBoundary PositiveInfinity() {
+    return RangeBoundary(kPositiveInfinity, 0, 0);
+  }
+
   static RangeBoundary FromDefinition(Definition* defn, intptr_t offs = 0);
 
   static RangeBoundary MinSmi() {
     return FromConstant(Smi::kMinValue);
   }
 
   static RangeBoundary MaxSmi() {
     return FromConstant(Smi::kMaxValue);
   }
 
-  static const intptr_t kMinusInfinity = Smi::kMinValue - 1;
-  static const intptr_t kPlusInfinity = Smi::kMaxValue + 1;
-
-  static RangeBoundary OverflowedMinSmi() {
-    return FromConstant(Smi::kMinValue - 1);
-  }
-
-  static RangeBoundary OverflowedMaxSmi() {
-    return FromConstant(Smi::kMaxValue + 1);
-  }
-
   static RangeBoundary Min(RangeBoundary a, RangeBoundary b);
 
   static RangeBoundary Max(RangeBoundary a, RangeBoundary b);
 
   bool Overflowed() const {
-    return IsConstant() && !Smi::IsValid(value());
+    // If the value is a constant outside of Smi range or infinity.
+    return (IsConstant() && !Smi::IsValid(value())) || IsInfinity();
   }
 
   RangeBoundary Clamp() const {
-    if (IsConstant()) {
+    if (IsNegativeInfinity()) {
+      return MinSmi();
+    } else if (IsPositiveInfinity()) {
+      return MaxSmi();
+    } else if (IsConstant()) {
       if (value() < Smi::kMinValue) return MinSmi();
       if (value() > Smi::kMaxValue) return MaxSmi();
     }
     return *this;
   }
 
-  bool Equals(const RangeBoundary& other) const {
-    return (kind_ == other.kind_) && (value_ == other.value_);
-  }
-
   bool IsUnknown() const { return kind_ == kUnknown; }
   bool IsConstant() const { return kind_ == kConstant; }
   bool IsSymbol() const { return kind_ == kSymbol; }
+  bool IsNegativeInfinity() const { return kind_ == kNegativeInfinity; }
+  bool IsPositiveInfinity() const { return kind_ == kPositiveInfinity; }
+  bool IsInfinity() const {
+    return IsNegativeInfinity() || IsPositiveInfinity();
+  }
 
   intptr_t value() const {
     ASSERT(IsConstant());
     return value_;
   }
 
   Definition* symbol() const {
     ASSERT(IsSymbol());
     return reinterpret_cast<Definition*>(value_);
   }
@@ skipping 49 matching lines @@
   static Range* Unknown() {
     return new Range(RangeBoundary::MinSmi(), RangeBoundary::MaxSmi());
   }
 
   void PrintTo(BufferFormatter* f) const;
   static const char* ToCString(Range* range);
 
   const RangeBoundary& min() const { return min_; }
   const RangeBoundary& max() const { return max_; }
 
-  bool Equals(Range* other) {
-    return min_.Equals(other->min_) && max_.Equals(other->max_);
-  }
-
   static RangeBoundary ConstantMin(const Range* range) {
-    if (range == NULL) return RangeBoundary::MinSmi();
+    if (range == NULL) {
+      return RangeBoundary::MinSmi();
+    }
     return range->min().LowerBound().Clamp();
   }
 
   static RangeBoundary ConstantMax(const Range* range) {
-    if (range == NULL) return RangeBoundary::MaxSmi();
+    if (range == NULL) {
+      return RangeBoundary::MaxSmi();
+    }
     return range->max().UpperBound().Clamp();
   }
 
+  // [0, +inf]
+  bool IsPositive() const;

[Florian Schneider, 2014/06/10 10:43:20]

I find IsPositive and IsNegative more confusing than explicitly using IsWithin,
and Overlaps:

IsPositive does not imply !IsNegative, and vice versa. There was a bug because
of that.

+
+  // [-inf, 0)
+  bool IsNegative() const;
+
+  // [-inf, val].
+  bool OnlyLessThanOrEqualTo(intptr_t val) const;
+
   // Inclusive.
   bool IsWithin(intptr_t min_int, intptr_t max_int) const;
 
   // Inclusive.
   bool Overlaps(intptr_t min_int, intptr_t max_int) const;
 
   bool IsUnsatisfiable() const;
 
  private:
   RangeBoundary min_;
@@ skipping 5339 matching lines @@
   ForwardInstructionIterator* current_iterator_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FlowGraphVisitor);
 };
 
 
 }  // namespace dart
 
 #endif  // VM_INTERMEDIATE_LANGUAGE_H_