Make RegExp objects not callable.

test/mjsunit/json.js

 // Copyright 2009 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 49 matching lines @@
           valueOf: "not callable",
           toString: function() { return Infinity; },
           toISOString: function() { return 42; }};
 
 assertEquals(null, d3.toJSON());
 
 var d4 = {toJSON: Date.prototype.toJSON,
           valueOf: "not callable",
           toString: "not callable either",
           toISOString: function() { return 42; }};
-assertThrows("d4.toJSON()", TypeError);  // ToPrimitive throws. 
+assertThrows("d4.toJSON()", TypeError);  // ToPrimitive throws.
 
 var d5 = {toJSON: Date.prototype.toJSON,
           valueOf: "not callable",
           toString: function() { return "Infinity"; },
           toISOString: function() { return 42; }};
 assertEquals(42, d5.toJSON());
 
 var d6 = {toJSON: Date.prototype.toJSON,
           toISOString: function() { return ["not primitive"]; }};
 assertEquals(["not primitive"], d6.toJSON());
@@ skipping 108 matching lines @@
 TestInvalid('"\\a invalid escape"');
 TestInvalid('"\\v invalid escape"');  // Valid JavaScript
 TestInvalid('"\\\' invalid escape"');  // Valid JavaScript
 TestInvalid('"\\x42 invalid escape"');  // Valid JavaScript
 TestInvalid('"\\u202 invalid escape"');
 TestInvalid('"\\012 invalid escape"');
 TestInvalid('"Unterminated string');
 TestInvalid('"Unterminated string\\"');
 TestInvalid('"Unterminated string\\\\\\"');
 
-// JavaScript RegExp literals not valid in JSON.
-TestInvalid('/true/');
-
 // Test bad JSON that would be good JavaScript (ES5).
 TestInvalid("{true:42}");
 TestInvalid("{false:42}");
 TestInvalid("{null:42}");
 TestInvalid("{'foo':42}");
 TestInvalid("{42:42}");
 TestInvalid("{0:42}");
 TestInvalid("{-1:42}");
 
 // Test for trailing garbage detection.
@@ skipping 163 matching lines @@
 
 var funcJSON = function() { /* Is callable */ };
 funcJSON.toJSON = function() { return "has toJSON"; };
 
 var re = /Is callable/;
 
 var reJSON = /Is callable/;
 reJSON.toJSON = function() { return "has toJSON"; };
 
 assertEquals(
-    '[37,null,1,"foo","37","true",null,"has toJSON",null,"has toJSON"]',
+    '[37,null,1,"foo","37","true",null,"has toJSON",{},"has toJSON"]',
     JSON.stringify([num37, numFoo, numTrue,
                     strFoo, str37, strTrue,
                     func, funcJSON, re, reJSON]));
 
 
 var oddball = Object(42);
 oddball.__proto__ = { __proto__: null, toString: function() { return true; } };
 assertEquals('1', JSON.stringify(oddball));
 
 var getCount = 0;
 var callCount = 0;
 var counter = { get toJSON() { getCount++;
                                return function() { callCount++;
                                                    return 42; }; } };
+
+// RegExps are not callable, so they are stringified as objects.
+assertEquals('{}', JSON.stringify(/regexp/));
 assertEquals('42', JSON.stringify(counter));
 assertEquals(1, getCount);
 assertEquals(1, callCount);
 
 var oddball2 = Object(42);
 var oddball3 = Object("foo");
 oddball3.__proto__ = { __proto__: null,
                        toString: "not callable",
                        valueOf: function() { return true; } };
 oddball2.__proto__ = { __proto__: null,
                        toJSON: function () { return oddball3; } }
 assertEquals('"true"', JSON.stringify(oddball2));
 
 
 var falseNum = Object("37");
 falseNum.__proto__ = Number.prototype;
 falseNum.toString = function() { return 42; };
 assertEquals('"42"', JSON.stringify(falseNum));
 
 // We don't currently allow plain properties called __proto__ in JSON
 // objects in JSON.parse. Instead we read them as we would JS object
 // literals. If we change that, this test should change with it.
-// 
-// Parse a non-object value as __proto__. This must not create a 
-// __proto__ property different from the original, and should not 
+//
+// Parse a non-object value as __proto__. This must not create a
+// __proto__ property different from the original, and should not
 // change the original.
 var o = JSON.parse('{"__proto__":5}');
 assertEquals(Object.prototype, o.__proto__);  // __proto__ isn't changed.
 assertEquals(0, Object.keys(o).length);  // __proto__ isn't added as enumerable.