Add interceptor support for symbols

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 52 matching lines @@
   void Check(const char* source,
              int get, int set, int has,
              Expectations expectations,
              v8::Handle<Value> value = Local<Value>());
 
   int get_count() const { return get_count_; }
   int set_count() const { return set_count_; }
   int query_count() const { return query_count_; }
 
  protected:
-  virtual v8::Handle<Value> Get(Local<String> key);
-  virtual v8::Handle<Value> Set(Local<String> key, Local<Value> value);
-  virtual v8::Handle<Integer> Query(Local<String> key);
+  virtual v8::Handle<Value> Get(Local<Name> key);
+  virtual v8::Handle<Value> Set(Local<Name> key, Local<Value> value);
+  virtual v8::Handle<Integer> Query(Local<Name> key);
 
   void InitializeIfNeeded();
 
   // Perform optional initialization steps on the context after it has
   // been created. Defaults to none but may be overwritten.
   virtual void PostInitializeContext(Handle<Context> context) {}
 
   // Get the holder for the interceptor. Default to the instance template
   // but may be overwritten.
   virtual Local<ObjectTemplate> GetHolder(Local<FunctionTemplate> function) {
     return function->InstanceTemplate();
   }
 
   // The handlers are called as static functions that forward
   // to the instance specific virtual methods.
-  static void HandleGet(Local<String> key,
+  static void HandleGet(Local<Name> key,
                         const v8::PropertyCallbackInfo<v8::Value>& info);
-  static void HandleSet(Local<String> key,
+  static void HandleSet(Local<Name> key,
                         Local<Value> value,
                         const v8::PropertyCallbackInfo<v8::Value>& info);
-  static void HandleQuery(Local<String> key,
+  static void HandleQuery(Local<Name> 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_;
@@ skipping 64 matching lines @@
     if (!value.IsEmpty()) {
       CHECK_EQ(value, catcher.Exception());
     }
   }
   // Clean slate for the next test.
   CcTest::heap()->CollectAllAvailableGarbage();
 }
 
 
 void DeclarationContext::HandleGet(
-    Local<String> key,
+    Local<Name> key,
     const v8::PropertyCallbackInfo<v8::Value>& info) {
   DeclarationContext* context = GetInstance(info.Data());
   context->get_count_++;
   info.GetReturnValue().Set(context->Get(key));
 }
 
 
 void DeclarationContext::HandleSet(
-    Local<String> key,
+    Local<Name> key,
     Local<Value> value,
     const v8::PropertyCallbackInfo<v8::Value>& info) {
   DeclarationContext* context = GetInstance(info.Data());
   context->set_count_++;
   info.GetReturnValue().Set(context->Set(key, value));
 }
 
 
 void DeclarationContext::HandleQuery(
-    Local<String> key,
+    Local<Name> key,
     const v8::PropertyCallbackInfo<v8::Integer>& info) {
   DeclarationContext* context = GetInstance(info.Data());
   context->query_count_++;
   info.GetReturnValue().Set(context->Query(key));
 }
 
 
 DeclarationContext* DeclarationContext::GetInstance(Local<Value> data) {
   void* value = Local<External>::Cast(data)->Value();
   return static_cast<DeclarationContext*>(value);
 }
 
 
-v8::Handle<Value> DeclarationContext::Get(Local<String> key) {
+v8::Handle<Value> DeclarationContext::Get(Local<Name> key) {
   return v8::Handle<Value>();
 }
 
 
-v8::Handle<Value> DeclarationContext::Set(Local<String> key,
+v8::Handle<Value> DeclarationContext::Set(Local<Name> key,
                                           Local<Value> value) {
   return v8::Handle<Value>();
 }
 
 
-v8::Handle<Integer> DeclarationContext::Query(Local<String> key) {
+v8::Handle<Integer> DeclarationContext::Query(Local<Name> key) {
   return v8::Handle<Integer>();
 }
 
 
 // Test global declaration of a property the interceptor doesn't know
 // about and doesn't handle.
 TEST(Unknown) {
   HandleScope scope(CcTest::isolate());
   v8::V8::Initialize();
 
@@ skipping 470 matching lines @@
                     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(CcTest::isolate(), 2));
     }
   }
 }