ES6: Duplicate properties are no longer an error

test/mjsunit/strict-mode.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 148 matching lines @@
   var y = "\0";
 })();
 
 // Octal before "use strict"
 assertThrows('\
   function strict() {\
     "octal\\032directive";\
     "use strict";\
   }', SyntaxError);
 
-// Duplicate data properties.
-CheckStrictMode("var x = { dupe : 1, nondupe: 3, dupe : 2 };", SyntaxError);
-CheckStrictMode("var x = { '1234' : 1, '2345' : 2, '1234' : 3 };", SyntaxError);
-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);
-
 // Non-conflicting data properties.
 (function StrictModeNonDuplicate() {
   "use strict";
   var x = { 123 : 1, "0123" : 2 };
   var x = {
     123: 1,
     '123.00000000000000000000000000000000000000000000000000000000000000000001':
       2
   };
 })();
 
-// Two getters (non-strict)
-assertThrows("var x = { get foo() { }, get foo() { } };", SyntaxError);
-assertThrows("var x = { get foo(){}, get 'foo'(){}};", SyntaxError);
-assertThrows("var x = { get 12(){}, get '12'(){}};", SyntaxError);
+// Duplicate properties are no longer errors in ES6.
+(function Duplicates() {
+  "use strict";
 
-// Two setters (non-strict)
-assertThrows("var x = { set foo(v) { }, set foo(v) { } };", SyntaxError);
-assertThrows("var x = { set foo(v) { }, set 'foo'(v) { } };", SyntaxError);
-assertThrows("var x = { set 13(v) { }, set '13'(v) { } };", SyntaxError);
+  ({ dupe : 1, nondupe: 3, dupe : 2 });
+  ({ '1234' : 1, '2345' : 2, '1234' : 3 });
+  ({ '1234' : 1, '2345' : 2, 1234 : 3 });
+  ({ 3.14 : 1, 2.71 : 2, 3.14 : 3 });
+  ({ 3.14 : 1, '3.14' : 2 });
+  ({
+    123: 1,
+    123.00000000000000000000000000000000000000000000000000000000000000000001: 2
+  });
 
-// Setter and data (non-strict)
-assertThrows("var x = { foo: 'data', set foo(v) { } };", SyntaxError);
-assertThrows("var x = { set foo(v) { }, foo: 'data' };", SyntaxError);
-assertThrows("var x = { foo: 'data', set 'foo'(v) { } };", SyntaxError);
-assertThrows("var x = { set foo(v) { }, 'foo': 'data' };", SyntaxError);
-assertThrows("var x = { 'foo': 'data', set foo(v) { } };", SyntaxError);
-assertThrows("var x = { set 'foo'(v) { }, foo: 'data' };", SyntaxError);
-assertThrows("var x = { 'foo': 'data', set 'foo'(v) { } };", SyntaxError);
-assertThrows("var x = { set 'foo'(v) { }, 'foo': 'data' };", SyntaxError);
-assertThrows("var x = { 12: 1, set '12'(v){}};", SyntaxError);
-assertThrows("var x = { 12: 1, set 12(v){}};", SyntaxError);
-assertThrows("var x = { '12': 1, set '12'(v){}};", SyntaxError);
-assertThrows("var x = { '12': 1, set 12(v){}};", SyntaxError);
+  // Two getters
+  ({ get foo() { }, get foo() { } });
+  ({ get foo(){}, get 'foo'(){}});
+  ({ get 12(){}, get '12'(){}});
 
-// Getter and data (non-strict)
-assertThrows("var x = { foo: 'data', get foo() { } };", SyntaxError);
-assertThrows("var x = { get foo() { }, foo: 'data' };", SyntaxError);
-assertThrows("var x = { 'foo': 'data', get foo() { } };", SyntaxError);
-assertThrows("var x = { get 'foo'() { }, 'foo': 'data' };", SyntaxError);
-assertThrows("var x = { '12': 1, get '12'(){}};", SyntaxError);
-assertThrows("var x = { '12': 1, get 12(){}};", SyntaxError);
+  // Two setters
+  ({ set foo(v) { }, set foo(v) { } });
+  ({ set foo(v) { }, set 'foo'(v) { } });
+  ({ set 13(v) { }, set '13'(v) { } });
+
+  // Setter and data
+  ({ foo: 'data', set foo(v) { } });
+  ({ set foo(v) { }, foo: 'data' });
+  ({ foo: 'data', set 'foo'(v) { } });
+  ({ set foo(v) { }, 'foo': 'data' });
+  ({ 'foo': 'data', set foo(v) { } });
+  ({ set 'foo'(v) { }, foo: 'data' });
+  ({ 'foo': 'data', set 'foo'(v) { } });
+  ({ set 'foo'(v) { }, 'foo': 'data' });
+  ({ 12: 1, set '12'(v){}});
+  ({ 12: 1, set 12(v){}});
+  ({ '12': 1, set '12'(v){}});
+  ({ '12': 1, set 12(v){}});
+
+  // Getter and data
+  ({ foo: 'data', get foo() { } });
+  ({ get foo() { }, foo: 'data' });
+  ({ 'foo': 'data', get foo() { } });
+  ({ get 'foo'() { }, 'foo': 'data' });
+  ({ '12': 1, get '12'(){}});
+  ({ '12': 1, get 12(){}});
+})();
 
 // 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);
@@ skipping 976 matching lines @@
     assertSame(null, test(i));
   }
 })();
 
 
 (function TestStrictModeEval() {
   "use strict";
   eval("var eval_local = 10;");
   assertThrows(function() { return eval_local; }, ReferenceError);
 })();