Destructuring declaration prefers type annotation type (microsoft#25282)

* Destructuring declaration prefers type annotation type

Previously, getTypeForBindingElement would always union the declarations type and
the type of the default initializer. Now, if the declaration has a type
annotation, it does not union with the initializer type. The type
annotation's type is the one used.

* Small cleanup in parentDeclarationHasTypeAnnotation

* Refactoring based on PR comments

* Combine getCombined*Flags into a single helper function

Retain the individual functions since they are used a lot.

* Remove unneeded temp

Author: sandersn

src/compiler/checker.ts

@@ -4161,7 +4161,7 @@ namespace ts {
                         }
                         const parent = getDeclarationContainer(node);
                         // If the node is not exported or it is not ambient module element (except import declaration)
-                        if (!(getCombinedModifierFlags(node) & ModifierFlags.Export) &&
+                        if (!(getCombinedModifierFlags(node as Declaration) & ModifierFlags.Export) &&
                             !(node.kind !== SyntaxKind.ImportEqualsDeclaration && parent.kind !== SyntaxKind.SourceFile && parent.flags & NodeFlags.Ambient)) {
                             return isGlobalSourceFile(parent);
                         }
@@ -4525,7 +4525,7 @@ namespace ts {
             if (strictNullChecks && declaration.initializer && !(getFalsyFlags(checkExpressionCached(declaration.initializer)) & TypeFlags.Undefined)) {
                 type = getTypeWithFacts(type, TypeFacts.NEUndefined);
             }
-            return declaration.initializer ?
+            return declaration.initializer && !getEffectiveTypeAnnotationNode(walkUpBindingElementsAndPatterns(declaration)) ?
                 getUnionType([type, checkExpressionCached(declaration.initializer)], UnionReduction.Subtype) :
                 type;
         }
@@ -22096,7 +22096,7 @@ namespace ts {
             return hasModifier(node, ModifierFlags.Private) && !!(node.flags & NodeFlags.Ambient);
         }
 
-        function getEffectiveDeclarationFlags(n: Node, flagsToCheck: ModifierFlags): ModifierFlags {
+        function getEffectiveDeclarationFlags(n: Declaration, flagsToCheck: ModifierFlags): ModifierFlags {
             let flags = getCombinedModifierFlags(n);
 
             // children of classes (even ambient classes) should not be marked as ambient or export

src/compiler/utilities.ts

@@ -903,7 +903,7 @@ namespace ts {
 
     export function isConst(node: Node): boolean {
         return !!(getCombinedNodeFlags(node) & NodeFlags.Const)
-            || !!(getCombinedModifierFlags(node) & ModifierFlags.Const);
+            || !!(isDeclaration(node) && getCombinedModifierFlags(node) & ModifierFlags.Const);
     }
 
     export function isLet(node: Node): boolean {
@@ -4605,33 +4605,36 @@ namespace ts {
         return isEmptyBindingPattern(node.name);
     }
 
-    function walkUpBindingElementsAndPatterns(node: Node): Node {
-        while (node && (node.kind === SyntaxKind.BindingElement || isBindingPattern(node))) {
-            node = node.parent;
+    export function walkUpBindingElementsAndPatterns(binding: BindingElement): VariableDeclaration | ParameterDeclaration {
+        let node = binding.parent;
+        while (isBindingElement(node.parent)) {
+            node = node.parent.parent;
         }
-
-        return node;
+        return node.parent;
     }
 
-    export function getCombinedModifierFlags(node: Node): ModifierFlags {
-        node = walkUpBindingElementsAndPatterns(node);
-        let flags = getModifierFlags(node);
+    function getCombinedFlags(node: Node, getFlags: (n: Node) => number): number {
+        if (isBindingElement(node)) {
+            node = walkUpBindingElementsAndPatterns(node);
+        }
+        let flags = getFlags(node);
         if (node.kind === SyntaxKind.VariableDeclaration) {
             node = node.parent;
         }
-
         if (node && node.kind === SyntaxKind.VariableDeclarationList) {
-            flags |= getModifierFlags(node);
+            flags |= getFlags(node);
             node = node.parent;
         }
-
         if (node && node.kind === SyntaxKind.VariableStatement) {
-            flags |= getModifierFlags(node);
+            flags |= getFlags(node);
         }
-
         return flags;
     }
 
+    export function getCombinedModifierFlags(node: Declaration): ModifierFlags {
+        return getCombinedFlags(node, getModifierFlags);
+    }
+
     // Returns the node flags for this node and all relevant parent nodes.  This is done so that
     // nodes like variable declarations and binding elements can returned a view of their flags
     // that includes the modifiers from their container.  i.e. flags like export/declare aren't
@@ -4640,23 +4643,7 @@ namespace ts {
     // list.  By calling this function, all those flags are combined so that the client can treat
     // the node as if it actually had those flags.
     export function getCombinedNodeFlags(node: Node): NodeFlags {
-        node = walkUpBindingElementsAndPatterns(node);
-
-        let flags = node.flags;
-        if (node.kind === SyntaxKind.VariableDeclaration) {
-            node = node.parent;
-        }
-
-        if (node && node.kind === SyntaxKind.VariableDeclarationList) {
-            flags |= node.flags;
-            node = node.parent;
-        }
-
-        if (node && node.kind === SyntaxKind.VariableStatement) {
-            flags |= node.flags;
-        }
-
-        return flags;
+        return getCombinedFlags(node, n => n.flags);
     }
 
     /**

src/services/utilities.ts

@@ -1044,7 +1044,7 @@ namespace ts {
     }
 
     export function getNodeModifiers(node: Node): string {
-        const flags = getCombinedModifierFlags(node);
+        const flags = isDeclaration(node) ? getCombinedModifierFlags(node) : ModifierFlags.None;
         const result: string[] = [];
 
         if (flags & ModifierFlags.Private) result.push(ScriptElementKindModifier.privateMemberModifier);

tests/baselines/reference/api/tsserverlibrary.d.ts

@@ -6677,7 +6677,8 @@ declare namespace ts {
     function isParameterPropertyDeclaration(node: Node): node is ParameterPropertyDeclaration;
     function isEmptyBindingPattern(node: BindingName): node is BindingPattern;
     function isEmptyBindingElement(node: BindingElement): boolean;
-    function getCombinedModifierFlags(node: Node): ModifierFlags;
+    function walkUpBindingElementsAndPatterns(binding: BindingElement): VariableDeclaration | ParameterDeclaration;
+    function getCombinedModifierFlags(node: Declaration): ModifierFlags;
     function getCombinedNodeFlags(node: Node): NodeFlags;
     /**
      * Checks to see if the locale is in the appropriate format,

tests/baselines/reference/api/typescript.d.ts

@@ -3175,7 +3175,8 @@ declare namespace ts {
     function isParameterPropertyDeclaration(node: Node): node is ParameterPropertyDeclaration;
     function isEmptyBindingPattern(node: BindingName): node is BindingPattern;
     function isEmptyBindingElement(node: BindingElement): boolean;
-    function getCombinedModifierFlags(node: Node): ModifierFlags;
+    function walkUpBindingElementsAndPatterns(binding: BindingElement): VariableDeclaration | ParameterDeclaration;
+    function getCombinedModifierFlags(node: Declaration): ModifierFlags;
     function getCombinedNodeFlags(node: Node): NodeFlags;
     /**
      * Checks to see if the locale is in the appropriate format,

tests/baselines/reference/contextuallyTypedBindingInitializerNegative.errors.txt

@@ -0,0 +1,67 @@
+tests/cases/conformance/types/contextualTypes/methodDeclarations/contextuallyTypedBindingInitializerNegative.ts(4,20): error TS2322: Type '(v: number) => number' is not assignable to type '(x: number) => string'.
+  Type 'number' is not assignable to type 'string'.
+tests/cases/conformance/types/contextualTypes/methodDeclarations/contextuallyTypedBindingInitializerNegative.ts(5,23): error TS2322: Type '(v: number) => number' is not assignable to type '(x: number) => string'.
+  Type 'number' is not assignable to type 'string'.
+tests/cases/conformance/types/contextualTypes/methodDeclarations/contextuallyTypedBindingInitializerNegative.ts(6,25): error TS2322: Type '(v: number) => number' is not assignable to type '(x: number) => string'.
+  Type 'number' is not assignable to type 'string'.
+tests/cases/conformance/types/contextualTypes/methodDeclarations/contextuallyTypedBindingInitializerNegative.ts(11,23): error TS2322: Type '{ show: (v: number) => number; }' is not assignable to type 'Show'.
+  Types of property 'show' are incompatible.
+    Type '(v: number) => number' is not assignable to type '(x: number) => string'.
+      Type 'number' is not assignable to type 'string'.
+tests/cases/conformance/types/contextualTypes/methodDeclarations/contextuallyTypedBindingInitializerNegative.ts(16,23): error TS2322: Type '(arg: string) => number' is not assignable to type '(s: string) => string'.
+  Type 'number' is not assignable to type 'string'.
+tests/cases/conformance/types/contextualTypes/methodDeclarations/contextuallyTypedBindingInitializerNegative.ts(21,14): error TS2322: Type '[number, number]' is not assignable to type '[string, number]'.
+  Type 'number' is not assignable to type 'string'.
+tests/cases/conformance/types/contextualTypes/methodDeclarations/contextuallyTypedBindingInitializerNegative.ts(26,14): error TS2322: Type '"baz"' is not assignable to type '"foo" | "bar"'.
+
+
+==== tests/cases/conformance/types/contextualTypes/methodDeclarations/contextuallyTypedBindingInitializerNegative.ts (7 errors) ====
+    interface Show {
+        show: (x: number) => string;
+    }
+    function f({ show: showRename = v => v }: Show) {}
+                       ~~~~~~~~~~
+!!! error TS2322: Type '(v: number) => number' is not assignable to type '(x: number) => string'.
+!!! error TS2322:   Type 'number' is not assignable to type 'string'.
+    function f2({ "show": showRename = v => v }: Show) {}
+                          ~~~~~~~~~~
+!!! error TS2322: Type '(v: number) => number' is not assignable to type '(x: number) => string'.
+!!! error TS2322:   Type 'number' is not assignable to type 'string'.
+    function f3({ ["show"]: showRename = v => v }: Show) {}
+                            ~~~~~~~~~~
+!!! error TS2322: Type '(v: number) => number' is not assignable to type '(x: number) => string'.
+!!! error TS2322:   Type 'number' is not assignable to type 'string'.
+    
+    interface Nested {
+        nested: Show
+    }
+    function ff({ nested: nestedRename = { show: v => v } }: Nested) {}
+                          ~~~~~~~~~~~~
+!!! error TS2322: Type '{ show: (v: number) => number; }' is not assignable to type 'Show'.
+!!! error TS2322:   Types of property 'show' are incompatible.
+!!! error TS2322:     Type '(v: number) => number' is not assignable to type '(x: number) => string'.
+!!! error TS2322:       Type 'number' is not assignable to type 'string'.
+    
+    interface StringIdentity {
+        stringIdentity(s: string): string;
+    }
+    let { stringIdentity: id = arg => arg.length }: StringIdentity = { stringIdentity: x => x};
+                          ~~
+!!! error TS2322: Type '(arg: string) => number' is not assignable to type '(s: string) => string'.
+!!! error TS2322:   Type 'number' is not assignable to type 'string'.
+    
+    interface Tuples {
+        prop: [string, number];
+    }
+    function g({ prop = [101, 1234] }: Tuples) {}
+                 ~~~~
+!!! error TS2322: Type '[number, number]' is not assignable to type '[string, number]'.
+!!! error TS2322:   Type 'number' is not assignable to type 'string'.
+    
+    interface StringUnion {
+        prop: "foo" | "bar";
+    }
+    function h({ prop = "baz" }: StringUnion) {}
+                 ~~~~
+!!! error TS2322: Type '"baz"' is not assignable to type '"foo" | "bar"'.
+    

tests/baselines/reference/contextuallyTypedBindingInitializerNegative.types

@@ -9,15 +9,15 @@ interface Show {
 function f({ show: showRename = v => v }: Show) {}
 >f : ({ show: showRename }: Show) => void
 >show : any
->showRename : ((x: number) => string) | ((v: number) => number)
+>showRename : (x: number) => string
 >v => v : (v: number) => number
 >v : number
 >v : number
 >Show : Show
 
 function f2({ "show": showRename = v => v }: Show) {}
 >f2 : ({ "show": showRename }: Show) => void
->showRename : ((x: number) => string) | ((v: number) => number)
+>showRename : (x: number) => string
 >v => v : (v: number) => number
 >v : number
 >v : number
@@ -26,7 +26,7 @@ function f2({ "show": showRename = v => v }: Show) {}
 function f3({ ["show"]: showRename = v => v }: Show) {}
 >f3 : ({ ["show"]: showRename }: Show) => void
 >"show" : "show"
->showRename : ((x: number) => string) | ((v: number) => number)
+>showRename : (x: number) => string
 >v => v : (v: number) => number
 >v : number
 >v : number
@@ -42,7 +42,7 @@ interface Nested {
 function ff({ nested: nestedRename = { show: v => v } }: Nested) {}
 >ff : ({ nested: nestedRename }: Nested) => void
 >nested : any
->nestedRename : Show | { show: (v: number) => number; }
+>nestedRename : Show
 >{ show: v => v } : { show: (v: number) => number; }
 >show : (v: number) => number
 >v => v : (v: number) => number
@@ -59,7 +59,7 @@ interface StringIdentity {
 }
 let { stringIdentity: id = arg => arg.length }: StringIdentity = { stringIdentity: x => x};
 >stringIdentity : any
->id : ((s: string) => string) | ((arg: string) => number)
+>id : (s: string) => string
 >arg => arg.length : (arg: string) => number
 >arg : string
 >arg.length : number
@@ -80,7 +80,7 @@ interface Tuples {
 }
 function g({ prop = [101, 1234] }: Tuples) {}
 >g : ({ prop }: Tuples) => void
->prop : [string, number] | [number, number]
+>prop : [string, number]
 >[101, 1234] : [number, number]
 >101 : 101
 >1234 : 1234
@@ -94,7 +94,7 @@ interface StringUnion {
 }
 function h({ prop = "baz" }: StringUnion) {}
 >h : ({ prop }: StringUnion) => void
->prop : "foo" | "bar" | "baz"
+>prop : "foo" | "bar"
 >"baz" : "baz"
 >StringUnion : StringUnion
 

tests/baselines/reference/destructuringParameterDeclaration8.errors.txt

@@ -0,0 +1,42 @@
+tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration8.ts(4,5): error TS2322: Type '"z"' is not assignable to type '"x" | "y"'.
+tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration8.ts(5,15): error TS2322: Type '"c"' is not assignable to type '"a" | "b"'.
+tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration8.ts(17,6): error TS2345: Argument of type '{ method: "z"; nested: { p: "b"; }; }' is not assignable to parameter of type '{ method?: "x" | "y"; nested?: { p: "a" | "b"; }; }'.
+  Types of property 'method' are incompatible.
+    Type '"z"' is not assignable to type '"x" | "y"'.
+tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration8.ts(18,6): error TS2345: Argument of type '{ method: "one"; nested: { p: "a"; }; }' is not assignable to parameter of type '{ method?: "x" | "y"; nested?: { p: "a" | "b"; }; }'.
+  Types of property 'method' are incompatible.
+    Type '"one"' is not assignable to type '"x" | "y"'.
+
+
+==== tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration8.ts (4 errors) ====
+    // explicit type annotation should cause `method` to have type 'x' | 'y'
+    // both inside and outside `test`.
+    function test({
+        method = 'z',
+        ~~~~~~
+!!! error TS2322: Type '"z"' is not assignable to type '"x" | "y"'.
+        nested: { p = 'c' }
+                  ~
+!!! error TS2322: Type '"c"' is not assignable to type '"a" | "b"'.
+    }: {
+        method?: 'x' | 'y',
+        nested?: { p: 'a' | 'b' }
+    })
+    {
+        method
+        p
+    }
+    
+    test({});
+    test({ method: 'x', nested: { p: 'a' } })
+    test({ method: 'z', nested: { p: 'b' } })
+         ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS2345: Argument of type '{ method: "z"; nested: { p: "b"; }; }' is not assignable to parameter of type '{ method?: "x" | "y"; nested?: { p: "a" | "b"; }; }'.
+!!! error TS2345:   Types of property 'method' are incompatible.
+!!! error TS2345:     Type '"z"' is not assignable to type '"x" | "y"'.
+    test({ method: 'one', nested: { p: 'a' } })
+         ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS2345: Argument of type '{ method: "one"; nested: { p: "a"; }; }' is not assignable to parameter of type '{ method?: "x" | "y"; nested?: { p: "a" | "b"; }; }'.
+!!! error TS2345:   Types of property 'method' are incompatible.
+!!! error TS2345:     Type '"one"' is not assignable to type '"x" | "y"'.
+    

tests/baselines/reference/destructuringParameterDeclaration8.js

@@ -0,0 +1,33 @@
+//// [destructuringParameterDeclaration8.ts]
+// explicit type annotation should cause `method` to have type 'x' | 'y'
+// both inside and outside `test`.
+function test({
+    method = 'z',
+    nested: { p = 'c' }
+}: {
+    method?: 'x' | 'y',
+    nested?: { p: 'a' | 'b' }
+})
+{
+    method
+    p
+}
+
+test({});
+test({ method: 'x', nested: { p: 'a' } })
+test({ method: 'z', nested: { p: 'b' } })
+test({ method: 'one', nested: { p: 'a' } })
+
+
+//// [destructuringParameterDeclaration8.js]
+// explicit type annotation should cause `method` to have type 'x' | 'y'
+// both inside and outside `test`.
+function test(_a) {
+    var _b = _a.method, method = _b === void 0 ? 'z' : _b, _c = _a.nested.p, p = _c === void 0 ? 'c' : _c;
+    method;
+    p;
+}
+test({});
+test({ method: 'x', nested: { p: 'a' } });
+test({ method: 'z', nested: { p: 'b' } });
+test({ method: 'one', nested: { p: 'a' } });