Split SetProperty(...attributes, strictmode) into AddProperty(...attributes) and SetProperty(...…

src/messages.js

 // Copyright 2012 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.
 
 // -------------------------------------------------------------------
 
 var kMessages = {
   // Error
   cyclic_proto:                  ["Cyclic __proto__ value"],
   code_gen_from_strings:         ["%0"],
@@ skipping 264 matching lines @@
 function MakeGenericError(constructor, type, args) {
   if (IS_UNDEFINED(args)) args = [];
   return new constructor(FormatMessage(type, args));
 }
 
 
 /**
  * Set up the Script function and constructor.
  */
 %FunctionSetInstanceClassName(Script, 'Script');
-%SetProperty(Script.prototype, 'constructor', Script,
+%AddProperty(Script.prototype, 'constructor', Script,
              DONT_ENUM | DONT_DELETE | READ_ONLY);
 %SetCode(Script, function(x) {
   // Script objects can only be created by the VM.
   throw new $Error("Not supported");
 });
 
 
 // Helper functions; called from the runtime system.
 function FormatMessage(type, args) {
   var format = kMessages[type];
@@ skipping 841 matching lines @@
   var stack = %CollectStackTrace(obj,
                                  cons_opt ? cons_opt : captureStackTrace,
                                  stackTraceLimit);
 
   var error_string = FormatErrorString(obj);
 
   // Set the 'stack' property on the receiver.  If the receiver is the same as
   // holder of this setter, the accessor pair is turned into a data property.
   var setter = function(v) {
     // Set data property on the receiver (not necessarily holder).
-    %DefineOrRedefineDataProperty(this, 'stack', v, NONE);
+    %DefineDataPropertyUnchecked(this, 'stack', v, NONE);
     if (this === obj) {
       // Release context values if holder is the same as the receiver.
       stack = error_string = UNDEFINED;
     }
   };
 
   // The holder of this getter ('obj') may not be the receiver ('this').
   // When this getter is called the first time, we use the context values to
   // format a stack trace string and turn this accessor pair into a data
   // property (on the holder).
   var getter = function() {
     // Stack is still a raw array awaiting to be formatted.
     var result = FormatStackTrace(obj, error_string, GetStackFrames(stack));
     // Replace this accessor to return result directly.
-    %DefineOrRedefineAccessorProperty(
+    %DefineAccessorPropertyUnchecked(
         obj, 'stack', function() { return result }, setter, DONT_ENUM);
     // Release context values.
     stack = error_string = UNDEFINED;
     return result;
   };
 
-  %DefineOrRedefineAccessorProperty(obj, 'stack', getter, setter, DONT_ENUM);
+  %DefineAccessorPropertyUnchecked(obj, 'stack', getter, setter, DONT_ENUM);
 }
 
 
 function SetUpError() {
   // Define special error type constructors.
 
   var DefineError = function(f) {
     // Store the error function in both the global object
     // and the runtime object. The function is fetched
     // from the runtime object when throwing errors from
     // within the runtime system to avoid strange side
     // effects when overwriting the error functions from
     // user code.
     var name = f.name;
-    %SetProperty(global, name, f, DONT_ENUM);
-    %SetProperty(builtins, '$' + name, f, DONT_ENUM | DONT_DELETE | READ_ONLY);
+    %AddProperty(global, name, f, DONT_ENUM);
+    %AddProperty(builtins, '$' + name, f,
+                 DONT_ENUM | DONT_DELETE | READ_ONLY);
     // Configure the error function.
     if (name == 'Error') {
       // The prototype of the Error object must itself be an error.
       // However, it can't be an instance of the Error object because
       // it hasn't been properly configured yet.  Instead we create a
       // special not-a-true-error-but-close-enough object.
       var ErrorPrototype = function() {};
       %FunctionSetPrototype(ErrorPrototype, $Object.prototype);
       %FunctionSetInstanceClassName(ErrorPrototype, 'Error');
       %FunctionSetPrototype(f, new ErrorPrototype());
     } else {
       %FunctionSetPrototype(f, new $Error());
     }
     %FunctionSetInstanceClassName(f, 'Error');
-    %SetProperty(f.prototype, 'constructor', f, DONT_ENUM);
-    %SetProperty(f.prototype, "name", name, DONT_ENUM);
+    %AddProperty(f.prototype, 'constructor', f, DONT_ENUM);
+    %AddProperty(f.prototype, "name", name, DONT_ENUM);
     %SetCode(f, function(m) {
       if (%_IsConstructCall()) {
         // Define all the expected properties directly on the error
         // object. This avoids going through getters and setters defined
         // on prototype objects.
-        %IgnoreAttributesAndSetProperty(this, 'stack', UNDEFINED, DONT_ENUM);
+        %AddProperty(this, 'stack', UNDEFINED, DONT_ENUM);
         if (!IS_UNDEFINED(m)) {
-          %IgnoreAttributesAndSetProperty(
-            this, 'message', ToString(m), DONT_ENUM);
+          %AddProperty(this, 'message', ToString(m), DONT_ENUM);
         }
         captureStackTrace(this, f);
       } else {
         return new f(m);
       }
     });
     %SetNativeFlag(f);
   };
 
   DefineError(function Error() { });
   DefineError(function TypeError() { });
   DefineError(function RangeError() { });
   DefineError(function SyntaxError() { });
   DefineError(function ReferenceError() { });
   DefineError(function EvalError() { });
   DefineError(function URIError() { });
 }
 
 SetUpError();
 
 $Error.captureStackTrace = captureStackTrace;
 
-%SetProperty($Error.prototype, 'message', '', DONT_ENUM);
+%AddProperty($Error.prototype, 'message', '', DONT_ENUM);
 
 // Global list of error objects visited during ErrorToString. This is
 // used to detect cycles in error toString formatting.
 var visited_errors = new InternalArray();
 var cyclic_error_marker = new $Object();
 
 function GetPropertyWithoutInvokingMonkeyGetters(error, name) {
   var current = error;
   // Climb the prototype chain until we find the holder.
   while (current && !%HasOwnProperty(current, name)) {
@@ skipping 56 matching lines @@
 // Boilerplate for exceptions for stack overflows. Used from
 // Isolate::StackOverflow().
 function SetUpStackOverflowBoilerplate() {
   var boilerplate = MakeRangeError('stack_overflow', []);
 
   var error_string = boilerplate.name + ": " + boilerplate.message;
 
   // Set the 'stack' property on the receiver.  If the receiver is the same as
   // holder of this setter, the accessor pair is turned into a data property.
   var setter = function(v) {
-    %DefineOrRedefineDataProperty(this, 'stack', v, NONE);
+    %DefineDataPropertyUnchecked(this, 'stack', v, NONE);
     // Tentatively clear the hidden property. If the receiver is the same as
     // holder, we release the raw stack trace this way.
     %GetAndClearOverflowedStackTrace(this);
   };
 
   // The raw stack trace is stored as a hidden property on the holder of this
   // getter, which may not be the same as the receiver.  Find the holder to
   // retrieve the raw stack trace and then turn this accessor pair into a
   // data property.
   var getter = function() {
     var holder = this;
     while (!IS_ERROR(holder)) {
       holder = %GetPrototype(holder);
       if (IS_NULL(holder)) return MakeSyntaxError('illegal_access', []);
     }
     var stack = %GetAndClearOverflowedStackTrace(holder);
     // We may not have captured any stack trace.
     if (IS_UNDEFINED(stack)) return stack;
 
     var result = FormatStackTrace(holder, error_string, GetStackFrames(stack));
     // Replace this accessor to return result directly.
-    %DefineOrRedefineAccessorProperty(
+    %DefineAccessorPropertyUnchecked(
         holder, 'stack', function() { return result }, setter, DONT_ENUM);
     return result;
   };
 
-  %DefineOrRedefineAccessorProperty(
+  %DefineAccessorPropertyUnchecked(
       boilerplate, 'stack', getter, setter, DONT_ENUM);
 
   return boilerplate;
 }
 
 var kStackOverflowBoilerplate = SetUpStackOverflowBoilerplate();