Forking the type system between Crankshaft & Turbofan.

src/effects.h

 // Copyright 2013 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef V8_EFFECTS_H_
 #define V8_EFFECTS_H_
 
-#include "src/types.h"
+#include "src/ast/ast-types.h"
 
 namespace v8 {
 namespace internal {
 
 
 // A simple struct to represent (write) effects. A write is represented as a
 // modification of type bounds (e.g. of a variable).
 //
 // An effect can either be definite, if the write is known to have taken place,
 // or 'possible', if it was optional. The difference is relevant when composing
 // effects.
 //
 // There are two ways to compose effects: sequentially (they happen one after
 // the other) or alternatively (either one or the other happens). A definite
 // effect cancels out any previous effect upon sequencing. A possible effect
 // merges into a previous effect, i.e., type bounds are merged. Alternative
 // composition always merges bounds. It yields a possible effect if at least
 // one was only possible.
 struct Effect {
   enum Modality { POSSIBLE, DEFINITE };
 
   Modality modality;
-  Bounds bounds;
+  AstBounds bounds;
 
   Effect() : modality(DEFINITE) {}
-  explicit Effect(Bounds b, Modality m = DEFINITE) : modality(m), bounds(b) {}
+  explicit Effect(AstBounds b, Modality m = DEFINITE)
+      : modality(m), bounds(b) {}
 
   // The unknown effect.
   static Effect Unknown(Zone* zone) {
-    return Effect(Bounds::Unbounded(), POSSIBLE);
+    return Effect(AstBounds::Unbounded(), POSSIBLE);
   }
 
   static Effect Forget(Zone* zone) {
-    return Effect(Bounds::Unbounded(), DEFINITE);
+    return Effect(AstBounds::Unbounded(), DEFINITE);
   }
 
   // Sequential composition, as in 'e1; e2'.
   static Effect Seq(Effect e1, Effect e2, Zone* zone) {
     if (e2.modality == DEFINITE) return e2;
-    return Effect(Bounds::Either(e1.bounds, e2.bounds, zone), e1.modality);
+    return Effect(AstBounds::Either(e1.bounds, e2.bounds, zone), e1.modality);
   }
 
   // Alternative composition, as in 'cond ? e1 : e2'.
   static Effect Alt(Effect e1, Effect e2, Zone* zone) {
-    return Effect(
-        Bounds::Either(e1.bounds, e2.bounds, zone),
-        e1.modality == POSSIBLE ? POSSIBLE : e2.modality);
+    return Effect(AstBounds::Either(e1.bounds, e2.bounds, zone),
+                  e1.modality == POSSIBLE ? POSSIBLE : e2.modality);
   }
 };
 
 
 // Classes encapsulating sets of effects on variables.
 //
 // Effects maps variables to effects and supports sequential and alternative
 // composition.
 //
 // NestedEffects is an incremental representation that supports persistence
@@ skipping 11 matching lines @@
 class EffectsMixin: public Base {
  public:
   explicit EffectsMixin(Zone* zone) : Base(zone) {}
 
   Effect Lookup(Var var) {
     Locator locator;
     return this->Find(var, &locator)
         ? locator.value() : Effect::Unknown(Base::zone());
   }
 
-  Bounds LookupBounds(Var var) {
+  AstBounds LookupBounds(Var var) {
     Effect effect = Lookup(var);
-    return effect.modality == Effect::DEFINITE
-        ? effect.bounds : Bounds::Unbounded();
+    return effect.modality == Effect::DEFINITE ? effect.bounds
+                                               : AstBounds::Unbounded();
   }
 
   // Sequential composition.
   void Seq(Var var, Effect effect) {
     Locator locator;
     if (!this->Insert(var, &locator)) {
       effect = Effect::Seq(locator.value(), effect, Base::zone());
     }
     locator.set_value(effect);
   }
@@ skipping 225 matching lines @@
     result.pop();
     DCHECK(!this->is_empty());
     return result;
   }
 };
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_EFFECTS_H_