Revert of Make Error.prototype.toString spec compliant; and fix various side-effect-free error printing metho…

test/mjsunit/error-constructors.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 51 matching lines @@
 
 try {
   eval("var error = reference");
 } catch (error) {
   e = error;
 }
 
 assertTrue(e.hasOwnProperty('stack'));
 
 // Check that intercepting property access from toString is prevented for
-// compiler errors. This is not specified, but allowing interception through a
-// getter can leak error objects from different script tags in the same context
-// in a browser setting. Use Realm.eval as a proxy for loading scripts. We
-// ignore the exception thrown from it since that would not be catchable from
-// user-land code.
+// compiler errors. This is not specified, but allowing interception
+// through a getter can leak error objects from different
+// script tags in the same context in a browser setting.
 var errors = [SyntaxError, ReferenceError, TypeError, RangeError, URIError];
 var error_triggers = ["syntax error",
                       "var error = reference",
                       "undefined()",
                       "String.fromCodePoint(0xFFFFFF)",
                       "decodeURI('%F')"];
 for (var i in errors) {
+  var name = errors[i].name;
+
   // Monkey-patch prototype.
-  for (var prop of ["name", "message", "stack"]) {
-    errors[i].prototype.__defineGetter__(prop, fail);
+  var props = ["name", "message", "stack"];
+  for (var j in props) {
+    errors[i].prototype.__defineGetter__(props[j], fail);
   }
   // String conversion should not invoke monkey-patched getters on prototype.
-  assertThrows(()=>Realm.eval(0, error_triggers[i]));
+  var error;
+  try {
+    eval(error_triggers[i]);
+  } catch (e) {
+    error = e;
+  }
+  assertTrue(error.toString().startsWith(name));
+
+  // Deleting message on the error (exposing the getter) is fine.
+  delete error.message;
+  assertEquals(name, error.toString());
+
+  // Custom properties shadowing the name are fine.
+  var myerror = { name: "myerror", message: "mymessage"};
+  myerror.__proto__ = error;
+  assertEquals("myerror: mymessage", myerror.toString());
+
+  // Custom getters in actual objects are welcome.
+  error.__defineGetter__("name", function() { return "mine"; });
+  assertEquals("mine", error.toString());
+
+  // Custom properties shadowing the name are fine.
+  var myerror2 = { message: "mymessage"};
+  myerror2.__proto__ = error;
+  assertEquals("mine: mymessage", myerror2.toString());
 }
 
 // Monkey-patching non-internal errors should still be observable.
 function MyError() {}
 MyError.prototype = new Error;
 var errors = [Error, RangeError, EvalError, URIError,
               SyntaxError, ReferenceError, TypeError, MyError];
 for (var i in errors) {
   errors[i].prototype.__defineGetter__("name", function() { return "my"; });
   errors[i].prototype.__defineGetter__("message", function() { return "moo"; });
   var e = new errors[i];
   assertEquals("my: moo", e.toString());
 }
 
 
 Error.prototype.toString = Object.prototype.toString;
 assertEquals("[object Object]", Error.prototype.toString());
 assertEquals(Object.prototype, Error.prototype.__proto__);
 var e = new Error("foo");
 assertEquals("[object Error]", e.toString());