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

src/js/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.
 
 // -------------------------------------------------------------------
 
 (function(global, utils) {
 
 %CheckIsBootstrapping();
 
 // -------------------------------------------------------------------
 // Imports
 
 var ArrayJoin;
 var Bool16x8ToString;
 var Bool32x4ToString;
 var Bool8x16ToString;
 var callSiteReceiverSymbol =
     utils.ImportNow("call_site_receiver_symbol");
 var callSiteFunctionSymbol =
     utils.ImportNow("call_site_function_symbol");
 var callSitePositionSymbol =
     utils.ImportNow("call_site_position_symbol");
 var callSiteStrictSymbol =
     utils.ImportNow("call_site_strict_symbol");
-var FLAG_harmony_tostring;
 var Float32x4ToString;
 var formattedStackTraceSymbol =
     utils.ImportNow("formatted_stack_trace_symbol");
 var FunctionSourceString
 var GlobalObject = global.Object;
 var Int16x8ToString;
 var Int32x4ToString;
 var Int8x16ToString;
 var InternalArray = utils.InternalArray;
 var internalErrorSymbol = utils.ImportNow("internal_error_symbol");
 var ObjectDefineProperty;
 var ObjectToString;
 var Script = utils.ImportNow("Script");
 var stackTraceSymbol = utils.ImportNow("stack_trace_symbol");
 var StringCharAt;
 var StringIndexOf;
 var StringSubstring;
 var SymbolToString;
-var toStringTagSymbol = utils.ImportNow("to_string_tag_symbol");
 var Uint16x8ToString;
 var Uint32x4ToString;
 var Uint8x16ToString;
 
 utils.Import(function(from) {
   ArrayJoin = from.ArrayJoin;
   Bool16x8ToString = from.Bool16x8ToString;
   Bool32x4ToString = from.Bool32x4ToString;
   Bool8x16ToString = from.Bool8x16ToString;
   Float32x4ToString = from.Float32x4ToString;
   FunctionSourceString = from.FunctionSourceString;
   Int16x8ToString = from.Int16x8ToString;
   Int32x4ToString = from.Int32x4ToString;
   Int8x16ToString = from.Int8x16ToString;
   ObjectDefineProperty = from.ObjectDefineProperty;
   ObjectToString = from.ObjectToString;
   StringCharAt = from.StringCharAt;
   StringIndexOf = from.StringIndexOf;
   StringSubstring = from.StringSubstring;
   SymbolToString = from.SymbolToString;
   Uint16x8ToString = from.Uint16x8ToString;
   Uint32x4ToString = from.Uint32x4ToString;
   Uint8x16ToString = from.Uint8x16ToString;
 });
 
-utils.ImportFromExperimental(function(from) {
-  FLAG_harmony_tostring = from.FLAG_harmony_tostring;
-});
-
 // -------------------------------------------------------------------
 
 var GlobalError;
 var GlobalTypeError;
 var GlobalRangeError;
 var GlobalURIError;
 var GlobalSyntaxError;
 var GlobalReferenceError;
 var GlobalEvalError;
 
 
 function NoSideEffectsObjectToString() {
   if (IS_UNDEFINED(this)) return "[object Undefined]";
   if (IS_NULL(this)) return "[object Null]";
-  var O = TO_OBJECT(this);
-  var builtinTag = %_ClassOf(O);
-  var tag;
-  if (FLAG_harmony_tostring) {
-    tag = %GetDataProperty(O, toStringTagSymbol);
-    if (!IS_STRING(tag)) {
-      tag = builtinTag;
-    }
-  } else {
-    tag = builtinTag;
-  }
-  return `[object ${tag}]`;
+  return "[object " + %_ClassOf(TO_OBJECT(this)) + "]";
 }
 
-function IsErrorObject(obj) {
-  return HAS_PRIVATE(obj, stackTraceSymbol);
-}
 
-function NoSideEffectsErrorToString() {
-  var name = %GetDataProperty(this, "name");
-  var message = %GetDataProperty(this, "message");
-  name = IS_UNDEFINED(name) ? "Error" : NoSideEffectsToString(name);
-  message = IS_UNDEFINED(message) ? "" : NoSideEffectsToString(message);
-  if (name == "") return message;
-  if (message == "") return name;
-  return `${name}: ${message}`;
-}
-
-function NoSideEffectsToString(obj) {
+function NoSideEffectToString(obj) {
   if (IS_STRING(obj)) return obj;
   if (IS_NUMBER(obj)) return %_NumberToString(obj);
   if (IS_BOOLEAN(obj)) return obj ? 'true' : 'false';
   if (IS_UNDEFINED(obj)) return 'undefined';
   if (IS_NULL(obj)) return 'null';
   if (IS_FUNCTION(obj)) {
     var str = %_Call(FunctionSourceString, obj, obj);
     if (str.length > 128) {
       str = %_SubString(str, 0, 111) + "...<omitted>..." +
             %_SubString(str, str.length - 2, str.length);
     }
     return str;
   }
   if (IS_SYMBOL(obj)) return %_Call(SymbolToString, obj);
   if (IS_SIMD_VALUE(obj)) {
     switch (typeof(obj)) {
       case 'float32x4': return %_Call(Float32x4ToString, obj);
       case 'int32x4':   return %_Call(Int32x4ToString, obj);
       case 'int16x8':   return %_Call(Int16x8ToString, obj);
       case 'int8x16':   return %_Call(Int8x16ToString, obj);
       case 'uint32x4':   return %_Call(Uint32x4ToString, obj);
       case 'uint16x8':   return %_Call(Uint16x8ToString, obj);
       case 'uint8x16':   return %_Call(Uint8x16ToString, obj);
       case 'bool32x4':  return %_Call(Bool32x4ToString, obj);
       case 'bool16x8':  return %_Call(Bool16x8ToString, obj);
       case 'bool8x16':  return %_Call(Bool8x16ToString, obj);
     }
   }
-
-  if (IS_SPEC_OBJECT(obj)) {
-    // When internally formatting error objects, use a side-effects-free version
-    // of Error.prototype.toString independent of the actually installed
-    // toString method.
-    if (IsErrorObject(obj) ||
-        %GetDataProperty(obj, "toString") === ErrorToString) {
-      return %_Call(NoSideEffectsErrorToString, obj);
-    }
-
-    if (%GetDataProperty(obj, "toString") === ObjectToString) {
-      var constructor = %GetDataProperty(obj, "constructor");
-      if (IS_FUNCTION(constructor)) {
-        var constructor_name = %FunctionGetName(constructor);
-        if (constructor_name != "") return `#<${constructor_name}>`;
+  if (IS_OBJECT(obj)
+      && %GetDataProperty(obj, "toString") === ObjectToString) {
+    var constructor = %GetDataProperty(obj, "constructor");
+    if (typeof constructor == "function") {
+      var constructorName = constructor.name;
+      if (IS_STRING(constructorName) && constructorName !== "") {
+        return "#<" + constructorName + ">";
       }
     }
   }
+  if (CanBeSafelyTreatedAsAnErrorObject(obj)) {
+    return %_Call(ErrorToString, obj);
+  }
 
   return %_Call(NoSideEffectsObjectToString, obj);
 }
 
+// To determine whether we can safely stringify an object using ErrorToString
+// without the risk of side-effects, we need to check whether the object is
+// either an instance of a native error type (via '%_ClassOf'), or has Error
+// in its prototype chain and hasn't overwritten 'toString' with something
+// strange and unusual.
+function CanBeSafelyTreatedAsAnErrorObject(obj) {
+  switch (%_ClassOf(obj)) {
+    case 'Error':
+    case 'EvalError':
+    case 'RangeError':
+    case 'ReferenceError':
+    case 'SyntaxError':
+    case 'TypeError':
+    case 'URIError':
+      return true;
+  }
 
+  var objToString = %GetDataProperty(obj, "toString");
+  return obj instanceof GlobalError && objToString === ErrorToString;
+}
+
+
+// When formatting internally created error messages, do not
+// invoke overwritten error toString methods but explicitly use
+// the error to string method. This is to avoid leaking error
+// objects between script tags in a browser setting.
+function ToStringCheckErrorObject(obj) {
+  if (CanBeSafelyTreatedAsAnErrorObject(obj)) {
+    return %_Call(ErrorToString, obj);
+  } else {
+    return TO_STRING(obj);
+  }
+}
+
+
+function ToDetailString(obj) {
+  if (obj != null && IS_OBJECT(obj) && obj.toString === ObjectToString) {
+    var constructor = obj.constructor;
+    if (typeof constructor == "function") {
+      var constructorName = constructor.name;
+      if (IS_STRING(constructorName) && constructorName !== "") {
+        return "#<" + constructorName + ">";
+      }
+    }
+  }
+  return ToStringCheckErrorObject(obj);
+}
+
+
 function MakeGenericError(constructor, type, arg0, arg1, arg2) {
   var error = new constructor(FormatMessage(type, arg0, arg1, arg2));
   error[internalErrorSymbol] = true;
   return error;
 }
 
 
 /**
  * Set up the Script function and constructor.
  */
 %FunctionSetInstanceClassName(Script, 'Script');
 %AddNamedProperty(Script.prototype, 'constructor', Script,
                   DONT_ENUM | DONT_DELETE | READ_ONLY);
 %SetCode(Script, function(x) {
   // Script objects can only be created by the VM.
   throw MakeError(kUnsupported);
 });
 
 
 // Helper functions; called from the runtime system.
 function FormatMessage(type, arg0, arg1, arg2) {
-  var arg0 = NoSideEffectsToString(arg0);
-  var arg1 = NoSideEffectsToString(arg1);
-  var arg2 = NoSideEffectsToString(arg2);
+  var arg0 = NoSideEffectToString(arg0);
+  var arg1 = NoSideEffectToString(arg1);
+  var arg2 = NoSideEffectToString(arg2);
   try {
     return %FormatMessageString(type, arg0, arg1, arg2);
   } catch (e) {
     return "<error>";
   }
 }
 
 
 function GetLineNumber(message) {
   var start_position = %MessageGetStartPosition(message);
@@ skipping 626 matching lines @@
       }
     }
     lines.push("    at " + line);
   }
   return %_Call(ArrayJoin, lines, "\n");
 }
 
 
 function GetTypeName(receiver, requireConstructor) {
   if (IS_NULL_OR_UNDEFINED(receiver)) return null;
-  if (%_IsJSProxy(receiver)) return "Proxy";
-
-  var constructor = %GetDataProperty(TO_OBJECT(receiver), "constructor");
-  if (!IS_FUNCTION(constructor)) {
-    return requireConstructor ? null : %_Call(NoSideEffectsToString, receiver);
+  if (%_IsJSProxy(receiver)) {
+    return "Proxy";
+  };
+  var constructor = receiver.constructor;
+  if (!constructor) {
+    return requireConstructor ? null :
+        %_Call(NoSideEffectsObjectToString, receiver);
   }
-  return %FunctionGetName(constructor);
+  var constructorName = constructor.name;
+  if (!constructorName) {
+    return requireConstructor ? null :
+        %_Call(NoSideEffectsObjectToString, receiver);
+  }
+  return constructorName;
 }
 
 
 // Format the stack trace if not yet done, and return it.
 // Cache the formatted stack trace on the holder.
 var StackTraceGetter = function() {
   var formatted_stack_trace = UNDEFINED;
   var holder = this;
   while (holder) {
     var formatted_stack_trace =
@@ skipping 13 matching lines @@
     }
     return formatted_stack_trace;
   }
   return UNDEFINED;
 };
 
 
 // If the receiver equals the holder, set the formatted stack trace that the
 // getter returns.
 var StackTraceSetter = function(v) {
-  if (IsErrorObject(this)) {
+  if (HAS_PRIVATE(this, stackTraceSymbol)) {
     SET_PRIVATE(this, stackTraceSymbol, UNDEFINED);
     SET_PRIVATE(this, formattedStackTraceSymbol, v);
   }
 };
 
 
 // Use a dummy function since we do not actually want to capture a stack trace
 // when constructing the initial Error prototytpes.
 var captureStackTrace = function() {};
 
@@ skipping 39 matching lines @@
 GlobalURIError = SetUpError(global.URIError);
 
 utils.InstallFunctions(GlobalError.prototype, DONT_ENUM,
                        ['toString', ErrorToString]);
 
 function ErrorToString() {
   if (!IS_SPEC_OBJECT(this)) {
     throw MakeTypeError(kCalledOnNonObject, "Error.prototype.toString");
   }
 
-  var name = this.name;
-  name = IS_UNDEFINED(name) ? "Error" : TO_STRING(name);
-
-  var message = this.message;
-  message = IS_UNDEFINED(message) ? "" : TO_STRING(message);
-
-  if (name == "") return message;
-  if (message == "") return name;
-  return `${name}: ${message}`
+  return %ErrorToStringRT(this);
 }
 
 function MakeError(type, arg0, arg1, arg2) {
   return MakeGenericError(GlobalError, type, arg0, arg1, arg2);
 }
 
 function MakeRangeError(type, arg0, arg1, arg2) {
   return MakeGenericError(GlobalRangeError, type, arg0, arg1, arg2);
 }
 
@@ skipping 27 matching lines @@
 GlobalError.captureStackTrace = captureStackTrace;
 
 %InstallToContext([
   "get_stack_trace_line_fun", GetStackTraceLine,
   "make_error_function", MakeGenericError,
   "make_range_error", MakeRangeError,
   "make_type_error", MakeTypeError,
   "message_get_column_number", GetColumnNumber,
   "message_get_line_number", GetLineNumber,
   "message_get_source_line", GetSourceLine,
-  "no_side_effects_to_string_fun", NoSideEffectsToString,
+  "no_side_effect_to_string_fun", NoSideEffectToString,
   "stack_overflow_boilerplate", StackOverflowBoilerplate,
+  "to_detail_string_fun", ToDetailString,
 ]);
 
 utils.Export(function(to) {
   to.ErrorToString = ErrorToString;
   to.MakeError = MakeError;
   to.MakeRangeError = MakeRangeError;
   to.MakeSyntaxError = MakeSyntaxError;
   to.MakeTypeError = MakeTypeError;
   to.MakeURIError = MakeURIError;
 });
 
 });