Revert "Strict mode ThrowTypeError functions for"

src/bootstrapper.cc

 // Copyright 2006-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 189 matching lines @@
   // triggered during environment creation there may be weak handle
   // processing callbacks which may create new environments.
   Genesis* previous_;
 
   Handle<Context> global_context() { return global_context_; }
 
   // Creates some basic objects. Used for creating a context from scratch.
   void CreateRoots();
   // Creates the empty function.  Used for creating a context from scratch.
   Handle<JSFunction> CreateEmptyFunction();
-  void CreateThrowTypeErrorCallbacks(
-      Handle<FixedArray> callbacks,
-      Builtins::Name builtin);
-  void CreateThrowTypeError(Handle<JSFunction> empty);
   // Creates the global objects using the global and the template passed in
   // through the API.  We call this regardless of whether we are building a
   // context from scratch or using a deserialized one from the partial snapshot
   // but in the latter case we don't use the objects it produces directly, as
   // we have to used the deserialized ones that are linked together with the
   // rest of the context snapshot.
   Handle<JSGlobalProxy> CreateNewGlobals(
       v8::Handle<v8::ObjectTemplate> global_template,
       Handle<Object> global_object,
       Handle<GlobalObject>* global_proxy_out);
@@ skipping 36 matching lines @@
   void TransferIndexedProperties(Handle<JSObject> from, Handle<JSObject> to);
 
   enum PrototypePropertyMode {
     DONT_ADD_PROTOTYPE,
     ADD_READONLY_PROTOTYPE,
     ADD_WRITEABLE_PROTOTYPE
   };
   Handle<DescriptorArray> ComputeFunctionInstanceDescriptor(
       PrototypePropertyMode prototypeMode);
   void MakeFunctionInstancePrototypeWritable();
-  Handle<DescriptorArray> ComputeStrictFunctionDescriptor(
-      PrototypePropertyMode propertyMode,
-      Handle<FixedArray> arguments,
-      Handle<FixedArray> caller);
 
   static bool CompileBuiltin(int index);
   static bool CompileNative(Vector<const char> name, Handle<String> source);
   static bool CompileScriptCached(Vector<const char> name,
                                   Handle<String> source,
                                   SourceCodeCache* cache,
                                   v8::Extension* extension,
                                   Handle<Context> top_context,
                                   bool use_runtime_context);
 
@@ skipping 216 matching lines @@
   Handle<Map> empty_fm = Factory::CopyMapDropDescriptors(
       function_without_prototype_map);
   empty_fm->set_instance_descriptors(
       *function_without_prototype_map_descriptors);
   empty_fm->set_prototype(global_context()->object_function()->prototype());
   empty_function->set_map(*empty_fm);
   return empty_function;
 }
 
 
-Handle<DescriptorArray> Genesis::ComputeStrictFunctionDescriptor(
-    PrototypePropertyMode prototypeMode,
-    Handle<FixedArray> arguments,
-    Handle<FixedArray> caller) {
-  Handle<DescriptorArray> descriptors =
-      Factory::NewDescriptorArray(prototypeMode == DONT_ADD_PROTOTYPE ? 4 : 5);
-  PropertyAttributes attributes = static_cast<PropertyAttributes>(
-      DONT_ENUM | DONT_DELETE | READ_ONLY);
-
-  {  // length
-    Handle<Proxy> proxy = Factory::NewProxy(&Accessors::FunctionLength);
-    CallbacksDescriptor d(*Factory::length_symbol(), *proxy, attributes);
-    descriptors->Set(0, &d);
-  }
-  {  // name
-    Handle<Proxy> proxy = Factory::NewProxy(&Accessors::FunctionName);
-    CallbacksDescriptor d(*Factory::name_symbol(), *proxy, attributes);
-    descriptors->Set(1, &d);
-  }
-  {  // arguments
-    CallbacksDescriptor d(*Factory::arguments_symbol(), *arguments, attributes);
-    descriptors->Set(2, &d);
-  }
-  {  // caller
-    CallbacksDescriptor d(*Factory::caller_symbol(), *caller, attributes);
-    descriptors->Set(3, &d);
-  }
-
-  // prototype
-  if (prototypeMode != DONT_ADD_PROTOTYPE) {
-    if (prototypeMode == ADD_WRITEABLE_PROTOTYPE) {
-      attributes = static_cast<PropertyAttributes>(attributes & ~READ_ONLY);
-    }
-    CallbacksDescriptor d(
-        *Factory::prototype_symbol(),
-        *Factory::NewProxy(&Accessors::FunctionPrototype),
-        attributes);
-    descriptors->Set(4, &d);
-  }
-
-  descriptors->Sort();
-  return descriptors;
-}
-
-
-void Genesis::CreateThrowTypeErrorCallbacks(
-    Handle<FixedArray> callbacks,
-    Builtins::Name builtin) {
-  // Create the ThrowTypeError function.
-  Handle<String> name = Factory::LookupAsciiSymbol("ThrowTypeError");
-  Handle<JSFunction> pill = Factory::NewFunctionWithoutPrototypeStrict(name);
-  Handle<Code> code = Handle<Code>(Builtins::builtin(builtin));
-  pill->set_map(global_context()->function_map_strict());
-  pill->set_code(*code);
-  pill->shared()->set_code(*code);
-  pill->shared()->DontAdaptArguments();
-
-  // Install the poison pills into the calbacks array.
-  callbacks->set(0, *pill);
-  callbacks->set(1, *pill);
-
-  PreventExtensions(pill);
-}
-
-
-// ECMAScript 5th Edition, 13.2.3
-void Genesis::CreateThrowTypeError(Handle<JSFunction> empty) {
-  // Create the pill callbacks arrays. The get/set callacks are installed
-  // after the maps get created below.
-  Handle<FixedArray> arguments = Factory::NewFixedArray(2, TENURED);
-  Handle<FixedArray> caller = Factory::NewFixedArray(2, TENURED);
-
-  {  // Allocate map for the strict mode function instances.
-    Handle<Map> map = Factory::NewMap(JS_FUNCTION_TYPE, JSFunction::kSize);
-    global_context()->set_function_instance_map_strict(*map);
-    Handle<DescriptorArray> descriptors = ComputeStrictFunctionDescriptor(
-        ADD_WRITEABLE_PROTOTYPE, arguments, caller);
-    map->set_instance_descriptors(*descriptors);
-    map->set_function_with_prototype(true);
-    map->set_prototype(*empty);
-  }
-
-  {  // Allocate map for the prototype-less strict mode instances.
-    Handle<Map> map = Factory::NewMap(JS_FUNCTION_TYPE, JSFunction::kSize);
-    global_context()->set_function_without_prototype_map_strict(*map);
-    Handle<DescriptorArray> descriptors = ComputeStrictFunctionDescriptor(
-        DONT_ADD_PROTOTYPE, arguments, caller);
-    map->set_instance_descriptors(*descriptors);
-    map->set_function_with_prototype(false);
-    map->set_prototype(*empty);
-  }
-
-  {  // Allocate map for the strict mode functions.
-    Handle<Map> map = Factory::NewMap(JS_FUNCTION_TYPE, JSFunction::kSize);
-    global_context()->set_function_map_strict(*map);
-    Handle<DescriptorArray> descriptors = ComputeStrictFunctionDescriptor(
-        ADD_READONLY_PROTOTYPE, arguments, caller);
-    map->set_instance_descriptors(*descriptors);
-    map->set_function_with_prototype(true);
-    map->set_prototype(*empty);
-  }
-
-  CreateThrowTypeErrorCallbacks(arguments, Builtins::StrictFunctionArguments);
-  CreateThrowTypeErrorCallbacks(caller, Builtins::StrictFunctionCaller);
-}
-
-
 static void AddToWeakGlobalContextList(Context* context) {
   ASSERT(context->IsGlobalContext());
 #ifdef DEBUG
   { // NOLINT
     ASSERT(context->get(Context::NEXT_CONTEXT_LINK)->IsUndefined());
     // Check that context is not in the list yet.
     for (Object* current = Heap::global_contexts_list();
          !current->IsUndefined();
          current = Context::cast(current)->get(Context::NEXT_CONTEXT_LINK)) {
       ASSERT(current != context);
@@ skipping 1339 matching lines @@
                          &inner_global);
 
     HookUpGlobalProxy(inner_global, global_proxy);
     HookUpInnerGlobal(inner_global);
 
     if (!ConfigureGlobalObjects(global_template)) return;
   } else {
     // We get here if there was no context snapshot.
     CreateRoots();
     Handle<JSFunction> empty_function = CreateEmptyFunction();
-    CreateThrowTypeError(empty_function);
     Handle<GlobalObject> inner_global;
     Handle<JSGlobalProxy> global_proxy =
         CreateNewGlobals(global_template, global_object, &inner_global);
     HookUpGlobalProxy(inner_global, global_proxy);
     InitializeGlobal(inner_global, empty_function);
     InstallJSFunctionResultCaches();
     InitializeNormalizedMapCaches();
     if (!InstallNatives()) return;
 
     MakeFunctionInstancePrototypeWritable();
@@ skipping 46 matching lines @@
 }
 
 
 // Restore statics that are thread local.
 char* BootstrapperActive::RestoreState(char* from) {
   nesting_ = *reinterpret_cast<int*>(from);
   return from + sizeof(nesting_);
 }
 
 } }  // namespace v8::internal