More API cleanup.

test/cctest/test-decls.cc

 // Copyright 2007-2008 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 78 matching lines @@
   // The handlers are called as static functions that forward
   // to the instance specific virtual methods.
   static void HandleGet(Local<String> key,
                         const v8::PropertyCallbackInfo<v8::Value>& info);
   static void HandleSet(Local<String> key,
                         Local<Value> value,
                         const v8::PropertyCallbackInfo<v8::Value>& info);
   static void HandleQuery(Local<String> key,
                           const v8::PropertyCallbackInfo<v8::Integer>& info);
 
+  v8::Isolate* isolate() const { return CcTest::isolate(); }
+
  private:
   bool is_initialized_;
   Persistent<Context> context_;
 
   int get_count_;
   int set_count_;
   int query_count_;
 
   static DeclarationContext* GetInstance(Local<Value> data);
 };
@@ skipping 128 matching lines @@
                   1,  // declaration
                   2,  // declaration + initialization
                   EXPECT_RESULT, Undefined(CcTest::isolate()));
   }
 
   { DeclarationContext context;
     context.Check("var x = 0; x",
                   1,  // access
                   2,  // declaration + initialization
                   2,  // declaration + initialization
-                  EXPECT_RESULT, Number::New(0));
+                  EXPECT_RESULT, Number::New(CcTest::isolate(), 0));
   }
 
   { DeclarationContext context;
     context.Check("function x() { }; x",
                   1,  // access
                   0,
                   0,
                   EXPECT_RESULT);
   }
 
@@ skipping 13 matching lines @@
                   1,  // declaration
                   EXPECT_RESULT, Undefined(CcTest::isolate()));
   }
 }
 
 
 
 class PresentPropertyContext: public DeclarationContext {
  protected:
   virtual v8::Handle<Integer> Query(Local<String> key) {
-    return Integer::New(v8::None);
+    return Integer::New(isolate(), v8::None);
   }
 };
 
 
 
 TEST(Present) {
   HandleScope scope(CcTest::isolate());
 
   { PresentPropertyContext context;
     context.Check("var x; x",
                   1,  // access
                   0,
                   2,  // declaration + initialization
                   EXPECT_EXCEPTION);  // x is not defined!
   }
 
   { PresentPropertyContext context;
     context.Check("var x = 0; x",
                   1,  // access
                   1,  // initialization
                   2,  // declaration + initialization
-                  EXPECT_RESULT, Number::New(0));
+                  EXPECT_RESULT, Number::New(CcTest::isolate(), 0));
   }
 
   { PresentPropertyContext context;
     context.Check("function x() { }; x",
                   1,  // access
                   0,
                   0,
                   EXPECT_RESULT);
   }
 
   { PresentPropertyContext context;
     context.Check("const x; x",
                   1,  // access
                   1,  // initialization
                   1,  // (re-)declaration
                   EXPECT_RESULT, Undefined(CcTest::isolate()));
   }
 
   { PresentPropertyContext context;
     context.Check("const x = 0; x",
                   1,  // access
                   1,  // initialization
                   1,  // (re-)declaration
-                  EXPECT_RESULT, Number::New(0));
+                  EXPECT_RESULT, Number::New(CcTest::isolate(), 0));
   }
 }
 
 
 
 class AbsentPropertyContext: public DeclarationContext {
  protected:
   virtual v8::Handle<Integer> Query(Local<String> key) {
     return v8::Handle<Integer>();
   }
@@ skipping 11 matching lines @@
                   1,  // declaration
                   2,  // declaration + initialization
                   EXPECT_RESULT, Undefined(isolate));
   }
 
   { AbsentPropertyContext context;
     context.Check("var x = 0; x",
                   1,  // access
                   2,  // declaration + initialization
                   2,  // declaration + initialization
-                  EXPECT_RESULT, Number::New(0));
+                  EXPECT_RESULT, Number::New(isolate, 0));
   }
 
   { AbsentPropertyContext context;
     context.Check("function x() { }; x",
                   1,  // access
                   0,
                   0,
                   EXPECT_RESULT);
   }
 
@@ skipping 39 matching lines @@
     switch (state_) {
       case DECLARE:
         // Force declaration by returning that the
         // property is absent.
         state_ = INITIALIZE_IF_ASSIGN;
         return Handle<Integer>();
       case INITIALIZE_IF_ASSIGN:
         // Return that the property is present so we only get the
         // setter called when initializing with a value.
         state_ = UNKNOWN;
-        return Integer::New(v8::None);
+        return Integer::New(isolate(), v8::None);
       default:
         CHECK(state_ == UNKNOWN);
         break;
     }
     // Do the lookup in the object.
     return v8::Handle<Integer>();
   }
 
  private:
   State state_;
@@ skipping 10 matching lines @@
                   1,  // declaration
                   2,  // declaration + initialization
                   EXPECT_RESULT, Undefined(CcTest::isolate()));
   }
 
   { AppearingPropertyContext context;
     context.Check("var x = 0; x",
                   1,  // access
                   2,  // declaration + initialization
                   2,  // declaration + initialization
-                  EXPECT_RESULT, Number::New(0));
+                  EXPECT_RESULT, Number::New(CcTest::isolate(), 0));
   }
 
   { AppearingPropertyContext context;
     context.Check("function x() { }; x",
                   1,  // access
                   0,
                   0,
                   EXPECT_RESULT);
   }
 
@@ skipping 34 matching lines @@
     switch (state_) {
       case DECLARE:
         // Force the first declaration by returning that
         // the property is absent.
         state_ = DONT_DECLARE;
         return Handle<Integer>();
       case DONT_DECLARE:
         // Ignore the second declaration by returning
         // that the property is already there.
         state_ = INITIALIZE;
-        return Integer::New(v8::None);
+        return Integer::New(isolate(), v8::None);
       case INITIALIZE:
         // Force an initialization by returning that
         // the property is absent. This will make sure
         // that the setter is called and it will not
         // lead to redeclaration conflicts (yet).
         state_ = UNKNOWN;
         return Handle<Integer>();
       default:
         CHECK(state_ == UNKNOWN);
         break;
@@ skipping 16 matching lines @@
                   0,
                   3,  // const declaration+initialization, var initialization
                   3,  // 2 x declaration + var initialization
                   EXPECT_RESULT, Undefined(CcTest::isolate()));
   }
 }
 
 
 
 class ExistsInPrototypeContext: public DeclarationContext {
+ public:
+  ExistsInPrototypeContext() { InitializeIfNeeded(); }
  protected:
   virtual v8::Handle<Integer> Query(Local<String> key) {
     // Let it seem that the property exists in the prototype object.
-    return Integer::New(v8::None);
+    return Integer::New(isolate(), v8::None);
   }
 
   // Use the prototype as the holder for the interceptors.
   virtual Local<ObjectTemplate> GetHolder(Local<FunctionTemplate> function) {
     return function->PrototypeTemplate();
   }
 };
 
 
 TEST(ExistsInPrototype) {
   i::FLAG_es52_globals = true;
   HandleScope scope(CcTest::isolate());
 
   // Sanity check to make sure that the holder of the interceptor
   // really is the prototype object.
   { ExistsInPrototypeContext context;
     context.Check("this.x = 87; this.x",
                   0,
                   0,
                   0,
-                  EXPECT_RESULT, Number::New(87));
+                  EXPECT_RESULT, Number::New(CcTest::isolate(), 87));
   }
 
   { ExistsInPrototypeContext context;
     context.Check("var x; x",
                   0,
                   0,
                   0,
                   EXPECT_RESULT, Undefined(CcTest::isolate()));
   }
 
   { ExistsInPrototypeContext context;
     context.Check("var x = 0; x",
                   0,
                   0,
                   0,
-                  EXPECT_RESULT, Number::New(0));
+                  EXPECT_RESULT, Number::New(CcTest::isolate(), 0));
   }
 
   { ExistsInPrototypeContext context;
     context.Check("const x; x",
                   0,
                   0,
                   0,
                   EXPECT_RESULT, Undefined(CcTest::isolate()));
   }
 
   { ExistsInPrototypeContext context;
     context.Check("const x = 0; x",
                   0,
                   0,
                   0,
-                  EXPECT_RESULT, Number::New(0));
+                  EXPECT_RESULT, Number::New(CcTest::isolate(), 0));
   }
 }
 
 
 
 class AbsentInPrototypeContext: public DeclarationContext {
  protected:
   virtual v8::Handle<Integer> Query(Local<String> key) {
     // Let it seem that the property is absent in the prototype object.
     return Handle<Integer>();
@@ skipping 25 matching lines @@
 class ExistsInHiddenPrototypeContext: public DeclarationContext {
  public:
   ExistsInHiddenPrototypeContext() {
     hidden_proto_ = FunctionTemplate::New(CcTest::isolate());
     hidden_proto_->SetHiddenPrototype(true);
   }
 
  protected:
   virtual v8::Handle<Integer> Query(Local<String> key) {
     // Let it seem that the property exists in the hidden prototype object.
-    return Integer::New(v8::None);
+    return Integer::New(isolate(), v8::None);
   }
 
   // Install the hidden prototype after the global object has been created.
   virtual void PostInitializeContext(Handle<Context> context) {
     Local<Object> global_object = context->Global();
     Local<Object> hidden_proto = hidden_proto_->GetFunction()->NewInstance();
     Local<Object> inner_global =
         Local<Object>::Cast(global_object->GetPrototype());
     inner_global->SetPrototype(hidden_proto);
   }
@@ skipping 18 matching lines @@
                   0,
                   2,  // declaration + initialization
                   EXPECT_EXCEPTION);  // x is not defined!
   }
 
   { ExistsInHiddenPrototypeContext context;
     context.Check("var x = 0; x",
                   1,  // access
                   1,  // initialization
                   2,  // declaration + initialization
-                  EXPECT_RESULT, Number::New(0));
+                  EXPECT_RESULT, Number::New(CcTest::isolate(), 0));
   }
 
   { ExistsInHiddenPrototypeContext context;
     context.Check("function x() { }; x",
                   0,
                   0,
                   0,
                   EXPECT_RESULT);
   }
 
   // TODO(mstarzinger): The semantics of global const is vague.
   { ExistsInHiddenPrototypeContext context;
     context.Check("const x; x",
                   0,
                   0,
                   1,  // (re-)declaration
                   EXPECT_RESULT, Undefined(CcTest::isolate()));
   }
 
   // TODO(mstarzinger): The semantics of global const is vague.
   { ExistsInHiddenPrototypeContext context;
     context.Check("const x = 0; x",
                   0,
                   0,
                   1,  // (re-)declaration
-                  EXPECT_RESULT, Number::New(0));
+                  EXPECT_RESULT, Number::New(CcTest::isolate(), 0));
   }
 }
 
 
 
 class SimpleContext {
  public:
   SimpleContext()
       : handle_scope_(CcTest::isolate()),
         context_(Context::New(CcTest::isolate())) {
@@ skipping 32 matching lines @@
     }
   }
 
  private:
   HandleScope handle_scope_;
   Local<Context> context_;
 };
 
 
 TEST(CrossScriptReferences) {
-  HandleScope scope(CcTest::isolate());
+  v8::Isolate* isolate = CcTest::isolate();
+  HandleScope scope(isolate);
 
   { SimpleContext context;
     context.Check("var x = 1; x",
-                  EXPECT_RESULT, Number::New(1));
+                  EXPECT_RESULT, Number::New(isolate, 1));
     context.Check("var x = 2; x",
-                  EXPECT_RESULT, Number::New(2));
+                  EXPECT_RESULT, Number::New(isolate, 2));
     context.Check("const x = 3; x",
-                  EXPECT_RESULT, Number::New(3));
+                  EXPECT_RESULT, Number::New(isolate, 3));
     context.Check("const x = 4; x",
-                  EXPECT_RESULT, Number::New(4));
+                  EXPECT_RESULT, Number::New(isolate, 4));
     context.Check("x = 5; x",
-                  EXPECT_RESULT, Number::New(5));
+                  EXPECT_RESULT, Number::New(isolate, 5));
     context.Check("var x = 6; x",
-                  EXPECT_RESULT, Number::New(6));
+                  EXPECT_RESULT, Number::New(isolate, 6));
     context.Check("this.x",
-                  EXPECT_RESULT, Number::New(6));
+                  EXPECT_RESULT, Number::New(isolate, 6));
     context.Check("function x() { return 7 }; x()",
-                  EXPECT_RESULT, Number::New(7));
+                  EXPECT_RESULT, Number::New(isolate, 7));
   }
 
   { SimpleContext context;
     context.Check("const x = 1; x",
-                  EXPECT_RESULT, Number::New(1));
+                  EXPECT_RESULT, Number::New(isolate, 1));
     context.Check("var x = 2; x",  // assignment ignored
-                  EXPECT_RESULT, Number::New(1));
+                  EXPECT_RESULT, Number::New(isolate, 1));
     context.Check("const x = 3; x",
-                  EXPECT_RESULT, Number::New(1));
+                  EXPECT_RESULT, Number::New(isolate, 1));
     context.Check("x = 4; x",  // assignment ignored
-                  EXPECT_RESULT, Number::New(1));
+                  EXPECT_RESULT, Number::New(isolate, 1));
     context.Check("var x = 5; x",  // assignment ignored
-                  EXPECT_RESULT, Number::New(1));
+                  EXPECT_RESULT, Number::New(isolate, 1));
     context.Check("this.x",
-                  EXPECT_RESULT, Number::New(1));
+                  EXPECT_RESULT, Number::New(isolate, 1));
     context.Check("function x() { return 7 }; x",
                   EXPECT_EXCEPTION);
   }
 }
 
 
 TEST(CrossScriptReferencesHarmony) {
   i::FLAG_use_strict = true;
   i::FLAG_harmony_scoping = true;
   i::FLAG_harmony_modules = true;
 
-  HandleScope scope(CcTest::isolate());
+  v8::Isolate* isolate = CcTest::isolate();
+  HandleScope scope(isolate);
 
   const char* decs[] = {
     "var x = 1; x", "x", "this.x",
     "function x() { return 1 }; x()", "x()", "this.x()",
     "let x = 1; x", "x", "this.x",
     "const x = 1; x", "x", "this.x",
     "module x { export let a = 1 }; x.a", "x.a", "this.x.a",
     NULL
   };
 
   for (int i = 0; decs[i] != NULL; i += 3) {
     SimpleContext context;
-    context.Check(decs[i], EXPECT_RESULT, Number::New(1));
-    context.Check(decs[i+1], EXPECT_RESULT, Number::New(1));
+    context.Check(decs[i], EXPECT_RESULT, Number::New(isolate, 1));
+    context.Check(decs[i+1], EXPECT_RESULT, Number::New(isolate, 1));
     // TODO(rossberg): The current ES6 draft spec does not reflect lexical
     // bindings on the global object. However, this will probably change, in
     // which case we reactivate the following test.
-    if (i/3 < 2) context.Check(decs[i+2], EXPECT_RESULT, Number::New(1));
+    if (i/3 < 2) {
+      context.Check(decs[i+2], EXPECT_RESULT, Number::New(isolate, 1));
+    }
   }
 }
 
 
 TEST(CrossScriptConflicts) {
   i::FLAG_use_strict = true;
   i::FLAG_harmony_scoping = true;
   i::FLAG_harmony_modules = true;
 
   HandleScope scope(CcTest::isolate());
@@ skipping 11 matching lines @@
     "function x() { return 2 }; x()",
     "let x = 2; x",
     "const x = 2; x",
     "module x { export let a = 2 }; x.a",
     NULL
   };
 
   for (int i = 0; firsts[i] != NULL; ++i) {
     for (int j = 0; seconds[j] != NULL; ++j) {
       SimpleContext context;
-      context.Check(firsts[i], EXPECT_RESULT, Number::New(1));
+      context.Check(firsts[i], EXPECT_RESULT,
+                    Number::New(CcTest::isolate(), 1));
       // TODO(rossberg): All tests should actually be errors in Harmony,
       // but we currently do not detect the cases where the first declaration
       // is not lexical.
       context.Check(seconds[j],
-                    i < 2 ? EXPECT_RESULT : EXPECT_ERROR, Number::New(2));
+                    i < 2 ? EXPECT_RESULT : EXPECT_ERROR,
+                    Number::New(CcTest::isolate(), 2));
     }
   }
 }