Allow destructuring the same property multiple times

Fixes: #35939

Author: ajafff

src/compiler/binder.ts

@@ -1865,7 +1865,7 @@ namespace ts {
                 Accessor = 2
             }
 
-            if (inStrictMode) {
+            if (inStrictMode && !isAssignmentTarget(node)) {
                 const seen = createUnderscoreEscapedMap<ElementKind>();
 
                 for (const prop of node.properties) {

src/compiler/checker.ts

@@ -35968,30 +35968,32 @@ namespace ts {
                         throw Debug.assertNever(prop, "Unexpected syntax kind:" + (<Node>prop).kind);
                 }
 
-                const effectiveName = getPropertyNameForPropertyNameNode(name);
-                if (effectiveName === undefined) {
-                    continue;
-                }
+                if (!inDestructuring) {
+                    const effectiveName = getPropertyNameForPropertyNameNode(name);
+                    if (effectiveName === undefined) {
+                        continue;
+                    }
 
-                const existingKind = seen.get(effectiveName);
-                if (!existingKind) {
-                    seen.set(effectiveName, currentKind);
-                }
-                else {
-                    if ((currentKind & DeclarationMeaning.PropertyAssignmentOrMethod) && (existingKind & DeclarationMeaning.PropertyAssignmentOrMethod)) {
-                        grammarErrorOnNode(name, Diagnostics.Duplicate_identifier_0, getTextOfNode(name));
+                    const existingKind = seen.get(effectiveName);
+                    if (!existingKind) {
+                        seen.set(effectiveName, currentKind);
                     }
-                    else if ((currentKind & DeclarationMeaning.GetOrSetAccessor) && (existingKind & DeclarationMeaning.GetOrSetAccessor)) {
-                        if (existingKind !== DeclarationMeaning.GetOrSetAccessor && currentKind !== existingKind) {
-                            seen.set(effectiveName, currentKind | existingKind);
+                    else {
+                        if ((currentKind & DeclarationMeaning.PropertyAssignmentOrMethod) && (existingKind & DeclarationMeaning.PropertyAssignmentOrMethod)) {
+                            grammarErrorOnNode(name, Diagnostics.Duplicate_identifier_0, getTextOfNode(name));
+                        }
+                        else if ((currentKind & DeclarationMeaning.GetOrSetAccessor) && (existingKind & DeclarationMeaning.GetOrSetAccessor)) {
+                            if (existingKind !== DeclarationMeaning.GetOrSetAccessor && currentKind !== existingKind) {
+                                seen.set(effectiveName, currentKind | existingKind);
+                            }
+                            else {
+                                return grammarErrorOnNode(name, Diagnostics.An_object_literal_cannot_have_multiple_get_Slashset_accessors_with_the_same_name);
+                            }
                         }
                         else {
-                            return grammarErrorOnNode(name, Diagnostics.An_object_literal_cannot_have_multiple_get_Slashset_accessors_with_the_same_name);
+                            return grammarErrorOnNode(name, Diagnostics.An_object_literal_cannot_have_property_and_accessor_with_the_same_name);
                         }
                     }
-                    else {
-                        return grammarErrorOnNode(name, Diagnostics.An_object_literal_cannot_have_property_and_accessor_with_the_same_name);
-                    }
                 }
             }
         }

tests/baselines/reference/destructuringSamePropertyTwice.js

@@ -0,0 +1,10 @@
+//// [destructuringSamePropertyTwice.ts]
+'use strict';
+let { foo, foo: bar } = { foo: 1 };
+({ foo, foo: bar } = { foo: 2 });
+
+//// [destructuringSamePropertyTwice.js]
+'use strict';
+var _a;
+var _b = { foo: 1 }, foo = _b.foo, bar = _b.foo;
+(_a = { foo: 2 }, foo = _a.foo, bar = _a.foo);

tests/baselines/reference/destructuringSamePropertyTwice.symbols

@@ -0,0 +1,14 @@
+=== tests/cases/conformance/es6/destructuring/destructuringSamePropertyTwice.ts ===
+'use strict';
+let { foo, foo: bar } = { foo: 1 };
+>foo : Symbol(foo, Decl(destructuringSamePropertyTwice.ts, 1, 5))
+>foo : Symbol(foo, Decl(destructuringSamePropertyTwice.ts, 1, 25))
+>bar : Symbol(bar, Decl(destructuringSamePropertyTwice.ts, 1, 10))
+>foo : Symbol(foo, Decl(destructuringSamePropertyTwice.ts, 1, 25))
+
+({ foo, foo: bar } = { foo: 2 });
+>foo : Symbol(foo, Decl(destructuringSamePropertyTwice.ts, 2, 2), Decl(destructuringSamePropertyTwice.ts, 2, 7))
+>foo : Symbol(foo, Decl(destructuringSamePropertyTwice.ts, 2, 2), Decl(destructuringSamePropertyTwice.ts, 2, 7))
+>bar : Symbol(bar, Decl(destructuringSamePropertyTwice.ts, 1, 10))
+>foo : Symbol(foo, Decl(destructuringSamePropertyTwice.ts, 2, 22))
+

tests/baselines/reference/destructuringSamePropertyTwice.types

@@ -0,0 +1,23 @@
+=== tests/cases/conformance/es6/destructuring/destructuringSamePropertyTwice.ts ===
+'use strict';
+>'use strict' : "use strict"
+
+let { foo, foo: bar } = { foo: 1 };
+>foo : number
+>foo : any
+>bar : number
+>{ foo: 1 } : { foo: number; }
+>foo : number
+>1 : 1
+
+({ foo, foo: bar } = { foo: 2 });
+>({ foo, foo: bar } = { foo: 2 }) : { foo: number; }
+>{ foo, foo: bar } = { foo: 2 } : { foo: number; }
+>{ foo, foo: bar } : { foo: number; }
+>foo : number
+>foo : number
+>bar : number
+>{ foo: 2 } : { foo: number; }
+>foo : number
+>2 : 2
+

tests/cases/conformance/es6/destructuring/destructuringSamePropertyTwice.ts

@@ -0,0 +1,3 @@
+'use strict';
+let { foo, foo: bar } = { foo: 1 };
+({ foo, foo: bar } = { foo: 2 });