Keep narrowing non-reassigned names coming from parameters

Author: Andarist

src/compiler/checker.ts

@@ -27393,7 +27393,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
             case SyntaxKind.Identifier:
                 if (!isThisInTypeQuery(node)) {
                     const symbol = getResolvedSymbol(node as Identifier);
-                    return isConstantVariable(symbol) || isParameterOrCatchClauseVariable(symbol) && !isSomeSymbolAssigned(getRootDeclaration(symbol.valueDeclaration!));
+                    return isConstantVariable(symbol) || isParameterOrCatchClauseVariable(symbol) && !isSymbolAssigned(symbol);
                 }
                 break;
             case SyntaxKind.PropertyAccessExpression:
@@ -28668,34 +28668,51 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
             node.kind === SyntaxKind.PropertyDeclaration)!;
     }
 
-    // Check if a parameter or catch variable (or their bindings elements) is assigned anywhere
-    function isSomeSymbolAssigned(rootDeclaration: Node) {
-        const parent = rootDeclaration.parent;
+    // Check if a parameter or catch variable is assigned anywhere
+    function isSymbolAssigned(symbol: Symbol) {
+        if (!symbol.valueDeclaration) {
+            return false;
+        }
+        const parent = getRootDeclaration(symbol.valueDeclaration).parent;
         const links = getNodeLinks(parent);
         if (!(links.flags & NodeCheckFlags.AssignmentsMarked)) {
             links.flags |= NodeCheckFlags.AssignmentsMarked;
             if (!hasParentWithAssignmentsMarked(parent)) {
                 markNodeAssignments(parent);
             }
         }
-        return !!getNodeLinks(rootDeclaration).someSymbolAssigned;
+        return symbol.isAssigned || false;
+    }
+
+    // Check if a parameter or catch variable (or their bindings elements) is assigned anywhere
+    function isSomeSymbolAssigned(rootDeclaration: Node) {
+        Debug.assert(isVariableDeclaration(rootDeclaration) || isParameter(rootDeclaration));
+        return isSomeSymbolAssignedWorker(rootDeclaration.name);
+    }
+
+    function isSomeSymbolAssignedWorker(node: BindingName): boolean {
+        if (node.kind === SyntaxKind.Identifier) {
+            return isSymbolAssigned(getSymbolOfDeclaration(node.parent as Declaration));
+        }
+
+        return some(node.elements, e => e.kind !== SyntaxKind.OmittedExpression && isSomeSymbolAssignedWorker(e.name));
     }
 
     function hasParentWithAssignmentsMarked(node: Node) {
         return !!findAncestor(node.parent, node => (isFunctionLike(node) || isCatchClause(node)) && !!(getNodeLinks(node).flags & NodeCheckFlags.AssignmentsMarked));
     }
 
-    function markNodeAssignments(node: Node): true | undefined {
+    function markNodeAssignments(node: Node) {
         if (node.kind === SyntaxKind.Identifier) {
             if (isAssignmentTarget(node)) {
                 const symbol = getResolvedSymbol(node as Identifier);
                 if (isParameterOrCatchClauseVariable(symbol)) {
-                    return getNodeLinks(getRootDeclaration(symbol.valueDeclaration!)).someSymbolAssigned = true;
+                    symbol.isAssigned = true;
                 }
             }
         }
         else {
-            return forEachChild(node, markNodeAssignments);
+            forEachChild(node, markNodeAssignments);
         }
     }
 
@@ -29045,8 +29062,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
         // The declaration container is the innermost function that encloses the declaration of the variable
         // or parameter. The flow container is the innermost function starting with which we analyze the control
         // flow graph to determine the control flow based type.
-        const rootDeclaration = getRootDeclaration(declaration);
-        const isParameter = rootDeclaration.kind === SyntaxKind.Parameter;
+        const isParameter = getRootDeclaration(declaration).kind === SyntaxKind.Parameter;
         const declarationContainer = getControlFlowContainer(declaration);
         let flowContainer = getControlFlowContainer(node);
         const isOuterVariable = flowContainer !== declarationContainer;
@@ -29060,7 +29076,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
         while (
             flowContainer !== declarationContainer && (flowContainer.kind === SyntaxKind.FunctionExpression ||
                 flowContainer.kind === SyntaxKind.ArrowFunction || isObjectLiteralOrClassExpressionMethodOrAccessor(flowContainer)) &&
-            (isConstantVariable(localOrExportSymbol) && type !== autoArrayType || isParameter && !isSomeSymbolAssigned(rootDeclaration))
+            (isConstantVariable(localOrExportSymbol) && type !== autoArrayType || isParameter && !isSymbolAssigned(localOrExportSymbol))
         ) {
             flowContainer = getControlFlowContainer(flowContainer);
         }

src/compiler/types.ts

@@ -5811,6 +5811,7 @@ export interface Symbol {
     /** @internal */ constEnumOnlyModule: boolean | undefined; // True if module contains only const enums or other modules with only const enums
     /** @internal */ isReferenced?: SymbolFlags; // True if the symbol is referenced elsewhere. Keeps track of the meaning of a reference in case a symbol is both a type parameter and parameter.
     /** @internal */ isReplaceableByMethod?: boolean; // Can this Javascript class property be replaced by a method symbol?
+    /** @internal */ isAssigned?: boolean; // True if the symbol is a parameter with assignments
     /** @internal */ assignmentDeclarationMembers?: Map<number, Declaration>; // detected late-bound assignment declarations associated with the symbol
 }
 
@@ -6049,7 +6050,6 @@ export interface NodeLinks {
     parameterInitializerContainsUndefined?: boolean; // True if this is a parameter declaration whose type annotation contains "undefined".
     fakeScopeForSignatureDeclaration?: "params" | "typeParams"; // If present, this is a fake scope injected into an enclosing declaration chain.
     assertionExpressionType?: Type;     // Cached type of the expression of a type assertion
-    someSymbolAssigned?: boolean;       // True if any symbol declared in a parameter or catch clause is being assigned to
 }
 
 /** @internal */

src/compiler/utilities.ts

@@ -5278,7 +5278,7 @@ export function isPushOrUnshiftIdentifier(node: Identifier) {
  *
  * @internal
  */
-export function isParameterDeclaration(node: Declaration): boolean {
+export function isParameterDeclaration(node: Declaration): node is ParameterDeclaration {
     const root = getRootDeclaration(node);
     return root.kind === SyntaxKind.Parameter;
 }
@@ -8155,6 +8155,7 @@ function Symbol(this: Symbol, flags: SymbolFlags, name: __String) {
     this.exportSymbol = undefined;
     this.constEnumOnlyModule = undefined;
     this.isReferenced = undefined;
+    this.isAssigned = undefined;
     (this as any).links = undefined; // used by TransientSymbol
 }
 

tests/baselines/reference/narrowRefinedConstLikeParameterBIndingElementNameInInnerScope.symbols

@@ -0,0 +1,24 @@
+//// [tests/cases/compiler/narrowRefinedConstLikeParameterBIndingElementNameInInnerScope.ts] ////
+
+=== narrowRefinedConstLikeParameterBIndingElementNameInInnerScope.ts ===
+function ff({ a, b }: { a: string | undefined, b: () => void }) {
+>ff : Symbol(ff, Decl(narrowRefinedConstLikeParameterBIndingElementNameInInnerScope.ts, 0, 0))
+>a : Symbol(a, Decl(narrowRefinedConstLikeParameterBIndingElementNameInInnerScope.ts, 0, 13))
+>b : Symbol(b, Decl(narrowRefinedConstLikeParameterBIndingElementNameInInnerScope.ts, 0, 16))
+>a : Symbol(a, Decl(narrowRefinedConstLikeParameterBIndingElementNameInInnerScope.ts, 0, 23))
+>b : Symbol(b, Decl(narrowRefinedConstLikeParameterBIndingElementNameInInnerScope.ts, 0, 46))
+
+  if (a !== undefined) {
+>a : Symbol(a, Decl(narrowRefinedConstLikeParameterBIndingElementNameInInnerScope.ts, 0, 13))
+>undefined : Symbol(undefined)
+
+    b = () => {
+>b : Symbol(b, Decl(narrowRefinedConstLikeParameterBIndingElementNameInInnerScope.ts, 0, 16))
+
+      const x: string = a;
+>x : Symbol(x, Decl(narrowRefinedConstLikeParameterBIndingElementNameInInnerScope.ts, 3, 11))
+>a : Symbol(a, Decl(narrowRefinedConstLikeParameterBIndingElementNameInInnerScope.ts, 0, 13))
+    }
+  }
+}
+

tests/baselines/reference/narrowRefinedConstLikeParameterBIndingElementNameInInnerScope.types

@@ -0,0 +1,27 @@
+//// [tests/cases/compiler/narrowRefinedConstLikeParameterBIndingElementNameInInnerScope.ts] ////
+
+=== narrowRefinedConstLikeParameterBIndingElementNameInInnerScope.ts ===
+function ff({ a, b }: { a: string | undefined, b: () => void }) {
+>ff : ({ a, b }: {    a: string | undefined;    b: () => void;}) => void
+>a : string | undefined
+>b : () => void
+>a : string | undefined
+>b : () => void
+
+  if (a !== undefined) {
+>a !== undefined : boolean
+>a : string | undefined
+>undefined : undefined
+
+    b = () => {
+>b = () => {      const x: string = a;    } : () => void
+>b : () => void
+>() => {      const x: string = a;    } : () => void
+
+      const x: string = a;
+>x : string
+>a : string
+    }
+  }
+}
+

tests/cases/compiler/narrowRefinedConstLikeParameterBIndingElementNameInInnerScope.ts

@@ -0,0 +1,10 @@
+// @strict: true
+// @noEmit: true
+
+function ff({ a, b }: { a: string | undefined, b: () => void }) {
+  if (a !== undefined) {
+    b = () => {
+      const x: string = a;
+    }
+  }
+}