Make functions on the built-in object non-writable.

src/messages.js

 // Copyright 2011 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 11 matching lines @@
 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 
 // -------------------------------------------------------------------
 //
 // Matches Script::Type from objects.h
-var TYPE_NATIVE = 0;
-var TYPE_EXTENSION = 1;
-var TYPE_NORMAL = 2;
+const TYPE_NATIVE = 0;

[Kevin Millikin (Chromium), 2011/09/01 07:58:24]

Is this change necessary?

If it is, can you instead define them as const macros in macros.py?  Our
implementation of const is slower than var, prevents optimization, and the
semantics of global const is somewhat up in the air and not something we should
rely on.

[Lasse Reichstein, 2011/09/01 09:26:58]

Nothing here is *necessary*, but it's an attempt to lock down the builtins
object to prevent tampering in case someone gets a hold of it (i.e., security in
depth).
Making them macros.py-macros is a better idea.

I do need some constants that can't be moved to macros.py, though (two of the
vars below have been changed in another CL). Is there a better way to make them
const than using "const" declarations? E.g., using %SetProperty(builtins, ...) ?

[Kevin Millikin (Chromium), 2011/09/01 09:53:14]

I think something like that, even if you have to implement a custom function,
might be better.

If we match Safari's behavior, we'll have surprising stuff like consts whose
value can change (a global const declaration overrides a pre-existing one).

+const TYPE_EXTENSION = 1;
+const TYPE_NORMAL = 2;
 
 // Matches Script::CompilationType from objects.h
-var COMPILATION_TYPE_HOST = 0;
-var COMPILATION_TYPE_EVAL = 1;
-var COMPILATION_TYPE_JSON = 2;
+const COMPILATION_TYPE_HOST = 0;
+const COMPILATION_TYPE_EVAL = 1;
+const COMPILATION_TYPE_JSON = 2;
 
 // Matches Messages::kNoLineNumberInfo from v8.h
-var kNoLineNumberInfo = 0;
+const kNoLineNumberInfo = 0;
 
 // If this object gets passed to an error constructor the error will
 // get an accessor for .message that constructs a descriptive error
 // message on access.
 var kAddMessageAccessorsMarker = { };
 
 var kMessages = 0;
 
 var kReplacementMarkers = [ "%0", "%1", "%2", "%3" ];
 
@@ skipping 947 matching lines @@
 
 function DefineError(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);
-  this['$' + name] = f;
+  %SetProperty(this, '$' + 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.
     function ErrorPrototype() {}
     %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);
   // The name property on the prototype of error objects is not
-  // specified as being read-one and dont-delete. However, allowing
+  // specified as being read-only and dont-delete. However, allowing
   // overwriting allows leaks of error objects between script blocks
   // in the same context in a browser setting. Therefore we fix the
   // name.
   %SetProperty(f.prototype, "name", name, DONT_ENUM | DONT_DELETE | READ_ONLY);
   %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', void 0, DONT_ENUM);
@@ skipping 103 matching lines @@
     throw e;
   }
 }
 
 
 InstallFunctions($Error.prototype, DONT_ENUM, ['toString', errorToString]);
 
 // Boilerplate for exceptions for stack overflows. Used from
 // Isolate::StackOverflow().
 const kStackOverflowBoilerplate = MakeRangeError('stack_overflow', []);