Add StackOverflowError and expose error type to api.

src/messages.js

 // Copyright 2012 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 111 matching lines @@
   invalid_typed_array_length:    ["Invalid typed array length"],
   invalid_typed_array_alignment: ["%0", " of ", "%1", " should be a multiple of ", "%2"],
   typed_array_set_source_too_large:
                                  ["Source is too large"],
   typed_array_set_negative_offset:
                                  ["Start offset is negative"],
   invalid_data_view_offset:      ["Start offset is outside the bounds of the buffer"],
   invalid_data_view_length:      ["Invalid data view length"],
   invalid_data_view_accessor_offset:
                                  ["Offset is outside the bounds of the DataView"],
-
-  stack_overflow:                ["Maximum call stack size exceeded"],
   invalid_time_value:            ["Invalid time value"],
   invalid_count_value:           ["Invalid count value"],
+  // StackOverflowError
+  stack_overflow:                ["Maximum call stack size exceeded"],
   // SyntaxError
   paren_in_arg_string:           ["Function arg string contains parenthesis"],
   not_isvar:                     ["builtin %IS_VAR: not a variable"],
   single_function_literal:       ["Single function literal required"],
   invalid_regexp_flags:          ["Invalid flags supplied to RegExp constructor '", "%0", "'"],
   invalid_regexp:                ["Invalid RegExp pattern /", "%0", "/"],
   illegal_break:                 ["Illegal break statement"],
   illegal_continue:              ["Illegal continue statement"],
   illegal_return:                ["Illegal return statement"],
   illegal_let:                   ["Illegal let declaration outside extended mode"],
@@ skipping 99 matching lines @@
 // strange and unusual.
 function CanBeSafelyTreatedAsAnErrorObject(obj) {
   switch (%_ClassOf(obj)) {
     case 'Error':
     case 'EvalError':
     case 'RangeError':
     case 'ReferenceError':
     case 'SyntaxError':
     case 'TypeError':
     case 'URIError':
+    case 'StackOverflowError':
       return true;
   }
 
   var objToString = %GetDataProperty(obj, "toString");
   return obj instanceof $Error && objToString === ErrorToString;
 }
 
 
 // When formatting internally created error messages, do not
 // invoke overwritten error toString methods but explicitly use
@@ skipping 73 matching lines @@
 function MakeTypeError(type, args) {
   return MakeGenericError($TypeError, type, args);
 }
 
 
 function MakeRangeError(type, args) {
   return MakeGenericError($RangeError, type, args);
 }
 
 
+function MakeStackOverflowError() {
+  return MakeGenericError($StackOverflowError, 'stack_overflow', []);
+}
+
+
 function MakeSyntaxError(type, args) {
   return MakeGenericError($SyntaxError, type, args);
 }
 
 
 function MakeReferenceError(type, args) {
   return MakeGenericError($ReferenceError, type, args);
 }
 
 
@@ skipping 822 matching lines @@
     }
   };
 
   %DefineOrRedefineAccessorProperty(obj, 'stack', getter, setter, DONT_ENUM);
 }
 
 
 function SetUpError() {
   // Define special error type constructors.
 
-  var DefineError = function(f) {
+  var DefineError = function(f, error_type) {
     // 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);
+    if (name != 'StackOverflowError') {  // StackOverflowError is not in spec.
+      %SetProperty(global, name, f, DONT_ENUM);
+    }
     %SetProperty(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 if (name == 'StackOverflowError') {
+      // StackOverflowError extends RangeError for backward compatibility.
+      %FunctionSetPrototype(f, new $RangeError());
     } else {
       %FunctionSetPrototype(f, new $Error());
     }
     %FunctionSetInstanceClassName(f, 'Error');
     %SetProperty(f.prototype, 'constructor', f, DONT_ENUM);
     %SetProperty(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);
         if (!IS_UNDEFINED(m)) {
           %IgnoreAttributesAndSetProperty(
             this, 'message', ToString(m), DONT_ENUM);
         }
+        // Define error_type property as a private symbol.
+        %IgnoreAttributesAndSetProperty(
+          this, error_type_symbol, error_type, READ_ONLY | DONT_DELETE);
         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() { });
+  DefineError(function Error() { }, kError);
+  DefineError(function TypeError() { }, kTypeError);
+  DefineError(function RangeError() { }, kRangeError);
+  DefineError(function SyntaxError() { }, kSyntaxError);
+  DefineError(function ReferenceError() { }, kReferenceError);
+  DefineError(function EvalError() { }, kEvalError);
+  DefineError(function URIError() { }, kURIError);
+  DefineError(function StackOverflowError() { }, kStackOverflowError);
 }
 
 SetUpError();
 
 $Error.captureStackTrace = captureStackTrace;
 
 %SetProperty($Error.prototype, 'message', '', DONT_ENUM);
 
 // Global list of error objects visited during ErrorToString. This is
 // used to detect cycles in error toString formatting.
@@ skipping 56 matching lines @@
     throw e;
   }
 }
 
 
 InstallFunctions($Error.prototype, DONT_ENUM, ['toString', ErrorToString]);
 
 // Boilerplate for exceptions for stack overflows. Used from
 // Isolate::StackOverflow().
 function SetUpStackOverflowBoilerplate() {
-  var boilerplate = MakeRangeError('stack_overflow', []);
+  var boilerplate = MakeStackOverflowError();
 
   var error_string = boilerplate.name + ": " + boilerplate.message;
 
   // 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)) {
@@ skipping 19 matching lines @@
     %GetAndClearOverflowedStackTrace(this);
   };
 
   %DefineOrRedefineAccessorProperty(
       boilerplate, 'stack', getter, setter, DONT_ENUM);
 
   return boilerplate;
 }
 
 var kStackOverflowBoilerplate = SetUpStackOverflowBoilerplate();