Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(251)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: test/mjsunit/strict-mode.js

Issue 6614010: [Isolates] Merge 6700:7030 from bleeding_edge to isolates. (Closed) Base URL: http://v8.googlecode.com/svn/branches/experimental/isolates/
Patch Set: '' Created 9 years, 10 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « test/mjsunit/regress/regress-crbug-72736.js ('k') | test/mjsunit/tools/codemap.js » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: test/mjsunit/strict-mode.js
===================================================================
--- test/mjsunit/strict-mode.js (revision 7031)
+++ test/mjsunit/strict-mode.js (working copy)
@@ -169,13 +169,20 @@
CheckStrictMode("var x = { '1234' : 1, '2345' : 2, 1234 : 3 };", SyntaxError);
CheckStrictMode("var x = { 3.14 : 1, 2.71 : 2, 3.14 : 3 };", SyntaxError);
CheckStrictMode("var x = { 3.14 : 1, '3.14' : 2 };", SyntaxError);
-CheckStrictMode("var x = { 123: 1, 123.00000000000000000000000000000000000000000000000000000000000000000001 : 2 }", SyntaxError);
+CheckStrictMode("var x = { \
+ 123: 1, \
+ 123.00000000000000000000000000000000000000000000000000000000000000000001: 2 \
+}", SyntaxError);
// Non-conflicting data properties.
(function StrictModeNonDuplicate() {
"use strict";
var x = { 123 : 1, "0123" : 2 };
- var x = { 123: 1, '123.00000000000000000000000000000000000000000000000000000000000000000001' : 2 }
+ var x = {
+ 123: 1,
+ '123.00000000000000000000000000000000000000000000000000000000000000000001':
+ 2
+ };
})();
// Two getters (non-strict)
@@ -214,23 +221,32 @@
CheckStrictMode("function strict() { eval = undefined; }", SyntaxError);
CheckStrictMode("function strict() { arguments = undefined; }", SyntaxError);
CheckStrictMode("function strict() { print(eval = undefined); }", SyntaxError);
-CheckStrictMode("function strict() { print(arguments = undefined); }", SyntaxError);
+CheckStrictMode("function strict() { print(arguments = undefined); }",
+ SyntaxError);
CheckStrictMode("function strict() { var x = eval = undefined; }", SyntaxError);
-CheckStrictMode("function strict() { var x = arguments = undefined; }", SyntaxError);
+CheckStrictMode("function strict() { var x = arguments = undefined; }",
+ SyntaxError);
// Compound assignment to eval or arguments
CheckStrictMode("function strict() { eval *= undefined; }", SyntaxError);
CheckStrictMode("function strict() { arguments /= undefined; }", SyntaxError);
CheckStrictMode("function strict() { print(eval %= undefined); }", SyntaxError);
-CheckStrictMode("function strict() { print(arguments %= undefined); }", SyntaxError);
-CheckStrictMode("function strict() { var x = eval += undefined; }", SyntaxError);
-CheckStrictMode("function strict() { var x = arguments -= undefined; }", SyntaxError);
+CheckStrictMode("function strict() { print(arguments %= undefined); }",
+ SyntaxError);
+CheckStrictMode("function strict() { var x = eval += undefined; }",
+ SyntaxError);
+CheckStrictMode("function strict() { var x = arguments -= undefined; }",
+ SyntaxError);
CheckStrictMode("function strict() { eval <<= undefined; }", SyntaxError);
CheckStrictMode("function strict() { arguments >>= undefined; }", SyntaxError);
-CheckStrictMode("function strict() { print(eval >>>= undefined); }", SyntaxError);
-CheckStrictMode("function strict() { print(arguments &= undefined); }", SyntaxError);
-CheckStrictMode("function strict() { var x = eval ^= undefined; }", SyntaxError);
-CheckStrictMode("function strict() { var x = arguments |= undefined; }", SyntaxError);
+CheckStrictMode("function strict() { print(eval >>>= undefined); }",
+ SyntaxError);
+CheckStrictMode("function strict() { print(arguments &= undefined); }",
+ SyntaxError);
+CheckStrictMode("function strict() { var x = eval ^= undefined; }",
+ SyntaxError);
+CheckStrictMode("function strict() { var x = arguments |= undefined; }",
+ SyntaxError);
// Postfix increment with eval or arguments
CheckStrictMode("function strict() { eval++; }", SyntaxError);
@@ -264,6 +280,37 @@
CheckStrictMode("function strict() { var x = --eval; }", SyntaxError);
CheckStrictMode("function strict() { var x = --arguments; }", SyntaxError);
+// Use of const in strict mode is disallowed in anticipation of ES Harmony.
+CheckStrictMode("const x = 0;", SyntaxError);
+CheckStrictMode("for (const x = 0; false;) {}", SyntaxError);
+CheckStrictMode("function strict() { const x = 0; }", SyntaxError);
+
+// Strict mode only allows functions in SourceElements
+CheckStrictMode("if (true) { function invalid() {} }", SyntaxError);
+CheckStrictMode("for (;false;) { function invalid() {} }", SyntaxError);
+CheckStrictMode("{ function invalid() {} }", SyntaxError);
+CheckStrictMode("try { function invalid() {} } catch(e) {}", SyntaxError);
+CheckStrictMode("try { } catch(e) { function invalid() {} }", SyntaxError);
+CheckStrictMode("function outer() {{ function invalid() {} }}", SyntaxError);
+
+// Delete of an unqualified identifier
+CheckStrictMode("delete unqualified;", SyntaxError);
+CheckStrictMode("function strict() { delete unqualified; }", SyntaxError);
+CheckStrictMode("function function_name() { delete function_name; }",
+ SyntaxError);
+CheckStrictMode("function strict(parameter) { delete parameter; }",
+ SyntaxError);
+CheckStrictMode("function strict() { var variable; delete variable; }",
+ SyntaxError);
+CheckStrictMode("var variable; delete variable;", SyntaxError);
+
+(function TestStrictDelete() {
+ "use strict";
+ // "delete this" is allowed in strict mode and should work.
+ function strict_delete() { delete this; }
+ strict_delete();
+})();
+
// Prefix unary operators other than delete, ++, -- are valid in strict mode
(function StrictModeUnaryOperators() {
"use strict";
@@ -318,21 +365,466 @@
// Function names and arguments when the body is strict
assertThrows("function " + word + " () { 'use strict'; }", SyntaxError);
assertThrows("function foo (" + word + ") 'use strict'; {}", SyntaxError);
- assertThrows("function foo (" + word + ", " + word + ") { 'use strict'; }", SyntaxError);
+ assertThrows("function foo (" + word + ", " + word + ") { 'use strict'; }",
+ SyntaxError);
assertThrows("function foo (a, " + word + ") { 'use strict'; }", SyntaxError);
assertThrows("function foo (" + word + ", a) { 'use strict'; }", SyntaxError);
- assertThrows("function foo (a, " + word + ", b) { 'use strict'; }", SyntaxError);
- assertThrows("var foo = function (" + word + ") { 'use strict'; }", SyntaxError);
+ assertThrows("function foo (a, " + word + ", b) { 'use strict'; }",
+ SyntaxError);
+ assertThrows("var foo = function (" + word + ") { 'use strict'; }",
+ SyntaxError);
// get/set when the body is strict
eval("var x = { get " + word + " () { 'use strict'; } };");
eval("var x = { set " + word + " (value) { 'use strict'; } };");
- assertThrows("var x = { get foo(" + word + ") { 'use strict'; } };", SyntaxError);
- assertThrows("var x = { set foo(" + word + ") { 'use strict'; } };", SyntaxError);
+ assertThrows("var x = { get foo(" + word + ") { 'use strict'; } };",
+ SyntaxError);
+ assertThrows("var x = { set foo(" + word + ") { 'use strict'; } };",
+ SyntaxError);
}
for (var i = 0; i < future_reserved_words.length; i++) {
testFutureReservedWord(future_reserved_words[i]);
}
+function testAssignToUndefined(should_throw) {
+ "use strict";
+ try {
+ possibly_undefined_variable_for_strict_mode_test = "should throw?";
+ } catch (e) {
+ assertTrue(should_throw, "strict mode");
+ assertInstanceof(e, ReferenceError, "strict mode");
+ return;
+ }
+ assertFalse(should_throw, "strict mode");
+}
+testAssignToUndefined(true);
+testAssignToUndefined(true);
+testAssignToUndefined(true);
+
+possibly_undefined_variable_for_strict_mode_test = "value";
+
+testAssignToUndefined(false);
+testAssignToUndefined(false);
+testAssignToUndefined(false);
+
+delete possibly_undefined_variable_for_strict_mode_test;
+
+testAssignToUndefined(true);
+testAssignToUndefined(true);
+testAssignToUndefined(true);
+
+function repeat(n, f) {
+ for (var i = 0; i < n; i ++) { f(); }
+}
+
+repeat(10, function() { testAssignToUndefined(true); });
+possibly_undefined_variable_for_strict_mode_test = "value";
+repeat(10, function() { testAssignToUndefined(false); });
+delete possibly_undefined_variable_for_strict_mode_test;
+repeat(10, function() { testAssignToUndefined(true); });
+possibly_undefined_variable_for_strict_mode_test = undefined;
+repeat(10, function() { testAssignToUndefined(false); });
+
+(function testDeleteNonConfigurable() {
+ function delete_property(o) {
+ "use strict";
+ delete o.property;
+ }
+ function delete_element(o, i) {
+ "use strict";
+ delete o[i];
+ }
+
+ var object = {};
+
+ Object.defineProperty(object, "property", { value: "property_value" });
+ Object.defineProperty(object, "1", { value: "one" });
+ Object.defineProperty(object, 7, { value: "seven" });
+ Object.defineProperty(object, 3.14, { value: "pi" });
+
+ assertThrows(function() { delete_property(object); }, TypeError);
+ assertEquals(object.property, "property_value");
+ assertThrows(function() { delete_element(object, "1"); }, TypeError);
+ assertThrows(function() { delete_element(object, 1); }, TypeError);
+ assertEquals(object[1], "one");
+ assertThrows(function() { delete_element(object, "7"); }, TypeError);
+ assertThrows(function() { delete_element(object, 7); }, TypeError);
+ assertEquals(object[7], "seven");
+ assertThrows(function() { delete_element(object, "3.14"); }, TypeError);
+ assertThrows(function() { delete_element(object, 3.14); }, TypeError);
+ assertEquals(object[3.14], "pi");
+})();
+
+// Not transforming this in Function.call and Function.apply.
+(function testThisTransformCallApply() {
+ function non_strict() {
+ return this;
+ }
+ function strict() {
+ "use strict";
+ return this;
+ }
+
+ var global_object = (function() { return this; })();
+ var object = {};
+
+ // Non-strict call.
+ assertTrue(non_strict.call(null) === global_object);
+ assertTrue(non_strict.call(undefined) === global_object);
+ assertEquals(typeof non_strict.call(7), "object");
+ assertEquals(typeof non_strict.call("Hello"), "object");
+ assertTrue(non_strict.call(object) === object);
+
+ // Non-strict apply.
+ assertTrue(non_strict.apply(null) === global_object);
+ assertTrue(non_strict.apply(undefined) === global_object);
+ assertEquals(typeof non_strict.apply(7), "object");
+ assertEquals(typeof non_strict.apply("Hello"), "object");
+ assertTrue(non_strict.apply(object) === object);
+
+ // Strict call.
+ assertTrue(strict.call(null) === null);
+ assertTrue(strict.call(undefined) === undefined);
+ assertEquals(typeof strict.call(7), "number");
+ assertEquals(typeof strict.call("Hello"), "string");
+ assertTrue(strict.call(object) === object);
+
+ // Strict apply.
+ assertTrue(strict.apply(null) === null);
+ assertTrue(strict.apply(undefined) === undefined);
+ assertEquals(typeof strict.apply(7), "number");
+ assertEquals(typeof strict.apply("Hello"), "string");
+ assertTrue(strict.apply(object) === object);
+})();
+
+(function testThisTransform() {
+ try {
+ function strict() {
+ "use strict";
+ return typeof(this);
+ }
+ function nonstrict() {
+ return typeof(this);
+ }
+
+ // Concat to avoid symbol.
+ var strict_name = "str" + "ict";
+ var nonstrict_name = "non" + "str" + "ict";
+ var strict_number = 17;
+ var nonstrict_number = 19;
+ var strict_name_get = "str" + "ict" + "get";
+ var nonstrict_name_get = "non" + "str" + "ict" + "get"
+ var strict_number_get = 23;
+ var nonstrict_number_get = 29;
+
+ function install(t) {
+ t.prototype.strict = strict;
+ t.prototype.nonstrict = nonstrict;
+ t.prototype[strict_number] = strict;
+ t.prototype[nonstrict_number] = nonstrict;
+ Object.defineProperty(t.prototype, strict_name_get,
+ { get: function() { return strict; },
+ configurable: true });
+ Object.defineProperty(t.prototype, nonstrict_name_get,
+ { get: function() { return nonstrict; },
+ configurable: true });
+ Object.defineProperty(t.prototype, strict_number_get,
+ { get: function() { return strict; },
+ configurable: true });
+ Object.defineProperty(t.prototype, nonstrict_number_get,
+ { get: function() { return nonstrict; },
+ configurable: true });
+ }
+
+ function cleanup(t) {
+ delete t.prototype.strict;
+ delete t.prototype.nonstrict;
+ delete t.prototype[strict_number];
+ delete t.prototype[nonstrict_number];
+ delete t.prototype[strict_name_get];
+ delete t.prototype[nonstrict_name_get];
+ delete t.prototype[strict_number_get];
+ delete t.prototype[nonstrict_number_get];
+ }
+
+ // Set up fakes
+ install(String);
+ install(Number);
+ install(Boolean)
+
+ function callStrict(o) {
+ return o.strict();
+ }
+ function callNonStrict(o) {
+ return o.nonstrict();
+ }
+ function callKeyedStrict(o) {
+ return o[strict_name]();
+ }
+ function callKeyedNonStrict(o) {
+ return o[nonstrict_name]();
+ }
+ function callIndexedStrict(o) {
+ return o[strict_number]();
+ }
+ function callIndexedNonStrict(o) {
+ return o[nonstrict_number]();
+ }
+ function callStrictGet(o) {
+ return o.strictget();
+ }
+ function callNonStrictGet(o) {
+ return o.nonstrictget();
+ }
+ function callKeyedStrictGet(o) {
+ return o[strict_name_get]();
+ }
+ function callKeyedNonStrictGet(o) {
+ return o[nonstrict_name_get]();
+ }
+ function callIndexedStrictGet(o) {
+ return o[strict_number_get]();
+ }
+ function callIndexedNonStrictGet(o) {
+ return o[nonstrict_number_get]();
+ }
+
+ for (var i = 0; i < 10; i ++) {
+ assertEquals(("hello").strict(), "string");
+ assertEquals(("hello").nonstrict(), "object");
+ assertEquals(("hello")[strict_name](), "string");
+ assertEquals(("hello")[nonstrict_name](), "object");
+ assertEquals(("hello")[strict_number](), "string");
+ assertEquals(("hello")[nonstrict_number](), "object");
+
+ assertEquals((10 + i).strict(), "number");
+ assertEquals((10 + i).nonstrict(), "object");
+ assertEquals((10 + i)[strict_name](), "number");
+ assertEquals((10 + i)[nonstrict_name](), "object");
+ assertEquals((10 + i)[strict_number](), "number");
+ assertEquals((10 + i)[nonstrict_number](), "object");
+
+ assertEquals((true).strict(), "boolean");
+ assertEquals((true).nonstrict(), "object");
+ assertEquals((true)[strict_name](), "boolean");
+ assertEquals((true)[nonstrict_name](), "object");
+ assertEquals((true)[strict_number](), "boolean");
+ assertEquals((true)[nonstrict_number](), "object");
+
+ assertEquals((false).strict(), "boolean");
+ assertEquals((false).nonstrict(), "object");
+ assertEquals((false)[strict_name](), "boolean");
+ assertEquals((false)[nonstrict_name](), "object");
+ assertEquals((false)[strict_number](), "boolean");
+ assertEquals((false)[nonstrict_number](), "object");
+
+ assertEquals(callStrict("howdy"), "string");
+ assertEquals(callNonStrict("howdy"), "object");
+ assertEquals(callKeyedStrict("howdy"), "string");
+ assertEquals(callKeyedNonStrict("howdy"), "object");
+ assertEquals(callIndexedStrict("howdy"), "string");
+ assertEquals(callIndexedNonStrict("howdy"), "object");
+
+ assertEquals(callStrict(17 + i), "number");
+ assertEquals(callNonStrict(17 + i), "object");
+ assertEquals(callKeyedStrict(17 + i), "number");
+ assertEquals(callKeyedNonStrict(17 + i), "object");
+ assertEquals(callIndexedStrict(17 + i), "number");
+ assertEquals(callIndexedNonStrict(17 + i), "object");
+
+ assertEquals(callStrict(true), "boolean");
+ assertEquals(callNonStrict(true), "object");
+ assertEquals(callKeyedStrict(true), "boolean");
+ assertEquals(callKeyedNonStrict(true), "object");
+ assertEquals(callIndexedStrict(true), "boolean");
+ assertEquals(callIndexedNonStrict(true), "object");
+
+ assertEquals(callStrict(false), "boolean");
+ assertEquals(callNonStrict(false), "object");
+ assertEquals(callKeyedStrict(false), "boolean");
+ assertEquals(callKeyedNonStrict(false), "object");
+ assertEquals(callIndexedStrict(false), "boolean");
+ assertEquals(callIndexedNonStrict(false), "object");
+
+ // All of the above, with getters
+ assertEquals(("hello").strictget(), "string");
+ assertEquals(("hello").nonstrictget(), "object");
+ assertEquals(("hello")[strict_name_get](), "string");
+ assertEquals(("hello")[nonstrict_name_get](), "object");
+ assertEquals(("hello")[strict_number_get](), "string");
+ assertEquals(("hello")[nonstrict_number_get](), "object");
+
+ assertEquals((10 + i).strictget(), "number");
+ assertEquals((10 + i).nonstrictget(), "object");
+ assertEquals((10 + i)[strict_name_get](), "number");
+ assertEquals((10 + i)[nonstrict_name_get](), "object");
+ assertEquals((10 + i)[strict_number_get](), "number");
+ assertEquals((10 + i)[nonstrict_number_get](), "object");
+
+ assertEquals((true).strictget(), "boolean");
+ assertEquals((true).nonstrictget(), "object");
+ assertEquals((true)[strict_name_get](), "boolean");
+ assertEquals((true)[nonstrict_name_get](), "object");
+ assertEquals((true)[strict_number_get](), "boolean");
+ assertEquals((true)[nonstrict_number_get](), "object");
+
+ assertEquals((false).strictget(), "boolean");
+ assertEquals((false).nonstrictget(), "object");
+ assertEquals((false)[strict_name_get](), "boolean");
+ assertEquals((false)[nonstrict_name_get](), "object");
+ assertEquals((false)[strict_number_get](), "boolean");
+ assertEquals((false)[nonstrict_number_get](), "object");
+
+ assertEquals(callStrictGet("howdy"), "string");
+ assertEquals(callNonStrictGet("howdy"), "object");
+ assertEquals(callKeyedStrictGet("howdy"), "string");
+ assertEquals(callKeyedNonStrictGet("howdy"), "object");
+ assertEquals(callIndexedStrictGet("howdy"), "string");
+ assertEquals(callIndexedNonStrictGet("howdy"), "object");
+
+ assertEquals(callStrictGet(17 + i), "number");
+ assertEquals(callNonStrictGet(17 + i), "object");
+ assertEquals(callKeyedStrictGet(17 + i), "number");
+ assertEquals(callKeyedNonStrictGet(17 + i), "object");
+ assertEquals(callIndexedStrictGet(17 + i), "number");
+ assertEquals(callIndexedNonStrictGet(17 + i), "object");
+
+ assertEquals(callStrictGet(true), "boolean");
+ assertEquals(callNonStrictGet(true), "object");
+ assertEquals(callKeyedStrictGet(true), "boolean");
+ assertEquals(callKeyedNonStrictGet(true), "object");
+ assertEquals(callIndexedStrictGet(true), "boolean");
+ assertEquals(callIndexedNonStrictGet(true), "object");
+
+ assertEquals(callStrictGet(false), "boolean");
+ assertEquals(callNonStrictGet(false), "object");
+ assertEquals(callKeyedStrictGet(false), "boolean");
+ assertEquals(callKeyedNonStrictGet(false), "object");
+ assertEquals(callIndexedStrictGet(false), "boolean");
+ assertEquals(callIndexedNonStrictGet(false), "object");
+
+ }
+ } finally {
+ // Cleanup
+ cleanup(String);
+ cleanup(Number);
+ cleanup(Boolean);
+ }
+})();
+
+
+(function ObjectEnvironment() {
+ var o = {};
+ Object.defineProperty(o, "foo", { value: "FOO", writable: false });
+ assertThrows(
+ function () {
+ with (o) {
+ (function() {
+ "use strict";
+ foo = "Hello";
+ })();
+ }
+ },
+ TypeError);
+})();
+
+
+(function TestSetPropertyWithoutSetter() {
+ var o = { get foo() { return "Yey"; } };
+ assertThrows(
+ function broken() {
+ "use strict";
+ o.foo = (0xBADBAD00 >> 1);
+ },
+ TypeError);
+})();
+
+
+(function TestSetPropertyNonConfigurable() {
+ var frozen = Object.freeze({});
+ var sealed = Object.seal({});
+
+ function strict(o) {
+ "use strict";
+ o.property = "value";
+ }
+
+ assertThrows(function() { strict(frozen); }, TypeError);
+ assertThrows(function() { strict(sealed); }, TypeError);
+})();
+
+
+(function TestAssignmentToReadOnlyProperty() {
+ "use strict";
+
+ var o = {};
+ Object.defineProperty(o, "property", { value: 7 });
+
+ assertThrows(function() { o.property = "new value"; }, TypeError);
+ assertThrows(function() { o.property += 10; }, TypeError);
+ assertThrows(function() { o.property -= 10; }, TypeError);
+ assertThrows(function() { o.property *= 10; }, TypeError);
+ assertThrows(function() { o.property /= 10; }, TypeError);
+ assertThrows(function() { o.property++; }, TypeError);
+ assertThrows(function() { o.property--; }, TypeError);
+ assertThrows(function() { ++o.property; }, TypeError);
+ assertThrows(function() { --o.property; }, TypeError);
+
+ var name = "prop" + "erty"; // to avoid symbol path.
+ assertThrows(function() { o[name] = "new value"; }, TypeError);
+ assertThrows(function() { o[name] += 10; }, TypeError);
+ assertThrows(function() { o[name] -= 10; }, TypeError);
+ assertThrows(function() { o[name] *= 10; }, TypeError);
+ assertThrows(function() { o[name] /= 10; }, TypeError);
+ assertThrows(function() { o[name]++; }, TypeError);
+ assertThrows(function() { o[name]--; }, TypeError);
+ assertThrows(function() { ++o[name]; }, TypeError);
+ assertThrows(function() { --o[name]; }, TypeError);
+
+ assertEquals(o.property, 7);
+})();
+
+
+(function TestAssignmentToReadOnlyLoop() {
+ var name = "prop" + "erty"; // to avoid symbol path.
+ var o = {};
+ Object.defineProperty(o, "property", { value: 7 });
+
+ function strict(o, name) {
+ "use strict";
+ o[name] = "new value";
+ }
+
+ for (var i = 0; i < 10; i ++) {
+ try {
+ strict(o, name);
+ assertUnreachable();
+ } catch(e) {
+ assertInstanceof(e, TypeError);
+ }
+ }
+})();
+
+
+// Specialized KeyedStoreIC experiencing miss.
+(function testKeyedStoreICStrict() {
+ var o = [9,8,7,6,5,4,3,2,1];
+
+ function test(o, i, v) {
+ "use strict";
+ o[i] = v;
+ }
+
+ for (var i = 0; i < 10; i ++) {
+ test(o, 5, 17); // start specialized for smi indices
+ assertEquals(o[5], 17);
+ test(o, "a", 19);
+ assertEquals(o["a"], 19);
+ test(o, "5", 29);
+ assertEquals(o[5], 29);
+ test(o, 100000, 31);
+ assertEquals(o[100000], 31);
+ }
+})();
« no previous file with comments | « test/mjsunit/regress/regress-crbug-72736.js ('k') | test/mjsunit/tools/codemap.js » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698