Make sure that the name accessor on functions return the expected...

src/messages.js

 // 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 30 matching lines @@
   var mapping = kVowelSounds;
   if (cons.length > 1 && (cons.charAt(0) != first)) {
     // First char is upper case
     var second = cons.charAt(1).toLowerCase();
     // Second char is upper case
     if (cons.charAt(1) != second)
       mapping = kCapitalVowelSounds;
   }
   var s = mapping[first] ? "an " : "a ";
   return s + cons;
-};
+}
 
 
 const kMessages = {
   // Error
   cyclic_proto:                 "Cyclic __proto__ value",
   // TypeError
   unexpected_token:             "Unexpected token %0",
   unexpected_token_number:      "Unexpected number",
   unexpected_token_string:      "Unexpected string",
   unexpected_token_identifier:  "Unexpected identifier",
@@ skipping 55 matching lines @@
 
 function FormatString(format, args) {
   var result = format;
   for (var i = 0; i < args.length; i++) {
     var str;
     try { str = ToDetailString(args[i]); }
     catch (e) { str = "#<error>"; }
     result = result.split("%" + i).join(str);
   }
   return result;
-};
+}
 
 
 function ToDetailString(obj) {
   if (obj != null && IS_OBJECT(obj) && obj.toString === $Object.prototype.toString) {
     var constructor = obj.constructor;
     if (!constructor) return ToString(obj);
     var constructorName = constructor.name;
     if (!constructorName) return ToString(obj);
     return "#<" + GetInstanceName(constructorName) + ">";
   } else {
     return ToString(obj);
   }
-};
+}
 
 
 function MakeGenericError(constructor, type, args) {
   if (args instanceof $Array) {
     for (var i = 0; i < args.length; i++) {
       var elem = args[i];
       if (elem instanceof $Array && elem.length > 100) { // arbitrary limit, grab a reasonable slice to report
         args[i] = elem.slice(0,20).concat("...");
       }
     }
   } else if (IS_UNDEFINED(args)) {
     args = [];
   }
 
   var e = new constructor();
   e.type = type;
   e.arguments = args;
   return e;
-};
+}
 
 
 /**
  * Setup the Script function and constructor.
  */
 %FunctionSetInstanceClassName(Script, 'Script');
 %AddProperty(Script.prototype, 'constructor', Script, DONT_ENUM);
 %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(message) {
   var format = kMessages[message.type];
   if (!format) return "<unknown message " + message.type + ">";
   return FormatString(format, message.args);
-};
+}
 
 
 function GetLineNumber(message) {
   if (message.startPos == -1) return -1;
   var location = message.script.locationFromPosition(message.startPos);
   if (location == null) return -1;
   return location.line + 1;
-};
+}
 
 
 // Returns the source code line containing the given source
 // position, or the empty string if the position is invalid.
 function GetSourceLine(message) {
   var location = message.script.locationFromPosition(message.startPos);
   if (location == null) return "";
   location.restrict();
   return location.sourceText();
-};
+}
 
 
 function MakeTypeError(type, args) {
   return MakeGenericError($TypeError, type, args);
-};
+}
 
 
 function MakeRangeError(type, args) {
   return MakeGenericError($RangeError, type, args);
-};
+}
 
 
 function MakeSyntaxError(type, args) {
   return MakeGenericError($SyntaxError, type, args);
-};
+}
 
 
 function MakeReferenceError(type, args) {
   return MakeGenericError($ReferenceError, type, args);
-};
+}
 
 
 function MakeEvalError(type, args) {
   return MakeGenericError($EvalError, type, args);
-};
+}
 
 
 function MakeError(type, args) {
   return MakeGenericError($Error, type, args);
-};
+}
 
 
 /**
  * Initialize the cached source information in a script. Currently all line
  * end positions are cached.
  */
 Script.prototype.initSourceInfo_ = function () {
   // Just return if initialized.
   if (this.lineEnds_) return;
 
@@ skipping 201 matching lines @@
  * @param {number} end Source position for end of source context
  * @constructor
  */
 function SourceLocation(script, position, line, column, start, end) {
   this.script = script;
   this.position = position;
   this.line = line;
   this.column = column;
   this.start = start;
   this.end = end;
-};
+}
 
 
 const kLineLengthLimit = 78;
 
 /**
  * Restrict source location start and end positions to make the source slice
  * no more that a certain number of characters wide.
  * @param {number} opt_limit The with limit of the source text with a default
  *     of 78
  * @param {number} opt_before The number of characters to prefer before the
  *     position with a default value of 10 less that the limit
  */
 SourceLocation.prototype.restrict = function (opt_limit, opt_before) {
   // Find the actual limit to use.
   var limit;
   var before;
   if (!IS_UNDEFINED(opt_limit)) {
     limit = opt_limit;
   } else {
     limit = kLineLengthLimit;
   }
   if (!IS_UNDEFINED(opt_before)) {
     before = opt_before;
   } else {
     // If no before is specified center for small limits and perfer more source
     // before the the position that after for longer limits.
     if (limit <= 20) {
-      before = $Math_floor(limit / 2);
+      before = $floor(limit / 2);
     } else {
       before = limit - 10;
     }
   }
   if (before >= limit) {
     before = limit - 1;
   }
 
   // If the [start, end[ interval is too big we restrict
   // it in one or both ends. We make sure to always produce
@@ skipping 60 matching lines @@
 };
 
 
 // Returns the offset of the given position within the containing
 // line.
 function GetPositionInLine(message) {
   var location = message.script.locationFromPosition(message.startPos);
   if (location == null) return -1;
   location.restrict();
   return message.startPos - location.start;
-};
+}
 
 
 function ErrorMessage(type, args, startPos, endPos, script, stackTrace) {
   this.startPos = startPos;
   this.endPos = endPos;
   this.type = type;
   this.args = args;
   this.script = script;
   this.stackTrace = stackTrace;
-};
+}
 
 
 function MakeMessage(type, args, startPos, endPos, script, stackTrace) {
   return new ErrorMessage(type, args, startPos, endPos, script, stackTrace);
-};
+}
 
 
 function GetStackTraceLine(recv, fun, pos, isGlobal) {
   try {
     return UnsafeGetStackTraceLine(recv, fun, pos, isGlobal);
   } catch (e) {
     return "<error: " + e + ">";
   }
-};
+}
 
 
 function GetFunctionName(fun, recv) {
   var name = %FunctionGetName(fun);
   if (name) return name;
   for (var prop in recv) {
     if (recv[prop] === fun)
       return prop;
   }
   return "[anonymous]";
-};
+}
 
 
 function UnsafeGetStackTraceLine(recv, fun, pos, isTopLevel) {
   var result = "";
   // The global frame has no meaningful function or receiver
   if (!isTopLevel) {
     // If the receiver is not the global object then prefix the
     // message send
     if (recv !== global)
       result += ToDetailString(recv) + ".";
     result += GetFunctionName(fun, recv);
   }
   if (pos != -1) {
     var script = %FunctionGetScript(fun);
     var file;
     if (script) {
       file = %FunctionGetScript(fun).data;
     }
     if (file) {
       var location = %FunctionGetScript(fun).locationFromPosition(pos);
       if (!isTopLevel) result += "(";
       result += file;
       if (location != null) {
         result += ":" + (location.line + 1) + ":" + (location.column + 1);
       }
       if (!isTopLevel) result += ")";
     }
   }
   return (result) ? "    at " + result : result;
-};
+}
 
 
 // ----------------------------------------------------------------------------
 // Error implementation
 
-function DefineError(name) {
-  var f = function(msg) {};
+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;
   %AddProperty(global, name, f, DONT_ENUM);
   this['$' + name] = f;
   // Configure the error function.
   // prototype of 'Error' must be as default: new Object().
   if (name != 'Error') %FunctionSetPrototype(f, new $Error());
   %FunctionSetInstanceClassName(f, 'Error');
   f.prototype.name = name;
   f.prototype.constructor = f;
   %SetCode(f, function(m) {
     if (%IsConstructCall()) {
       if (!IS_UNDEFINED(m)) this.message = ToString(m);
     } else {
       return new f(m);
     }
   });
-};
+}
 
 $Math.__proto__ = global.Object.prototype;
 
-DefineError('Error');
-DefineError('TypeError');
-DefineError('RangeError');
-DefineError('SyntaxError');
-DefineError('ReferenceError');
-DefineError('EvalError');
-DefineError('URIError');
+DefineError(function Error() { });
+DefineError(function TypeError() { });
+DefineError(function RangeError() { });
+DefineError(function SyntaxError() { });
+DefineError(function ReferenceError() { });
+DefineError(function EvalError() { });
+DefineError(function URIError() { });
 
 // Setup extra properties of the Error.prototype object.
 $Error.prototype.message = '';
 
-%AddProperty($Error.prototype, 'toString', function() {
+%AddProperty($Error.prototype, 'toString', function toString() {
   var type = this.type;
   if (type && !this.hasOwnProperty("message")) {
     return this.name + ": " + FormatMessage({ type: type, args: this.arguments });
   }
   var message = this.message;
   return this.name + (message ? (": " + message) : "");
 }, DONT_ENUM);
 
 
 // Boilerplate for exceptions for stack overflows. Used from
 // Top::StackOverflow().
 const kStackOverflowBoilerplate = MakeRangeError('stack_overflow', []);