Zonify types in compiler frontend

src/effects.h

 // Copyright 2013 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 41 matching lines @@
 struct Effect {
   enum Modality { POSSIBLE, DEFINITE };
 
   Modality modality;
   Bounds bounds;
 
   Effect() : modality(DEFINITE) {}
   Effect(Bounds b, Modality m = DEFINITE) : modality(m), bounds(b) {}
 
   // The unknown effect.
-  static Effect Unknown(Isolate* isolate) {
-    return Effect(Bounds::Unbounded(isolate), POSSIBLE);
+  static Effect Unknown(Zone* zone) {
+    return Effect(Bounds::Unbounded(zone), POSSIBLE);
   }
 
-  static Effect Forget(Isolate* isolate) {
-    return Effect(Bounds::Unbounded(isolate), DEFINITE);
+  static Effect Forget(Zone* zone) {
+    return Effect(Bounds::Unbounded(zone), DEFINITE);
   }
 
   // Sequential composition, as in 'e1; e2'.
-  static Effect Seq(Effect e1, Effect e2, Isolate* isolate) {
+  static Effect Seq(Effect e1, Effect e2, Zone* zone) {
     if (e2.modality == DEFINITE) return e2;
-    return Effect(Bounds::Either(e1.bounds, e2.bounds, isolate), e1.modality);
+    return Effect(Bounds::Either(e1.bounds, e2.bounds, zone), e1.modality);
   }
 
   // Alternative composition, as in 'cond ? e1 : e2'.
-  static Effect Alt(Effect e1, Effect e2, Isolate* isolate) {
+  static Effect Alt(Effect e1, Effect e2, Zone* zone) {
     return Effect(
-        Bounds::Either(e1.bounds, e2.bounds, isolate),
+        Bounds::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
 // through functional extension. It represents the map as an adjoin of a list
 // of maps, whose tail can be shared.
 //
 // Both classes provide similar interfaces, implemented in parts through the
 // EffectsMixin below (using sandwich style, to work around the style guide's
 // MI restriction).
 //
 // We also (ab)use Effects/NestedEffects as a representation for abstract
 // store typings. In that case, only definite effects are of interest.
 
 template<class Var, class Base, class Effects>
 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::isolate());
+        ? locator.value() : Effect::Unknown(Base::zone());
   }
 
   Bounds LookupBounds(Var var) {
     Effect effect = Lookup(var);
     return effect.modality == Effect::DEFINITE
-        ? effect.bounds : Bounds::Unbounded(Base::isolate());
+        ? effect.bounds : Bounds::Unbounded(Base::zone());
   }
 
   // Sequential composition.
   void Seq(Var var, Effect effect) {
     Locator locator;
     if (!this->Insert(var, &locator)) {
-      effect = Effect::Seq(locator.value(), effect, Base::isolate());
+      effect = Effect::Seq(locator.value(), effect, Base::zone());
     }
     locator.set_value(effect);
   }
 
   void Seq(Effects that) {
     SeqMerger<EffectsMixin> merge = { *this };
     that.ForEach(&merge);
   }
 
   // Alternative composition.
   void Alt(Var var, Effect effect) {
     Locator locator;
     if (!this->Insert(var, &locator)) {
-      effect = Effect::Alt(locator.value(), effect, Base::isolate());
+      effect = Effect::Alt(locator.value(), effect, Base::zone());
     }
     locator.set_value(effect);
   }
 
   void Alt(Effects that) {
     AltWeakener<EffectsMixin> weaken = { *this, that };
     this->ForEach(&weaken);
     AltMerger<EffectsMixin> merge = { *this };
     that.ForEach(&merge);
   }
 
   // Invalidation.
   void Forget() {
     Overrider override = {
-        Effect::Forget(Base::isolate()), Effects(Base::zone()) };
+        Effect::Forget(Base::zone()), Effects(Base::zone()) };
     this->ForEach(&override);
     Seq(override.effects);
   }
 
  protected:
   typedef typename Base::Locator Locator;
 
   template<class Self>
   struct SeqMerger {
     void Call(Var var, Effect effect) { self.Seq(var, effect); }
@@ skipping 37 matching lines @@
   explicit EffectsBase(Zone* zone) : map_(new(zone) Mapping(zone)) {}
 
   bool IsEmpty() { return map_->is_empty(); }
 
  protected:
   friend class NestedEffectsBase<Var, kNoVar>;
   friend class
       EffectsMixin<Var, NestedEffectsBase<Var, kNoVar>, Effects<Var, kNoVar> >;
 
   Zone* zone() { return map_->allocator().zone(); }
-  Isolate* isolate() { return zone()->isolate(); }
 
   struct SplayTreeConfig {
     typedef Var Key;
     typedef Effect Value;
     static const Var kNoKey = kNoVar;
     static Effect NoValue() { return Effect(); }
     static int Compare(int x, int y) { return y - x; }
   };
   typedef ZoneSplayTree<SplayTreeConfig> Mapping;
   typedef typename Mapping::Locator Locator;
@@ skipping 50 matching lines @@
     for (Node* node = node_; node != NULL; node = node->previous) {
       if (!node->effects.IsEmpty()) return false;
     }
     return true;
   }
 
  protected:
   typedef typename EffectsBase<Var, kNoVar>::Locator Locator;
 
   Zone* zone() { return node_->zone; }
-  Isolate* isolate() { return zone()->isolate(); }
 
   void push() { node_ = new(node_->zone) Node(node_->zone, node_); }
   void pop() { node_ = node_->previous; }
   bool is_empty() { return node_ == NULL; }
 
   bool Contains(Var var) {
     ASSERT(var != kNoVar);
     for (Node* node = node_; node != NULL; node = node->previous) {
       if (node->effects.Contains(var)) return true;
     }
@@ skipping 61 matching lines @@
     NestedEffects result = *this;
     result.pop();
     ASSERT(!this->is_empty());
     return result;
   }
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_EFFECTS_H_