bulk replace Isolate::Current in tests

test/cctest/test-types.cc

 // 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 174 matching lines @@
     return handle(Type::Intersect(type1, type2), isolate_);
   }
 
  private:
   Isolate* isolate_;
 };
 
 
 TEST(Bitset) {
   CcTest::InitializeVM();
-  Isolate* isolate = Isolate::Current();
+  Isolate* isolate = CcTest::i_isolate();
   HandleScope scope(isolate);
   HandlifiedTypes T(isolate);
 
   CHECK(IsBitset(*T.None));
   CHECK(IsBitset(*T.Any));
   CHECK(IsBitset(*T.String));
   CHECK(IsBitset(*T.Object));
 
   CHECK(IsBitset(Type::Union(T.String, T.Number)));
   CHECK(IsBitset(Type::Union(T.String, T.Receiver)));
   CHECK(IsBitset(Type::Optional(T.Object)));
 
   CHECK_EQ(0, AsBitset(*T.None));
   CHECK_EQ(AsBitset(*T.Number) | AsBitset(*T.String),
            AsBitset(Type::Union(T.String, T.Number)));
   CHECK_EQ(AsBitset(*T.Receiver),
            AsBitset(Type::Union(T.Receiver, T.Object)));
   CHECK_EQ(AsBitset(*T.String) | AsBitset(*T.Undefined),
            AsBitset(Type::Optional(T.String)));
 }
 
 
 TEST(Class) {
   CcTest::InitializeVM();
-  Isolate* isolate = Isolate::Current();
+  Isolate* isolate = CcTest::i_isolate();
   HandleScope scope(isolate);
   HandlifiedTypes T(isolate);
 
   CHECK(IsClass(*T.ObjectClass));
   CHECK(IsClass(*T.ArrayClass));
 
   CHECK(*T.object_map == AsClass(*T.ObjectClass));
   CHECK(*T.array_map == AsClass(*T.ArrayClass));
 }
 
 
 TEST(Constant) {
   CcTest::InitializeVM();
-  Isolate* isolate = Isolate::Current();
+  Isolate* isolate = CcTest::i_isolate();
   HandleScope scope(isolate);
   HandlifiedTypes T(isolate);
 
   CHECK(IsConstant(*T.Integer31Constant));
   CHECK(IsConstant(*T.ObjectConstant1));
   CHECK(IsConstant(*T.ObjectConstant2));
   CHECK(IsConstant(*T.ArrayConstant1));
   CHECK(IsConstant(*T.ArrayConstant2));
 
   CHECK(*T.smi == AsConstant(*T.Integer31Constant));
   CHECK(*T.object1 == AsConstant(*T.ObjectConstant1));
   CHECK(*T.object2 == AsConstant(*T.ObjectConstant2));
   CHECK(*T.object1 != AsConstant(*T.ObjectConstant2));
   CHECK(*T.array == AsConstant(*T.ArrayConstant1));
   CHECK(*T.array == AsConstant(*T.ArrayConstant2));
 }
 
 
 TEST(Is) {
   CcTest::InitializeVM();
-  Isolate* isolate = Isolate::Current();
+  Isolate* isolate = CcTest::i_isolate();
   HandleScope scope(isolate);
   HandlifiedTypes T(isolate);
 
   // Reflexivity
   CHECK(T.None->Is(T.None));
   CHECK(T.Any->Is(T.Any));
   CHECK(T.Object->Is(T.Object));
 
   CHECK(T.ObjectClass->Is(T.ObjectClass));
   CHECK(T.ObjectConstant1->Is(T.ObjectConstant1));
@@ skipping 59 matching lines @@
   CheckUnordered(T.ObjectConstant1, T.ObjectClass);
   CheckUnordered(T.ObjectConstant2, T.ObjectClass);
   CheckUnordered(T.ObjectConstant1, T.ArrayClass);
   CheckUnordered(T.ObjectConstant2, T.ArrayClass);
   CheckUnordered(T.ArrayConstant1, T.ObjectClass);
 }
 
 
 TEST(Maybe) {
   CcTest::InitializeVM();
-  Isolate* isolate = Isolate::Current();
+  Isolate* isolate = CcTest::i_isolate();
   HandleScope scope(isolate);
   HandlifiedTypes T(isolate);
 
   CheckOverlap(T.Any, T.Any);
   CheckOverlap(T.Object, T.Object);
 
   CheckOverlap(T.Oddball, T.Any);
   CheckOverlap(T.Boolean, T.Oddball);
   CheckOverlap(T.Null, T.Oddball);
   CheckOverlap(T.Undefined, T.Oddball);
@@ skipping 50 matching lines @@
   CheckDisjoint(T.ObjectConstant1, T.ObjectClass);
   CheckDisjoint(T.ObjectConstant2, T.ObjectClass);
   CheckDisjoint(T.ObjectConstant1, T.ArrayClass);
   CheckDisjoint(T.ObjectConstant2, T.ArrayClass);
   CheckDisjoint(T.ArrayConstant1, T.ObjectClass);
 }
 
 
 TEST(Union) {
   CcTest::InitializeVM();
-  Isolate* isolate = Isolate::Current();
+  Isolate* isolate = CcTest::i_isolate();
   HandleScope scope(isolate);
   HandlifiedTypes T(isolate);
 
   // Bitset-bitset
   CHECK(IsBitset(Type::Union(T.Object, T.Number)));
   CHECK(IsBitset(Type::Union(T.Object, T.Object)));
   CHECK(IsBitset(Type::Union(T.Any, T.None)));
 
   CheckEqual(T.Union(T.None, T.Number), T.Number);
   CheckEqual(T.Union(T.Object, T.Proxy), T.Receiver);
@@ skipping 145 matching lines @@
           T.Union(T.ObjectConstant1, T.ArrayConstant2)),
       T.Union(T.Union(T.ObjectConstant1, T.ObjectConstant2), T.ArrayConstant1));
   CheckEqual(
       T.Union(T.Union(T.Number, T.ArrayClass), T.Union(T.Integer31, T.Array)),
       T.Union(T.Number, T.Array));
 }
 
 
 TEST(Intersect) {
   CcTest::InitializeVM();
-  Isolate* isolate = Isolate::Current();
+  Isolate* isolate = CcTest::i_isolate();
   HandleScope scope(isolate);
   HandlifiedTypes T(isolate);
 
   // Bitset-bitset
   CHECK(IsBitset(Type::Intersect(T.Object, T.Number)));
   CHECK(IsBitset(Type::Intersect(T.Object, T.Object)));
   CHECK(IsBitset(Type::Intersect(T.Any, T.None)));
 
   CheckEqual(T.Intersect(T.None, T.Number), T.None);
   CheckEqual(T.Intersect(T.Object, T.Proxy), T.None);
@@ skipping 118 matching lines @@
           T.Union(T.Union(T.ObjectConstant2, T.ObjectConstant1), T.ArrayClass),
           T.Union(
               T.ObjectConstant1, T.Union(T.ArrayConstant1, T.ObjectConstant2))),
       T.Union(T.ObjectConstant2, T.ObjectConstant1));
   CheckEqual(
       T.Intersect(
           T.Union(T.ObjectConstant2, T.ArrayConstant1),
           T.Union(T.ObjectConstant1, T.ArrayConstant2)),
       T.ArrayConstant1);
 }