Rename ASSERT* to DCHECK*.

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/v8.h"
 
 #include "src/types.h"
@@ skipping 177 matching lines @@
     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;
 
   bool Contains(Var var) {
-    ASSERT(var != kNoVar);
+    DCHECK(var != kNoVar);
     return map_->Contains(var);
   }
   bool Find(Var var, Locator* locator) {
-    ASSERT(var != kNoVar);
+    DCHECK(var != kNoVar);
     return map_->Find(var, locator);
   }
   bool Insert(Var var, Locator* locator) {
-    ASSERT(var != kNoVar);
+    DCHECK(var != kNoVar);
     return map_->Insert(var, locator);
   }
 
   template<class Callback>
   void ForEach(Callback* callback) {
     return map_->ForEach(callback);
   }
 
  private:
   Mapping* map_;
@@ skipping 35 matching lines @@
  protected:
   typedef typename EffectsBase<Var, kNoVar>::Locator Locator;
 
   Zone* zone() { return node_->zone; }
 
   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);
+    DCHECK(var != kNoVar);
     for (Node* node = node_; node != NULL; node = node->previous) {
       if (node->effects.Contains(var)) return true;
     }
     return false;
   }
 
   bool Find(Var var, Locator* locator) {
-    ASSERT(var != kNoVar);
+    DCHECK(var != kNoVar);
     for (Node* node = node_; node != NULL; node = node->previous) {
       if (node->effects.Find(var, locator)) return true;
     }
     return false;
   }
 
   bool Insert(Var var, Locator* locator);
 
  private:
   struct Node: ZoneObject {
     Zone* zone;
     Effects<Var, kNoVar> effects;
     Node* previous;
     explicit Node(Zone* zone, Node* previous = NULL)
         : zone(zone), effects(zone), previous(previous) {}
   };
 
   explicit NestedEffectsBase(Node* node) : node_(node) {}
 
   Node* node_;
 };
 
 
 template<class Var, Var kNoVar>
 bool NestedEffectsBase<Var, kNoVar>::Insert(Var var, Locator* locator) {
-  ASSERT(var != kNoVar);
+  DCHECK(var != kNoVar);
   if (!node_->effects.Insert(var, locator)) return false;
   Locator shadowed;
   for (Node* node = node_->previous; node != NULL; node = node->previous) {
     if (node->effects.Find(var, &shadowed)) {
       // Initialize with shadowed entry.
       locator->set_value(shadowed.value());
       return false;
     }
   }
   return true;
@@ skipping 12 matching lines @@
   // be modified while the extension is in use.
   NestedEffects Push() {
     NestedEffects result = *this;
     result.push();
     return result;
   }
 
   NestedEffects Pop() {
     NestedEffects result = *this;
     result.pop();
-    ASSERT(!this->is_empty());
+    DCHECK(!this->is_empty());
     return result;
   }
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_EFFECTS_H_