Cherry pick PR 57887 into release-5.4 (#57898)

Co-authored-by: Wesley Wigham <[email protected]>

Author: jakebailey

src/compiler/checker.ts

@@ -6306,7 +6306,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
         }
     }
 
-    function isEntityNameVisible(entityName: EntityNameOrEntityNameExpression, enclosingDeclaration: Node): SymbolVisibilityResult {
+    function getMeaningOfEntityNameReference(entityName: EntityNameOrEntityNameExpression): SymbolFlags {
         // get symbol of the first identifier of the entityName
         let meaning: SymbolFlags;
         if (
@@ -6319,7 +6319,10 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
         }
         else if (
             entityName.kind === SyntaxKind.QualifiedName || entityName.kind === SyntaxKind.PropertyAccessExpression ||
-            entityName.parent.kind === SyntaxKind.ImportEqualsDeclaration
+            entityName.parent.kind === SyntaxKind.ImportEqualsDeclaration ||
+            (entityName.parent.kind === SyntaxKind.QualifiedName && (entityName.parent as QualifiedName).left === entityName) ||
+            (entityName.parent.kind === SyntaxKind.PropertyAccessExpression && (entityName.parent as PropertyAccessExpression).expression === entityName) ||
+            (entityName.parent.kind === SyntaxKind.ElementAccessExpression && (entityName.parent as ElementAccessExpression).expression === entityName)
         ) {
             // Left identifier from type reference or TypeAlias
             // Entity name of the import declaration
@@ -6329,7 +6332,11 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
             // Type Reference or TypeAlias entity = Identifier
             meaning = SymbolFlags.Type;
         }
+        return meaning;
+    }
 
+    function isEntityNameVisible(entityName: EntityNameOrEntityNameExpression, enclosingDeclaration: Node): SymbolVisibilityResult {
+        const meaning = getMeaningOfEntityNameReference(entityName);
         const firstIdentifier = getFirstIdentifier(entityName);
         const symbol = resolveName(enclosingDeclaration, firstIdentifier.escapedText, meaning, /*nameNotFoundMessage*/ undefined, /*nameArg*/ undefined, /*isUse*/ false);
         if (symbol && symbol.flags & SymbolFlags.TypeParameter && meaning & SymbolFlags.Type) {
@@ -8512,13 +8519,14 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
                 introducesError = true;
                 return { introducesError, node };
             }
-            const sym = resolveEntityName(leftmost, SymbolFlags.All, /*ignoreErrors*/ true, /*dontResolveAlias*/ true);
+            const meaning = getMeaningOfEntityNameReference(node);
+            const sym = resolveEntityName(leftmost, meaning, /*ignoreErrors*/ true, /*dontResolveAlias*/ true);
             if (sym) {
-                if (isSymbolAccessible(sym, context.enclosingDeclaration, SymbolFlags.All, /*shouldComputeAliasesToMakeVisible*/ false).accessibility !== SymbolAccessibility.Accessible) {
+                if (isSymbolAccessible(sym, context.enclosingDeclaration, meaning, /*shouldComputeAliasesToMakeVisible*/ false).accessibility !== SymbolAccessibility.Accessible) {
                     introducesError = true;
                 }
                 else {
-                    context.tracker.trackSymbol(sym, context.enclosingDeclaration, SymbolFlags.All);
+                    context.tracker.trackSymbol(sym, context.enclosingDeclaration, meaning);
                     includePrivateSymbol?.(sym);
                 }
                 if (isIdentifier(node)) {

tests/baselines/reference/ParameterList5.types

@@ -2,6 +2,6 @@
 
 === ParameterList5.ts ===
 function A(): (public B) => C {
->A : () => (B: any) => C
+>A : () => (public B) => C
 >B : any
 }

tests/baselines/reference/annotatedThisPropertyInitializerDoesntNarrow.types

@@ -4,7 +4,7 @@
 // from webpack/lib/Compilation.js and filed at #26427
 /** @param {{ [s: string]: number }} map */
 function mappy(map) {}
->mappy : (map: { [s: string]: number; }) => void
+>mappy : (map: {    [s: string]: number;}) => void
 >map : { [s: string]: number; }
 
 export class C {

tests/baselines/reference/anonterface.types

@@ -8,7 +8,7 @@ module M {
 >C : C
 
         m(fn:{ (n:number):string; },n2:number):string {
->m : (fn: (n: number) => string, n2: number) => string
+>m : (fn: {    (n: number): string;}, n2: number) => string
 >fn : (n: number) => string
 >n : number
 >n2 : number

tests/baselines/reference/anyAssignabilityInInheritance.types

@@ -168,7 +168,7 @@ var r3 = foo3(a); // any
 >a : any
 
 declare function foo12(x: (x) => number): (x) => number;
->foo12 : { (x: (x: any) => number): (x: any) => number; (x: any): any; }
+>foo12 : { (x: (x) => number): (x) => number; (x: any): any; }
 >x : (x: any) => number
 >x : any
 >x : any

tests/baselines/reference/arrayLiteralContextualType.types

@@ -35,7 +35,7 @@ function foo(animals: IAnimal[]) { }
 >animals : IAnimal[]
 
 function bar(animals: { [n: number]: IAnimal }) { }
->bar : (animals: { [n: number]: IAnimal; }) => void
+>bar : (animals: {    [n: number]: IAnimal;}) => void
 >animals : { [n: number]: IAnimal; }
 >n : number
 

tests/baselines/reference/assignmentCompatWithCallSignatures3.types

@@ -130,7 +130,7 @@ var a17: {
 
 };
 var a18: {
->a18 : { (x: { (a: number): number; (a: string): string; }): any[]; (x: { (a: boolean): boolean; (a: Date): Date; }): any[]; }
+>a18 : { (x: {    (a: number): number;    (a: string): string;}): any[]; (x: {    (a: boolean): boolean;    (a: Date): Date;}): any[]; }
 
     (x: {
 >x : { (a: number): number; (a: string): string; }

tests/baselines/reference/assignmentCompatWithCallSignatures4.types

@@ -81,7 +81,7 @@ module Errors {
 >b : number
 
         var a16: {
->a16 : { (x: { (a: number): number; (a?: number): number; }): number[]; (x: { (a: boolean): boolean; (a?: boolean): boolean; }): boolean[]; }
+>a16 : { (x: {    (a: number): number;    (a?: number): number;}): number[]; (x: {    (a: boolean): boolean;    (a?: boolean): boolean;}): boolean[]; }
 
                 (x: {
 >x : { (a: number): number; (a?: number): number; }

tests/baselines/reference/assignmentCompatWithConstructSignatures3.types

@@ -130,7 +130,7 @@ var a17: {
 
 };
 var a18: {
->a18 : { new (x: { new (a: number): number; new (a: string): string; }): any[]; new (x: { new (a: boolean): boolean; new (a: Date): Date; }): any[]; }
+>a18 : { new (x: {    new (a: number): number;    new (a: string): string;}): any[]; new (x: {    new (a: boolean): boolean;    new (a: Date): Date;}): any[]; }
 
     new (x: {
 >x : { new (a: number): number; new (a: string): string; }

tests/baselines/reference/assignmentCompatWithConstructSignatures4.types

@@ -81,7 +81,7 @@ module Errors {
 >b : number
 
         var a16: {
->a16 : { new (x: { new (a: number): number; new (a?: number): number; }): number[]; new (x: { new (a: boolean): boolean; new (a?: boolean): boolean; }): boolean[]; }
+>a16 : { new (x: {    new (a: number): number;    new (a?: number): number;}): number[]; new (x: {    new (a: boolean): boolean;    new (a?: boolean): boolean;}): boolean[]; }
 
                 new (x: {
 >x : { new (a: number): number; new (a?: number): number; }