diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 92005a36b655e..fcc4577763477 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -4370,6 +4370,9 @@ namespace ts {
                             return [symbol!];
                         }
                     }
+                    if (meaning !== SymbolFlags.Value && symbolFromSymbolTable.flags & SymbolFlags.TypeAlias && isAccessible(symbolFromSymbolTable, getDeclaredTypeOfTypeAlias(symbolFromSymbolTable).symbol)) {
+                        return [symbolFromSymbolTable];
+                    }
                 });
 
                 // If there's no result and we're looking at the global symbol table, treat `globalThis` like an alias and try to lookup thru that
@@ -5866,9 +5869,6 @@ namespace ts {
                 if (parameterDeclaration && isRequiredInitializedParameter(parameterDeclaration)) {
                     parameterType = getOptionalType(parameterType);
                 }
-                if ((context.flags & NodeBuilderFlags.NoUndefinedOptionalParameterType) && parameterDeclaration && !isJSDocParameterTag(parameterDeclaration) && isOptionalUninitializedParameter(parameterDeclaration)) {
-                    parameterType = getTypeWithFacts(parameterType, TypeFacts.NEUndefined);
-                }
                 const parameterTypeNode = serializeTypeForDeclaration(context, parameterType, parameterSymbol, context.enclosingDeclaration, privateSymbolVisitor, bundledImports);
 
                 const modifiers = !(context.flags & NodeBuilderFlags.OmitParameterModifiers) && preserveModifierFlags && parameterDeclaration && parameterDeclaration.modifiers ? parameterDeclaration.modifiers.map(factory.cloneNode) : undefined;
@@ -6495,7 +6495,7 @@ namespace ts {
                     if (declWithExistingAnnotation && !isFunctionLikeDeclaration(declWithExistingAnnotation) && !isGetAccessorDeclaration(declWithExistingAnnotation)) {
                         // try to reuse the existing annotation
                         const existing = getEffectiveTypeAnnotationNode(declWithExistingAnnotation)!;
-                        if (getTypeFromTypeNode(existing) === type && existingTypeNodeIsNotReferenceOrIsReferenceWithCompatibleTypeArgumentCount(existing, type)) {
+                        if (typeNodeIsEquivalentToType(existing, declWithExistingAnnotation, type) && existingTypeNodeIsNotReferenceOrIsReferenceWithCompatibleTypeArgumentCount(existing, type)) {
                             const result = serializeExistingTypeNode(context, existing, includePrivateSymbol, bundled);
                             if (result) {
                                 return result;
@@ -6513,6 +6513,17 @@ namespace ts {
                 return result;
             }
 
+            function typeNodeIsEquivalentToType(typeNode: TypeNode, annotatedDeclaration: Declaration, type: Type) {
+                const typeFromTypeNode = getTypeFromTypeNode(typeNode);
+                if (typeFromTypeNode === type) {
+                    return true;
+                }
+                if (isParameter(annotatedDeclaration) && annotatedDeclaration.questionToken) {
+                    return getTypeWithFacts(type, TypeFacts.NEUndefined) === typeFromTypeNode;
+                }
+                return false;
+            }
+
             function serializeReturnTypeForSignature(context: NodeBuilderContext, type: Type, signature: Signature, includePrivateSymbol?: (s: Symbol) => void, bundled?: boolean) {
                 if (!isErrorType(type) && context.enclosingDeclaration) {
                     const annotation = signature.declaration && getEffectiveReturnTypeNode(signature.declaration);
@@ -42445,12 +42456,6 @@ namespace ts {
                 hasSyntacticModifier(parameter, ModifierFlags.ParameterPropertyModifier);
         }
 
-        function isOptionalUninitializedParameter(parameter: ParameterDeclaration) {
-            return !!strictNullChecks &&
-                isOptionalParameter(parameter) &&
-                !parameter.initializer;
-        }
-
         function isExpandoFunctionDeclaration(node: Declaration): boolean {
             const declaration = getParseTreeNode(node, isFunctionDeclaration);
             if (!declaration) {
diff --git a/src/compiler/types.ts b/src/compiler/types.ts
index ac4faa72e97bc..d2838a052cc41 100644
--- a/src/compiler/types.ts
+++ b/src/compiler/types.ts
@@ -4488,7 +4488,6 @@ namespace ts {
         UseAliasDefinedOutsideCurrentScope      = 1 << 14,  // Allow non-visible aliases
         UseSingleQuotesForStringLiteralType     = 1 << 28,  // Use single quotes for string literal type
         NoTypeReduction                         = 1 << 29,  // Don't call getReducedType
-        NoUndefinedOptionalParameterType        = 1 << 30,  // Do not add undefined to optional parameter type
 
         // Error handling
         AllowThisInObjectLiteral                = 1 << 15,
diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts
index 2465c336345ae..6d91c2aaf95fc 100644
--- a/src/compiler/utilities.ts
+++ b/src/compiler/utilities.ts
@@ -7655,4 +7655,8 @@ namespace ts {
 
         return state > States.NodeModules ? { topLevelNodeModulesIndex, topLevelPackageNameIndex, packageRootIndex, fileNameIndex } : undefined;
     }
+
+    export function getParameterTypeNode(parameter: ParameterDeclaration | JSDocParameterTag) {
+        return parameter.kind === SyntaxKind.JSDocParameterTag ? parameter.typeExpression?.type : parameter.type;
+    }
 }
diff --git a/src/services/codefixes/helpers.ts b/src/services/codefixes/helpers.ts
index cc6575912beb1..2495d231337f5 100644
--- a/src/services/codefixes/helpers.ts
+++ b/src/services/codefixes/helpers.ts
@@ -192,7 +192,7 @@ namespace ts.codefix {
         const program = context.program;
         const checker = program.getTypeChecker();
         const scriptTarget = getEmitScriptTarget(program.getCompilerOptions());
-        const flags = NodeBuilderFlags.NoTruncation | NodeBuilderFlags.NoUndefinedOptionalParameterType | NodeBuilderFlags.SuppressAnyReturnType | (quotePreference === QuotePreference.Single ? NodeBuilderFlags.UseSingleQuotesForStringLiteralType : 0);
+        const flags = NodeBuilderFlags.NoTruncation | NodeBuilderFlags.SuppressAnyReturnType | (quotePreference === QuotePreference.Single ? NodeBuilderFlags.UseSingleQuotesForStringLiteralType : 0);
         const signatureDeclaration = checker.signatureToSignatureDeclaration(signature, kind, enclosingDeclaration, flags, getNoopSymbolTrackerWithResolver(context)) as ArrowFunction | FunctionExpression | MethodDeclaration;
         if (!signatureDeclaration) {
             return undefined;
diff --git a/tests/baselines/reference/DeclarationErrorsNoEmitOnError.symbols b/tests/baselines/reference/DeclarationErrorsNoEmitOnError.symbols
index f57bd8d6cc415..461087ae03996 100644
--- a/tests/baselines/reference/DeclarationErrorsNoEmitOnError.symbols
+++ b/tests/baselines/reference/DeclarationErrorsNoEmitOnError.symbols
@@ -1,7 +1,7 @@
 === tests/cases/compiler/DeclarationErrorsNoEmitOnError.ts ===
 type T = { x : number }
 >T : Symbol(T, Decl(DeclarationErrorsNoEmitOnError.ts, 0, 0))
->x : Symbol(x, Decl(DeclarationErrorsNoEmitOnError.ts, 0, 10))
+>x : Symbol(T.x, Decl(DeclarationErrorsNoEmitOnError.ts, 0, 10))
 
 export interface I {
 >I : Symbol(I, Decl(DeclarationErrorsNoEmitOnError.ts, 0, 23))
diff --git a/tests/baselines/reference/accessorBodyInTypeContext.symbols b/tests/baselines/reference/accessorBodyInTypeContext.symbols
index 4eb8bfd31289e..2fda96e7b57dd 100644
--- a/tests/baselines/reference/accessorBodyInTypeContext.symbols
+++ b/tests/baselines/reference/accessorBodyInTypeContext.symbols
@@ -3,7 +3,7 @@ type A = {
 >A : Symbol(A, Decl(accessorBodyInTypeContext.ts, 0, 0))
 
     get foo() { return 0 }
->foo : Symbol(foo, Decl(accessorBodyInTypeContext.ts, 0, 10))
+>foo : Symbol(A.foo, Decl(accessorBodyInTypeContext.ts, 0, 10))
 
 };
 
@@ -11,7 +11,7 @@ type B = {
 >B : Symbol(B, Decl(accessorBodyInTypeContext.ts, 2, 2))
 
     set foo(v: any) { }
->foo : Symbol(foo, Decl(accessorBodyInTypeContext.ts, 4, 10))
+>foo : Symbol(B.foo, Decl(accessorBodyInTypeContext.ts, 4, 10))
 >v : Symbol(v, Decl(accessorBodyInTypeContext.ts, 5, 12))
 
 };
diff --git a/tests/baselines/reference/allowJscheckJsTypeParameterNoCrash.symbols b/tests/baselines/reference/allowJscheckJsTypeParameterNoCrash.symbols
index 0926d38c1c457..a278bd20d13f7 100644
--- a/tests/baselines/reference/allowJscheckJsTypeParameterNoCrash.symbols
+++ b/tests/baselines/reference/allowJscheckJsTypeParameterNoCrash.symbols
@@ -40,7 +40,7 @@ export var a = vextend({
 >val : Symbol(val, Decl(app.js, 4, 10))
 
       this.data2 = 1;
->this : Symbol(__type, Decl(lib.es5.d.ts, --, --))
+>this : Symbol(Record, Decl(lib.es5.d.ts, --, --))
 >data2 : Symbol(data2, Decl(app.js, 4, 16), Decl(app.js, 6, 6))
 
     },
diff --git a/tests/baselines/reference/api/tsserverlibrary.d.ts b/tests/baselines/reference/api/tsserverlibrary.d.ts
index a5bd8005936da..5663315abafb8 100644
--- a/tests/baselines/reference/api/tsserverlibrary.d.ts
+++ b/tests/baselines/reference/api/tsserverlibrary.d.ts
@@ -2391,7 +2391,6 @@ declare namespace ts {
         UseAliasDefinedOutsideCurrentScope = 16384,
         UseSingleQuotesForStringLiteralType = 268435456,
         NoTypeReduction = 536870912,
-        NoUndefinedOptionalParameterType = 1073741824,
         AllowThisInObjectLiteral = 32768,
         AllowQualifiedNameInPlaceOfIdentifier = 65536,
         /** @deprecated AllowQualifedNameInPlaceOfIdentifier. Use AllowQualifiedNameInPlaceOfIdentifier instead. */
diff --git a/tests/baselines/reference/api/typescript.d.ts b/tests/baselines/reference/api/typescript.d.ts
index 01ed44a4dfe9b..64f59a8124a1b 100644
--- a/tests/baselines/reference/api/typescript.d.ts
+++ b/tests/baselines/reference/api/typescript.d.ts
@@ -2391,7 +2391,6 @@ declare namespace ts {
         UseAliasDefinedOutsideCurrentScope = 16384,
         UseSingleQuotesForStringLiteralType = 268435456,
         NoTypeReduction = 536870912,
-        NoUndefinedOptionalParameterType = 1073741824,
         AllowThisInObjectLiteral = 32768,
         AllowQualifiedNameInPlaceOfIdentifier = 65536,
         /** @deprecated AllowQualifedNameInPlaceOfIdentifier. Use AllowQualifiedNameInPlaceOfIdentifier instead. */
diff --git a/tests/baselines/reference/argumentsAsPropertyName.symbols b/tests/baselines/reference/argumentsAsPropertyName.symbols
index f55ac5741b69b..16924998656e9 100644
--- a/tests/baselines/reference/argumentsAsPropertyName.symbols
+++ b/tests/baselines/reference/argumentsAsPropertyName.symbols
@@ -4,7 +4,7 @@ type MyType = {
 >MyType : Symbol(MyType, Decl(argumentsAsPropertyName.ts, 0, 0))
 
     arguments: Array<string>
->arguments : Symbol(arguments, Decl(argumentsAsPropertyName.ts, 1, 15))
+>arguments : Symbol(MyType.arguments, Decl(argumentsAsPropertyName.ts, 1, 15))
 >Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 }
 
@@ -24,9 +24,9 @@ function myFunction(myType: MyType) {
 
         use(myType.arguments[i]);
 >use : Symbol(use, Decl(argumentsAsPropertyName.ts, 3, 1))
->myType.arguments : Symbol(arguments, Decl(argumentsAsPropertyName.ts, 1, 15))
+>myType.arguments : Symbol(MyType.arguments, Decl(argumentsAsPropertyName.ts, 1, 15))
 >myType : Symbol(myType, Decl(argumentsAsPropertyName.ts, 7, 20))
->arguments : Symbol(arguments, Decl(argumentsAsPropertyName.ts, 1, 15))
+>arguments : Symbol(MyType.arguments, Decl(argumentsAsPropertyName.ts, 1, 15))
 >i : Symbol(i, Decl(argumentsAsPropertyName.ts, 8, 12))
 
         // create closure so that tsc will turn loop body into function
diff --git a/tests/baselines/reference/arrayFakeFlatNoCrashInferenceDeclarations.types b/tests/baselines/reference/arrayFakeFlatNoCrashInferenceDeclarations.types
index fd8dccc975c77..692e007dd92ba 100644
--- a/tests/baselines/reference/arrayFakeFlatNoCrashInferenceDeclarations.types
+++ b/tests/baselines/reference/arrayFakeFlatNoCrashInferenceDeclarations.types
@@ -19,7 +19,7 @@ type BadFlatArray<Arr, Depth extends number> = {obj: {
 >1 : 1
 
 declare function flat<A, D extends number = 1>(
->flat : <A, D extends number = 1>(arr: A, depth?: D | undefined) => BadFlatArray<A, D>[]
+>flat : <A, D extends number = 1>(arr: A, depth?: D) => BadFlatArray<A, D>[]
 
     arr: A,
 >arr : A
diff --git a/tests/baselines/reference/assertionTypePredicates1.types b/tests/baselines/reference/assertionTypePredicates1.types
index e72b3077c9b95..064cf6066f4dd 100644
--- a/tests/baselines/reference/assertionTypePredicates1.types
+++ b/tests/baselines/reference/assertionTypePredicates1.types
@@ -270,7 +270,7 @@ namespace Debug {
 >Debug : typeof Debug
 
     export declare function assert(value: unknown, message?: string): asserts value;
->assert : (value: unknown, message?: string | undefined) => asserts value
+>assert : (value: unknown, message?: string) => asserts value
 >value : unknown
 >message : string | undefined
 
diff --git a/tests/baselines/reference/assignmentCompatWithDiscriminatedUnion.symbols b/tests/baselines/reference/assignmentCompatWithDiscriminatedUnion.symbols
index 2e62cc8b7afc7..1a9b9f20e3d13 100644
--- a/tests/baselines/reference/assignmentCompatWithDiscriminatedUnion.symbols
+++ b/tests/baselines/reference/assignmentCompatWithDiscriminatedUnion.symbols
@@ -7,8 +7,8 @@ namespace Example1 {
 
     type S = { done: boolean, value: number };
 >S : Symbol(S, Decl(assignmentCompatWithDiscriminatedUnion.ts, 3, 20))
->done : Symbol(done, Decl(assignmentCompatWithDiscriminatedUnion.ts, 4, 14))
->value : Symbol(value, Decl(assignmentCompatWithDiscriminatedUnion.ts, 4, 29))
+>done : Symbol(S.done, Decl(assignmentCompatWithDiscriminatedUnion.ts, 4, 14))
+>value : Symbol(S.value, Decl(assignmentCompatWithDiscriminatedUnion.ts, 4, 29))
 
     type T =
 >T : Symbol(T, Decl(assignmentCompatWithDiscriminatedUnion.ts, 4, 46))
@@ -42,8 +42,8 @@ namespace Example2 {
 
     type S = { a: 0 | 2, b: 4 };
 >S : Symbol(S, Decl(assignmentCompatWithDiscriminatedUnion.ts, 18, 20))
->a : Symbol(a, Decl(assignmentCompatWithDiscriminatedUnion.ts, 19, 14))
->b : Symbol(b, Decl(assignmentCompatWithDiscriminatedUnion.ts, 19, 24))
+>a : Symbol(S.a, Decl(assignmentCompatWithDiscriminatedUnion.ts, 19, 14))
+>b : Symbol(S.b, Decl(assignmentCompatWithDiscriminatedUnion.ts, 19, 24))
 
     type T = { a: 0,     b: 1 | 4 }     // T0
 >T : Symbol(T, Decl(assignmentCompatWithDiscriminatedUnion.ts, 19, 32))
@@ -79,8 +79,8 @@ namespace Example3 {
 
     type S = { a: 0 | 2, b: 4 };
 >S : Symbol(S, Decl(assignmentCompatWithDiscriminatedUnion.ts, 32, 20))
->a : Symbol(a, Decl(assignmentCompatWithDiscriminatedUnion.ts, 33, 14))
->b : Symbol(b, Decl(assignmentCompatWithDiscriminatedUnion.ts, 33, 24))
+>a : Symbol(S.a, Decl(assignmentCompatWithDiscriminatedUnion.ts, 33, 14))
+>b : Symbol(S.b, Decl(assignmentCompatWithDiscriminatedUnion.ts, 33, 24))
 
     type T = { a: 0,     b: 1 | 4 }     // T0
 >T : Symbol(T, Decl(assignmentCompatWithDiscriminatedUnion.ts, 33, 32))
@@ -117,8 +117,8 @@ namespace Example4 {
 
     type S = { a: 0 | 2, b: 4 };
 >S : Symbol(S, Decl(assignmentCompatWithDiscriminatedUnion.ts, 47, 20))
->a : Symbol(a, Decl(assignmentCompatWithDiscriminatedUnion.ts, 48, 14))
->b : Symbol(b, Decl(assignmentCompatWithDiscriminatedUnion.ts, 48, 24))
+>a : Symbol(S.a, Decl(assignmentCompatWithDiscriminatedUnion.ts, 48, 14))
+>b : Symbol(S.b, Decl(assignmentCompatWithDiscriminatedUnion.ts, 48, 24))
 
     type T = { a: 0,     b: 1 | 4 }             // T0
 >T : Symbol(T, Decl(assignmentCompatWithDiscriminatedUnion.ts, 48, 32))
@@ -161,11 +161,11 @@ namespace Example5 {
 
     type S = { a: N, b: N, c: N };
 >S : Symbol(S, Decl(assignmentCompatWithDiscriminatedUnion.ts, 65, 23))
->a : Symbol(a, Decl(assignmentCompatWithDiscriminatedUnion.ts, 66, 14))
+>a : Symbol(S.a, Decl(assignmentCompatWithDiscriminatedUnion.ts, 66, 14))
 >N : Symbol(N, Decl(assignmentCompatWithDiscriminatedUnion.ts, 61, 20))
->b : Symbol(b, Decl(assignmentCompatWithDiscriminatedUnion.ts, 66, 20))
+>b : Symbol(S.b, Decl(assignmentCompatWithDiscriminatedUnion.ts, 66, 20))
 >N : Symbol(N, Decl(assignmentCompatWithDiscriminatedUnion.ts, 61, 20))
->c : Symbol(c, Decl(assignmentCompatWithDiscriminatedUnion.ts, 66, 26))
+>c : Symbol(S.c, Decl(assignmentCompatWithDiscriminatedUnion.ts, 66, 26))
 >N : Symbol(N, Decl(assignmentCompatWithDiscriminatedUnion.ts, 61, 20))
 
     type T = { a: 0, b: N, c: N }
@@ -273,10 +273,10 @@ namespace GH14865 {
 >Style2 : Symbol(Style2, Decl(assignmentCompatWithDiscriminatedUnion.ts, 92, 6))
 
         type: "A" | "B";
->type : Symbol(type, Decl(assignmentCompatWithDiscriminatedUnion.ts, 94, 19))
+>type : Symbol(Style2.type, Decl(assignmentCompatWithDiscriminatedUnion.ts, 94, 19))
 
         data: string;
->data : Symbol(data, Decl(assignmentCompatWithDiscriminatedUnion.ts, 95, 24))
+>data : Symbol(Style2.data, Decl(assignmentCompatWithDiscriminatedUnion.ts, 95, 24))
     }
 
     const a: Style2 = { type: "A", data: "whatevs" };
@@ -290,9 +290,9 @@ namespace GH14865 {
 >Style1 : Symbol(Style1, Decl(assignmentCompatWithDiscriminatedUnion.ts, 85, 19))
 
     a.type; // "A" | "B"
->a.type : Symbol(type, Decl(assignmentCompatWithDiscriminatedUnion.ts, 94, 19))
+>a.type : Symbol(Style2.type, Decl(assignmentCompatWithDiscriminatedUnion.ts, 94, 19))
 >a : Symbol(a, Decl(assignmentCompatWithDiscriminatedUnion.ts, 99, 9))
->type : Symbol(type, Decl(assignmentCompatWithDiscriminatedUnion.ts, 94, 19))
+>type : Symbol(Style2.type, Decl(assignmentCompatWithDiscriminatedUnion.ts, 94, 19))
 
     b.type; // "A" | "B"
 >b.type : Symbol(type, Decl(assignmentCompatWithDiscriminatedUnion.ts, 86, 19), Decl(assignmentCompatWithDiscriminatedUnion.ts, 89, 9))
diff --git a/tests/baselines/reference/asyncFunctionsAndStrictNullChecks.types b/tests/baselines/reference/asyncFunctionsAndStrictNullChecks.types
index 33ccf9c331fcc..f67fe49a61fb0 100644
--- a/tests/baselines/reference/asyncFunctionsAndStrictNullChecks.types
+++ b/tests/baselines/reference/asyncFunctionsAndStrictNullChecks.types
@@ -75,7 +75,7 @@ declare function resolve2<T>(value: T): Windows.Foundation.IPromise<T>;
 >Foundation : any
 
 async function sample2(x?: number) {
->sample2 : (x?: number | undefined) => Promise<void>
+>sample2 : (x?: number) => Promise<void>
 >x : number | undefined
 
     let x1 = await resolve1(x);
diff --git a/tests/baselines/reference/awaitedType.symbols b/tests/baselines/reference/awaitedType.symbols
index 594afc9fc2e82..252f0d5a6ed8f 100644
--- a/tests/baselines/reference/awaitedType.symbols
+++ b/tests/baselines/reference/awaitedType.symbols
@@ -21,7 +21,7 @@ type T4 = Awaited<number | Promise<string>>;
 type T5 = Awaited<{ then: number }>;
 >T5 : Symbol(T5, Decl(awaitedType.ts, 3, 44))
 >Awaited : Symbol(Awaited, Decl(lib.es5.d.ts, --, --))
->then : Symbol(then, Decl(awaitedType.ts, 4, 19))
+>then : Symbol(T5.then, Decl(awaitedType.ts, 4, 19))
 
 type T6 = Awaited<{ then(): void }>; // never (non-promise "thenable")
 >T6 : Symbol(T6, Decl(awaitedType.ts, 4, 36))
diff --git a/tests/baselines/reference/awaitedTypeStrictNull.symbols b/tests/baselines/reference/awaitedTypeStrictNull.symbols
index 8c8225dc122d4..9f29ec6c12912 100644
--- a/tests/baselines/reference/awaitedTypeStrictNull.symbols
+++ b/tests/baselines/reference/awaitedTypeStrictNull.symbols
@@ -21,7 +21,7 @@ type T4 = Awaited<number | Promise<string>>;
 type T5 = Awaited<{ then: number }>;
 >T5 : Symbol(T5, Decl(awaitedTypeStrictNull.ts, 3, 44))
 >Awaited : Symbol(Awaited, Decl(lib.es5.d.ts, --, --))
->then : Symbol(then, Decl(awaitedTypeStrictNull.ts, 4, 19))
+>then : Symbol(T5.then, Decl(awaitedTypeStrictNull.ts, 4, 19))
 
 type T6 = Awaited<{ then(): void }>; // never (non-promise "thenable")
 >T6 : Symbol(T6, Decl(awaitedTypeStrictNull.ts, 4, 36))
diff --git a/tests/baselines/reference/callWithSpread4.symbols b/tests/baselines/reference/callWithSpread4.symbols
index 428f41b17c340..c37a9c2c661ef 100644
--- a/tests/baselines/reference/callWithSpread4.symbols
+++ b/tests/baselines/reference/callWithSpread4.symbols
@@ -1,16 +1,16 @@
 === tests/cases/conformance/expressions/functionCalls/callWithSpread4.ts ===
 type R = { a: number }
 >R : Symbol(R, Decl(callWithSpread4.ts, 0, 0))
->a : Symbol(a, Decl(callWithSpread4.ts, 0, 10))
+>a : Symbol(R.a, Decl(callWithSpread4.ts, 0, 10))
 
 type W = { b: number }
 >W : Symbol(W, Decl(callWithSpread4.ts, 0, 22))
->b : Symbol(b, Decl(callWithSpread4.ts, 1, 10))
+>b : Symbol(W.b, Decl(callWithSpread4.ts, 1, 10))
 
 type RW = { a: number, b: number }
 >RW : Symbol(RW, Decl(callWithSpread4.ts, 1, 22))
->a : Symbol(a, Decl(callWithSpread4.ts, 2, 11))
->b : Symbol(b, Decl(callWithSpread4.ts, 2, 22))
+>a : Symbol(RW.a, Decl(callWithSpread4.ts, 2, 11))
+>b : Symbol(RW.b, Decl(callWithSpread4.ts, 2, 22))
 
 declare const pli: {
 >pli : Symbol(pli, Decl(callWithSpread4.ts, 3, 13))
diff --git a/tests/baselines/reference/callsOnComplexSignatures.types b/tests/baselines/reference/callsOnComplexSignatures.types
index a255300662666..192c64474400f 100644
--- a/tests/baselines/reference/callsOnComplexSignatures.types
+++ b/tests/baselines/reference/callsOnComplexSignatures.types
@@ -110,7 +110,7 @@ function test3(items: string[] | number[]) {
 }
 
 function test4(
->test4 : (arg1: ((...objs: {    x: number;}[]) => number) | ((...objs: {    y: number;}[]) => number), arg2: ((a: {    x: number;}, b: object) => number) | ((a: object, b: {    x: number;}) => number), arg3: ((a: {    x: number;}, ...objs: {    y: number;}[]) => number) | ((...objs: {    x: number;}[]) => number), arg4: ((a?: { x: number; } | undefined, b?: { x: number; } | undefined) => number) | ((a?: { y: number; } | undefined) => number), arg5: ((a?: { x: number; } | undefined, ...b: {    x: number;}[]) => number) | ((a?: { y: number; } | undefined) => number), arg6: ((a?: { x: number; } | undefined, b?: { x: number; } | undefined) => number) | ((...a: {    y: number;}[]) => number)) => void
+>test4 : (arg1: ((...objs: {    x: number;}[]) => number) | ((...objs: {    y: number;}[]) => number), arg2: ((a: {    x: number;}, b: object) => number) | ((a: object, b: {    x: number;}) => number), arg3: ((a: {    x: number;}, ...objs: {    y: number;}[]) => number) | ((...objs: {    x: number;}[]) => number), arg4: ((a?: {    x: number;}, b?: {    x: number;}) => number) | ((a?: {    y: number;}) => number), arg5: ((a?: {    x: number;}, ...b: {    x: number;}[]) => number) | ((a?: {    y: number;}) => number), arg6: ((a?: {    x: number;}, b?: {    x: number;}) => number) | ((...a: {    y: number;}[]) => number)) => void
 
     arg1: ((...objs: {x: number}[]) => number) | ((...objs: {y: number}[]) => number),
 >arg1 : ((...objs: {    x: number;}[]) => number) | ((...objs: {    y: number;}[]) => number)
@@ -138,7 +138,7 @@ function test4(
 >x : number
 
     arg4: ((a?: {x: number}, b?: {x: number}) => number) | ((a?: {y: number}) => number),
->arg4 : ((a?: { x: number; } | undefined, b?: { x: number; } | undefined) => number) | ((a?: { y: number; } | undefined) => number)
+>arg4 : ((a?: {    x: number;}, b?: {    x: number;}) => number) | ((a?: {    y: number;}) => number)
 >a : { x: number; } | undefined
 >x : number
 >b : { x: number; } | undefined
@@ -147,7 +147,7 @@ function test4(
 >y : number
 
     arg5: ((a?: {x: number}, ...b: {x: number}[]) => number) | ((a?: {y: number}) => number),
->arg5 : ((a?: { x: number; } | undefined, ...b: {    x: number;}[]) => number) | ((a?: { y: number; } | undefined) => number)
+>arg5 : ((a?: {    x: number;}, ...b: {    x: number;}[]) => number) | ((a?: {    y: number;}) => number)
 >a : { x: number; } | undefined
 >x : number
 >b : { x: number; }[]
@@ -156,7 +156,7 @@ function test4(
 >y : number
 
     arg6: ((a?: {x: number}, b?: {x: number}) => number) | ((...a: {y: number}[]) => number),
->arg6 : ((a?: { x: number; } | undefined, b?: { x: number; } | undefined) => number) | ((...a: {    y: number;}[]) => number)
+>arg6 : ((a?: {    x: number;}, b?: {    x: number;}) => number) | ((...a: {    y: number;}[]) => number)
 >a : { x: number; } | undefined
 >x : number
 >b : { x: number; } | undefined
@@ -339,7 +339,7 @@ function test5() {
 
     // Pair of non-like intrinsics
     function render(url?: string): React.ReactNode {
->render : (url?: string | undefined) => React.ReactNode
+>render : (url?: string) => React.ReactNode
 >url : string | undefined
 >React : any
 
diff --git a/tests/baselines/reference/caseInsensitiveFileSystemWithCapsImportTypeDeclarations.symbols b/tests/baselines/reference/caseInsensitiveFileSystemWithCapsImportTypeDeclarations.symbols
index 2b5c3accb2712..a903b7c3c0d8c 100644
--- a/tests/baselines/reference/caseInsensitiveFileSystemWithCapsImportTypeDeclarations.symbols
+++ b/tests/baselines/reference/caseInsensitiveFileSystemWithCapsImportTypeDeclarations.symbols
@@ -33,7 +33,7 @@ export type TypeA = {
 >TypeA : Symbol(TypeA, Decl(type-a.ts, 0, 0))
 
     a: string;
->a : Symbol(a, Decl(type-a.ts, 0, 21))
+>a : Symbol(TypeA.a, Decl(type-a.ts, 0, 21))
 }
 === tests/cases/compiler/Uppercased_Dir/src/types.ts ===
 export type Merge<T, U> = T & U;
diff --git a/tests/baselines/reference/checkJsdocTypeTag4.symbols b/tests/baselines/reference/checkJsdocTypeTag4.symbols
index 50e70ad394403..e7da77af23662 100644
--- a/tests/baselines/reference/checkJsdocTypeTag4.symbols
+++ b/tests/baselines/reference/checkJsdocTypeTag4.symbols
@@ -2,7 +2,7 @@
 type A<T extends string> = { a: T }
 >A : Symbol(A, Decl(t.d.ts, 0, 0))
 >T : Symbol(T, Decl(t.d.ts, 0, 7))
->a : Symbol(a, Decl(t.d.ts, 0, 28))
+>a : Symbol(A.a, Decl(t.d.ts, 0, 28))
 >T : Symbol(T, Decl(t.d.ts, 0, 7))
 
 === tests/cases/conformance/jsdoc/test.js ===
diff --git a/tests/baselines/reference/checkJsdocTypedefInParamTag1.symbols b/tests/baselines/reference/checkJsdocTypedefInParamTag1.symbols
index e6f98a76fa316..ca838f18d1cf9 100644
--- a/tests/baselines/reference/checkJsdocTypedefInParamTag1.symbols
+++ b/tests/baselines/reference/checkJsdocTypedefInParamTag1.symbols
@@ -14,9 +14,9 @@ function foo(opts) {
 >opts : Symbol(opts, Decl(0.js, 10, 13))
 
     opts.x;
->opts.x : Symbol(x, Decl(0.js, 3, 3))
+>opts.x : Symbol(Opts.x, Decl(0.js, 3, 3))
 >opts : Symbol(opts, Decl(0.js, 10, 13))
->x : Symbol(x, Decl(0.js, 3, 3))
+>x : Symbol(Opts.x, Decl(0.js, 3, 3))
 }
 
 foo({x: 'abc'});
@@ -35,9 +35,9 @@ function foo1(opts) {
 >opts : Symbol(opts, Decl(0.js, 23, 14))
 
     opts.anotherX;
->opts.anotherX : Symbol(anotherX, Decl(0.js, 18, 3))
+>opts.anotherX : Symbol(AnotherOpts.anotherX, Decl(0.js, 18, 3))
 >opts : Symbol(opts, Decl(0.js, 23, 14))
->anotherX : Symbol(anotherX, Decl(0.js, 18, 3))
+>anotherX : Symbol(AnotherOpts.anotherX, Decl(0.js, 18, 3))
 }
 
 foo1({anotherX: "world"});
@@ -58,9 +58,9 @@ function foo2(opts) {
 >opts : Symbol(opts, Decl(0.js, 38, 14))
 
     opts.x;
->opts.x : Symbol(x, Decl(0.js, 31, 3))
+>opts.x : Symbol(Opts1.x, Decl(0.js, 31, 3))
 >opts : Symbol(opts, Decl(0.js, 38, 14))
->x : Symbol(x, Decl(0.js, 31, 3))
+>x : Symbol(Opts1.x, Decl(0.js, 31, 3))
 }
 foo2({x: 'abc'});
 >foo2 : Symbol(foo2, Decl(0.js, 27, 26))
diff --git a/tests/baselines/reference/checkerInitializationCrash.symbols b/tests/baselines/reference/checkerInitializationCrash.symbols
index 2cd749dd4c3a3..6ee443d423bc2 100644
--- a/tests/baselines/reference/checkerInitializationCrash.symbols
+++ b/tests/baselines/reference/checkerInitializationCrash.symbols
@@ -11,7 +11,7 @@ declare global {
     export import VNode = react.ReactNode;
 >VNode : Symbol(FullCalendarVDom.VNode, Decl(index.d.ts, 2, 30))
 >react : Symbol(react, Decl(index.d.ts, 0, 6))
->ReactNode : Symbol(react.ReactNode, Decl(index.d.ts, 2, 25), Decl(index.d.ts, 2, 30))
+>ReactNode : Symbol(ReactNode, Decl(index.d.ts, 2, 25), Decl(index.d.ts, 2, 30))
   }
 }
 
@@ -30,7 +30,7 @@ declare global {
 >FullCalendarVDom : Symbol(FullCalendarVDom, Decl(index.d.ts, 1, 16), Decl(index.d.ts, 1, 16))
 
     type VNode = preact.VNode<any>;
->VNode : Symbol(React.ReactNode, Decl(index.d.ts, 2, 25), Decl(index.d.ts, 2, 30))
+>VNode : Symbol(ReactNode, Decl(index.d.ts, 2, 25), Decl(index.d.ts, 2, 30))
 >preact : Symbol(preact, Decl(index.d.ts, 0, 6))
 >VNode : Symbol(preact.VNode, Decl(index.d.ts, 0, 27))
   }
diff --git a/tests/baselines/reference/circularAccessorAnnotations.symbols b/tests/baselines/reference/circularAccessorAnnotations.symbols
index b3514fc1ea494..afdf8ff6704d6 100644
--- a/tests/baselines/reference/circularAccessorAnnotations.symbols
+++ b/tests/baselines/reference/circularAccessorAnnotations.symbols
@@ -38,7 +38,7 @@ type T1 = {
 >T1 : Symbol(T1, Decl(circularAccessorAnnotations.ts, 11, 1))
 
     get foo(): T1["foo"];
->foo : Symbol(foo, Decl(circularAccessorAnnotations.ts, 13, 11))
+>foo : Symbol(T1.foo, Decl(circularAccessorAnnotations.ts, 13, 11))
 >T1 : Symbol(T1, Decl(circularAccessorAnnotations.ts, 11, 1))
 }
 
@@ -46,7 +46,7 @@ type T2 = {
 >T2 : Symbol(T2, Decl(circularAccessorAnnotations.ts, 15, 1))
 
     set foo(value: T2["foo"]);
->foo : Symbol(foo, Decl(circularAccessorAnnotations.ts, 17, 11))
+>foo : Symbol(T2.foo, Decl(circularAccessorAnnotations.ts, 17, 11))
 >value : Symbol(value, Decl(circularAccessorAnnotations.ts, 18, 12))
 >T2 : Symbol(T2, Decl(circularAccessorAnnotations.ts, 15, 1))
 }
@@ -55,10 +55,10 @@ type T3 = {
 >T3 : Symbol(T3, Decl(circularAccessorAnnotations.ts, 19, 1))
 
     get foo(): string;
->foo : Symbol(foo, Decl(circularAccessorAnnotations.ts, 21, 11), Decl(circularAccessorAnnotations.ts, 22, 22))
+>foo : Symbol(T3.foo, Decl(circularAccessorAnnotations.ts, 21, 11), Decl(circularAccessorAnnotations.ts, 22, 22))
 
     set foo(value: T3["foo"]);
->foo : Symbol(foo, Decl(circularAccessorAnnotations.ts, 21, 11), Decl(circularAccessorAnnotations.ts, 22, 22))
+>foo : Symbol(T3.foo, Decl(circularAccessorAnnotations.ts, 21, 11), Decl(circularAccessorAnnotations.ts, 22, 22))
 >value : Symbol(value, Decl(circularAccessorAnnotations.ts, 23, 12))
 >T3 : Symbol(T3, Decl(circularAccessorAnnotations.ts, 19, 1))
 }
diff --git a/tests/baselines/reference/circularBaseTypes.symbols b/tests/baselines/reference/circularBaseTypes.symbols
index 9acd4d6928b67..21da811739f76 100644
--- a/tests/baselines/reference/circularBaseTypes.symbols
+++ b/tests/baselines/reference/circularBaseTypes.symbols
@@ -4,7 +4,7 @@
 type M<T> = { value: T };
 >M : Symbol(M, Decl(circularBaseTypes.ts, 0, 0))
 >T : Symbol(T, Decl(circularBaseTypes.ts, 2, 7))
->value : Symbol(value, Decl(circularBaseTypes.ts, 2, 13))
+>value : Symbol(M.value, Decl(circularBaseTypes.ts, 2, 13))
 >T : Symbol(T, Decl(circularBaseTypes.ts, 2, 7))
 
 interface M2 extends M<M3> {};  // Error
diff --git a/tests/baselines/reference/circularIndexedAccessErrors.symbols b/tests/baselines/reference/circularIndexedAccessErrors.symbols
index 469e9f7ceb7e0..ffd5507485755 100644
--- a/tests/baselines/reference/circularIndexedAccessErrors.symbols
+++ b/tests/baselines/reference/circularIndexedAccessErrors.symbols
@@ -3,7 +3,7 @@ type T1 = {
 >T1 : Symbol(T1, Decl(circularIndexedAccessErrors.ts, 0, 0))
 
     x: T1["x"];  // Error
->x : Symbol(x, Decl(circularIndexedAccessErrors.ts, 0, 11))
+>x : Symbol(T1.x, Decl(circularIndexedAccessErrors.ts, 0, 11))
 >T1 : Symbol(T1, Decl(circularIndexedAccessErrors.ts, 0, 0))
 
 };
@@ -13,13 +13,13 @@ type T2<K extends "x" | "y"> = {
 >K : Symbol(K, Decl(circularIndexedAccessErrors.ts, 4, 8))
 
     x: T2<K>[K];  // Error
->x : Symbol(x, Decl(circularIndexedAccessErrors.ts, 4, 32))
+>x : Symbol(T2.x, Decl(circularIndexedAccessErrors.ts, 4, 32))
 >T2 : Symbol(T2, Decl(circularIndexedAccessErrors.ts, 2, 2))
 >K : Symbol(K, Decl(circularIndexedAccessErrors.ts, 4, 8))
 >K : Symbol(K, Decl(circularIndexedAccessErrors.ts, 4, 8))
 
     y: number;
->y : Symbol(y, Decl(circularIndexedAccessErrors.ts, 5, 16))
+>y : Symbol(T2.y, Decl(circularIndexedAccessErrors.ts, 5, 16))
 }
 
 declare let x2: T2<"x">;
@@ -28,9 +28,9 @@ declare let x2: T2<"x">;
 
 let x2x = x2.x;
 >x2x : Symbol(x2x, Decl(circularIndexedAccessErrors.ts, 10, 3))
->x2.x : Symbol(x, Decl(circularIndexedAccessErrors.ts, 4, 32))
+>x2.x : Symbol(T2.x, Decl(circularIndexedAccessErrors.ts, 4, 32))
 >x2 : Symbol(x2, Decl(circularIndexedAccessErrors.ts, 9, 11))
->x : Symbol(x, Decl(circularIndexedAccessErrors.ts, 4, 32))
+>x : Symbol(T2.x, Decl(circularIndexedAccessErrors.ts, 4, 32))
 
 interface T3<T extends T3<T>> {
 >T3 : Symbol(T3, Decl(circularIndexedAccessErrors.ts, 10, 15))
diff --git a/tests/baselines/reference/circularOptionalityRemoval.types b/tests/baselines/reference/circularOptionalityRemoval.types
index 5783b24a6c379..f35bd580699b7 100644
--- a/tests/baselines/reference/circularOptionalityRemoval.types
+++ b/tests/baselines/reference/circularOptionalityRemoval.types
@@ -12,7 +12,7 @@ function fn1(x: number | undefined = x > 0 ? x : 0) { }
 
 // Report from user
 function fn2(x?: string = someCondition ? 'value1' : x) { }
->fn2 : (x?: string | undefined) => void
+>fn2 : (x?: string) => void
 >x : string | undefined
 >someCondition ? 'value1' : x : string | undefined
 >someCondition : any
diff --git a/tests/baselines/reference/coAndContraVariantInferences.symbols b/tests/baselines/reference/coAndContraVariantInferences.symbols
index d41ee57875da9..4e5866564c892 100644
--- a/tests/baselines/reference/coAndContraVariantInferences.symbols
+++ b/tests/baselines/reference/coAndContraVariantInferences.symbols
@@ -1,11 +1,11 @@
 === tests/cases/compiler/coAndContraVariantInferences.ts ===
 type A = { kind: 'a' };
 >A : Symbol(A, Decl(coAndContraVariantInferences.ts, 0, 0))
->kind : Symbol(kind, Decl(coAndContraVariantInferences.ts, 0, 10))
+>kind : Symbol(A.kind, Decl(coAndContraVariantInferences.ts, 0, 10))
 
 type B = { kind: 'b' };
 >B : Symbol(B, Decl(coAndContraVariantInferences.ts, 0, 23))
->kind : Symbol(kind, Decl(coAndContraVariantInferences.ts, 1, 10))
+>kind : Symbol(B.kind, Decl(coAndContraVariantInferences.ts, 1, 10))
 
 declare const a: A;
 >a : Symbol(a, Decl(coAndContraVariantInferences.ts, 3, 13))
diff --git a/tests/baselines/reference/computedPropertyName.symbols b/tests/baselines/reference/computedPropertyName.symbols
index 9a8e912fae160..442156666ee5e 100644
--- a/tests/baselines/reference/computedPropertyName.symbols
+++ b/tests/baselines/reference/computedPropertyName.symbols
@@ -19,7 +19,7 @@ type T = {
 >T : Symbol(T, Decl(component.ts, 4, 1))
 
   [onInit]: any;
->[onInit] : Symbol([onInit], Decl(component.ts, 6, 10))
+>[onInit] : Symbol(T[onInit], Decl(component.ts, 6, 10))
 >onInit : Symbol(onInit, Decl(component.ts, 0, 13))
 }
 
diff --git a/tests/baselines/reference/computedTypesKeyofNoIndexSignatureType.symbols b/tests/baselines/reference/computedTypesKeyofNoIndexSignatureType.symbols
index a329413972d07..e8e26d4ce7867 100644
--- a/tests/baselines/reference/computedTypesKeyofNoIndexSignatureType.symbols
+++ b/tests/baselines/reference/computedTypesKeyofNoIndexSignatureType.symbols
@@ -55,8 +55,8 @@ type IndexObject = { [key: string]: unknown; };
 
 type FooBar = { foo: "hello"; bar: "world"; };
 >FooBar : Symbol(FooBar, Decl(computedTypesKeyofNoIndexSignatureType.ts, 11, 47))
->foo : Symbol(foo, Decl(computedTypesKeyofNoIndexSignatureType.ts, 12, 15))
->bar : Symbol(bar, Decl(computedTypesKeyofNoIndexSignatureType.ts, 12, 29))
+>foo : Symbol(FooBar.foo, Decl(computedTypesKeyofNoIndexSignatureType.ts, 12, 15))
+>bar : Symbol(FooBar.bar, Decl(computedTypesKeyofNoIndexSignatureType.ts, 12, 29))
 
 type WithIndex = Compute<FooBar & IndexObject>;   // { [x: string]: {}; foo: "hello"; bar: "world"; } <-- OK
 >WithIndex : Symbol(WithIndex, Decl(computedTypesKeyofNoIndexSignatureType.ts, 12, 46))
diff --git a/tests/baselines/reference/conditionalTypeAssignabilityWhenDeferred.symbols b/tests/baselines/reference/conditionalTypeAssignabilityWhenDeferred.symbols
index 575e09460c822..095ba81ca9d0b 100644
--- a/tests/baselines/reference/conditionalTypeAssignabilityWhenDeferred.symbols
+++ b/tests/baselines/reference/conditionalTypeAssignabilityWhenDeferred.symbols
@@ -270,7 +270,7 @@ function testAssignabilityToConditionalType<T>() {
 type Wrapped<T> = { ___secret: T };
 >Wrapped : Symbol(Wrapped, Decl(conditionalTypeAssignabilityWhenDeferred.ts, 79, 1))
 >T : Symbol(T, Decl(conditionalTypeAssignabilityWhenDeferred.ts, 81, 13))
->___secret : Symbol(___secret, Decl(conditionalTypeAssignabilityWhenDeferred.ts, 81, 19))
+>___secret : Symbol(Wrapped.___secret, Decl(conditionalTypeAssignabilityWhenDeferred.ts, 81, 19))
 >T : Symbol(T, Decl(conditionalTypeAssignabilityWhenDeferred.ts, 81, 13))
 
 type Unwrap<T> = T extends Wrapped<infer U> ? U : T;
diff --git a/tests/baselines/reference/conditionalTypes1.symbols b/tests/baselines/reference/conditionalTypes1.symbols
index e5c6ae3d6c7f7..abd55674d60cb 100644
--- a/tests/baselines/reference/conditionalTypes1.symbols
+++ b/tests/baselines/reference/conditionalTypes1.symbols
@@ -124,8 +124,8 @@ type Options = { k: "a", a: number } | { k: "b", b: string } | { k: "c", c: bool
 >a : Symbol(a, Decl(conditionalTypes1.ts, 33, 24))
 >k : Symbol(k, Decl(conditionalTypes1.ts, 33, 40))
 >b : Symbol(b, Decl(conditionalTypes1.ts, 33, 48))
->k : Symbol(k, Decl(conditionalTypes1.ts, 33, 64))
->c : Symbol(c, Decl(conditionalTypes1.ts, 33, 72))
+>k : Symbol(T10.k, Decl(conditionalTypes1.ts, 33, 64))
+>c : Symbol(T10.c, Decl(conditionalTypes1.ts, 33, 72))
 
 type T10 = Exclude<Options, { k: "a" | "b" }>;  // { k: "c", c: boolean }
 >T10 : Symbol(T10, Decl(conditionalTypes1.ts, 33, 86))
@@ -254,13 +254,13 @@ type T23 = TypeName<{}>;  // "object"
 type KnockoutObservable<T> = { object: T };
 >KnockoutObservable : Symbol(KnockoutObservable, Decl(conditionalTypes1.ts, 66, 24))
 >T : Symbol(T, Decl(conditionalTypes1.ts, 68, 24))
->object : Symbol(object, Decl(conditionalTypes1.ts, 68, 30))
+>object : Symbol(KnockoutObservable.object, Decl(conditionalTypes1.ts, 68, 30))
 >T : Symbol(T, Decl(conditionalTypes1.ts, 68, 24))
 
 type KnockoutObservableArray<T> = { array: T };
 >KnockoutObservableArray : Symbol(KnockoutObservableArray, Decl(conditionalTypes1.ts, 68, 43))
 >T : Symbol(T, Decl(conditionalTypes1.ts, 69, 29))
->array : Symbol(array, Decl(conditionalTypes1.ts, 69, 35))
+>array : Symbol(KnockoutObservableArray.array, Decl(conditionalTypes1.ts, 69, 35))
 >T : Symbol(T, Decl(conditionalTypes1.ts, 69, 29))
 
 type KnockedOut<T> = T extends any[] ? KnockoutObservableArray<T[number]> : KnockoutObservable<T>;
diff --git a/tests/baselines/reference/conditionalTypes2.symbols b/tests/baselines/reference/conditionalTypes2.symbols
index b085d8b255ea5..f00e526f1e6ea 100644
--- a/tests/baselines/reference/conditionalTypes2.symbols
+++ b/tests/baselines/reference/conditionalTypes2.symbols
@@ -175,11 +175,11 @@ function f12(x: string | (() => string) | undefined) {
 
 type Foo = { foo: string };
 >Foo : Symbol(Foo, Decl(conditionalTypes2.ts, 55, 1))
->foo : Symbol(foo, Decl(conditionalTypes2.ts, 57, 12))
+>foo : Symbol(Foo.foo, Decl(conditionalTypes2.ts, 57, 12))
 
 type Bar = { bar: string };
 >Bar : Symbol(Bar, Decl(conditionalTypes2.ts, 57, 27))
->bar : Symbol(bar, Decl(conditionalTypes2.ts, 58, 12))
+>bar : Symbol(Bar.bar, Decl(conditionalTypes2.ts, 58, 12))
 
 declare function fooBar(x: { foo: string, bar: string }): void;
 >fooBar : Symbol(fooBar, Decl(conditionalTypes2.ts, 58, 27))
@@ -589,9 +589,9 @@ type Product<A extends Union, B> = { f1: A, f2: B};
 >A : Symbol(A, Decl(conditionalTypes2.ts, 159, 13))
 >Union : Symbol(Union, Decl(conditionalTypes2.ts, 154, 36))
 >B : Symbol(B, Decl(conditionalTypes2.ts, 159, 29))
->f1 : Symbol(f1, Decl(conditionalTypes2.ts, 159, 36))
+>f1 : Symbol(Product.f1, Decl(conditionalTypes2.ts, 159, 36))
 >A : Symbol(A, Decl(conditionalTypes2.ts, 159, 13))
->f2 : Symbol(f2, Decl(conditionalTypes2.ts, 159, 43))
+>f2 : Symbol(Product.f2, Decl(conditionalTypes2.ts, 159, 43))
 >B : Symbol(B, Decl(conditionalTypes2.ts, 159, 29))
 
 type ProductUnion = Product<'a', 0> | Product<'b', 1>;
@@ -771,7 +771,7 @@ declare type IResponse<T> = {
 >T : Symbol(T, Decl(conditionalTypes2.ts, 219, 23))
 
 	sendValue(name: keyof GetAllPropertiesOfType<T, string>): void;
->sendValue : Symbol(sendValue, Decl(conditionalTypes2.ts, 219, 29))
+>sendValue : Symbol(IResponse.sendValue, Decl(conditionalTypes2.ts, 219, 29))
 >name : Symbol(name, Decl(conditionalTypes2.ts, 220, 11))
 >GetAllPropertiesOfType : Symbol(GetAllPropertiesOfType, Decl(conditionalTypes2.ts, 225, 28))
 >T : Symbol(T, Decl(conditionalTypes2.ts, 219, 23))
diff --git a/tests/baselines/reference/contextualTypingArrayDestructuringWithDefaults.symbols b/tests/baselines/reference/contextualTypingArrayDestructuringWithDefaults.symbols
index 0e6d0a31569e6..b2d5be7d2bf58 100644
--- a/tests/baselines/reference/contextualTypingArrayDestructuringWithDefaults.symbols
+++ b/tests/baselines/reference/contextualTypingArrayDestructuringWithDefaults.symbols
@@ -1,7 +1,7 @@
 === tests/cases/compiler/contextualTypingArrayDestructuringWithDefaults.ts ===
 type I = { a: "a" };
 >I : Symbol(I, Decl(contextualTypingArrayDestructuringWithDefaults.ts, 0, 0))
->a : Symbol(a, Decl(contextualTypingArrayDestructuringWithDefaults.ts, 0, 10))
+>a : Symbol(I.a, Decl(contextualTypingArrayDestructuringWithDefaults.ts, 0, 10))
 
 let [ c0 = {a: "a"} ]: [I?] = [];
 >c0 : Symbol(c0, Decl(contextualTypingArrayDestructuringWithDefaults.ts, 1, 5))
diff --git a/tests/baselines/reference/contextuallyTypedBooleanLiterals.symbols b/tests/baselines/reference/contextuallyTypedBooleanLiterals.symbols
index da1ec08b5bfcd..2f732d7e04eda 100644
--- a/tests/baselines/reference/contextuallyTypedBooleanLiterals.symbols
+++ b/tests/baselines/reference/contextuallyTypedBooleanLiterals.symbols
@@ -6,11 +6,11 @@ type Box<T> = {
 >T : Symbol(T, Decl(contextuallyTypedBooleanLiterals.ts, 2, 9))
 
     get: () => T,
->get : Symbol(get, Decl(contextuallyTypedBooleanLiterals.ts, 2, 15))
+>get : Symbol(Box.get, Decl(contextuallyTypedBooleanLiterals.ts, 2, 15))
 >T : Symbol(T, Decl(contextuallyTypedBooleanLiterals.ts, 2, 9))
 
     set: (value: T) => void
->set : Symbol(set, Decl(contextuallyTypedBooleanLiterals.ts, 3, 17))
+>set : Symbol(Box.set, Decl(contextuallyTypedBooleanLiterals.ts, 3, 17))
 >value : Symbol(value, Decl(contextuallyTypedBooleanLiterals.ts, 4, 10))
 >T : Symbol(T, Decl(contextuallyTypedBooleanLiterals.ts, 2, 9))
 }
diff --git a/tests/baselines/reference/contextuallyTypedParametersWithInitializers.types b/tests/baselines/reference/contextuallyTypedParametersWithInitializers.types
index db65878b320d3..e39e3bde4d733 100644
--- a/tests/baselines/reference/contextuallyTypedParametersWithInitializers.types
+++ b/tests/baselines/reference/contextuallyTypedParametersWithInitializers.types
@@ -21,7 +21,7 @@ declare function id4<T extends (x: { foo?: number }) => any>(input: T): T;
 >input : T
 
 declare function id5<T extends (x?: number) => any>(input: T): T;
->id5 : <T extends (x?: number | undefined) => any>(input: T) => T
+>id5 : <T extends (x?: number) => any>(input: T) => T
 >x : number | undefined
 >input : T
 
diff --git a/tests/baselines/reference/controlFlowAliasing.types b/tests/baselines/reference/controlFlowAliasing.types
index a3c7f9f7f4f19..fff20fd6389b2 100644
--- a/tests/baselines/reference/controlFlowAliasing.types
+++ b/tests/baselines/reference/controlFlowAliasing.types
@@ -532,7 +532,7 @@ function f27(outer: { obj: { kind: 'foo', foo: string } | { kind: 'bar', bar: nu
 }
 
 function f28(obj?: { kind: 'foo', foo: string } | { kind: 'bar', bar: number }) {
->f28 : (obj?: { kind: 'foo'; foo: string; } | { kind: 'bar'; bar: number; } | undefined) => void
+>f28 : (obj?: {    kind: 'foo';    foo: string;} | {    kind: 'bar';    bar: number;}) => void
 >obj : { kind: 'foo'; foo: string; } | { kind: 'bar'; bar: number; } | undefined
 >kind : "foo"
 >foo : string
diff --git a/tests/baselines/reference/controlFlowForCatchAndFinally.symbols b/tests/baselines/reference/controlFlowForCatchAndFinally.symbols
index f6a6574f36871..bb30be650572a 100644
--- a/tests/baselines/reference/controlFlowForCatchAndFinally.symbols
+++ b/tests/baselines/reference/controlFlowForCatchAndFinally.symbols
@@ -1,14 +1,14 @@
 === tests/cases/compiler/controlFlowForCatchAndFinally.ts ===
 type Page = {close(): Promise<void>; content(): Promise<string>};
 >Page : Symbol(Page, Decl(controlFlowForCatchAndFinally.ts, 0, 0))
->close : Symbol(close, Decl(controlFlowForCatchAndFinally.ts, 0, 13))
+>close : Symbol(Page.close, Decl(controlFlowForCatchAndFinally.ts, 0, 13))
 >Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->content : Symbol(content, Decl(controlFlowForCatchAndFinally.ts, 0, 36))
+>content : Symbol(Page.content, Decl(controlFlowForCatchAndFinally.ts, 0, 36))
 >Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
 
 type Browser = {close(): Promise<void>};
 >Browser : Symbol(Browser, Decl(controlFlowForCatchAndFinally.ts, 0, 65))
->close : Symbol(close, Decl(controlFlowForCatchAndFinally.ts, 1, 16))
+>close : Symbol(Browser.close, Decl(controlFlowForCatchAndFinally.ts, 1, 16))
 >Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
 
 declare function test1(): Promise<Browser>;
@@ -48,27 +48,27 @@ async function test(): Promise<string> {
 >browser : Symbol(browser, Decl(controlFlowForCatchAndFinally.ts, 5, 7))
 
         return await page.content();;
->page.content : Symbol(content, Decl(controlFlowForCatchAndFinally.ts, 0, 36))
+>page.content : Symbol(Page.content, Decl(controlFlowForCatchAndFinally.ts, 0, 36))
 >page : Symbol(page, Decl(controlFlowForCatchAndFinally.ts, 6, 7))
->content : Symbol(content, Decl(controlFlowForCatchAndFinally.ts, 0, 36))
+>content : Symbol(Page.content, Decl(controlFlowForCatchAndFinally.ts, 0, 36))
 
     } finally {
         if (page) {
 >page : Symbol(page, Decl(controlFlowForCatchAndFinally.ts, 6, 7))
 
             await page.close(); // ok
->page.close : Symbol(close, Decl(controlFlowForCatchAndFinally.ts, 0, 13))
+>page.close : Symbol(Page.close, Decl(controlFlowForCatchAndFinally.ts, 0, 13))
 >page : Symbol(page, Decl(controlFlowForCatchAndFinally.ts, 6, 7))
->close : Symbol(close, Decl(controlFlowForCatchAndFinally.ts, 0, 13))
+>close : Symbol(Page.close, Decl(controlFlowForCatchAndFinally.ts, 0, 13))
         }
 
         if (browser) {
 >browser : Symbol(browser, Decl(controlFlowForCatchAndFinally.ts, 5, 7))
 
             await browser.close(); // ok
->browser.close : Symbol(close, Decl(controlFlowForCatchAndFinally.ts, 1, 16))
+>browser.close : Symbol(Browser.close, Decl(controlFlowForCatchAndFinally.ts, 1, 16))
 >browser : Symbol(browser, Decl(controlFlowForCatchAndFinally.ts, 5, 7))
->close : Symbol(close, Decl(controlFlowForCatchAndFinally.ts, 1, 16))
+>close : Symbol(Browser.close, Decl(controlFlowForCatchAndFinally.ts, 1, 16))
         }
     }
 }
diff --git a/tests/baselines/reference/controlFlowForInStatement2.symbols b/tests/baselines/reference/controlFlowForInStatement2.symbols
index 8277e2352d04f..71226846f9616 100644
--- a/tests/baselines/reference/controlFlowForInStatement2.symbols
+++ b/tests/baselines/reference/controlFlowForInStatement2.symbols
@@ -7,12 +7,12 @@ const keywordB = 'b';
 
 type A = { [keywordA]: number };
 >A : Symbol(A, Decl(controlFlowForInStatement2.ts, 1, 21))
->[keywordA] : Symbol([keywordA], Decl(controlFlowForInStatement2.ts, 3, 10))
+>[keywordA] : Symbol(A[keywordA], Decl(controlFlowForInStatement2.ts, 3, 10))
 >keywordA : Symbol(keywordA, Decl(controlFlowForInStatement2.ts, 0, 5))
 
 type B = { [keywordB]: string };
 >B : Symbol(B, Decl(controlFlowForInStatement2.ts, 3, 32))
->[keywordB] : Symbol([keywordB], Decl(controlFlowForInStatement2.ts, 4, 10))
+>[keywordB] : Symbol(B[keywordB], Decl(controlFlowForInStatement2.ts, 4, 10))
 >keywordB : Symbol(keywordB, Decl(controlFlowForInStatement2.ts, 1, 5))
 
 declare const c: A | B;
diff --git a/tests/baselines/reference/controlFlowGenericTypes.symbols b/tests/baselines/reference/controlFlowGenericTypes.symbols
index 1a1edf72f0afc..519e48f4d9bd1 100644
--- a/tests/baselines/reference/controlFlowGenericTypes.symbols
+++ b/tests/baselines/reference/controlFlowGenericTypes.symbols
@@ -215,18 +215,18 @@ export function bounceAndTakeIfA<AB extends 'A' | 'B'>(value: AB): AB {
 
 type Common = { id: number };
 >Common : Symbol(Common, Decl(controlFlowGenericTypes.ts, 69, 1))
->id : Symbol(id, Decl(controlFlowGenericTypes.ts, 73, 15))
+>id : Symbol(Common.id, Decl(controlFlowGenericTypes.ts, 73, 15))
 
 type AA = { tag: 'A', id: number };
 >AA : Symbol(AA, Decl(controlFlowGenericTypes.ts, 73, 29))
->tag : Symbol(tag, Decl(controlFlowGenericTypes.ts, 74, 11))
->id : Symbol(id, Decl(controlFlowGenericTypes.ts, 74, 21))
+>tag : Symbol(AA.tag, Decl(controlFlowGenericTypes.ts, 74, 11))
+>id : Symbol(AA.id, Decl(controlFlowGenericTypes.ts, 74, 21))
 
 type BB = { tag: 'B', id: number, foo: number };
 >BB : Symbol(BB, Decl(controlFlowGenericTypes.ts, 74, 35))
->tag : Symbol(tag, Decl(controlFlowGenericTypes.ts, 75, 11))
->id : Symbol(id, Decl(controlFlowGenericTypes.ts, 75, 21))
->foo : Symbol(foo, Decl(controlFlowGenericTypes.ts, 75, 33))
+>tag : Symbol(BB.tag, Decl(controlFlowGenericTypes.ts, 75, 11))
+>id : Symbol(BB.id, Decl(controlFlowGenericTypes.ts, 75, 21))
+>foo : Symbol(BB.foo, Decl(controlFlowGenericTypes.ts, 75, 33))
 
 type MyUnion = AA | BB;
 >MyUnion : Symbol(MyUnion, Decl(controlFlowGenericTypes.ts, 75, 48))
@@ -245,9 +245,9 @@ const fn = (value: MyUnion) => {
 >value : Symbol(value, Decl(controlFlowGenericTypes.ts, 79, 12))
 
         value.foo;
->value.foo : Symbol(foo, Decl(controlFlowGenericTypes.ts, 75, 33))
+>value.foo : Symbol(BB.foo, Decl(controlFlowGenericTypes.ts, 75, 33))
 >value : Symbol(value, Decl(controlFlowGenericTypes.ts, 79, 12))
->foo : Symbol(foo, Decl(controlFlowGenericTypes.ts, 75, 33))
+>foo : Symbol(BB.foo, Decl(controlFlowGenericTypes.ts, 75, 33))
     }
     if (value.tag === 'B') {
 >value.tag : Symbol(tag, Decl(controlFlowGenericTypes.ts, 74, 11), Decl(controlFlowGenericTypes.ts, 75, 11))
@@ -255,9 +255,9 @@ const fn = (value: MyUnion) => {
 >tag : Symbol(tag, Decl(controlFlowGenericTypes.ts, 74, 11), Decl(controlFlowGenericTypes.ts, 75, 11))
 
         value.foo;
->value.foo : Symbol(foo, Decl(controlFlowGenericTypes.ts, 75, 33))
+>value.foo : Symbol(BB.foo, Decl(controlFlowGenericTypes.ts, 75, 33))
 >value : Symbol(value, Decl(controlFlowGenericTypes.ts, 79, 12))
->foo : Symbol(foo, Decl(controlFlowGenericTypes.ts, 75, 33))
+>foo : Symbol(BB.foo, Decl(controlFlowGenericTypes.ts, 75, 33))
     }
 };
 
@@ -276,9 +276,9 @@ const fn2 = <T extends MyUnion>(value: T): MyUnion => {
 >value : Symbol(value, Decl(controlFlowGenericTypes.ts, 89, 32))
 
         value.foo;
->value.foo : Symbol(foo, Decl(controlFlowGenericTypes.ts, 75, 33))
+>value.foo : Symbol(BB.foo, Decl(controlFlowGenericTypes.ts, 75, 33))
 >value : Symbol(value, Decl(controlFlowGenericTypes.ts, 89, 32))
->foo : Symbol(foo, Decl(controlFlowGenericTypes.ts, 75, 33))
+>foo : Symbol(BB.foo, Decl(controlFlowGenericTypes.ts, 75, 33))
     }
     if (value.tag === 'B') {
 >value.tag : Symbol(tag, Decl(controlFlowGenericTypes.ts, 74, 11), Decl(controlFlowGenericTypes.ts, 75, 11))
@@ -286,9 +286,9 @@ const fn2 = <T extends MyUnion>(value: T): MyUnion => {
 >tag : Symbol(tag, Decl(controlFlowGenericTypes.ts, 74, 11), Decl(controlFlowGenericTypes.ts, 75, 11))
 
         value.foo;
->value.foo : Symbol(foo, Decl(controlFlowGenericTypes.ts, 75, 33))
+>value.foo : Symbol(BB.foo, Decl(controlFlowGenericTypes.ts, 75, 33))
 >value : Symbol(value, Decl(controlFlowGenericTypes.ts, 89, 32))
->foo : Symbol(foo, Decl(controlFlowGenericTypes.ts, 75, 33))
+>foo : Symbol(BB.foo, Decl(controlFlowGenericTypes.ts, 75, 33))
     }
 };
 
@@ -298,16 +298,16 @@ type A1 = {
 >A1 : Symbol(A1, Decl(controlFlowGenericTypes.ts, 97, 2))
 
     testable: true
->testable : Symbol(testable, Decl(controlFlowGenericTypes.ts, 101, 11))
+>testable : Symbol(A1.testable, Decl(controlFlowGenericTypes.ts, 101, 11))
 
     doTest: () => void
->doTest : Symbol(doTest, Decl(controlFlowGenericTypes.ts, 102, 18))
+>doTest : Symbol(A1.doTest, Decl(controlFlowGenericTypes.ts, 102, 18))
 }
 type B1 = {
 >B1 : Symbol(B1, Decl(controlFlowGenericTypes.ts, 104, 1))
 
     testable: false
->testable : Symbol(testable, Decl(controlFlowGenericTypes.ts, 105, 11))
+>testable : Symbol(B1.testable, Decl(controlFlowGenericTypes.ts, 105, 11))
 
 };
 
@@ -329,9 +329,9 @@ function notWorking<T extends Union>(object: T) {
 >testable : Symbol(testable, Decl(controlFlowGenericTypes.ts, 101, 11), Decl(controlFlowGenericTypes.ts, 105, 11))
 
     object.doTest();
->object.doTest : Symbol(doTest, Decl(controlFlowGenericTypes.ts, 102, 18))
+>object.doTest : Symbol(A1.doTest, Decl(controlFlowGenericTypes.ts, 102, 18))
 >object : Symbol(object, Decl(controlFlowGenericTypes.ts, 111, 37))
->doTest : Symbol(doTest, Decl(controlFlowGenericTypes.ts, 102, 18))
+>doTest : Symbol(A1.doTest, Decl(controlFlowGenericTypes.ts, 102, 18))
 }
 
 // Repro from #42939
diff --git a/tests/baselines/reference/controlFlowInOperator.symbols b/tests/baselines/reference/controlFlowInOperator.symbols
index 03b0e4b40b4b5..408d029e5213f 100644
--- a/tests/baselines/reference/controlFlowInOperator.symbols
+++ b/tests/baselines/reference/controlFlowInOperator.symbols
@@ -10,12 +10,12 @@ const d = 'd';
 
 type A = { [a]: number; };
 >A : Symbol(A, Decl(controlFlowInOperator.ts, 2, 14))
->[a] : Symbol([a], Decl(controlFlowInOperator.ts, 4, 10))
+>[a] : Symbol(A[a], Decl(controlFlowInOperator.ts, 4, 10))
 >a : Symbol(a, Decl(controlFlowInOperator.ts, 0, 5))
 
 type B = { [b]: string; };
 >B : Symbol(B, Decl(controlFlowInOperator.ts, 4, 26))
->[b] : Symbol([b], Decl(controlFlowInOperator.ts, 5, 10))
+>[b] : Symbol(B[b], Decl(controlFlowInOperator.ts, 5, 10))
 >b : Symbol(b, Decl(controlFlowInOperator.ts, 1, 5))
 
 declare const c: A | B;
@@ -31,7 +31,7 @@ if ('a' in c) {
 
     c['a']; // number;
 >c : Symbol(c, Decl(controlFlowInOperator.ts, 7, 13))
->'a' : Symbol([a], Decl(controlFlowInOperator.ts, 4, 10))
+>'a' : Symbol(A[a], Decl(controlFlowInOperator.ts, 4, 10))
 }
 
 if ('d' in c) {
diff --git a/tests/baselines/reference/controlFlowOptionalChain.symbols b/tests/baselines/reference/controlFlowOptionalChain.symbols
index be03f36c67da6..806ecf63c5579 100644
--- a/tests/baselines/reference/controlFlowOptionalChain.symbols
+++ b/tests/baselines/reference/controlFlowOptionalChain.symbols
@@ -602,9 +602,9 @@ function f01(x: unknown) {
 
 type Thing = { foo: string | number, bar(): number, baz: object };
 >Thing : Symbol(Thing, Decl(controlFlowOptionalChain.ts, 159, 1))
->foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
->bar : Symbol(bar, Decl(controlFlowOptionalChain.ts, 161, 36))
->baz : Symbol(baz, Decl(controlFlowOptionalChain.ts, 161, 51))
+>foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>bar : Symbol(Thing.bar, Decl(controlFlowOptionalChain.ts, 161, 36))
+>baz : Symbol(Thing.baz, Decl(controlFlowOptionalChain.ts, 161, 51))
 
 function f10(o: Thing | undefined, value: number) {
 >f10 : Symbol(f10, Decl(controlFlowOptionalChain.ts, 161, 66))
@@ -613,15 +613,15 @@ function f10(o: Thing | undefined, value: number) {
 >value : Symbol(value, Decl(controlFlowOptionalChain.ts, 163, 34))
 
     if (o?.foo === value) {
->o?.foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>o?.foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 163, 13))
->foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >value : Symbol(value, Decl(controlFlowOptionalChain.ts, 163, 34))
 
         o.foo;
->o.foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>o.foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 163, 13))
->foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
     }
     if (o?.["foo"] === value) {
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 163, 13))
@@ -629,29 +629,29 @@ function f10(o: Thing | undefined, value: number) {
 
         o["foo"];
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 163, 13))
->"foo" : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>"foo" : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
     }
     if (o?.bar() === value) {
->o?.bar : Symbol(bar, Decl(controlFlowOptionalChain.ts, 161, 36))
+>o?.bar : Symbol(Thing.bar, Decl(controlFlowOptionalChain.ts, 161, 36))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 163, 13))
->bar : Symbol(bar, Decl(controlFlowOptionalChain.ts, 161, 36))
+>bar : Symbol(Thing.bar, Decl(controlFlowOptionalChain.ts, 161, 36))
 >value : Symbol(value, Decl(controlFlowOptionalChain.ts, 163, 34))
 
         o.bar;
->o.bar : Symbol(bar, Decl(controlFlowOptionalChain.ts, 161, 36))
+>o.bar : Symbol(Thing.bar, Decl(controlFlowOptionalChain.ts, 161, 36))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 163, 13))
->bar : Symbol(bar, Decl(controlFlowOptionalChain.ts, 161, 36))
+>bar : Symbol(Thing.bar, Decl(controlFlowOptionalChain.ts, 161, 36))
     }
     if (o?.foo == value) {
->o?.foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>o?.foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 163, 13))
->foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >value : Symbol(value, Decl(controlFlowOptionalChain.ts, 163, 34))
 
         o.foo;
->o.foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>o.foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 163, 13))
->foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
     }
     if (o?.["foo"] == value) {
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 163, 13))
@@ -659,18 +659,18 @@ function f10(o: Thing | undefined, value: number) {
 
         o["foo"];
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 163, 13))
->"foo" : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>"foo" : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
     }
     if (o?.bar() == value) {
->o?.bar : Symbol(bar, Decl(controlFlowOptionalChain.ts, 161, 36))
+>o?.bar : Symbol(Thing.bar, Decl(controlFlowOptionalChain.ts, 161, 36))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 163, 13))
->bar : Symbol(bar, Decl(controlFlowOptionalChain.ts, 161, 36))
+>bar : Symbol(Thing.bar, Decl(controlFlowOptionalChain.ts, 161, 36))
 >value : Symbol(value, Decl(controlFlowOptionalChain.ts, 163, 34))
 
         o.bar;
->o.bar : Symbol(bar, Decl(controlFlowOptionalChain.ts, 161, 36))
+>o.bar : Symbol(Thing.bar, Decl(controlFlowOptionalChain.ts, 161, 36))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 163, 13))
->bar : Symbol(bar, Decl(controlFlowOptionalChain.ts, 161, 36))
+>bar : Symbol(Thing.bar, Decl(controlFlowOptionalChain.ts, 161, 36))
     }
 }
 
@@ -681,15 +681,15 @@ function f11(o: Thing | null, value: number) {
 >value : Symbol(value, Decl(controlFlowOptionalChain.ts, 184, 29))
 
     if (o?.foo === value) {
->o?.foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>o?.foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 184, 13))
->foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >value : Symbol(value, Decl(controlFlowOptionalChain.ts, 184, 29))
 
         o.foo;
->o.foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>o.foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 184, 13))
->foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
     }
     if (o?.["foo"] === value) {
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 184, 13))
@@ -697,29 +697,29 @@ function f11(o: Thing | null, value: number) {
 
         o["foo"];
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 184, 13))
->"foo" : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>"foo" : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
     }
     if (o?.bar() === value) {
->o?.bar : Symbol(bar, Decl(controlFlowOptionalChain.ts, 161, 36))
+>o?.bar : Symbol(Thing.bar, Decl(controlFlowOptionalChain.ts, 161, 36))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 184, 13))
->bar : Symbol(bar, Decl(controlFlowOptionalChain.ts, 161, 36))
+>bar : Symbol(Thing.bar, Decl(controlFlowOptionalChain.ts, 161, 36))
 >value : Symbol(value, Decl(controlFlowOptionalChain.ts, 184, 29))
 
         o.bar;
->o.bar : Symbol(bar, Decl(controlFlowOptionalChain.ts, 161, 36))
+>o.bar : Symbol(Thing.bar, Decl(controlFlowOptionalChain.ts, 161, 36))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 184, 13))
->bar : Symbol(bar, Decl(controlFlowOptionalChain.ts, 161, 36))
+>bar : Symbol(Thing.bar, Decl(controlFlowOptionalChain.ts, 161, 36))
     }
     if (o?.foo == value) {
->o?.foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>o?.foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 184, 13))
->foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >value : Symbol(value, Decl(controlFlowOptionalChain.ts, 184, 29))
 
         o.foo;
->o.foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>o.foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 184, 13))
->foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
     }
     if (o?.["foo"] == value) {
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 184, 13))
@@ -727,18 +727,18 @@ function f11(o: Thing | null, value: number) {
 
         o["foo"];
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 184, 13))
->"foo" : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>"foo" : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
     }
     if (o?.bar() == value) {
->o?.bar : Symbol(bar, Decl(controlFlowOptionalChain.ts, 161, 36))
+>o?.bar : Symbol(Thing.bar, Decl(controlFlowOptionalChain.ts, 161, 36))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 184, 13))
->bar : Symbol(bar, Decl(controlFlowOptionalChain.ts, 161, 36))
+>bar : Symbol(Thing.bar, Decl(controlFlowOptionalChain.ts, 161, 36))
 >value : Symbol(value, Decl(controlFlowOptionalChain.ts, 184, 29))
 
         o.bar;
->o.bar : Symbol(bar, Decl(controlFlowOptionalChain.ts, 161, 36))
+>o.bar : Symbol(Thing.bar, Decl(controlFlowOptionalChain.ts, 161, 36))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 184, 13))
->bar : Symbol(bar, Decl(controlFlowOptionalChain.ts, 161, 36))
+>bar : Symbol(Thing.bar, Decl(controlFlowOptionalChain.ts, 161, 36))
     }
 }
 
@@ -749,15 +749,15 @@ function f12(o: Thing | undefined, value: number | undefined) {
 >value : Symbol(value, Decl(controlFlowOptionalChain.ts, 205, 34))
 
     if (o?.foo === value) {
->o?.foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>o?.foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 205, 13))
->foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >value : Symbol(value, Decl(controlFlowOptionalChain.ts, 205, 34))
 
         o.foo;  // Error
->o.foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>o.foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 205, 13))
->foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
     }
     if (o?.["foo"] === value) {
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 205, 13))
@@ -767,26 +767,26 @@ function f12(o: Thing | undefined, value: number | undefined) {
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 205, 13))
     }
     if (o?.bar() === value) {
->o?.bar : Symbol(bar, Decl(controlFlowOptionalChain.ts, 161, 36))
+>o?.bar : Symbol(Thing.bar, Decl(controlFlowOptionalChain.ts, 161, 36))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 205, 13))
->bar : Symbol(bar, Decl(controlFlowOptionalChain.ts, 161, 36))
+>bar : Symbol(Thing.bar, Decl(controlFlowOptionalChain.ts, 161, 36))
 >value : Symbol(value, Decl(controlFlowOptionalChain.ts, 205, 34))
 
         o.bar;  // Error
->o.bar : Symbol(bar, Decl(controlFlowOptionalChain.ts, 161, 36))
+>o.bar : Symbol(Thing.bar, Decl(controlFlowOptionalChain.ts, 161, 36))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 205, 13))
->bar : Symbol(bar, Decl(controlFlowOptionalChain.ts, 161, 36))
+>bar : Symbol(Thing.bar, Decl(controlFlowOptionalChain.ts, 161, 36))
     }
     if (o?.foo == value) {
->o?.foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>o?.foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 205, 13))
->foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >value : Symbol(value, Decl(controlFlowOptionalChain.ts, 205, 34))
 
         o.foo;  // Error
->o.foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>o.foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 205, 13))
->foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
     }
     if (o?.["foo"] == value) {
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 205, 13))
@@ -796,15 +796,15 @@ function f12(o: Thing | undefined, value: number | undefined) {
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 205, 13))
     }
     if (o?.bar() == value) {
->o?.bar : Symbol(bar, Decl(controlFlowOptionalChain.ts, 161, 36))
+>o?.bar : Symbol(Thing.bar, Decl(controlFlowOptionalChain.ts, 161, 36))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 205, 13))
->bar : Symbol(bar, Decl(controlFlowOptionalChain.ts, 161, 36))
+>bar : Symbol(Thing.bar, Decl(controlFlowOptionalChain.ts, 161, 36))
 >value : Symbol(value, Decl(controlFlowOptionalChain.ts, 205, 34))
 
         o.bar;  // Error
->o.bar : Symbol(bar, Decl(controlFlowOptionalChain.ts, 161, 36))
+>o.bar : Symbol(Thing.bar, Decl(controlFlowOptionalChain.ts, 161, 36))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 205, 13))
->bar : Symbol(bar, Decl(controlFlowOptionalChain.ts, 161, 36))
+>bar : Symbol(Thing.bar, Decl(controlFlowOptionalChain.ts, 161, 36))
     }
 }
 
@@ -815,15 +815,15 @@ function f12a(o: Thing | undefined, value: number | null) {
 >value : Symbol(value, Decl(controlFlowOptionalChain.ts, 226, 35))
 
     if (o?.foo === value) {
->o?.foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>o?.foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 226, 14))
->foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >value : Symbol(value, Decl(controlFlowOptionalChain.ts, 226, 35))
 
         o.foo;
->o.foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>o.foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 226, 14))
->foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
     }
     if (o?.["foo"] === value) {
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 226, 14))
@@ -831,29 +831,29 @@ function f12a(o: Thing | undefined, value: number | null) {
 
         o["foo"];
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 226, 14))
->"foo" : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>"foo" : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
     }
     if (o?.bar() === value) {
->o?.bar : Symbol(bar, Decl(controlFlowOptionalChain.ts, 161, 36))
+>o?.bar : Symbol(Thing.bar, Decl(controlFlowOptionalChain.ts, 161, 36))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 226, 14))
->bar : Symbol(bar, Decl(controlFlowOptionalChain.ts, 161, 36))
+>bar : Symbol(Thing.bar, Decl(controlFlowOptionalChain.ts, 161, 36))
 >value : Symbol(value, Decl(controlFlowOptionalChain.ts, 226, 35))
 
         o.bar;
->o.bar : Symbol(bar, Decl(controlFlowOptionalChain.ts, 161, 36))
+>o.bar : Symbol(Thing.bar, Decl(controlFlowOptionalChain.ts, 161, 36))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 226, 14))
->bar : Symbol(bar, Decl(controlFlowOptionalChain.ts, 161, 36))
+>bar : Symbol(Thing.bar, Decl(controlFlowOptionalChain.ts, 161, 36))
     }
     if (o?.foo == value) {
->o?.foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>o?.foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 226, 14))
->foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >value : Symbol(value, Decl(controlFlowOptionalChain.ts, 226, 35))
 
         o.foo;  // Error
->o.foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>o.foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 226, 14))
->foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
     }
     if (o?.["foo"] == value) {
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 226, 14))
@@ -863,15 +863,15 @@ function f12a(o: Thing | undefined, value: number | null) {
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 226, 14))
     }
     if (o?.bar() == value) {
->o?.bar : Symbol(bar, Decl(controlFlowOptionalChain.ts, 161, 36))
+>o?.bar : Symbol(Thing.bar, Decl(controlFlowOptionalChain.ts, 161, 36))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 226, 14))
->bar : Symbol(bar, Decl(controlFlowOptionalChain.ts, 161, 36))
+>bar : Symbol(Thing.bar, Decl(controlFlowOptionalChain.ts, 161, 36))
 >value : Symbol(value, Decl(controlFlowOptionalChain.ts, 226, 35))
 
         o.bar;  // Error
->o.bar : Symbol(bar, Decl(controlFlowOptionalChain.ts, 161, 36))
+>o.bar : Symbol(Thing.bar, Decl(controlFlowOptionalChain.ts, 161, 36))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 226, 14))
->bar : Symbol(bar, Decl(controlFlowOptionalChain.ts, 161, 36))
+>bar : Symbol(Thing.bar, Decl(controlFlowOptionalChain.ts, 161, 36))
     }
 }
 
@@ -881,15 +881,15 @@ function f13(o: Thing | undefined) {
 >Thing : Symbol(Thing, Decl(controlFlowOptionalChain.ts, 159, 1))
 
     if (o?.foo !== undefined) {
->o?.foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>o?.foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 247, 13))
->foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >undefined : Symbol(undefined)
 
         o.foo;
->o.foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>o.foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 247, 13))
->foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
     }
     if (o?.["foo"] !== undefined) {
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 247, 13))
@@ -897,29 +897,29 @@ function f13(o: Thing | undefined) {
 
         o["foo"];
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 247, 13))
->"foo" : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>"foo" : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
     }
     if (o?.bar() !== undefined) {
->o?.bar : Symbol(bar, Decl(controlFlowOptionalChain.ts, 161, 36))
+>o?.bar : Symbol(Thing.bar, Decl(controlFlowOptionalChain.ts, 161, 36))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 247, 13))
->bar : Symbol(bar, Decl(controlFlowOptionalChain.ts, 161, 36))
+>bar : Symbol(Thing.bar, Decl(controlFlowOptionalChain.ts, 161, 36))
 >undefined : Symbol(undefined)
 
         o.bar;
->o.bar : Symbol(bar, Decl(controlFlowOptionalChain.ts, 161, 36))
+>o.bar : Symbol(Thing.bar, Decl(controlFlowOptionalChain.ts, 161, 36))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 247, 13))
->bar : Symbol(bar, Decl(controlFlowOptionalChain.ts, 161, 36))
+>bar : Symbol(Thing.bar, Decl(controlFlowOptionalChain.ts, 161, 36))
     }
     if (o?.foo != undefined) {
->o?.foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>o?.foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 247, 13))
->foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >undefined : Symbol(undefined)
 
         o.foo;
->o.foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>o.foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 247, 13))
->foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
     }
     if (o?.["foo"] != undefined) {
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 247, 13))
@@ -927,18 +927,18 @@ function f13(o: Thing | undefined) {
 
         o["foo"];
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 247, 13))
->"foo" : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>"foo" : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
     }
     if (o?.bar() != undefined) {
->o?.bar : Symbol(bar, Decl(controlFlowOptionalChain.ts, 161, 36))
+>o?.bar : Symbol(Thing.bar, Decl(controlFlowOptionalChain.ts, 161, 36))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 247, 13))
->bar : Symbol(bar, Decl(controlFlowOptionalChain.ts, 161, 36))
+>bar : Symbol(Thing.bar, Decl(controlFlowOptionalChain.ts, 161, 36))
 >undefined : Symbol(undefined)
 
         o.bar;
->o.bar : Symbol(bar, Decl(controlFlowOptionalChain.ts, 161, 36))
+>o.bar : Symbol(Thing.bar, Decl(controlFlowOptionalChain.ts, 161, 36))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 247, 13))
->bar : Symbol(bar, Decl(controlFlowOptionalChain.ts, 161, 36))
+>bar : Symbol(Thing.bar, Decl(controlFlowOptionalChain.ts, 161, 36))
     }
 }
 
@@ -948,14 +948,14 @@ function f13a(o: Thing | undefined) {
 >Thing : Symbol(Thing, Decl(controlFlowOptionalChain.ts, 159, 1))
 
     if (o?.foo !== null) {
->o?.foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>o?.foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 268, 14))
->foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 
         o.foo;  // Error
->o.foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>o.foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 268, 14))
->foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
     }
     if (o?.["foo"] !== null) {
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 268, 14))
@@ -964,41 +964,41 @@ function f13a(o: Thing | undefined) {
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 268, 14))
     }
     if (o?.bar() !== null) {
->o?.bar : Symbol(bar, Decl(controlFlowOptionalChain.ts, 161, 36))
+>o?.bar : Symbol(Thing.bar, Decl(controlFlowOptionalChain.ts, 161, 36))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 268, 14))
->bar : Symbol(bar, Decl(controlFlowOptionalChain.ts, 161, 36))
+>bar : Symbol(Thing.bar, Decl(controlFlowOptionalChain.ts, 161, 36))
 
         o.bar;  // Error
->o.bar : Symbol(bar, Decl(controlFlowOptionalChain.ts, 161, 36))
+>o.bar : Symbol(Thing.bar, Decl(controlFlowOptionalChain.ts, 161, 36))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 268, 14))
->bar : Symbol(bar, Decl(controlFlowOptionalChain.ts, 161, 36))
+>bar : Symbol(Thing.bar, Decl(controlFlowOptionalChain.ts, 161, 36))
     }
     if (o?.foo != null) {
->o?.foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>o?.foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 268, 14))
->foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 
         o.foo;
->o.foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>o.foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 268, 14))
->foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
     }
     if (o?.["foo"] != null) {
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 268, 14))
 
         o["foo"];
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 268, 14))
->"foo" : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>"foo" : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
     }
     if (o?.bar() != null) {
->o?.bar : Symbol(bar, Decl(controlFlowOptionalChain.ts, 161, 36))
+>o?.bar : Symbol(Thing.bar, Decl(controlFlowOptionalChain.ts, 161, 36))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 268, 14))
->bar : Symbol(bar, Decl(controlFlowOptionalChain.ts, 161, 36))
+>bar : Symbol(Thing.bar, Decl(controlFlowOptionalChain.ts, 161, 36))
 
         o.bar;
->o.bar : Symbol(bar, Decl(controlFlowOptionalChain.ts, 161, 36))
+>o.bar : Symbol(Thing.bar, Decl(controlFlowOptionalChain.ts, 161, 36))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 268, 14))
->bar : Symbol(bar, Decl(controlFlowOptionalChain.ts, 161, 36))
+>bar : Symbol(Thing.bar, Decl(controlFlowOptionalChain.ts, 161, 36))
     }
 }
 
@@ -1008,15 +1008,15 @@ function f14(o: Thing | null) {
 >Thing : Symbol(Thing, Decl(controlFlowOptionalChain.ts, 159, 1))
 
     if (o?.foo !== undefined) {
->o?.foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>o?.foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 289, 13))
->foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >undefined : Symbol(undefined)
 
         o.foo;
->o.foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>o.foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 289, 13))
->foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
     }
     if (o?.["foo"] !== undefined) {
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 289, 13))
@@ -1024,18 +1024,18 @@ function f14(o: Thing | null) {
 
         o["foo"];
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 289, 13))
->"foo" : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>"foo" : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
     }
     if (o?.bar() !== undefined) {
->o?.bar : Symbol(bar, Decl(controlFlowOptionalChain.ts, 161, 36))
+>o?.bar : Symbol(Thing.bar, Decl(controlFlowOptionalChain.ts, 161, 36))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 289, 13))
->bar : Symbol(bar, Decl(controlFlowOptionalChain.ts, 161, 36))
+>bar : Symbol(Thing.bar, Decl(controlFlowOptionalChain.ts, 161, 36))
 >undefined : Symbol(undefined)
 
         o.bar;
->o.bar : Symbol(bar, Decl(controlFlowOptionalChain.ts, 161, 36))
+>o.bar : Symbol(Thing.bar, Decl(controlFlowOptionalChain.ts, 161, 36))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 289, 13))
->bar : Symbol(bar, Decl(controlFlowOptionalChain.ts, 161, 36))
+>bar : Symbol(Thing.bar, Decl(controlFlowOptionalChain.ts, 161, 36))
     }
 }
 
@@ -1046,72 +1046,72 @@ function f15(o: Thing | undefined, value: number) {
 >value : Symbol(value, Decl(controlFlowOptionalChain.ts, 301, 34))
 
     if (o?.foo === value) {
->o?.foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>o?.foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 301, 13))
->foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >value : Symbol(value, Decl(controlFlowOptionalChain.ts, 301, 34))
 
         o.foo;
->o.foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>o.foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 301, 13))
->foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
     }
     else {
         o.foo;  // Error
->o.foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>o.foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 301, 13))
->foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
     }
     if (o?.foo !== value) {
->o?.foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>o?.foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 301, 13))
->foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >value : Symbol(value, Decl(controlFlowOptionalChain.ts, 301, 34))
 
         o.foo;  // Error
->o.foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>o.foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 301, 13))
->foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
     }
     else {
         o.foo;
->o.foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>o.foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 301, 13))
->foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
     }
     if (o?.foo == value) {
->o?.foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>o?.foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 301, 13))
->foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >value : Symbol(value, Decl(controlFlowOptionalChain.ts, 301, 34))
 
         o.foo;
->o.foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>o.foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 301, 13))
->foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
     }
     else {
         o.foo;  // Error
->o.foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>o.foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 301, 13))
->foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
     }
     if (o?.foo != value) {
->o?.foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>o?.foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 301, 13))
->foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >value : Symbol(value, Decl(controlFlowOptionalChain.ts, 301, 34))
 
         o.foo;  // Error
->o.foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>o.foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 301, 13))
->foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
     }
     else {
         o.foo;
->o.foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>o.foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 301, 13))
->foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
     }
 }
 
@@ -1122,72 +1122,72 @@ function f15a(o: Thing | undefined, value: unknown) {
 >value : Symbol(value, Decl(controlFlowOptionalChain.ts, 328, 35))
 
     if (o?.foo === value) {
->o?.foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>o?.foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 328, 14))
->foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >value : Symbol(value, Decl(controlFlowOptionalChain.ts, 328, 35))
 
         o.foo;  // Error
->o.foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>o.foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 328, 14))
->foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
     }
     else {
         o.foo;  // Error
->o.foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>o.foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 328, 14))
->foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
     }
     if (o?.foo !== value) {
->o?.foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>o?.foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 328, 14))
->foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >value : Symbol(value, Decl(controlFlowOptionalChain.ts, 328, 35))
 
         o.foo;  // Error
->o.foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>o.foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 328, 14))
->foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
     }
     else {
         o.foo;  // Error
->o.foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>o.foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 328, 14))
->foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
     }
     if (o?.foo == value) {
->o?.foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>o?.foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 328, 14))
->foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >value : Symbol(value, Decl(controlFlowOptionalChain.ts, 328, 35))
 
         o.foo;  // Error
->o.foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>o.foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 328, 14))
->foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
     }
     else {
         o.foo;  // Error
->o.foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>o.foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 328, 14))
->foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
     }
     if (o?.foo != value) {
->o?.foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>o?.foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 328, 14))
->foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >value : Symbol(value, Decl(controlFlowOptionalChain.ts, 328, 35))
 
         o.foo;  // Error
->o.foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>o.foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 328, 14))
->foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
     }
     else {
         o.foo;  // Error
->o.foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>o.foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 328, 14))
->foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
     }
 }
 
@@ -1197,72 +1197,72 @@ function f16(o: Thing | undefined) {
 >Thing : Symbol(Thing, Decl(controlFlowOptionalChain.ts, 159, 1))
 
     if (o?.foo === undefined) {
->o?.foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>o?.foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 355, 13))
->foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >undefined : Symbol(undefined)
 
         o.foo;  // Error
->o.foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>o.foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 355, 13))
->foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
     }
     else {
         o.foo;
->o.foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>o.foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 355, 13))
->foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
     }
     if (o?.foo !== undefined) {
->o?.foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>o?.foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 355, 13))
->foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >undefined : Symbol(undefined)
 
         o.foo;
->o.foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>o.foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 355, 13))
->foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
     }
     else {
         o.foo;  // Error
->o.foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>o.foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 355, 13))
->foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
     }
     if (o?.foo == undefined) {
->o?.foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>o?.foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 355, 13))
->foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >undefined : Symbol(undefined)
 
         o.foo;  // Error
->o.foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>o.foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 355, 13))
->foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
     }
     else {
         o.foo;
->o.foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>o.foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 355, 13))
->foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
     }
     if (o?.foo != undefined) {
->o?.foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>o?.foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 355, 13))
->foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >undefined : Symbol(undefined)
 
         o.foo;
->o.foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>o.foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 355, 13))
->foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
     }
     else {
         o.foo;  // Error
->o.foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>o.foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 355, 13))
->foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
     }
 }
 
@@ -1272,42 +1272,42 @@ function f20(o: Thing | undefined) {
 >Thing : Symbol(Thing, Decl(controlFlowOptionalChain.ts, 159, 1))
 
     if (typeof o?.foo === "number") {
->o?.foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>o?.foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 382, 13))
->foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 
         o.foo;
->o.foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>o.foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 382, 13))
->foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
     }
     if (typeof o?.["foo"] === "number") {
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 382, 13))
 
         o["foo"];
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 382, 13))
->"foo" : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>"foo" : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
     }
     if (typeof o?.bar() === "number") {
->o?.bar : Symbol(bar, Decl(controlFlowOptionalChain.ts, 161, 36))
+>o?.bar : Symbol(Thing.bar, Decl(controlFlowOptionalChain.ts, 161, 36))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 382, 13))
->bar : Symbol(bar, Decl(controlFlowOptionalChain.ts, 161, 36))
+>bar : Symbol(Thing.bar, Decl(controlFlowOptionalChain.ts, 161, 36))
 
         o.bar;
->o.bar : Symbol(bar, Decl(controlFlowOptionalChain.ts, 161, 36))
+>o.bar : Symbol(Thing.bar, Decl(controlFlowOptionalChain.ts, 161, 36))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 382, 13))
->bar : Symbol(bar, Decl(controlFlowOptionalChain.ts, 161, 36))
+>bar : Symbol(Thing.bar, Decl(controlFlowOptionalChain.ts, 161, 36))
     }
     if (o?.baz instanceof Error) {
->o?.baz : Symbol(baz, Decl(controlFlowOptionalChain.ts, 161, 51))
+>o?.baz : Symbol(Thing.baz, Decl(controlFlowOptionalChain.ts, 161, 51))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 382, 13))
->baz : Symbol(baz, Decl(controlFlowOptionalChain.ts, 161, 51))
+>baz : Symbol(Thing.baz, Decl(controlFlowOptionalChain.ts, 161, 51))
 >Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 
         o.baz;
->o.baz : Symbol(baz, Decl(controlFlowOptionalChain.ts, 161, 51))
+>o.baz : Symbol(Thing.baz, Decl(controlFlowOptionalChain.ts, 161, 51))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 382, 13))
->baz : Symbol(baz, Decl(controlFlowOptionalChain.ts, 161, 51))
+>baz : Symbol(Thing.baz, Decl(controlFlowOptionalChain.ts, 161, 51))
     }
 }
 
@@ -1317,42 +1317,42 @@ function f21(o: Thing | null) {
 >Thing : Symbol(Thing, Decl(controlFlowOptionalChain.ts, 159, 1))
 
     if (typeof o?.foo === "number") {
->o?.foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>o?.foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 397, 13))
->foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 
         o.foo;
->o.foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>o.foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 397, 13))
->foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
     }
     if (typeof o?.["foo"] === "number") {
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 397, 13))
 
         o["foo"];
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 397, 13))
->"foo" : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>"foo" : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
     }
     if (typeof o?.bar() === "number") {
->o?.bar : Symbol(bar, Decl(controlFlowOptionalChain.ts, 161, 36))
+>o?.bar : Symbol(Thing.bar, Decl(controlFlowOptionalChain.ts, 161, 36))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 397, 13))
->bar : Symbol(bar, Decl(controlFlowOptionalChain.ts, 161, 36))
+>bar : Symbol(Thing.bar, Decl(controlFlowOptionalChain.ts, 161, 36))
 
         o.bar;
->o.bar : Symbol(bar, Decl(controlFlowOptionalChain.ts, 161, 36))
+>o.bar : Symbol(Thing.bar, Decl(controlFlowOptionalChain.ts, 161, 36))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 397, 13))
->bar : Symbol(bar, Decl(controlFlowOptionalChain.ts, 161, 36))
+>bar : Symbol(Thing.bar, Decl(controlFlowOptionalChain.ts, 161, 36))
     }
     if (o?.baz instanceof Error) {
->o?.baz : Symbol(baz, Decl(controlFlowOptionalChain.ts, 161, 51))
+>o?.baz : Symbol(Thing.baz, Decl(controlFlowOptionalChain.ts, 161, 51))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 397, 13))
->baz : Symbol(baz, Decl(controlFlowOptionalChain.ts, 161, 51))
+>baz : Symbol(Thing.baz, Decl(controlFlowOptionalChain.ts, 161, 51))
 >Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 
         o.baz;
->o.baz : Symbol(baz, Decl(controlFlowOptionalChain.ts, 161, 51))
+>o.baz : Symbol(Thing.baz, Decl(controlFlowOptionalChain.ts, 161, 51))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 397, 13))
->baz : Symbol(baz, Decl(controlFlowOptionalChain.ts, 161, 51))
+>baz : Symbol(Thing.baz, Decl(controlFlowOptionalChain.ts, 161, 51))
     }
 }
 
@@ -1362,68 +1362,68 @@ function f22(o: Thing | undefined) {
 >Thing : Symbol(Thing, Decl(controlFlowOptionalChain.ts, 159, 1))
 
     if (typeof o?.foo === "number") {
->o?.foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>o?.foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 412, 13))
->foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 
         o.foo;
->o.foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>o.foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 412, 13))
->foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
     }
     else {
         o.foo;  // Error
->o.foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>o.foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 412, 13))
->foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
     }
     if (typeof o?.foo !== "number") {
->o?.foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>o?.foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 412, 13))
->foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 
         o.foo;  // Error
->o.foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>o.foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 412, 13))
->foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
     }
     else {
         o.foo;
->o.foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>o.foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 412, 13))
->foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
     }
     if (typeof o?.foo == "number") {
->o?.foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>o?.foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 412, 13))
->foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 
         o.foo;
->o.foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>o.foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 412, 13))
->foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
     }
     else {
         o.foo;  // Error
->o.foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>o.foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 412, 13))
->foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
     }
     if (typeof o?.foo != "number") {
->o?.foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>o?.foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 412, 13))
->foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 
         o.foo;  // Error
->o.foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>o.foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 412, 13))
->foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
     }
     else {
         o.foo;
->o.foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>o.foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 412, 13))
->foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
     }
 }
 
@@ -1433,68 +1433,68 @@ function f23(o: Thing | undefined) {
 >Thing : Symbol(Thing, Decl(controlFlowOptionalChain.ts, 159, 1))
 
     if (typeof o?.foo === "undefined") {
->o?.foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>o?.foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 439, 13))
->foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 
         o.foo;  // Error
->o.foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>o.foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 439, 13))
->foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
     }
     else {
         o.foo;
->o.foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>o.foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 439, 13))
->foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
     }
     if (typeof o?.foo !== "undefined") {
->o?.foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>o?.foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 439, 13))
->foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 
         o.foo;
->o.foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>o.foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 439, 13))
->foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
     }
     else {
         o.foo;  // Error
->o.foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>o.foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 439, 13))
->foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
     }
     if (typeof o?.foo == "undefined") {
->o?.foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>o?.foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 439, 13))
->foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 
         o.foo;  // Error
->o.foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>o.foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 439, 13))
->foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
     }
     else {
         o.foo;
->o.foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>o.foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 439, 13))
->foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
     }
     if (typeof o?.foo != "undefined") {
->o?.foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>o?.foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 439, 13))
->foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 
         o.foo;
->o.foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>o.foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 439, 13))
->foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
     }
     else {
         o.foo;  // Error
->o.foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>o.foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 439, 13))
->foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
     }
 }
 
@@ -1520,50 +1520,50 @@ function f30(o: Thing | undefined) {
     if (!!true) {
         assert(o?.foo);
 >assert : Symbol(assert, Decl(controlFlowOptionalChain.ts, 464, 1))
->o?.foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>o?.foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 469, 13))
->foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 
         o.foo;
->o.foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>o.foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 469, 13))
->foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
     }
     if (!!true) {
         assert(o?.foo === 42);
 >assert : Symbol(assert, Decl(controlFlowOptionalChain.ts, 464, 1))
->o?.foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>o?.foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 469, 13))
->foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 
         o.foo;
->o.foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>o.foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 469, 13))
->foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
     }
     if (!!true) {
         assert(typeof o?.foo === "number");
 >assert : Symbol(assert, Decl(controlFlowOptionalChain.ts, 464, 1))
->o?.foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>o?.foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 469, 13))
->foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 
         o.foo;
->o.foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>o.foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 469, 13))
->foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
     }
     if (!!true) {
         assertNonNull(o?.foo);
 >assertNonNull : Symbol(assertNonNull, Decl(controlFlowOptionalChain.ts, 466, 47))
->o?.foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>o?.foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 469, 13))
->foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 
         o.foo;
->o.foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>o.foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 469, 13))
->foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
     }
 }
 
@@ -1573,38 +1573,38 @@ function f40(o: Thing | undefined) {
 >Thing : Symbol(Thing, Decl(controlFlowOptionalChain.ts, 159, 1))
 
     switch (o?.foo) {
->o?.foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>o?.foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 488, 13))
->foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 
         case "abc":
             o.foo;
->o.foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>o.foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 488, 13))
->foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 
             break;
         case 42:
             o.foo;
->o.foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>o.foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 488, 13))
->foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 
             break;
         case undefined:
 >undefined : Symbol(undefined)
 
             o.foo;  // Error
->o.foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>o.foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 488, 13))
->foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 
             break;
         default:
             o.foo;  // Error
->o.foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>o.foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 488, 13))
->foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 
             break;
     }
@@ -1616,36 +1616,36 @@ function f41(o: Thing | undefined) {
 >Thing : Symbol(Thing, Decl(controlFlowOptionalChain.ts, 159, 1))
 
     switch (typeof o?.foo) {
->o?.foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>o?.foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 505, 13))
->foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 
         case "string":
             o.foo;
->o.foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>o.foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 505, 13))
->foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 
             break;
         case "number":
             o.foo;
->o.foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>o.foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 505, 13))
->foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 
             break;
         case "undefined":
             o.foo;  // Error
->o.foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>o.foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 505, 13))
->foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 
             break;
         default:
             o.foo;  // Error
->o.foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>o.foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 >o : Symbol(o, Decl(controlFlowOptionalChain.ts, 505, 13))
->foo : Symbol(foo, Decl(controlFlowOptionalChain.ts, 161, 14))
+>foo : Symbol(Thing.foo, Decl(controlFlowOptionalChain.ts, 161, 14))
 
             break;
     }
@@ -1702,10 +1702,10 @@ type Feature = {
 >Feature : Symbol(Feature, Decl(controlFlowOptionalChain.ts, 537, 1))
 
   id: string;
->id : Symbol(id, Decl(controlFlowOptionalChain.ts, 539, 16))
+>id : Symbol(Feature.id, Decl(controlFlowOptionalChain.ts, 539, 16))
 
   geometry?: {
->geometry : Symbol(geometry, Decl(controlFlowOptionalChain.ts, 540, 13))
+>geometry : Symbol(Feature.geometry, Decl(controlFlowOptionalChain.ts, 540, 13))
 
     type: string;
 >type : Symbol(type, Decl(controlFlowOptionalChain.ts, 541, 14))
@@ -1724,18 +1724,18 @@ function extractCoordinates(f: Feature): number[] {
 
     if (f.geometry?.type !== 'test') {
 >f.geometry?.type : Symbol(type, Decl(controlFlowOptionalChain.ts, 541, 14))
->f.geometry : Symbol(geometry, Decl(controlFlowOptionalChain.ts, 540, 13))
+>f.geometry : Symbol(Feature.geometry, Decl(controlFlowOptionalChain.ts, 540, 13))
 >f : Symbol(f, Decl(controlFlowOptionalChain.ts, 548, 28))
->geometry : Symbol(geometry, Decl(controlFlowOptionalChain.ts, 540, 13))
+>geometry : Symbol(Feature.geometry, Decl(controlFlowOptionalChain.ts, 540, 13))
 >type : Symbol(type, Decl(controlFlowOptionalChain.ts, 541, 14))
 
         return [];
     }
     return f.geometry.coordinates;
 >f.geometry.coordinates : Symbol(coordinates, Decl(controlFlowOptionalChain.ts, 542, 17))
->f.geometry : Symbol(geometry, Decl(controlFlowOptionalChain.ts, 540, 13))
+>f.geometry : Symbol(Feature.geometry, Decl(controlFlowOptionalChain.ts, 540, 13))
 >f : Symbol(f, Decl(controlFlowOptionalChain.ts, 548, 28))
->geometry : Symbol(geometry, Decl(controlFlowOptionalChain.ts, 540, 13))
+>geometry : Symbol(Feature.geometry, Decl(controlFlowOptionalChain.ts, 540, 13))
 >coordinates : Symbol(coordinates, Decl(controlFlowOptionalChain.ts, 542, 17))
 }
 
diff --git a/tests/baselines/reference/controlFlowOptionalChain.types b/tests/baselines/reference/controlFlowOptionalChain.types
index 4e335fca6d287..03cd8762fe7dc 100644
--- a/tests/baselines/reference/controlFlowOptionalChain.types
+++ b/tests/baselines/reference/controlFlowOptionalChain.types
@@ -1882,7 +1882,7 @@ type Shape =
 >radius : number
 
 function getArea(shape?: Shape) {
->getArea : (shape?: Shape | undefined) => number
+>getArea : (shape?: Shape) => number
 >shape : Shape | undefined
 
     switch (shape?.type) {
diff --git a/tests/baselines/reference/controlFlowOptionalChain2.symbols b/tests/baselines/reference/controlFlowOptionalChain2.symbols
index e4b2184a8895e..ac5de7bd5310f 100644
--- a/tests/baselines/reference/controlFlowOptionalChain2.symbols
+++ b/tests/baselines/reference/controlFlowOptionalChain2.symbols
@@ -3,17 +3,17 @@ type A = {
 >A : Symbol(A, Decl(controlFlowOptionalChain2.ts, 0, 0))
 
   type: 'A';
->type : Symbol(type, Decl(controlFlowOptionalChain2.ts, 0, 10))
+>type : Symbol(A.type, Decl(controlFlowOptionalChain2.ts, 0, 10))
 
   name: string;
->name : Symbol(name, Decl(controlFlowOptionalChain2.ts, 1, 12))
+>name : Symbol(A.name, Decl(controlFlowOptionalChain2.ts, 1, 12))
 }
 
 type B = {
 >B : Symbol(B, Decl(controlFlowOptionalChain2.ts, 3, 1))
 
   type: 'B';
->type : Symbol(type, Decl(controlFlowOptionalChain2.ts, 5, 10))
+>type : Symbol(B.type, Decl(controlFlowOptionalChain2.ts, 5, 10))
 }
 
 function funcTwo(arg: A | B | undefined) {
@@ -37,9 +37,9 @@ function funcTwo(arg: A | B | undefined) {
 >arg : Symbol(arg, Decl(controlFlowOptionalChain2.ts, 9, 17))
 
   arg?.name;
->arg?.name : Symbol(name, Decl(controlFlowOptionalChain2.ts, 1, 12))
+>arg?.name : Symbol(A.name, Decl(controlFlowOptionalChain2.ts, 1, 12))
 >arg : Symbol(arg, Decl(controlFlowOptionalChain2.ts, 9, 17))
->name : Symbol(name, Decl(controlFlowOptionalChain2.ts, 1, 12))
+>name : Symbol(A.name, Decl(controlFlowOptionalChain2.ts, 1, 12))
 }
 
 function funcThree(arg: A | B | null) {
@@ -63,25 +63,25 @@ function funcThree(arg: A | B | null) {
 >arg : Symbol(arg, Decl(controlFlowOptionalChain2.ts, 19, 19))
 
   arg?.name;
->arg?.name : Symbol(name, Decl(controlFlowOptionalChain2.ts, 1, 12))
+>arg?.name : Symbol(A.name, Decl(controlFlowOptionalChain2.ts, 1, 12))
 >arg : Symbol(arg, Decl(controlFlowOptionalChain2.ts, 19, 19))
->name : Symbol(name, Decl(controlFlowOptionalChain2.ts, 1, 12))
+>name : Symbol(A.name, Decl(controlFlowOptionalChain2.ts, 1, 12))
 }
 
 type U = { kind: undefined, u: 'u' }
 >U : Symbol(U, Decl(controlFlowOptionalChain2.ts, 27, 1))
->kind : Symbol(kind, Decl(controlFlowOptionalChain2.ts, 29, 10))
->u : Symbol(u, Decl(controlFlowOptionalChain2.ts, 29, 27))
+>kind : Symbol(U.kind, Decl(controlFlowOptionalChain2.ts, 29, 10))
+>u : Symbol(U.u, Decl(controlFlowOptionalChain2.ts, 29, 27))
 
 type N = { kind: null, n: 'n' }
 >N : Symbol(N, Decl(controlFlowOptionalChain2.ts, 29, 36))
->kind : Symbol(kind, Decl(controlFlowOptionalChain2.ts, 30, 10))
->n : Symbol(n, Decl(controlFlowOptionalChain2.ts, 30, 22))
+>kind : Symbol(N.kind, Decl(controlFlowOptionalChain2.ts, 30, 10))
+>n : Symbol(N.n, Decl(controlFlowOptionalChain2.ts, 30, 22))
 
 type X = { kind: 'X', x: 'x' }
 >X : Symbol(X, Decl(controlFlowOptionalChain2.ts, 30, 31))
->kind : Symbol(kind, Decl(controlFlowOptionalChain2.ts, 31, 10))
->x : Symbol(x, Decl(controlFlowOptionalChain2.ts, 31, 21))
+>kind : Symbol(X.kind, Decl(controlFlowOptionalChain2.ts, 31, 10))
+>x : Symbol(X.x, Decl(controlFlowOptionalChain2.ts, 31, 21))
 
 function f1(x: X | U | undefined) {
 >f1 : Symbol(f1, Decl(controlFlowOptionalChain2.ts, 31, 30))
diff --git a/tests/baselines/reference/controlFlowStringIndex.symbols b/tests/baselines/reference/controlFlowStringIndex.symbols
index 85eacfd0ede7b..aab09bf386f6e 100644
--- a/tests/baselines/reference/controlFlowStringIndex.symbols
+++ b/tests/baselines/reference/controlFlowStringIndex.symbols
@@ -3,7 +3,7 @@ type A = {
 >A : Symbol(A, Decl(controlFlowStringIndex.ts, 0, 0))
 
     other: number | null;
->other : Symbol(other, Decl(controlFlowStringIndex.ts, 0, 10))
+>other : Symbol(A.other, Decl(controlFlowStringIndex.ts, 0, 10))
 
     [index: string]: number | null
 >index : Symbol(index, Decl(controlFlowStringIndex.ts, 2, 5))
@@ -22,9 +22,9 @@ if (value.foo !== null) {
 >toExponential : Symbol(Number.toExponential, Decl(lib.es5.d.ts, --, --))
 
     value.other // should still be number | null
->value.other : Symbol(other, Decl(controlFlowStringIndex.ts, 0, 10))
+>value.other : Symbol(A.other, Decl(controlFlowStringIndex.ts, 0, 10))
 >value : Symbol(value, Decl(controlFlowStringIndex.ts, 4, 13))
->other : Symbol(other, Decl(controlFlowStringIndex.ts, 0, 10))
+>other : Symbol(A.other, Decl(controlFlowStringIndex.ts, 0, 10))
 
     value.bar // should still be number | null
 >value : Symbol(value, Decl(controlFlowStringIndex.ts, 4, 13))
diff --git a/tests/baselines/reference/correlatedUnions.symbols b/tests/baselines/reference/correlatedUnions.symbols
index 9485b70c5dcd5..d23a9a09d3b2f 100644
--- a/tests/baselines/reference/correlatedUnions.symbols
+++ b/tests/baselines/reference/correlatedUnions.symbols
@@ -3,9 +3,9 @@
 
 type RecordMap = { n: number, s: string, b: boolean };
 >RecordMap : Symbol(RecordMap, Decl(correlatedUnions.ts, 0, 0))
->n : Symbol(n, Decl(correlatedUnions.ts, 2, 18))
->s : Symbol(s, Decl(correlatedUnions.ts, 2, 29))
->b : Symbol(b, Decl(correlatedUnions.ts, 2, 40))
+>n : Symbol(RecordMap.n, Decl(correlatedUnions.ts, 2, 18))
+>s : Symbol(RecordMap.s, Decl(correlatedUnions.ts, 2, 29))
+>b : Symbol(RecordMap.b, Decl(correlatedUnions.ts, 2, 40))
 
 type UnionRecord<K extends keyof RecordMap = keyof RecordMap> = { [P in K]: {
 >UnionRecord : Symbol(UnionRecord, Decl(correlatedUnions.ts, 2, 54))
@@ -80,22 +80,22 @@ processRecord({ kind: 'n', v: 42, f: v => v.toExponential() });
 
 type TextFieldData = { value: string }
 >TextFieldData : Symbol(TextFieldData, Decl(correlatedUnions.ts, 18, 63))
->value : Symbol(value, Decl(correlatedUnions.ts, 22, 22))
+>value : Symbol(TextFieldData.value, Decl(correlatedUnions.ts, 22, 22))
 
 type SelectFieldData = { options: string[], selectedValue: string }
 >SelectFieldData : Symbol(SelectFieldData, Decl(correlatedUnions.ts, 22, 38))
->options : Symbol(options, Decl(correlatedUnions.ts, 23, 24))
->selectedValue : Symbol(selectedValue, Decl(correlatedUnions.ts, 23, 43))
+>options : Symbol(SelectFieldData.options, Decl(correlatedUnions.ts, 23, 24))
+>selectedValue : Symbol(SelectFieldData.selectedValue, Decl(correlatedUnions.ts, 23, 43))
 
 type FieldMap = {
 >FieldMap : Symbol(FieldMap, Decl(correlatedUnions.ts, 23, 67))
 
     text: TextFieldData;
->text : Symbol(text, Decl(correlatedUnions.ts, 25, 17))
+>text : Symbol(FieldMap.text, Decl(correlatedUnions.ts, 25, 17))
 >TextFieldData : Symbol(TextFieldData, Decl(correlatedUnions.ts, 18, 63))
 
     select: SelectFieldData;
->select : Symbol(select, Decl(correlatedUnions.ts, 26, 24))
+>select : Symbol(FieldMap.select, Decl(correlatedUnions.ts, 26, 24))
 >SelectFieldData : Symbol(SelectFieldData, Decl(correlatedUnions.ts, 22, 38))
 }
 
@@ -103,9 +103,9 @@ type FormField<K extends keyof FieldMap> = { type: K, data: FieldMap[K] };
 >FormField : Symbol(FormField, Decl(correlatedUnions.ts, 28, 1))
 >K : Symbol(K, Decl(correlatedUnions.ts, 30, 15))
 >FieldMap : Symbol(FieldMap, Decl(correlatedUnions.ts, 23, 67))
->type : Symbol(type, Decl(correlatedUnions.ts, 30, 44))
+>type : Symbol(FormField.type, Decl(correlatedUnions.ts, 30, 44))
 >K : Symbol(K, Decl(correlatedUnions.ts, 30, 15))
->data : Symbol(data, Decl(correlatedUnions.ts, 30, 53))
+>data : Symbol(FormField.data, Decl(correlatedUnions.ts, 30, 53))
 >FieldMap : Symbol(FieldMap, Decl(correlatedUnions.ts, 23, 67))
 >K : Symbol(K, Decl(correlatedUnions.ts, 30, 15))
 
@@ -159,15 +159,15 @@ function renderField<K extends keyof FieldMap>(field: FormField<K>) {
     const renderFn = renderFuncs[field.type];
 >renderFn : Symbol(renderFn, Decl(correlatedUnions.ts, 44, 9))
 >renderFuncs : Symbol(renderFuncs, Decl(correlatedUnions.ts, 38, 5))
->field.type : Symbol(type, Decl(correlatedUnions.ts, 30, 44))
+>field.type : Symbol(FormField.type, Decl(correlatedUnions.ts, 30, 44))
 >field : Symbol(field, Decl(correlatedUnions.ts, 43, 47))
->type : Symbol(type, Decl(correlatedUnions.ts, 30, 44))
+>type : Symbol(FormField.type, Decl(correlatedUnions.ts, 30, 44))
 
     renderFn(field.data);
 >renderFn : Symbol(renderFn, Decl(correlatedUnions.ts, 44, 9))
->field.data : Symbol(data, Decl(correlatedUnions.ts, 30, 53))
+>field.data : Symbol(FormField.data, Decl(correlatedUnions.ts, 30, 53))
 >field : Symbol(field, Decl(correlatedUnions.ts, 43, 47))
->data : Symbol(data, Decl(correlatedUnions.ts, 30, 53))
+>data : Symbol(FormField.data, Decl(correlatedUnions.ts, 30, 53))
 }
 
 // --------
@@ -176,10 +176,10 @@ type TypeMap = {
 >TypeMap : Symbol(TypeMap, Decl(correlatedUnions.ts, 46, 1))
 
     foo: string,
->foo : Symbol(foo, Decl(correlatedUnions.ts, 50, 16))
+>foo : Symbol(TypeMap.foo, Decl(correlatedUnions.ts, 50, 16))
 
     bar: number
->bar : Symbol(bar, Decl(correlatedUnions.ts, 51, 16))
+>bar : Symbol(TypeMap.bar, Decl(correlatedUnions.ts, 51, 16))
 
 };
 
@@ -298,8 +298,8 @@ process([{ type: 'foo', data: 'abc' }]);
 
 type LetterMap = { A: string, B: number }
 >LetterMap : Symbol(LetterMap, Decl(correlatedUnions.ts, 84, 40))
->A : Symbol(A, Decl(correlatedUnions.ts, 88, 18))
->B : Symbol(B, Decl(correlatedUnions.ts, 88, 29))
+>A : Symbol(LetterMap.A, Decl(correlatedUnions.ts, 88, 18))
+>B : Symbol(LetterMap.B, Decl(correlatedUnions.ts, 88, 29))
 
 type LetterCaller<K extends keyof LetterMap> = { [P in K]: { letter: Record<P, LetterMap[P]>, caller: (x: Record<P, LetterMap[P]>) => void } }[K];
 >LetterCaller : Symbol(LetterCaller, Decl(correlatedUnions.ts, 88, 41))
@@ -336,11 +336,11 @@ function call<K extends keyof LetterMap>({ letter, caller }: LetterCaller<K>): v
 
 type A = { A: string };
 >A : Symbol(A, Decl(correlatedUnions.ts, 93, 1))
->A : Symbol(A, Decl(correlatedUnions.ts, 95, 10))
+>A : Symbol(A.A, Decl(correlatedUnions.ts, 95, 10))
 
 type B = { B: number };
 >B : Symbol(B, Decl(correlatedUnions.ts, 95, 23))
->B : Symbol(B, Decl(correlatedUnions.ts, 96, 10))
+>B : Symbol(B.B, Decl(correlatedUnions.ts, 96, 10))
 
 type ACaller = (a: A) => void;
 >ACaller : Symbol(ACaller, Decl(correlatedUnions.ts, 96, 23))
@@ -512,10 +512,10 @@ function ff1() {
 >ArgMap : Symbol(ArgMap, Decl(correlatedUnions.ts, 141, 16))
 
         sum: [a: number, b: number],
->sum : Symbol(sum, Decl(correlatedUnions.ts, 142, 19))
+>sum : Symbol(ArgMap.sum, Decl(correlatedUnions.ts, 142, 19))
 
         concat: [a: string, b: string, c: string]
->concat : Symbol(concat, Decl(correlatedUnions.ts, 143, 36))
+>concat : Symbol(ArgMap.concat, Decl(correlatedUnions.ts, 143, 36))
     }
     type Keys = keyof ArgMap;
 >Keys : Symbol(Keys, Decl(correlatedUnions.ts, 145, 5))
@@ -577,8 +577,8 @@ function ff1() {
 
 type ArgMap = { a: number, b: string };
 >ArgMap : Symbol(ArgMap, Decl(correlatedUnions.ts, 157, 1))
->a : Symbol(a, Decl(correlatedUnions.ts, 161, 15))
->b : Symbol(b, Decl(correlatedUnions.ts, 161, 26))
+>a : Symbol(ArgMap.a, Decl(correlatedUnions.ts, 161, 15))
+>b : Symbol(ArgMap.b, Decl(correlatedUnions.ts, 161, 26))
 
 type Func<K extends keyof ArgMap> = (x: ArgMap[K]) => void;
 >Func : Symbol(Func, Decl(correlatedUnions.ts, 161, 39))
diff --git a/tests/baselines/reference/declFileTypeAnnotationTypeAlias.symbols b/tests/baselines/reference/declFileTypeAnnotationTypeAlias.symbols
index 88ec0a5df0ba8..12c8d83c1a465 100644
--- a/tests/baselines/reference/declFileTypeAnnotationTypeAlias.symbols
+++ b/tests/baselines/reference/declFileTypeAnnotationTypeAlias.symbols
@@ -28,7 +28,7 @@ module M {
     export type MC = m.c;
 >MC : Symbol(MC, Decl(declFileTypeAnnotationTypeAlias.ts, 12, 5))
 >m : Symbol(m, Decl(declFileTypeAnnotationTypeAlias.ts, 7, 22))
->c : Symbol(m.c, Decl(declFileTypeAnnotationTypeAlias.ts, 9, 21))
+>c : Symbol(MC, Decl(declFileTypeAnnotationTypeAlias.ts, 9, 21))
 
     export type fc = () => c;
 >fc : Symbol(fc, Decl(declFileTypeAnnotationTypeAlias.ts, 14, 25))
diff --git a/tests/baselines/reference/declFileTypeAnnotationTypeAlias.types b/tests/baselines/reference/declFileTypeAnnotationTypeAlias.types
index 4f8a9cf021867..8284fc7ad9992 100644
--- a/tests/baselines/reference/declFileTypeAnnotationTypeAlias.types
+++ b/tests/baselines/reference/declFileTypeAnnotationTypeAlias.types
@@ -24,7 +24,7 @@ module M {
     }
 
     export type MC = m.c;
->MC : m.c
+>MC : MC
 >m : any
 
     export type fc = () => c;
diff --git a/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorTypeAlias.symbols b/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorTypeAlias.symbols
index 5219fd37b3164..2e5f864af8aad 100644
--- a/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorTypeAlias.symbols
+++ b/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorTypeAlias.symbols
@@ -80,11 +80,11 @@ module M2 {
     type t111 = m3.public1;
 >t111 : Symbol(t111, Decl(declFileTypeAnnotationVisibilityErrorTypeAlias.ts, 34, 30))
 >m3 : Symbol(m3, Decl(declFileTypeAnnotationVisibilityErrorTypeAlias.ts, 24, 5))
->public1 : Symbol(m3.public1, Decl(declFileTypeAnnotationVisibilityErrorTypeAlias.ts, 25, 15))
+>public1 : Symbol(t111, Decl(declFileTypeAnnotationVisibilityErrorTypeAlias.ts, 25, 15))
 
     export type t112 = m3.public1; // error
 >t112 : Symbol(t112, Decl(declFileTypeAnnotationVisibilityErrorTypeAlias.ts, 36, 27))
 >m3 : Symbol(m3, Decl(declFileTypeAnnotationVisibilityErrorTypeAlias.ts, 24, 5))
->public1 : Symbol(m3.public1, Decl(declFileTypeAnnotationVisibilityErrorTypeAlias.ts, 25, 15))
+>public1 : Symbol(t111, Decl(declFileTypeAnnotationVisibilityErrorTypeAlias.ts, 25, 15))
 }
 
diff --git a/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorTypeAlias.types b/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorTypeAlias.types
index e1f08d5893836..2b65a595f32aa 100644
--- a/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorTypeAlias.types
+++ b/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorTypeAlias.types
@@ -68,11 +68,11 @@ module M2 {
 >t12 : public1
 
     type t111 = m3.public1;
->t111 : m3.public1
+>t111 : t111
 >m3 : any
 
     export type t112 = m3.public1; // error
->t112 : m3.public1
+>t112 : t111
 >m3 : any
 }
 
diff --git a/tests/baselines/reference/declarationEmitAliasFromIndirectFile.symbols b/tests/baselines/reference/declarationEmitAliasFromIndirectFile.symbols
index 4475277094a40..46eaf6ca195ec 100644
--- a/tests/baselines/reference/declarationEmitAliasFromIndirectFile.symbols
+++ b/tests/baselines/reference/declarationEmitAliasFromIndirectFile.symbols
@@ -3,7 +3,7 @@ export type Locale = {
 >Locale : Symbol(Locale, Decl(locale.d.ts, 0, 0))
 
     weekdays: {
->weekdays : Symbol(weekdays, Decl(locale.d.ts, 0, 22))
+>weekdays : Symbol(Locale.weekdays, Decl(locale.d.ts, 0, 22))
 
         shorthand: [string, string, string, string, string, string, string];
 >shorthand : Symbol(shorthand, Decl(locale.d.ts, 1, 15))
@@ -17,7 +17,7 @@ export type CustomLocale = {
 >CustomLocale : Symbol(CustomLocale, Decl(locale.d.ts, 5, 2))
 
     weekdays: {
->weekdays : Symbol(weekdays, Decl(locale.d.ts, 6, 28))
+>weekdays : Symbol(CustomLocale.weekdays, Decl(locale.d.ts, 6, 28))
 
         shorthand: [string, string, string, string, string, string, string];
 >shorthand : Symbol(shorthand, Decl(locale.d.ts, 7, 15))
diff --git a/tests/baselines/reference/declarationEmitDestructuringParameterProperties.symbols b/tests/baselines/reference/declarationEmitDestructuringParameterProperties.symbols
index 60ddd35504e44..a564267134c10 100644
--- a/tests/baselines/reference/declarationEmitDestructuringParameterProperties.symbols
+++ b/tests/baselines/reference/declarationEmitDestructuringParameterProperties.symbols
@@ -25,9 +25,9 @@ class C2 {
 
 type ObjType1 = { x: number; y: string; z: boolean }
 >ObjType1 : Symbol(ObjType1, Decl(declarationEmitDestructuringParameterProperties.ts, 9, 1))
->x : Symbol(x, Decl(declarationEmitDestructuringParameterProperties.ts, 11, 17))
->y : Symbol(y, Decl(declarationEmitDestructuringParameterProperties.ts, 11, 28))
->z : Symbol(z, Decl(declarationEmitDestructuringParameterProperties.ts, 11, 39))
+>x : Symbol(ObjType1.x, Decl(declarationEmitDestructuringParameterProperties.ts, 11, 17))
+>y : Symbol(ObjType1.y, Decl(declarationEmitDestructuringParameterProperties.ts, 11, 28))
+>z : Symbol(ObjType1.z, Decl(declarationEmitDestructuringParameterProperties.ts, 11, 39))
 
 class C3 {
 >C3 : Symbol(C3, Decl(declarationEmitDestructuringParameterProperties.ts, 11, 52))
diff --git a/tests/baselines/reference/declarationEmitExportAssignedNamespaceNoTripleSlashTypesReference.symbols b/tests/baselines/reference/declarationEmitExportAssignedNamespaceNoTripleSlashTypesReference.symbols
index 87304e8e84fa2..62c26fa549fd8 100644
--- a/tests/baselines/reference/declarationEmitExportAssignedNamespaceNoTripleSlashTypesReference.symbols
+++ b/tests/baselines/reference/declarationEmitExportAssignedNamespaceNoTripleSlashTypesReference.symbols
@@ -10,11 +10,11 @@ declare namespace React {
 >T : Symbol(T, Decl(index.d.ts, 3, 26))
 >U : Symbol(U, Decl(index.d.ts, 3, 34))
 >V : Symbol(V, Decl(index.d.ts, 3, 42))
->x : Symbol(x, Decl(index.d.ts, 3, 54))
+>x : Symbol(Component.x, Decl(index.d.ts, 3, 54))
 >T : Symbol(T, Decl(index.d.ts, 3, 26))
->y : Symbol(y, Decl(index.d.ts, 3, 60))
+>y : Symbol(Component.y, Decl(index.d.ts, 3, 60))
 >U : Symbol(U, Decl(index.d.ts, 3, 34))
->z : Symbol(z, Decl(index.d.ts, 3, 66))
+>z : Symbol(Component.z, Decl(index.d.ts, 3, 66))
 >V : Symbol(V, Decl(index.d.ts, 3, 42))
 
     export interface DOMAttributes<T> { }
diff --git a/tests/baselines/reference/declarationEmitExpressionWithNonlocalPrivateUniqueSymbol.symbols b/tests/baselines/reference/declarationEmitExpressionWithNonlocalPrivateUniqueSymbol.symbols
index 3294e8e38c30f..fc590255bfae9 100644
--- a/tests/baselines/reference/declarationEmitExpressionWithNonlocalPrivateUniqueSymbol.symbols
+++ b/tests/baselines/reference/declarationEmitExpressionWithNonlocalPrivateUniqueSymbol.symbols
@@ -1,7 +1,7 @@
 === tests/cases/compiler/a.ts ===
 type AX = { readonly A: unique symbol };
 >AX : Symbol(AX, Decl(a.ts, 0, 0))
->A : Symbol(A, Decl(a.ts, 0, 11))
+>A : Symbol(AX.A, Decl(a.ts, 0, 11))
 
 export const A: AX = 0 as any;
 >A : Symbol(A, Decl(a.ts, 1, 12))
diff --git a/tests/baselines/reference/declarationEmitPathMappingMonorepo.symbols b/tests/baselines/reference/declarationEmitPathMappingMonorepo.symbols
index e94b520dead25..45c178df2b1e8 100644
--- a/tests/baselines/reference/declarationEmitPathMappingMonorepo.symbols
+++ b/tests/baselines/reference/declarationEmitPathMappingMonorepo.symbols
@@ -6,7 +6,7 @@ declare module "@ts-bug/a" {
 >AText : Symbol(AText, Decl(index.d.ts, 0, 28))
 
       value: string;
->value : Symbol(value, Decl(index.d.ts, 1, 25))
+>value : Symbol(AText.value, Decl(index.d.ts, 1, 25))
 
     };
     export function a(text: string): AText;
diff --git a/tests/baselines/reference/declarationEmitReexportedSymlinkReference.symbols b/tests/baselines/reference/declarationEmitReexportedSymlinkReference.symbols
index 4006ea88a86e1..2054b3304bf63 100644
--- a/tests/baselines/reference/declarationEmitReexportedSymlinkReference.symbols
+++ b/tests/baselines/reference/declarationEmitReexportedSymlinkReference.symbols
@@ -5,14 +5,14 @@ export declare type A = {
 >A : Symbol(A, Decl(types.d.ts, 0, 0))
 
     id: string;
->id : Symbol(id, Decl(types.d.ts, 0, 25))
+>id : Symbol(A.id, Decl(types.d.ts, 0, 25))
 
 };
 export declare type B = {
 >B : Symbol(B, Decl(types.d.ts, 2, 2))
 
     id: number;
->id : Symbol(id, Decl(types.d.ts, 3, 25))
+>id : Symbol(B.id, Decl(types.d.ts, 3, 25))
 
 };
 export declare type IdType = A | B;
diff --git a/tests/baselines/reference/declarationEmitReexportedSymlinkReference2.symbols b/tests/baselines/reference/declarationEmitReexportedSymlinkReference2.symbols
index 683969e356f33..100a73744b91c 100644
--- a/tests/baselines/reference/declarationEmitReexportedSymlinkReference2.symbols
+++ b/tests/baselines/reference/declarationEmitReexportedSymlinkReference2.symbols
@@ -5,14 +5,14 @@ export declare type A = {
 >A : Symbol(A, Decl(types.d.ts, 0, 0))
 
     id: string;
->id : Symbol(id, Decl(types.d.ts, 0, 25))
+>id : Symbol(A.id, Decl(types.d.ts, 0, 25))
 
 };
 export declare type B = {
 >B : Symbol(B, Decl(types.d.ts, 2, 2))
 
     id: number;
->id : Symbol(id, Decl(types.d.ts, 3, 25))
+>id : Symbol(B.id, Decl(types.d.ts, 3, 25))
 
 };
 export declare type IdType = A | B;
diff --git a/tests/baselines/reference/declarationEmitReexportedSymlinkReference3.symbols b/tests/baselines/reference/declarationEmitReexportedSymlinkReference3.symbols
index df33b515a8d44..44bd81b8d8b27 100644
--- a/tests/baselines/reference/declarationEmitReexportedSymlinkReference3.symbols
+++ b/tests/baselines/reference/declarationEmitReexportedSymlinkReference3.symbols
@@ -5,14 +5,14 @@ export declare type A = {
 >A : Symbol(A, Decl(types.d.ts, 0, 0))
 
     id: string;
->id : Symbol(id, Decl(types.d.ts, 0, 25))
+>id : Symbol(A.id, Decl(types.d.ts, 0, 25))
 
 };
 export declare type B = {
 >B : Symbol(B, Decl(types.d.ts, 2, 2))
 
     id: number;
->id : Symbol(id, Decl(types.d.ts, 3, 25))
+>id : Symbol(B.id, Decl(types.d.ts, 3, 25))
 
 };
 export declare type IdType = A | B;
diff --git a/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters3.symbols b/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters3.symbols
index b524c052c958f..26e63acef7648 100644
--- a/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters3.symbols
+++ b/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters3.symbols
@@ -4,7 +4,7 @@ type Foo<T> = {
 >T : Symbol(T, Decl(declarationEmitTypeAliasWithTypeParameters3.ts, 0, 9))
 
     foo<U>(): Foo<U>
->foo : Symbol(foo, Decl(declarationEmitTypeAliasWithTypeParameters3.ts, 0, 15))
+>foo : Symbol(Foo.foo, Decl(declarationEmitTypeAliasWithTypeParameters3.ts, 0, 15))
 >U : Symbol(U, Decl(declarationEmitTypeAliasWithTypeParameters3.ts, 1, 8))
 >Foo : Symbol(Foo, Decl(declarationEmitTypeAliasWithTypeParameters3.ts, 0, 0))
 >U : Symbol(U, Decl(declarationEmitTypeAliasWithTypeParameters3.ts, 1, 8))
diff --git a/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters4.symbols b/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters4.symbols
index 6a94160c663fc..430a45965c68f 100644
--- a/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters4.symbols
+++ b/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters4.symbols
@@ -5,7 +5,7 @@ type Foo<T, Y> = {
 >Y : Symbol(Y, Decl(declarationEmitTypeAliasWithTypeParameters4.ts, 0, 11))
 
     foo<U, J>(): Foo<U, J>
->foo : Symbol(foo, Decl(declarationEmitTypeAliasWithTypeParameters4.ts, 0, 18))
+>foo : Symbol(Foo.foo, Decl(declarationEmitTypeAliasWithTypeParameters4.ts, 0, 18))
 >U : Symbol(U, Decl(declarationEmitTypeAliasWithTypeParameters4.ts, 1, 8))
 >J : Symbol(J, Decl(declarationEmitTypeAliasWithTypeParameters4.ts, 1, 10))
 >Foo : Symbol(Foo, Decl(declarationEmitTypeAliasWithTypeParameters4.ts, 0, 0))
diff --git a/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters5.symbols b/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters5.symbols
index 53e9183bf1778..87e2a7a9ae85b 100644
--- a/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters5.symbols
+++ b/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters5.symbols
@@ -5,7 +5,7 @@ type Foo<T, Y> = {
 >Y : Symbol(Y, Decl(declarationEmitTypeAliasWithTypeParameters5.ts, 0, 11))
 
     foo<U, J>(): Foo<U, J>
->foo : Symbol(foo, Decl(declarationEmitTypeAliasWithTypeParameters5.ts, 0, 18))
+>foo : Symbol(Foo.foo, Decl(declarationEmitTypeAliasWithTypeParameters5.ts, 0, 18))
 >U : Symbol(U, Decl(declarationEmitTypeAliasWithTypeParameters5.ts, 1, 8))
 >J : Symbol(J, Decl(declarationEmitTypeAliasWithTypeParameters5.ts, 1, 10))
 >Foo : Symbol(Foo, Decl(declarationEmitTypeAliasWithTypeParameters5.ts, 0, 0))
diff --git a/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters6.symbols b/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters6.symbols
index 47769eb8727d9..af85a2d70b780 100644
--- a/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters6.symbols
+++ b/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters6.symbols
@@ -5,7 +5,7 @@ type Foo<T, Y> = {
 >Y : Symbol(Y, Decl(declarationEmitTypeAliasWithTypeParameters6.ts, 0, 11))
 
     foo<U, J>(): Foo<U, J>
->foo : Symbol(foo, Decl(declarationEmitTypeAliasWithTypeParameters6.ts, 0, 18))
+>foo : Symbol(Foo.foo, Decl(declarationEmitTypeAliasWithTypeParameters6.ts, 0, 18))
 >U : Symbol(U, Decl(declarationEmitTypeAliasWithTypeParameters6.ts, 1, 8))
 >J : Symbol(J, Decl(declarationEmitTypeAliasWithTypeParameters6.ts, 1, 10))
 >Foo : Symbol(Foo, Decl(declarationEmitTypeAliasWithTypeParameters6.ts, 0, 0))
diff --git a/tests/baselines/reference/declarationEmitWithDefaultAsComputedName.symbols b/tests/baselines/reference/declarationEmitWithDefaultAsComputedName.symbols
index 50d91d4c6030a..acbc81223d1b1 100644
--- a/tests/baselines/reference/declarationEmitWithDefaultAsComputedName.symbols
+++ b/tests/baselines/reference/declarationEmitWithDefaultAsComputedName.symbols
@@ -4,7 +4,7 @@ type Experiment<Name> = {
 >Name : Symbol(Name, Decl(other.ts, 0, 16))
 
     name: Name;
->name : Symbol(name, Decl(other.ts, 0, 25))
+>name : Symbol(Experiment.name, Decl(other.ts, 0, 25))
 >Name : Symbol(Name, Decl(other.ts, 0, 16))
 
 };
diff --git a/tests/baselines/reference/declarationEmitWithDefaultAsComputedName2.symbols b/tests/baselines/reference/declarationEmitWithDefaultAsComputedName2.symbols
index 3f4be4d8b43bf..5f2db37614f5c 100644
--- a/tests/baselines/reference/declarationEmitWithDefaultAsComputedName2.symbols
+++ b/tests/baselines/reference/declarationEmitWithDefaultAsComputedName2.symbols
@@ -4,7 +4,7 @@ type Experiment<Name> = {
 >Name : Symbol(Name, Decl(other.ts, 0, 16))
 
     name: Name;
->name : Symbol(name, Decl(other.ts, 0, 25))
+>name : Symbol(Experiment.name, Decl(other.ts, 0, 25))
 >Name : Symbol(Name, Decl(other.ts, 0, 16))
 
 };
diff --git a/tests/baselines/reference/declarationImportTypeAliasInferredAndEmittable.js b/tests/baselines/reference/declarationImportTypeAliasInferredAndEmittable.js
index b92a354acc0f3..65d1c55182c4f 100644
--- a/tests/baselines/reference/declarationImportTypeAliasInferredAndEmittable.js
+++ b/tests/baselines/reference/declarationImportTypeAliasInferredAndEmittable.js
@@ -52,7 +52,9 @@ declare class Conn {
 }
 export = Conn;
 //// [usage.d.ts]
+declare type Conn = import("./foo");
 export declare class Wrap {
     connItem: number;
-    constructor(c?: import("./foo"));
+    constructor(c?: Conn);
 }
+export {};
diff --git a/tests/baselines/reference/declarationImportTypeAliasInferredAndEmittable.types b/tests/baselines/reference/declarationImportTypeAliasInferredAndEmittable.types
index c125e9b1c08bc..bd197d4aefcc3 100644
--- a/tests/baselines/reference/declarationImportTypeAliasInferredAndEmittable.types
+++ b/tests/baselines/reference/declarationImportTypeAliasInferredAndEmittable.types
@@ -16,10 +16,10 @@ export = Conn;
 
 === tests/cases/compiler/usage.ts ===
 type Conn = import("./foo");
->Conn : import("tests/cases/compiler/foo")
+>Conn : Conn
 
 declare var x: Conn;
->x : import("tests/cases/compiler/foo")
+>x : Conn
 
 export class Wrap {
 >Wrap : Wrap
@@ -28,8 +28,8 @@ export class Wrap {
 >connItem : number
 
     constructor(c = x) {
->c : import("tests/cases/compiler/foo")
->x : import("tests/cases/compiler/foo")
+>c : Conn
+>x : Conn
 
         this.connItem = c.item;
 >this.connItem = c.item : number
@@ -37,7 +37,7 @@ export class Wrap {
 >this : this
 >connItem : number
 >c.item : number
->c : import("tests/cases/compiler/foo")
+>c : Conn
 >item : number
     }
 }
diff --git a/tests/baselines/reference/declarationsForFileShadowingGlobalNoError.symbols b/tests/baselines/reference/declarationsForFileShadowingGlobalNoError.symbols
index 70b06cd520976..da4d45587e868 100644
--- a/tests/baselines/reference/declarationsForFileShadowingGlobalNoError.symbols
+++ b/tests/baselines/reference/declarationsForFileShadowingGlobalNoError.symbols
@@ -1,7 +1,7 @@
 === tests/cases/compiler/dom.ts ===
 export type DOMNode = Node;
 >DOMNode : Symbol(DOMNode, Decl(dom.ts, 0, 0))
->Node : Symbol(Node, Decl(lib.dom.d.ts, --, --), Decl(lib.dom.d.ts, --, --))
+>Node : Symbol(DOMNode, Decl(lib.dom.d.ts, --, --), Decl(lib.dom.d.ts, --, --))
 
 === tests/cases/compiler/custom.ts ===
 export type Node = {};
diff --git a/tests/baselines/reference/declarationsForFileShadowingGlobalNoError.types b/tests/baselines/reference/declarationsForFileShadowingGlobalNoError.types
index c15ad37bccca8..f31125fc65499 100644
--- a/tests/baselines/reference/declarationsForFileShadowingGlobalNoError.types
+++ b/tests/baselines/reference/declarationsForFileShadowingGlobalNoError.types
@@ -1,6 +1,6 @@
 === tests/cases/compiler/dom.ts ===
 export type DOMNode = Node;
->DOMNode : Node
+>DOMNode : DOMNode
 
 === tests/cases/compiler/custom.ts ===
 export type Node = {};
diff --git a/tests/baselines/reference/declarationsIndirectGeneratedAliasReference.symbols b/tests/baselines/reference/declarationsIndirectGeneratedAliasReference.symbols
index f09bdc55a78e1..2f01011f676d4 100644
--- a/tests/baselines/reference/declarationsIndirectGeneratedAliasReference.symbols
+++ b/tests/baselines/reference/declarationsIndirectGeneratedAliasReference.symbols
@@ -8,8 +8,8 @@ export interface Ctor {
 export type ExtendedCtor<T> = {x: number, ext: T};
 >ExtendedCtor : Symbol(ExtendedCtor, Decl(ctor.d.ts, 2, 1))
 >T : Symbol(T, Decl(ctor.d.ts, 3, 25))
->x : Symbol(x, Decl(ctor.d.ts, 3, 31))
->ext : Symbol(ext, Decl(ctor.d.ts, 3, 41))
+>x : Symbol(ExtendedCtor.x, Decl(ctor.d.ts, 3, 31))
+>ext : Symbol(ExtendedCtor.ext, Decl(ctor.d.ts, 3, 41))
 >T : Symbol(T, Decl(ctor.d.ts, 3, 25))
 
 export interface CtorConstructor {
diff --git a/tests/baselines/reference/deepComparisons.symbols b/tests/baselines/reference/deepComparisons.symbols
index 7b2dbd596ebfd..3b8b3af189d4d 100644
--- a/tests/baselines/reference/deepComparisons.symbols
+++ b/tests/baselines/reference/deepComparisons.symbols
@@ -36,14 +36,14 @@ function f1<T, K1 extends keyof T, K2 extends keyof T[K1]>() {
 type Foo<T> = { x: Foo<T> };
 >Foo : Symbol(Foo, Decl(deepComparisons.ts, 4, 1))
 >T : Symbol(T, Decl(deepComparisons.ts, 6, 9))
->x : Symbol(x, Decl(deepComparisons.ts, 6, 15))
+>x : Symbol(Foo.x, Decl(deepComparisons.ts, 6, 15))
 >Foo : Symbol(Foo, Decl(deepComparisons.ts, 4, 1))
 >T : Symbol(T, Decl(deepComparisons.ts, 6, 9))
 
 type Bar<T> = { x: Bar<T[]> };
 >Bar : Symbol(Bar, Decl(deepComparisons.ts, 6, 28))
 >T : Symbol(T, Decl(deepComparisons.ts, 7, 9))
->x : Symbol(x, Decl(deepComparisons.ts, 7, 15))
+>x : Symbol(Bar.x, Decl(deepComparisons.ts, 7, 15))
 >Bar : Symbol(Bar, Decl(deepComparisons.ts, 6, 28))
 >T : Symbol(T, Decl(deepComparisons.ts, 7, 9))
 
@@ -62,14 +62,14 @@ function f2<U>() {
 type Foo1<T> = { x: Foo2<T> };
 >Foo1 : Symbol(Foo1, Decl(deepComparisons.ts, 11, 1))
 >T : Symbol(T, Decl(deepComparisons.ts, 13, 10))
->x : Symbol(x, Decl(deepComparisons.ts, 13, 16))
+>x : Symbol(Foo1.x, Decl(deepComparisons.ts, 13, 16))
 >Foo2 : Symbol(Foo2, Decl(deepComparisons.ts, 13, 30))
 >T : Symbol(T, Decl(deepComparisons.ts, 13, 10))
 
 type Foo2<T> = { x: Foo1<T> };
 >Foo2 : Symbol(Foo2, Decl(deepComparisons.ts, 13, 30))
 >T : Symbol(T, Decl(deepComparisons.ts, 14, 10))
->x : Symbol(x, Decl(deepComparisons.ts, 14, 16))
+>x : Symbol(Foo2.x, Decl(deepComparisons.ts, 14, 16))
 >Foo1 : Symbol(Foo1, Decl(deepComparisons.ts, 11, 1))
 >T : Symbol(T, Decl(deepComparisons.ts, 14, 10))
 
diff --git a/tests/baselines/reference/defaultParameterAddsUndefinedWithStrictNullChecks.types b/tests/baselines/reference/defaultParameterAddsUndefinedWithStrictNullChecks.types
index ef1aca3806809..a38d95d19f4c1 100644
--- a/tests/baselines/reference/defaultParameterAddsUndefinedWithStrictNullChecks.types
+++ b/tests/baselines/reference/defaultParameterAddsUndefinedWithStrictNullChecks.types
@@ -1,6 +1,6 @@
 === tests/cases/compiler/defaultParameterAddsUndefinedWithStrictNullChecks.ts ===
 function f(addUndefined1 = "J", addUndefined2?: number) {
->f : (addUndefined1?: string, addUndefined2?: number | undefined) => number
+>f : (addUndefined1?: string, addUndefined2?: number) => number
 >addUndefined1 : string
 >"J" : "J"
 >addUndefined2 : number | undefined
diff --git a/tests/baselines/reference/dependentDestructuredVariables.symbols b/tests/baselines/reference/dependentDestructuredVariables.symbols
index f859b5ee7566f..e9699d6d508c1 100644
--- a/tests/baselines/reference/dependentDestructuredVariables.symbols
+++ b/tests/baselines/reference/dependentDestructuredVariables.symbols
@@ -601,7 +601,7 @@ type FooMethod = {
 >FooMethod : Symbol(FooMethod, Decl(dependentDestructuredVariables.ts, 225, 59))
 
   method(...args:
->method : Symbol(method, Decl(dependentDestructuredVariables.ts, 229, 18))
+>method : Symbol(FooMethod.method, Decl(dependentDestructuredVariables.ts, 229, 18))
 >args : Symbol(args, Decl(dependentDestructuredVariables.ts, 230, 9))
 
     [type: "str", cb: (e: string) => void] |
@@ -639,7 +639,7 @@ type FooAsyncMethod = {
 >FooAsyncMethod : Symbol(FooAsyncMethod, Decl(dependentDestructuredVariables.ts, 244, 2))
 
   method(...args:
->method : Symbol(method, Decl(dependentDestructuredVariables.ts, 246, 23))
+>method : Symbol(FooAsyncMethod.method, Decl(dependentDestructuredVariables.ts, 246, 23))
 >args : Symbol(args, Decl(dependentDestructuredVariables.ts, 247, 9))
 
     [type: "str", cb: (e: string) => void] |
@@ -678,7 +678,7 @@ type FooGenMethod = {
 >FooGenMethod : Symbol(FooGenMethod, Decl(dependentDestructuredVariables.ts, 261, 2))
 
   method(...args:
->method : Symbol(method, Decl(dependentDestructuredVariables.ts, 263, 21))
+>method : Symbol(FooGenMethod.method, Decl(dependentDestructuredVariables.ts, 263, 21))
 >args : Symbol(args, Decl(dependentDestructuredVariables.ts, 264, 9))
 
     [type: "str", cb: (e: string) => void] |
@@ -717,7 +717,7 @@ type FooAsyncGenMethod = {
 >FooAsyncGenMethod : Symbol(FooAsyncGenMethod, Decl(dependentDestructuredVariables.ts, 278, 2))
 
   method(...args:
->method : Symbol(method, Decl(dependentDestructuredVariables.ts, 280, 26))
+>method : Symbol(FooAsyncGenMethod.method, Decl(dependentDestructuredVariables.ts, 280, 26))
 >args : Symbol(args, Decl(dependentDestructuredVariables.ts, 281, 9))
 
     [type: "str", cb: (e: string) => void] |
diff --git a/tests/baselines/reference/destructureOptionalParameter.types b/tests/baselines/reference/destructureOptionalParameter.types
index 984b2da856ae7..01b45c1cb4bf4 100644
--- a/tests/baselines/reference/destructureOptionalParameter.types
+++ b/tests/baselines/reference/destructureOptionalParameter.types
@@ -1,6 +1,6 @@
 === tests/cases/compiler/destructureOptionalParameter.ts ===
 declare function f1({ a, b }?: { a: number, b: string }): void;
->f1 : ({ a, b }?: { a: number; b: string; } | undefined) => void
+>f1 : ({ a, b }?: {    a: number;    b: string;}) => void
 >a : number
 >b : string
 >a : number
diff --git a/tests/baselines/reference/destructuringAssignmentWithDefault.types b/tests/baselines/reference/destructuringAssignmentWithDefault.types
index 379bfe8b3bdbd..170d1d26ba509 100644
--- a/tests/baselines/reference/destructuringAssignmentWithDefault.types
+++ b/tests/baselines/reference/destructuringAssignmentWithDefault.types
@@ -61,7 +61,7 @@ function f1(options?: { color?: string, width?: number }) {
 }
 
 function f2(options?: [string?, number?]) {
->f2 : (options?: [(string | undefined)?, (number | undefined)?] | undefined) => void
+>f2 : (options?: [string?, number?]) => void
 >options : [(string | undefined)?, (number | undefined)?] | undefined
 
     let [str, num] = options || [];
@@ -133,7 +133,7 @@ function f3(options?: { color: string, width: number }) {
 }
 
 function f4(options?: [string, number]) {
->f4 : (options?: [string, number] | undefined) => void
+>f4 : (options?: [string, number]) => void
 >options : [string, number] | undefined
 
     let [str, num] = options || [];
diff --git a/tests/baselines/reference/destructuringInFunctionType.symbols b/tests/baselines/reference/destructuringInFunctionType.symbols
index de4645753efc1..b0e200db5e389 100644
--- a/tests/baselines/reference/destructuringInFunctionType.symbols
+++ b/tests/baselines/reference/destructuringInFunctionType.symbols
@@ -25,7 +25,7 @@ type F1 = ([a, b, c]) => void;
 
 type T2 = ({ a });
 >T2 : Symbol(T2, Decl(destructuringInFunctionType.ts, 5, 30))
->a : Symbol(a, Decl(destructuringInFunctionType.ts, 7, 12))
+>a : Symbol(T2.a, Decl(destructuringInFunctionType.ts, 7, 12))
 
 type F2 = ({ a }) => void;
 >F2 : Symbol(F2, Decl(destructuringInFunctionType.ts, 7, 18))
diff --git a/tests/baselines/reference/destructuringParameterProperties1.symbols b/tests/baselines/reference/destructuringParameterProperties1.symbols
index 02f7887925300..fc7a42b27424a 100644
--- a/tests/baselines/reference/destructuringParameterProperties1.symbols
+++ b/tests/baselines/reference/destructuringParameterProperties1.symbols
@@ -25,9 +25,9 @@ class C2 {
 
 type ObjType1 = { x: number; y: string; z: boolean }
 >ObjType1 : Symbol(ObjType1, Decl(destructuringParameterProperties1.ts, 10, 1))
->x : Symbol(x, Decl(destructuringParameterProperties1.ts, 12, 17))
->y : Symbol(y, Decl(destructuringParameterProperties1.ts, 12, 28))
->z : Symbol(z, Decl(destructuringParameterProperties1.ts, 12, 39))
+>x : Symbol(ObjType1.x, Decl(destructuringParameterProperties1.ts, 12, 17))
+>y : Symbol(ObjType1.y, Decl(destructuringParameterProperties1.ts, 12, 28))
+>z : Symbol(ObjType1.z, Decl(destructuringParameterProperties1.ts, 12, 39))
 
 class C3 {
 >C3 : Symbol(C3, Decl(destructuringParameterProperties1.ts, 12, 52))
diff --git a/tests/baselines/reference/destructuringParameterProperties5.symbols b/tests/baselines/reference/destructuringParameterProperties5.symbols
index a42501a1a9799..cc8178682c06f 100644
--- a/tests/baselines/reference/destructuringParameterProperties5.symbols
+++ b/tests/baselines/reference/destructuringParameterProperties5.symbols
@@ -1,9 +1,9 @@
 === tests/cases/conformance/es6/destructuring/destructuringParameterProperties5.ts ===
 type ObjType1 = { x: number; y: string; z: boolean }
 >ObjType1 : Symbol(ObjType1, Decl(destructuringParameterProperties5.ts, 0, 0))
->x : Symbol(x, Decl(destructuringParameterProperties5.ts, 0, 17))
->y : Symbol(y, Decl(destructuringParameterProperties5.ts, 0, 28))
->z : Symbol(z, Decl(destructuringParameterProperties5.ts, 0, 39))
+>x : Symbol(ObjType1.x, Decl(destructuringParameterProperties5.ts, 0, 17))
+>y : Symbol(ObjType1.y, Decl(destructuringParameterProperties5.ts, 0, 28))
+>z : Symbol(ObjType1.z, Decl(destructuringParameterProperties5.ts, 0, 39))
 
 type TupleType1 = [ObjType1, number, string]
 >TupleType1 : Symbol(TupleType1, Decl(destructuringParameterProperties5.ts, 0, 52))
diff --git a/tests/baselines/reference/destructuringTypeGuardFlow.symbols b/tests/baselines/reference/destructuringTypeGuardFlow.symbols
index 4c601acb0ae79..7b5a39d5b16fc 100644
--- a/tests/baselines/reference/destructuringTypeGuardFlow.symbols
+++ b/tests/baselines/reference/destructuringTypeGuardFlow.symbols
@@ -3,13 +3,13 @@ type foo = {
 >foo : Symbol(foo, Decl(destructuringTypeGuardFlow.ts, 0, 0))
 
   bar: number | null;
->bar : Symbol(bar, Decl(destructuringTypeGuardFlow.ts, 0, 12))
+>bar : Symbol(foo.bar, Decl(destructuringTypeGuardFlow.ts, 0, 12))
 
   baz: string;
->baz : Symbol(baz, Decl(destructuringTypeGuardFlow.ts, 1, 21))
+>baz : Symbol(foo.baz, Decl(destructuringTypeGuardFlow.ts, 1, 21))
 
   nested: {
->nested : Symbol(nested, Decl(destructuringTypeGuardFlow.ts, 2, 14))
+>nested : Symbol(foo.nested, Decl(destructuringTypeGuardFlow.ts, 2, 14))
 
     a: number;
 >a : Symbol(a, Decl(destructuringTypeGuardFlow.ts, 3, 11))
@@ -29,19 +29,19 @@ const aFoo: foo = { bar: 3, baz: "b", nested: { a: 1, b: "y" } };
 >b : Symbol(b, Decl(destructuringTypeGuardFlow.ts, 9, 53))
 
 if (aFoo.bar && aFoo.nested.b) {
->aFoo.bar : Symbol(bar, Decl(destructuringTypeGuardFlow.ts, 0, 12))
+>aFoo.bar : Symbol(foo.bar, Decl(destructuringTypeGuardFlow.ts, 0, 12))
 >aFoo : Symbol(aFoo, Decl(destructuringTypeGuardFlow.ts, 9, 5))
->bar : Symbol(bar, Decl(destructuringTypeGuardFlow.ts, 0, 12))
+>bar : Symbol(foo.bar, Decl(destructuringTypeGuardFlow.ts, 0, 12))
 >aFoo.nested.b : Symbol(b, Decl(destructuringTypeGuardFlow.ts, 4, 14))
->aFoo.nested : Symbol(nested, Decl(destructuringTypeGuardFlow.ts, 2, 14))
+>aFoo.nested : Symbol(foo.nested, Decl(destructuringTypeGuardFlow.ts, 2, 14))
 >aFoo : Symbol(aFoo, Decl(destructuringTypeGuardFlow.ts, 9, 5))
->nested : Symbol(nested, Decl(destructuringTypeGuardFlow.ts, 2, 14))
+>nested : Symbol(foo.nested, Decl(destructuringTypeGuardFlow.ts, 2, 14))
 >b : Symbol(b, Decl(destructuringTypeGuardFlow.ts, 4, 14))
 
   const { bar, baz, nested: {a, b: text} } = aFoo;
 >bar : Symbol(bar, Decl(destructuringTypeGuardFlow.ts, 12, 9))
 >baz : Symbol(baz, Decl(destructuringTypeGuardFlow.ts, 12, 14))
->nested : Symbol(nested, Decl(destructuringTypeGuardFlow.ts, 2, 14))
+>nested : Symbol(foo.nested, Decl(destructuringTypeGuardFlow.ts, 2, 14))
 >a : Symbol(a, Decl(destructuringTypeGuardFlow.ts, 12, 29))
 >b : Symbol(b, Decl(destructuringTypeGuardFlow.ts, 4, 14))
 >text : Symbol(text, Decl(destructuringTypeGuardFlow.ts, 12, 31))
@@ -49,9 +49,9 @@ if (aFoo.bar && aFoo.nested.b) {
 
   const right: number = aFoo.bar;
 >right : Symbol(right, Decl(destructuringTypeGuardFlow.ts, 13, 7))
->aFoo.bar : Symbol(bar, Decl(destructuringTypeGuardFlow.ts, 0, 12))
+>aFoo.bar : Symbol(foo.bar, Decl(destructuringTypeGuardFlow.ts, 0, 12))
 >aFoo : Symbol(aFoo, Decl(destructuringTypeGuardFlow.ts, 9, 5))
->bar : Symbol(bar, Decl(destructuringTypeGuardFlow.ts, 0, 12))
+>bar : Symbol(foo.bar, Decl(destructuringTypeGuardFlow.ts, 0, 12))
 
   const wrong: number = bar;
 >wrong : Symbol(wrong, Decl(destructuringTypeGuardFlow.ts, 14, 7))
@@ -74,10 +74,10 @@ type bar = {
 >bar : Symbol(bar, Decl(destructuringTypeGuardFlow.ts, 18, 1))
 
   elem1: number | null;
->elem1 : Symbol(elem1, Decl(destructuringTypeGuardFlow.ts, 20, 12))
+>elem1 : Symbol(bar.elem1, Decl(destructuringTypeGuardFlow.ts, 20, 12))
 
   elem2: foo | null;
->elem2 : Symbol(elem2, Decl(destructuringTypeGuardFlow.ts, 21, 23))
+>elem2 : Symbol(bar.elem2, Decl(destructuringTypeGuardFlow.ts, 21, 23))
 >foo : Symbol(foo, Decl(destructuringTypeGuardFlow.ts, 0, 0))
 
 };
@@ -92,23 +92,23 @@ if (bBar.elem2 && bBar.elem2.bar && bBar.elem2.nested.b) {
 >bBar.elem2 : Symbol(elem2, Decl(destructuringTypeGuardFlow.ts, 25, 24))
 >bBar : Symbol(bBar, Decl(destructuringTypeGuardFlow.ts, 25, 5))
 >elem2 : Symbol(elem2, Decl(destructuringTypeGuardFlow.ts, 25, 24))
->bBar.elem2.bar : Symbol(bar, Decl(destructuringTypeGuardFlow.ts, 0, 12))
+>bBar.elem2.bar : Symbol(foo.bar, Decl(destructuringTypeGuardFlow.ts, 0, 12))
 >bBar.elem2 : Symbol(elem2, Decl(destructuringTypeGuardFlow.ts, 25, 24))
 >bBar : Symbol(bBar, Decl(destructuringTypeGuardFlow.ts, 25, 5))
 >elem2 : Symbol(elem2, Decl(destructuringTypeGuardFlow.ts, 25, 24))
->bar : Symbol(bar, Decl(destructuringTypeGuardFlow.ts, 0, 12))
+>bar : Symbol(foo.bar, Decl(destructuringTypeGuardFlow.ts, 0, 12))
 >bBar.elem2.nested.b : Symbol(b, Decl(destructuringTypeGuardFlow.ts, 4, 14))
->bBar.elem2.nested : Symbol(nested, Decl(destructuringTypeGuardFlow.ts, 2, 14))
+>bBar.elem2.nested : Symbol(foo.nested, Decl(destructuringTypeGuardFlow.ts, 2, 14))
 >bBar.elem2 : Symbol(elem2, Decl(destructuringTypeGuardFlow.ts, 25, 24))
 >bBar : Symbol(bBar, Decl(destructuringTypeGuardFlow.ts, 25, 5))
 >elem2 : Symbol(elem2, Decl(destructuringTypeGuardFlow.ts, 25, 24))
->nested : Symbol(nested, Decl(destructuringTypeGuardFlow.ts, 2, 14))
+>nested : Symbol(foo.nested, Decl(destructuringTypeGuardFlow.ts, 2, 14))
 >b : Symbol(b, Decl(destructuringTypeGuardFlow.ts, 4, 14))
 
   const { bar, baz, nested: {a, b: text} } = bBar.elem2;
 >bar : Symbol(bar, Decl(destructuringTypeGuardFlow.ts, 28, 9))
 >baz : Symbol(baz, Decl(destructuringTypeGuardFlow.ts, 28, 14))
->nested : Symbol(nested, Decl(destructuringTypeGuardFlow.ts, 2, 14))
+>nested : Symbol(foo.nested, Decl(destructuringTypeGuardFlow.ts, 2, 14))
 >a : Symbol(a, Decl(destructuringTypeGuardFlow.ts, 28, 29))
 >b : Symbol(b, Decl(destructuringTypeGuardFlow.ts, 4, 14))
 >text : Symbol(text, Decl(destructuringTypeGuardFlow.ts, 28, 31))
@@ -118,11 +118,11 @@ if (bBar.elem2 && bBar.elem2.bar && bBar.elem2.nested.b) {
 
   const right: number = bBar.elem2.bar;
 >right : Symbol(right, Decl(destructuringTypeGuardFlow.ts, 29, 7))
->bBar.elem2.bar : Symbol(bar, Decl(destructuringTypeGuardFlow.ts, 0, 12))
+>bBar.elem2.bar : Symbol(foo.bar, Decl(destructuringTypeGuardFlow.ts, 0, 12))
 >bBar.elem2 : Symbol(elem2, Decl(destructuringTypeGuardFlow.ts, 25, 24))
 >bBar : Symbol(bBar, Decl(destructuringTypeGuardFlow.ts, 25, 5))
 >elem2 : Symbol(elem2, Decl(destructuringTypeGuardFlow.ts, 25, 24))
->bar : Symbol(bar, Decl(destructuringTypeGuardFlow.ts, 0, 12))
+>bar : Symbol(foo.bar, Decl(destructuringTypeGuardFlow.ts, 0, 12))
 
   const wrong: number = bar;
 >wrong : Symbol(wrong, Decl(destructuringTypeGuardFlow.ts, 30, 7))
diff --git a/tests/baselines/reference/directDependenceBetweenTypeAliases.symbols b/tests/baselines/reference/directDependenceBetweenTypeAliases.symbols
index 2fb07f415f795..d10057388e95b 100644
--- a/tests/baselines/reference/directDependenceBetweenTypeAliases.symbols
+++ b/tests/baselines/reference/directDependenceBetweenTypeAliases.symbols
@@ -107,7 +107,7 @@ type T13 = typeof zz
 
 var zz: { x: T11 }
 >zz : Symbol(zz, Decl(directDependenceBetweenTypeAliases.ts, 39, 3))
->x : Symbol(x, Decl(directDependenceBetweenTypeAliases.ts, 39, 9))
+>x : Symbol(T13.x, Decl(directDependenceBetweenTypeAliases.ts, 39, 9))
 >T11 : Symbol(T11, Decl(directDependenceBetweenTypeAliases.ts, 35, 47))
 
 
diff --git a/tests/baselines/reference/discriminantPropertyCheck.symbols b/tests/baselines/reference/discriminantPropertyCheck.symbols
index 7fa10ac46e28e..c791f00d7086c 100644
--- a/tests/baselines/reference/discriminantPropertyCheck.symbols
+++ b/tests/baselines/reference/discriminantPropertyCheck.symbols
@@ -459,13 +459,13 @@ type UnionOfBar = TypeBar1 | TypeBar2;
 
 type TypeBar1 = { type: BarEnum.bar1 };
 >TypeBar1 : Symbol(TypeBar1, Decl(discriminantPropertyCheck.ts, 159, 38))
->type : Symbol(type, Decl(discriminantPropertyCheck.ts, 160, 17))
+>type : Symbol(TypeBar1.type, Decl(discriminantPropertyCheck.ts, 160, 17))
 >BarEnum : Symbol(BarEnum, Decl(discriminantPropertyCheck.ts, 152, 44))
 >bar1 : Symbol(BarEnum.bar1, Decl(discriminantPropertyCheck.ts, 154, 20))
 
 type TypeBar2 = { type: BarEnum.bar2 };
 >TypeBar2 : Symbol(TypeBar2, Decl(discriminantPropertyCheck.ts, 160, 39))
->type : Symbol(type, Decl(discriminantPropertyCheck.ts, 161, 17))
+>type : Symbol(TypeBar2.type, Decl(discriminantPropertyCheck.ts, 161, 17))
 >BarEnum : Symbol(BarEnum, Decl(discriminantPropertyCheck.ts, 152, 44))
 >bar2 : Symbol(BarEnum.bar2, Decl(discriminantPropertyCheck.ts, 155, 13))
 
@@ -587,20 +587,20 @@ type TestA = {
 >TestA : Symbol(TestA, Decl(discriminantPropertyCheck.ts, 204, 1))
 
     type: 'testA';
->type : Symbol(type, Decl(discriminantPropertyCheck.ts, 208, 14))
+>type : Symbol(TestA.type, Decl(discriminantPropertyCheck.ts, 208, 14))
 
     bananas: 3;
->bananas : Symbol(bananas, Decl(discriminantPropertyCheck.ts, 209, 18))
+>bananas : Symbol(TestA.bananas, Decl(discriminantPropertyCheck.ts, 209, 18))
 }
   
 type TestB = {
 >TestB : Symbol(TestB, Decl(discriminantPropertyCheck.ts, 211, 1))
 
     type: 'testB';
->type : Symbol(type, Decl(discriminantPropertyCheck.ts, 213, 14))
+>type : Symbol(TestB.type, Decl(discriminantPropertyCheck.ts, 213, 14))
 
     apples: 5;
->apples : Symbol(apples, Decl(discriminantPropertyCheck.ts, 214, 18))
+>apples : Symbol(TestB.apples, Decl(discriminantPropertyCheck.ts, 214, 18))
 }
   
 type AllTests = TestA | TestB;
@@ -642,9 +642,9 @@ const doTestingStuff = (mapOfTests: MapOfAllTests, ids: string[]) => {
 >console.log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --))
 >console : Symbol(console, Decl(lib.dom.d.ts, --, --))
 >log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --))
->test.bananas : Symbol(bananas, Decl(discriminantPropertyCheck.ts, 209, 18))
+>test.bananas : Symbol(TestA.bananas, Decl(discriminantPropertyCheck.ts, 209, 18))
 >test : Symbol(test, Decl(discriminantPropertyCheck.ts, 224, 11))
->bananas : Symbol(bananas, Decl(discriminantPropertyCheck.ts, 209, 18))
+>bananas : Symbol(TestA.bananas, Decl(discriminantPropertyCheck.ts, 209, 18))
         }
         switch (test.type) {
 >test.type : Symbol(type, Decl(discriminantPropertyCheck.ts, 208, 14), Decl(discriminantPropertyCheck.ts, 213, 14))
@@ -656,9 +656,9 @@ const doTestingStuff = (mapOfTests: MapOfAllTests, ids: string[]) => {
 >console.log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --))
 >console : Symbol(console, Decl(lib.dom.d.ts, --, --))
 >log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --))
->test.bananas : Symbol(bananas, Decl(discriminantPropertyCheck.ts, 209, 18))
+>test.bananas : Symbol(TestA.bananas, Decl(discriminantPropertyCheck.ts, 209, 18))
 >test : Symbol(test, Decl(discriminantPropertyCheck.ts, 224, 11))
->bananas : Symbol(bananas, Decl(discriminantPropertyCheck.ts, 209, 18))
+>bananas : Symbol(TestA.bananas, Decl(discriminantPropertyCheck.ts, 209, 18))
             }
         }
     });
diff --git a/tests/baselines/reference/discriminantPropertyInference.symbols b/tests/baselines/reference/discriminantPropertyInference.symbols
index 1908bdd984321..3ae46e78409e3 100644
--- a/tests/baselines/reference/discriminantPropertyInference.symbols
+++ b/tests/baselines/reference/discriminantPropertyInference.symbols
@@ -5,10 +5,10 @@ type DiscriminatorTrue = {
 >DiscriminatorTrue : Symbol(DiscriminatorTrue, Decl(discriminantPropertyInference.ts, 0, 0))
 
     disc: true;
->disc : Symbol(disc, Decl(discriminantPropertyInference.ts, 2, 26))
+>disc : Symbol(DiscriminatorTrue.disc, Decl(discriminantPropertyInference.ts, 2, 26))
 
     cb: (x: string) => void;
->cb : Symbol(cb, Decl(discriminantPropertyInference.ts, 3, 15))
+>cb : Symbol(DiscriminatorTrue.cb, Decl(discriminantPropertyInference.ts, 3, 15))
 >x : Symbol(x, Decl(discriminantPropertyInference.ts, 4, 9))
 }
 
@@ -16,10 +16,10 @@ type DiscriminatorFalse = {
 >DiscriminatorFalse : Symbol(DiscriminatorFalse, Decl(discriminantPropertyInference.ts, 5, 1))
 
     disc?: false;
->disc : Symbol(disc, Decl(discriminantPropertyInference.ts, 7, 27))
+>disc : Symbol(DiscriminatorFalse.disc, Decl(discriminantPropertyInference.ts, 7, 27))
 
     cb: (x: number) => void;
->cb : Symbol(cb, Decl(discriminantPropertyInference.ts, 8, 17))
+>cb : Symbol(DiscriminatorFalse.cb, Decl(discriminantPropertyInference.ts, 8, 17))
 >x : Symbol(x, Decl(discriminantPropertyInference.ts, 9, 9))
 }
 
diff --git a/tests/baselines/reference/discriminatedUnionErrorMessage.symbols b/tests/baselines/reference/discriminatedUnionErrorMessage.symbols
index 3afcb68385723..124a1d89d8772 100644
--- a/tests/baselines/reference/discriminatedUnionErrorMessage.symbols
+++ b/tests/baselines/reference/discriminatedUnionErrorMessage.symbols
@@ -1,19 +1,19 @@
 === tests/cases/compiler/discriminatedUnionErrorMessage.ts ===
 type Square = { kind: "sq", size: number }
 >Square : Symbol(Square, Decl(discriminatedUnionErrorMessage.ts, 0, 0))
->kind : Symbol(kind, Decl(discriminatedUnionErrorMessage.ts, 0, 15))
->size : Symbol(size, Decl(discriminatedUnionErrorMessage.ts, 0, 27))
+>kind : Symbol(Square.kind, Decl(discriminatedUnionErrorMessage.ts, 0, 15))
+>size : Symbol(Square.size, Decl(discriminatedUnionErrorMessage.ts, 0, 27))
 
 type Rectangle = { kind: "rt", x: number, y: number }
 >Rectangle : Symbol(Rectangle, Decl(discriminatedUnionErrorMessage.ts, 0, 42))
->kind : Symbol(kind, Decl(discriminatedUnionErrorMessage.ts, 1, 18))
->x : Symbol(x, Decl(discriminatedUnionErrorMessage.ts, 1, 30))
->y : Symbol(y, Decl(discriminatedUnionErrorMessage.ts, 1, 41))
+>kind : Symbol(Rectangle.kind, Decl(discriminatedUnionErrorMessage.ts, 1, 18))
+>x : Symbol(Rectangle.x, Decl(discriminatedUnionErrorMessage.ts, 1, 30))
+>y : Symbol(Rectangle.y, Decl(discriminatedUnionErrorMessage.ts, 1, 41))
 
 type Circle = { kind: "cr", radius: number }
 >Circle : Symbol(Circle, Decl(discriminatedUnionErrorMessage.ts, 1, 53))
->kind : Symbol(kind, Decl(discriminatedUnionErrorMessage.ts, 2, 15))
->radius : Symbol(radius, Decl(discriminatedUnionErrorMessage.ts, 2, 27))
+>kind : Symbol(Circle.kind, Decl(discriminatedUnionErrorMessage.ts, 2, 15))
+>radius : Symbol(Circle.radius, Decl(discriminatedUnionErrorMessage.ts, 2, 27))
 
 type Shape =
 >Shape : Symbol(Shape, Decl(discriminatedUnionErrorMessage.ts, 2, 44))
diff --git a/tests/baselines/reference/discriminatedUnionInference.symbols b/tests/baselines/reference/discriminatedUnionInference.symbols
index d8643b7ba6af6..4db3efb16e01e 100644
--- a/tests/baselines/reference/discriminatedUnionInference.symbols
+++ b/tests/baselines/reference/discriminatedUnionInference.symbols
@@ -4,13 +4,13 @@
 type Foo<A> = { type: "foo", (): A[] };
 >Foo : Symbol(Foo, Decl(discriminatedUnionInference.ts, 0, 0))
 >A : Symbol(A, Decl(discriminatedUnionInference.ts, 2, 9))
->type : Symbol(type, Decl(discriminatedUnionInference.ts, 2, 15))
+>type : Symbol(Foo.type, Decl(discriminatedUnionInference.ts, 2, 15))
 >A : Symbol(A, Decl(discriminatedUnionInference.ts, 2, 9))
 
 type Bar<A> = { type: "bar", (): A };
 >Bar : Symbol(Bar, Decl(discriminatedUnionInference.ts, 2, 39))
 >A : Symbol(A, Decl(discriminatedUnionInference.ts, 3, 9))
->type : Symbol(type, Decl(discriminatedUnionInference.ts, 3, 15))
+>type : Symbol(Bar.type, Decl(discriminatedUnionInference.ts, 3, 15))
 >A : Symbol(A, Decl(discriminatedUnionInference.ts, 3, 9))
 
 type FooBar<A> = Foo<A> | Bar<A>;
diff --git a/tests/baselines/reference/discriminatedUnionTypes2.symbols b/tests/baselines/reference/discriminatedUnionTypes2.symbols
index 747f43ac21e4c..0476eab5c6c25 100644
--- a/tests/baselines/reference/discriminatedUnionTypes2.symbols
+++ b/tests/baselines/reference/discriminatedUnionTypes2.symbols
@@ -279,28 +279,28 @@ type a = {
 >a : Symbol(a, Decl(discriminatedUnionTypes2.ts, 93, 1))
 
     type: 'a',
->type : Symbol(type, Decl(discriminatedUnionTypes2.ts, 97, 10))
+>type : Symbol(a.type, Decl(discriminatedUnionTypes2.ts, 97, 10))
 
     data: string
->data : Symbol(data, Decl(discriminatedUnionTypes2.ts, 98, 14))
+>data : Symbol(a.data, Decl(discriminatedUnionTypes2.ts, 98, 14))
 }
 type b = {
 >b : Symbol(b, Decl(discriminatedUnionTypes2.ts, 100, 1))
 
     type: 'b',
->type : Symbol(type, Decl(discriminatedUnionTypes2.ts, 101, 10))
+>type : Symbol(b.type, Decl(discriminatedUnionTypes2.ts, 101, 10))
 
     name: string
->name : Symbol(name, Decl(discriminatedUnionTypes2.ts, 102, 14))
+>name : Symbol(b.name, Decl(discriminatedUnionTypes2.ts, 102, 14))
 }
 type c = {
 >c : Symbol(c, Decl(discriminatedUnionTypes2.ts, 104, 1))
 
     type: 'c',
->type : Symbol(type, Decl(discriminatedUnionTypes2.ts, 105, 10))
+>type : Symbol(c.type, Decl(discriminatedUnionTypes2.ts, 105, 10))
 
     other: string
->other : Symbol(other, Decl(discriminatedUnionTypes2.ts, 106, 14))
+>other : Symbol(c.other, Decl(discriminatedUnionTypes2.ts, 106, 14))
 }
 
 type abc = a | b | c;
@@ -322,15 +322,15 @@ function f(problem: abc & (b | c)) {
 >type : Symbol(type, Decl(discriminatedUnionTypes2.ts, 101, 10), Decl(discriminatedUnionTypes2.ts, 105, 10))
 
         problem.name;
->problem.name : Symbol(name, Decl(discriminatedUnionTypes2.ts, 102, 14))
+>problem.name : Symbol(b.name, Decl(discriminatedUnionTypes2.ts, 102, 14))
 >problem : Symbol(problem, Decl(discriminatedUnionTypes2.ts, 112, 11))
->name : Symbol(name, Decl(discriminatedUnionTypes2.ts, 102, 14))
+>name : Symbol(b.name, Decl(discriminatedUnionTypes2.ts, 102, 14))
     }
     else {
         problem.other;
->problem.other : Symbol(other, Decl(discriminatedUnionTypes2.ts, 106, 14))
+>problem.other : Symbol(c.other, Decl(discriminatedUnionTypes2.ts, 106, 14))
 >problem : Symbol(problem, Decl(discriminatedUnionTypes2.ts, 112, 11))
->other : Symbol(other, Decl(discriminatedUnionTypes2.ts, 106, 14))
+>other : Symbol(c.other, Decl(discriminatedUnionTypes2.ts, 106, 14))
     }
 }
 
diff --git a/tests/baselines/reference/discriminatedUnionTypes3.symbols b/tests/baselines/reference/discriminatedUnionTypes3.symbols
index 65fdd49877055..507fd93dba279 100644
--- a/tests/baselines/reference/discriminatedUnionTypes3.symbols
+++ b/tests/baselines/reference/discriminatedUnionTypes3.symbols
@@ -5,19 +5,19 @@ type Correct = {
 >Correct : Symbol(Correct, Decl(discriminatedUnionTypes3.ts, 0, 0))
 
 	code: string
->code : Symbol(code, Decl(discriminatedUnionTypes3.ts, 2, 16))
+>code : Symbol(Correct.code, Decl(discriminatedUnionTypes3.ts, 2, 16))
 
 	property: true
->property : Symbol(property, Decl(discriminatedUnionTypes3.ts, 3, 13))
+>property : Symbol(Correct.property, Decl(discriminatedUnionTypes3.ts, 3, 13))
 
 	err: undefined
->err : Symbol(err, Decl(discriminatedUnionTypes3.ts, 4, 15))
+>err : Symbol(Correct.err, Decl(discriminatedUnionTypes3.ts, 4, 15))
 }
 type Err = {
 >Err : Symbol(Err, Decl(discriminatedUnionTypes3.ts, 6, 1))
 
 	err: `${string} is wrong!`
->err : Symbol(err, Decl(discriminatedUnionTypes3.ts, 7, 12))
+>err : Symbol(Err.err, Decl(discriminatedUnionTypes3.ts, 7, 12))
 }
 type SomeReturnType = Correct | Err;
 >SomeReturnType : Symbol(SomeReturnType, Decl(discriminatedUnionTypes3.ts, 9, 1))
@@ -36,7 +36,7 @@ if (example.err === undefined) {
 >undefined : Symbol(undefined)
 
 	example.property;  // true
->example.property : Symbol(property, Decl(discriminatedUnionTypes3.ts, 3, 13))
+>example.property : Symbol(Correct.property, Decl(discriminatedUnionTypes3.ts, 3, 13))
 >example : Symbol(example, Decl(discriminatedUnionTypes3.ts, 12, 5))
->property : Symbol(property, Decl(discriminatedUnionTypes3.ts, 3, 13))
+>property : Symbol(Correct.property, Decl(discriminatedUnionTypes3.ts, 3, 13))
 }
diff --git a/tests/baselines/reference/divergentAccessors1.symbols b/tests/baselines/reference/divergentAccessors1.symbols
index d8253a6d1f285..889922292e17b 100644
--- a/tests/baselines/reference/divergentAccessors1.symbols
+++ b/tests/baselines/reference/divergentAccessors1.symbols
@@ -34,10 +34,10 @@
 >T_HasGetSet : Symbol(T_HasGetSet, Decl(divergentAccessors1.ts, 13, 1))
 
         get foo(): number;
->foo : Symbol(foo, Decl(divergentAccessors1.ts, 14, 24), Decl(divergentAccessors1.ts, 15, 26))
+>foo : Symbol(T_HasGetSet.foo, Decl(divergentAccessors1.ts, 14, 24), Decl(divergentAccessors1.ts, 15, 26))
 
         set foo(v: number | string);
->foo : Symbol(foo, Decl(divergentAccessors1.ts, 14, 24), Decl(divergentAccessors1.ts, 15, 26))
+>foo : Symbol(T_HasGetSet.foo, Decl(divergentAccessors1.ts, 14, 24), Decl(divergentAccessors1.ts, 15, 26))
 >v : Symbol(v, Decl(divergentAccessors1.ts, 16, 16))
     }
     
@@ -46,14 +46,14 @@
 >T_HasGetSet : Symbol(T_HasGetSet, Decl(divergentAccessors1.ts, 13, 1))
 
     t_hgs.foo = "32";
->t_hgs.foo : Symbol(foo, Decl(divergentAccessors1.ts, 14, 24), Decl(divergentAccessors1.ts, 15, 26))
+>t_hgs.foo : Symbol(T_HasGetSet.foo, Decl(divergentAccessors1.ts, 14, 24), Decl(divergentAccessors1.ts, 15, 26))
 >t_hgs : Symbol(t_hgs, Decl(divergentAccessors1.ts, 19, 9))
->foo : Symbol(foo, Decl(divergentAccessors1.ts, 14, 24), Decl(divergentAccessors1.ts, 15, 26))
+>foo : Symbol(T_HasGetSet.foo, Decl(divergentAccessors1.ts, 14, 24), Decl(divergentAccessors1.ts, 15, 26))
 
     let r_t_hgs_foo: number = t_hgs.foo;
 >r_t_hgs_foo : Symbol(r_t_hgs_foo, Decl(divergentAccessors1.ts, 21, 7))
->t_hgs.foo : Symbol(foo, Decl(divergentAccessors1.ts, 14, 24), Decl(divergentAccessors1.ts, 15, 26))
+>t_hgs.foo : Symbol(T_HasGetSet.foo, Decl(divergentAccessors1.ts, 14, 24), Decl(divergentAccessors1.ts, 15, 26))
 >t_hgs : Symbol(t_hgs, Decl(divergentAccessors1.ts, 19, 9))
->foo : Symbol(foo, Decl(divergentAccessors1.ts, 14, 24), Decl(divergentAccessors1.ts, 15, 26))
+>foo : Symbol(T_HasGetSet.foo, Decl(divergentAccessors1.ts, 14, 24), Decl(divergentAccessors1.ts, 15, 26))
 }
 
diff --git a/tests/baselines/reference/divergentAccessorsTypes1.symbols b/tests/baselines/reference/divergentAccessorsTypes1.symbols
index 3df60f476a285..5d08a72e26162 100644
--- a/tests/baselines/reference/divergentAccessorsTypes1.symbols
+++ b/tests/baselines/reference/divergentAccessorsTypes1.symbols
@@ -49,17 +49,17 @@ type Test3 = {
 >Test3 : Symbol(Test3, Decl(divergentAccessorsTypes1.ts, 18, 1))
 
     get foo(): string;
->foo : Symbol(foo, Decl(divergentAccessorsTypes1.ts, 20, 14), Decl(divergentAccessorsTypes1.ts, 21, 22))
+>foo : Symbol(Test3.foo, Decl(divergentAccessorsTypes1.ts, 20, 14), Decl(divergentAccessorsTypes1.ts, 21, 22))
 
     set foo(s: string | number);
->foo : Symbol(foo, Decl(divergentAccessorsTypes1.ts, 20, 14), Decl(divergentAccessorsTypes1.ts, 21, 22))
+>foo : Symbol(Test3.foo, Decl(divergentAccessorsTypes1.ts, 20, 14), Decl(divergentAccessorsTypes1.ts, 21, 22))
 >s : Symbol(s, Decl(divergentAccessorsTypes1.ts, 22, 12))
 
     get bar(): string | number;
->bar : Symbol(bar, Decl(divergentAccessorsTypes1.ts, 22, 32), Decl(divergentAccessorsTypes1.ts, 24, 31))
+>bar : Symbol(Test3.bar, Decl(divergentAccessorsTypes1.ts, 22, 32), Decl(divergentAccessorsTypes1.ts, 24, 31))
 
     set bar(s: string | number | boolean);
->bar : Symbol(bar, Decl(divergentAccessorsTypes1.ts, 22, 32), Decl(divergentAccessorsTypes1.ts, 24, 31))
+>bar : Symbol(Test3.bar, Decl(divergentAccessorsTypes1.ts, 22, 32), Decl(divergentAccessorsTypes1.ts, 24, 31))
 >s : Symbol(s, Decl(divergentAccessorsTypes1.ts, 25, 12))
 
 };
@@ -150,36 +150,36 @@ type Test3 = {
 >Test3 : Symbol(Test3, Decl(divergentAccessorsTypes1.ts, 18, 1))
 
     t.foo = 32;
->t.foo : Symbol(foo, Decl(divergentAccessorsTypes1.ts, 20, 14), Decl(divergentAccessorsTypes1.ts, 21, 22))
+>t.foo : Symbol(Test3.foo, Decl(divergentAccessorsTypes1.ts, 20, 14), Decl(divergentAccessorsTypes1.ts, 21, 22))
 >t : Symbol(t, Decl(divergentAccessorsTypes1.ts, 53, 9))
->foo : Symbol(foo, Decl(divergentAccessorsTypes1.ts, 20, 14), Decl(divergentAccessorsTypes1.ts, 21, 22))
+>foo : Symbol(Test3.foo, Decl(divergentAccessorsTypes1.ts, 20, 14), Decl(divergentAccessorsTypes1.ts, 21, 22))
 
     let m: string = t.foo;
 >m : Symbol(m, Decl(divergentAccessorsTypes1.ts, 55, 7))
->t.foo : Symbol(foo, Decl(divergentAccessorsTypes1.ts, 20, 14), Decl(divergentAccessorsTypes1.ts, 21, 22))
+>t.foo : Symbol(Test3.foo, Decl(divergentAccessorsTypes1.ts, 20, 14), Decl(divergentAccessorsTypes1.ts, 21, 22))
 >t : Symbol(t, Decl(divergentAccessorsTypes1.ts, 53, 9))
->foo : Symbol(foo, Decl(divergentAccessorsTypes1.ts, 20, 14), Decl(divergentAccessorsTypes1.ts, 21, 22))
+>foo : Symbol(Test3.foo, Decl(divergentAccessorsTypes1.ts, 20, 14), Decl(divergentAccessorsTypes1.ts, 21, 22))
 
     // See how CFA interacts with out-of-type writes
     t.bar = 42;
->t.bar : Symbol(bar, Decl(divergentAccessorsTypes1.ts, 22, 32), Decl(divergentAccessorsTypes1.ts, 24, 31))
+>t.bar : Symbol(Test3.bar, Decl(divergentAccessorsTypes1.ts, 22, 32), Decl(divergentAccessorsTypes1.ts, 24, 31))
 >t : Symbol(t, Decl(divergentAccessorsTypes1.ts, 53, 9))
->bar : Symbol(bar, Decl(divergentAccessorsTypes1.ts, 22, 32), Decl(divergentAccessorsTypes1.ts, 24, 31))
+>bar : Symbol(Test3.bar, Decl(divergentAccessorsTypes1.ts, 22, 32), Decl(divergentAccessorsTypes1.ts, 24, 31))
 
     let n: number = t.bar;
 >n : Symbol(n, Decl(divergentAccessorsTypes1.ts, 59, 7))
->t.bar : Symbol(bar, Decl(divergentAccessorsTypes1.ts, 22, 32), Decl(divergentAccessorsTypes1.ts, 24, 31))
+>t.bar : Symbol(Test3.bar, Decl(divergentAccessorsTypes1.ts, 22, 32), Decl(divergentAccessorsTypes1.ts, 24, 31))
 >t : Symbol(t, Decl(divergentAccessorsTypes1.ts, 53, 9))
->bar : Symbol(bar, Decl(divergentAccessorsTypes1.ts, 22, 32), Decl(divergentAccessorsTypes1.ts, 24, 31))
+>bar : Symbol(Test3.bar, Decl(divergentAccessorsTypes1.ts, 22, 32), Decl(divergentAccessorsTypes1.ts, 24, 31))
 
     t.bar = false;
->t.bar : Symbol(bar, Decl(divergentAccessorsTypes1.ts, 22, 32), Decl(divergentAccessorsTypes1.ts, 24, 31))
+>t.bar : Symbol(Test3.bar, Decl(divergentAccessorsTypes1.ts, 22, 32), Decl(divergentAccessorsTypes1.ts, 24, 31))
 >t : Symbol(t, Decl(divergentAccessorsTypes1.ts, 53, 9))
->bar : Symbol(bar, Decl(divergentAccessorsTypes1.ts, 22, 32), Decl(divergentAccessorsTypes1.ts, 24, 31))
+>bar : Symbol(Test3.bar, Decl(divergentAccessorsTypes1.ts, 22, 32), Decl(divergentAccessorsTypes1.ts, 24, 31))
 
     let o = t.bar;
 >o : Symbol(o, Decl(divergentAccessorsTypes1.ts, 61, 7))
->t.bar : Symbol(bar, Decl(divergentAccessorsTypes1.ts, 22, 32), Decl(divergentAccessorsTypes1.ts, 24, 31))
+>t.bar : Symbol(Test3.bar, Decl(divergentAccessorsTypes1.ts, 22, 32), Decl(divergentAccessorsTypes1.ts, 24, 31))
 >t : Symbol(t, Decl(divergentAccessorsTypes1.ts, 53, 9))
->bar : Symbol(bar, Decl(divergentAccessorsTypes1.ts, 22, 32), Decl(divergentAccessorsTypes1.ts, 24, 31))
+>bar : Symbol(Test3.bar, Decl(divergentAccessorsTypes1.ts, 22, 32), Decl(divergentAccessorsTypes1.ts, 24, 31))
 }
diff --git a/tests/baselines/reference/dynamicNames.symbols b/tests/baselines/reference/dynamicNames.symbols
index 08f7be94fd5ad..83b575106b4d9 100644
--- a/tests/baselines/reference/dynamicNames.symbols
+++ b/tests/baselines/reference/dynamicNames.symbols
@@ -48,15 +48,15 @@ export declare type T3 = {
 >T3 : Symbol(T3, Decl(module.ts, 14, 1))
 
     [c0]: number;
->[c0] : Symbol([c0], Decl(module.ts, 15, 26))
+>[c0] : Symbol(T3[c0], Decl(module.ts, 15, 26))
 >c0 : Symbol(c0, Decl(module.ts, 0, 12))
 
     [c1]: string;
->[c1] : Symbol([c1], Decl(module.ts, 16, 17))
+>[c1] : Symbol(T3[c1], Decl(module.ts, 16, 17))
 >c1 : Symbol(c1, Decl(module.ts, 1, 12))
 
     [s0]: boolean;
->[s0] : Symbol([s0], Decl(module.ts, 17, 17))
+>[s0] : Symbol(T3[s0], Decl(module.ts, 17, 17))
 >s0 : Symbol(s0, Decl(module.ts, 2, 12))
 
 };
@@ -139,19 +139,19 @@ namespace N {
 >T7 : Symbol(T7, Decl(main.ts, 19, 5))
 
         [N.c2]: number;
->[N.c2] : Symbol([N.c2], Decl(main.ts, 20, 30))
+>[N.c2] : Symbol(T7[N.c2], Decl(main.ts, 20, 30))
 >N.c2 : Symbol(c2, Decl(main.ts, 4, 16))
 >N : Symbol(N, Decl(main.ts, 1, 30))
 >c2 : Symbol(c2, Decl(main.ts, 4, 16))
 
         [N.c3]: string;
->[N.c3] : Symbol([N.c3], Decl(main.ts, 21, 23))
+>[N.c3] : Symbol(T7[N.c3], Decl(main.ts, 21, 23))
 >N.c3 : Symbol(c3, Decl(main.ts, 5, 16))
 >N : Symbol(N, Decl(main.ts, 1, 30))
 >c3 : Symbol(c3, Decl(main.ts, 5, 16))
 
         [N.s1]: boolean;
->[N.s1] : Symbol([N.s1], Decl(main.ts, 22, 23))
+>[N.s1] : Symbol(T7[N.s1], Decl(main.ts, 22, 23))
 >N.s1 : Symbol(s1, Decl(main.ts, 6, 16))
 >N : Symbol(N, Decl(main.ts, 1, 30))
 >s1 : Symbol(s1, Decl(main.ts, 6, 16))
@@ -209,15 +209,15 @@ declare type T11 = {
 >T11 : Symbol(T11, Decl(main.ts, 42, 1))
 
     [c4]: number;
->[c4] : Symbol([c4], Decl(main.ts, 43, 20))
+>[c4] : Symbol(T11[c4], Decl(main.ts, 43, 20))
 >c4 : Symbol(c4, Decl(main.ts, 27, 12))
 
     [c5]: string;
->[c5] : Symbol([c5], Decl(main.ts, 44, 17))
+>[c5] : Symbol(T11[c5], Decl(main.ts, 44, 17))
 >c5 : Symbol(c5, Decl(main.ts, 28, 12))
 
     [s2]: boolean;
->[s2] : Symbol([s2], Decl(main.ts, 45, 17))
+>[s2] : Symbol(T11[s2], Decl(main.ts, 45, 17))
 >s2 : Symbol(s2, Decl(main.ts, 29, 12))
 
 };
@@ -257,13 +257,13 @@ declare type T15 = {
 >T15 : Symbol(T15, Decl(main.ts, 60, 1))
 
     a: number;
->a : Symbol(a, Decl(main.ts, 61, 20))
+>a : Symbol(T15.a, Decl(main.ts, 61, 20))
 
     1: string;
->1 : Symbol(1, Decl(main.ts, 62, 14))
+>1 : Symbol(T15[1], Decl(main.ts, 62, 14))
 
     [s2]: boolean;
->[s2] : Symbol([s2], Decl(main.ts, 63, 14))
+>[s2] : Symbol(T15[s2], Decl(main.ts, 63, 14))
 >s2 : Symbol(s2, Decl(main.ts, 29, 12))
 
 };
diff --git a/tests/baselines/reference/dynamicNamesErrors.symbols b/tests/baselines/reference/dynamicNamesErrors.symbols
index 95fa0cd751e9a..c54eee0549308 100644
--- a/tests/baselines/reference/dynamicNamesErrors.symbols
+++ b/tests/baselines/reference/dynamicNamesErrors.symbols
@@ -130,11 +130,11 @@ export type ObjectTypeVisibility = {
 >ObjectTypeVisibility : Symbol(ObjectTypeVisibility, Decl(dynamicNamesErrors.ts, 46, 1))
 
     [x]: number;
->[x] : Symbol([x], Decl(dynamicNamesErrors.ts, 48, 36))
+>[x] : Symbol(ObjectTypeVisibility[x], Decl(dynamicNamesErrors.ts, 48, 36))
 >x : Symbol(x, Decl(dynamicNamesErrors.ts, 26, 5))
 
     [y](): number;
->[y] : Symbol([y], Decl(dynamicNamesErrors.ts, 49, 16))
+>[y] : Symbol(ObjectTypeVisibility[y], Decl(dynamicNamesErrors.ts, 49, 16))
 >y : Symbol(y, Decl(dynamicNamesErrors.ts, 27, 5))
 
 };
diff --git a/tests/baselines/reference/enumLiteralTypes3.symbols b/tests/baselines/reference/enumLiteralTypes3.symbols
index a22ae88e50443..2f5757f225c1d 100644
--- a/tests/baselines/reference/enumLiteralTypes3.symbols
+++ b/tests/baselines/reference/enumLiteralTypes3.symbols
@@ -2,18 +2,18 @@
 const enum Choice { Unknown, Yes, No };
 >Choice : Symbol(Choice, Decl(enumLiteralTypes3.ts, 0, 0))
 >Unknown : Symbol(Choice.Unknown, Decl(enumLiteralTypes3.ts, 0, 19))
->Yes : Symbol(Choice.Yes, Decl(enumLiteralTypes3.ts, 0, 28))
+>Yes : Symbol(Yes, Decl(enumLiteralTypes3.ts, 0, 28))
 >No : Symbol(Choice.No, Decl(enumLiteralTypes3.ts, 0, 33))
 
 type Yes = Choice.Yes;
 >Yes : Symbol(Yes, Decl(enumLiteralTypes3.ts, 0, 39))
 >Choice : Symbol(Choice, Decl(enumLiteralTypes3.ts, 0, 0))
->Yes : Symbol(Choice.Yes, Decl(enumLiteralTypes3.ts, 0, 28))
+>Yes : Symbol(Yes, Decl(enumLiteralTypes3.ts, 0, 28))
 
 type YesNo = Choice.Yes | Choice.No;
 >YesNo : Symbol(YesNo, Decl(enumLiteralTypes3.ts, 2, 22))
 >Choice : Symbol(Choice, Decl(enumLiteralTypes3.ts, 0, 0))
->Yes : Symbol(Choice.Yes, Decl(enumLiteralTypes3.ts, 0, 28))
+>Yes : Symbol(Yes, Decl(enumLiteralTypes3.ts, 0, 28))
 >Choice : Symbol(Choice, Decl(enumLiteralTypes3.ts, 0, 0))
 >No : Symbol(Choice.No, Decl(enumLiteralTypes3.ts, 0, 33))
 
@@ -22,14 +22,14 @@ type NoYes = Choice.No | Choice.Yes;
 >Choice : Symbol(Choice, Decl(enumLiteralTypes3.ts, 0, 0))
 >No : Symbol(Choice.No, Decl(enumLiteralTypes3.ts, 0, 33))
 >Choice : Symbol(Choice, Decl(enumLiteralTypes3.ts, 0, 0))
->Yes : Symbol(Choice.Yes, Decl(enumLiteralTypes3.ts, 0, 28))
+>Yes : Symbol(Yes, Decl(enumLiteralTypes3.ts, 0, 28))
 
 type UnknownYesNo = Choice.Unknown | Choice.Yes | Choice.No;
 >UnknownYesNo : Symbol(UnknownYesNo, Decl(enumLiteralTypes3.ts, 4, 36))
 >Choice : Symbol(Choice, Decl(enumLiteralTypes3.ts, 0, 0))
 >Unknown : Symbol(Choice.Unknown, Decl(enumLiteralTypes3.ts, 0, 19))
 >Choice : Symbol(Choice, Decl(enumLiteralTypes3.ts, 0, 0))
->Yes : Symbol(Choice.Yes, Decl(enumLiteralTypes3.ts, 0, 28))
+>Yes : Symbol(Yes, Decl(enumLiteralTypes3.ts, 0, 28))
 >Choice : Symbol(Choice, Decl(enumLiteralTypes3.ts, 0, 0))
 >No : Symbol(Choice.No, Decl(enumLiteralTypes3.ts, 0, 33))
 
@@ -164,9 +164,9 @@ function f5(a: Yes, b: YesNo, c: UnknownYesNo, d: Choice) {
 
     a = Choice.Yes;
 >a : Symbol(a, Decl(enumLiteralTypes3.ts, 35, 12))
->Choice.Yes : Symbol(Choice.Yes, Decl(enumLiteralTypes3.ts, 0, 28))
+>Choice.Yes : Symbol(Yes, Decl(enumLiteralTypes3.ts, 0, 28))
 >Choice : Symbol(Choice, Decl(enumLiteralTypes3.ts, 0, 0))
->Yes : Symbol(Choice.Yes, Decl(enumLiteralTypes3.ts, 0, 28))
+>Yes : Symbol(Yes, Decl(enumLiteralTypes3.ts, 0, 28))
 
     a = Choice.No;
 >a : Symbol(a, Decl(enumLiteralTypes3.ts, 35, 12))
@@ -182,9 +182,9 @@ function f5(a: Yes, b: YesNo, c: UnknownYesNo, d: Choice) {
 
     b = Choice.Yes;
 >b : Symbol(b, Decl(enumLiteralTypes3.ts, 35, 19))
->Choice.Yes : Symbol(Choice.Yes, Decl(enumLiteralTypes3.ts, 0, 28))
+>Choice.Yes : Symbol(Yes, Decl(enumLiteralTypes3.ts, 0, 28))
 >Choice : Symbol(Choice, Decl(enumLiteralTypes3.ts, 0, 0))
->Yes : Symbol(Choice.Yes, Decl(enumLiteralTypes3.ts, 0, 28))
+>Yes : Symbol(Yes, Decl(enumLiteralTypes3.ts, 0, 28))
 
     b = Choice.No;
 >b : Symbol(b, Decl(enumLiteralTypes3.ts, 35, 19))
@@ -200,9 +200,9 @@ function f5(a: Yes, b: YesNo, c: UnknownYesNo, d: Choice) {
 
     c = Choice.Yes;
 >c : Symbol(c, Decl(enumLiteralTypes3.ts, 35, 29))
->Choice.Yes : Symbol(Choice.Yes, Decl(enumLiteralTypes3.ts, 0, 28))
+>Choice.Yes : Symbol(Yes, Decl(enumLiteralTypes3.ts, 0, 28))
 >Choice : Symbol(Choice, Decl(enumLiteralTypes3.ts, 0, 0))
->Yes : Symbol(Choice.Yes, Decl(enumLiteralTypes3.ts, 0, 28))
+>Yes : Symbol(Yes, Decl(enumLiteralTypes3.ts, 0, 28))
 
     c = Choice.No;
 >c : Symbol(c, Decl(enumLiteralTypes3.ts, 35, 29))
@@ -218,9 +218,9 @@ function f5(a: Yes, b: YesNo, c: UnknownYesNo, d: Choice) {
 
     d = Choice.Yes;
 >d : Symbol(d, Decl(enumLiteralTypes3.ts, 35, 46))
->Choice.Yes : Symbol(Choice.Yes, Decl(enumLiteralTypes3.ts, 0, 28))
+>Choice.Yes : Symbol(Yes, Decl(enumLiteralTypes3.ts, 0, 28))
 >Choice : Symbol(Choice, Decl(enumLiteralTypes3.ts, 0, 0))
->Yes : Symbol(Choice.Yes, Decl(enumLiteralTypes3.ts, 0, 28))
+>Yes : Symbol(Yes, Decl(enumLiteralTypes3.ts, 0, 28))
 
     d = Choice.No;
 >d : Symbol(d, Decl(enumLiteralTypes3.ts, 35, 46))
@@ -248,9 +248,9 @@ function f6(a: Yes, b: YesNo, c: UnknownYesNo, d: Choice) {
 
     a === Choice.Yes;
 >a : Symbol(a, Decl(enumLiteralTypes3.ts, 50, 12))
->Choice.Yes : Symbol(Choice.Yes, Decl(enumLiteralTypes3.ts, 0, 28))
+>Choice.Yes : Symbol(Yes, Decl(enumLiteralTypes3.ts, 0, 28))
 >Choice : Symbol(Choice, Decl(enumLiteralTypes3.ts, 0, 0))
->Yes : Symbol(Choice.Yes, Decl(enumLiteralTypes3.ts, 0, 28))
+>Yes : Symbol(Yes, Decl(enumLiteralTypes3.ts, 0, 28))
 
     a === Choice.No;
 >a : Symbol(a, Decl(enumLiteralTypes3.ts, 50, 12))
@@ -266,9 +266,9 @@ function f6(a: Yes, b: YesNo, c: UnknownYesNo, d: Choice) {
 
     b === Choice.Yes;
 >b : Symbol(b, Decl(enumLiteralTypes3.ts, 50, 19))
->Choice.Yes : Symbol(Choice.Yes, Decl(enumLiteralTypes3.ts, 0, 28))
+>Choice.Yes : Symbol(Yes, Decl(enumLiteralTypes3.ts, 0, 28))
 >Choice : Symbol(Choice, Decl(enumLiteralTypes3.ts, 0, 0))
->Yes : Symbol(Choice.Yes, Decl(enumLiteralTypes3.ts, 0, 28))
+>Yes : Symbol(Yes, Decl(enumLiteralTypes3.ts, 0, 28))
 
     b === Choice.No;
 >b : Symbol(b, Decl(enumLiteralTypes3.ts, 50, 19))
@@ -284,9 +284,9 @@ function f6(a: Yes, b: YesNo, c: UnknownYesNo, d: Choice) {
 
     c === Choice.Yes;
 >c : Symbol(c, Decl(enumLiteralTypes3.ts, 50, 29))
->Choice.Yes : Symbol(Choice.Yes, Decl(enumLiteralTypes3.ts, 0, 28))
+>Choice.Yes : Symbol(Yes, Decl(enumLiteralTypes3.ts, 0, 28))
 >Choice : Symbol(Choice, Decl(enumLiteralTypes3.ts, 0, 0))
->Yes : Symbol(Choice.Yes, Decl(enumLiteralTypes3.ts, 0, 28))
+>Yes : Symbol(Yes, Decl(enumLiteralTypes3.ts, 0, 28))
 
     c === Choice.No;
 >c : Symbol(c, Decl(enumLiteralTypes3.ts, 50, 29))
@@ -302,9 +302,9 @@ function f6(a: Yes, b: YesNo, c: UnknownYesNo, d: Choice) {
 
     d === Choice.Yes;
 >d : Symbol(d, Decl(enumLiteralTypes3.ts, 50, 46))
->Choice.Yes : Symbol(Choice.Yes, Decl(enumLiteralTypes3.ts, 0, 28))
+>Choice.Yes : Symbol(Yes, Decl(enumLiteralTypes3.ts, 0, 28))
 >Choice : Symbol(Choice, Decl(enumLiteralTypes3.ts, 0, 0))
->Yes : Symbol(Choice.Yes, Decl(enumLiteralTypes3.ts, 0, 28))
+>Yes : Symbol(Yes, Decl(enumLiteralTypes3.ts, 0, 28))
 
     d === Choice.No;
 >d : Symbol(d, Decl(enumLiteralTypes3.ts, 50, 46))
@@ -405,9 +405,9 @@ function f10(x: Yes): Yes {
 >x : Symbol(x, Decl(enumLiteralTypes3.ts, 84, 13))
 
         case Choice.Yes: return x;
->Choice.Yes : Symbol(Choice.Yes, Decl(enumLiteralTypes3.ts, 0, 28))
+>Choice.Yes : Symbol(Yes, Decl(enumLiteralTypes3.ts, 0, 28))
 >Choice : Symbol(Choice, Decl(enumLiteralTypes3.ts, 0, 0))
->Yes : Symbol(Choice.Yes, Decl(enumLiteralTypes3.ts, 0, 28))
+>Yes : Symbol(Yes, Decl(enumLiteralTypes3.ts, 0, 28))
 >x : Symbol(x, Decl(enumLiteralTypes3.ts, 84, 13))
 
         case Choice.No: return x;
@@ -436,9 +436,9 @@ function f11(x: YesNo): YesNo {
 >x : Symbol(x, Decl(enumLiteralTypes3.ts, 93, 13))
 
         case Choice.Yes: return x;
->Choice.Yes : Symbol(Choice.Yes, Decl(enumLiteralTypes3.ts, 0, 28))
+>Choice.Yes : Symbol(Yes, Decl(enumLiteralTypes3.ts, 0, 28))
 >Choice : Symbol(Choice, Decl(enumLiteralTypes3.ts, 0, 0))
->Yes : Symbol(Choice.Yes, Decl(enumLiteralTypes3.ts, 0, 28))
+>Yes : Symbol(Yes, Decl(enumLiteralTypes3.ts, 0, 28))
 >x : Symbol(x, Decl(enumLiteralTypes3.ts, 93, 13))
 
         case Choice.No: return x;
@@ -467,9 +467,9 @@ function f12(x: UnknownYesNo): UnknownYesNo {
 >x : Symbol(x, Decl(enumLiteralTypes3.ts, 102, 13))
 
         case Choice.Yes: return x;
->Choice.Yes : Symbol(Choice.Yes, Decl(enumLiteralTypes3.ts, 0, 28))
+>Choice.Yes : Symbol(Yes, Decl(enumLiteralTypes3.ts, 0, 28))
 >Choice : Symbol(Choice, Decl(enumLiteralTypes3.ts, 0, 0))
->Yes : Symbol(Choice.Yes, Decl(enumLiteralTypes3.ts, 0, 28))
+>Yes : Symbol(Yes, Decl(enumLiteralTypes3.ts, 0, 28))
 >x : Symbol(x, Decl(enumLiteralTypes3.ts, 102, 13))
 
         case Choice.No: return x;
@@ -498,9 +498,9 @@ function f13(x: Choice): Choice {
 >x : Symbol(x, Decl(enumLiteralTypes3.ts, 111, 13))
 
         case Choice.Yes: return x;
->Choice.Yes : Symbol(Choice.Yes, Decl(enumLiteralTypes3.ts, 0, 28))
+>Choice.Yes : Symbol(Yes, Decl(enumLiteralTypes3.ts, 0, 28))
 >Choice : Symbol(Choice, Decl(enumLiteralTypes3.ts, 0, 0))
->Yes : Symbol(Choice.Yes, Decl(enumLiteralTypes3.ts, 0, 28))
+>Yes : Symbol(Yes, Decl(enumLiteralTypes3.ts, 0, 28))
 >x : Symbol(x, Decl(enumLiteralTypes3.ts, 111, 13))
 
         case Choice.No: return x;
diff --git a/tests/baselines/reference/errorForUsingPropertyOfTypeAsType01.symbols b/tests/baselines/reference/errorForUsingPropertyOfTypeAsType01.symbols
index db8d48194a6e6..adc630631bee0 100644
--- a/tests/baselines/reference/errorForUsingPropertyOfTypeAsType01.symbols
+++ b/tests/baselines/reference/errorForUsingPropertyOfTypeAsType01.symbols
@@ -50,7 +50,7 @@ namespace Test3 {
 >Foo : Symbol(Foo, Decl(errorForUsingPropertyOfTypeAsType01.ts, 18, 17))
 
         bar: string;
->bar : Symbol(bar, Decl(errorForUsingPropertyOfTypeAsType01.ts, 19, 23))
+>bar : Symbol(Foo.bar, Decl(errorForUsingPropertyOfTypeAsType01.ts, 19, 23))
     }
 
     var x: Foo.bar = "";
diff --git a/tests/baselines/reference/excessPropertyCheckWithUnions.symbols b/tests/baselines/reference/excessPropertyCheckWithUnions.symbols
index 80921fedad26c..4621ee656e620 100644
--- a/tests/baselines/reference/excessPropertyCheckWithUnions.symbols
+++ b/tests/baselines/reference/excessPropertyCheckWithUnions.symbols
@@ -175,7 +175,7 @@ type AN = { a: string } | { c: string }
 
 type BN = { b: string }
 >BN : Symbol(BN, Decl(excessPropertyCheckWithUnions.ts, 58, 39))
->b : Symbol(b, Decl(excessPropertyCheckWithUnions.ts, 59, 11))
+>b : Symbol(BN.b, Decl(excessPropertyCheckWithUnions.ts, 59, 11))
 
 type AB = { kind: "A", n: AN } | { kind: "B", n: BN }
 >AB : Symbol(AB, Decl(excessPropertyCheckWithUnions.ts, 59, 23))
@@ -224,14 +224,14 @@ const abac: AB = {
 // Excess property checks must match all discriminable properties
 type Button = { tag: 'button'; type?: 'submit'; };
 >Button : Symbol(Button, Decl(excessPropertyCheckWithUnions.ts, 74, 1))
->tag : Symbol(tag, Decl(excessPropertyCheckWithUnions.ts, 77, 15))
->type : Symbol(type, Decl(excessPropertyCheckWithUnions.ts, 77, 30))
+>tag : Symbol(Button.tag, Decl(excessPropertyCheckWithUnions.ts, 77, 15))
+>type : Symbol(Button.type, Decl(excessPropertyCheckWithUnions.ts, 77, 30))
 
 type Anchor = { tag: 'a'; type?: string; href: string };
 >Anchor : Symbol(Anchor, Decl(excessPropertyCheckWithUnions.ts, 77, 50))
->tag : Symbol(tag, Decl(excessPropertyCheckWithUnions.ts, 78, 15))
->type : Symbol(type, Decl(excessPropertyCheckWithUnions.ts, 78, 25))
->href : Symbol(href, Decl(excessPropertyCheckWithUnions.ts, 78, 40))
+>tag : Symbol(Anchor.tag, Decl(excessPropertyCheckWithUnions.ts, 78, 15))
+>type : Symbol(Anchor.type, Decl(excessPropertyCheckWithUnions.ts, 78, 25))
+>href : Symbol(Anchor.href, Decl(excessPropertyCheckWithUnions.ts, 78, 40))
 
 type Union = Button | Anchor;
 >Union : Symbol(Union, Decl(excessPropertyCheckWithUnions.ts, 78, 56))
diff --git a/tests/baselines/reference/exhaustiveSwitchStatements1.symbols b/tests/baselines/reference/exhaustiveSwitchStatements1.symbols
index a9c2d820f2bfc..a230f8f7b58e1 100644
--- a/tests/baselines/reference/exhaustiveSwitchStatements1.symbols
+++ b/tests/baselines/reference/exhaustiveSwitchStatements1.symbols
@@ -571,10 +571,10 @@ type O = {
 >O : Symbol(O, Decl(exhaustiveSwitchStatements1.ts, 220, 1))
 
     a: number,
->a : Symbol(a, Decl(exhaustiveSwitchStatements1.ts, 224, 10))
+>a : Symbol(O.a, Decl(exhaustiveSwitchStatements1.ts, 224, 10))
 
     b: number
->b : Symbol(b, Decl(exhaustiveSwitchStatements1.ts, 225, 14))
+>b : Symbol(O.b, Decl(exhaustiveSwitchStatements1.ts, 225, 14))
 
 };
 type K = keyof O | 'c';
diff --git a/tests/baselines/reference/expandoFunctionContextualTypesJs.symbols b/tests/baselines/reference/expandoFunctionContextualTypesJs.symbols
index 5d5696d84bd9b..0d013a5b45fee 100644
--- a/tests/baselines/reference/expandoFunctionContextualTypesJs.symbols
+++ b/tests/baselines/reference/expandoFunctionContextualTypesJs.symbols
@@ -12,9 +12,9 @@ const MyComponent = () => /* @type {any} */(null);
 >MyComponent : Symbol(MyComponent, Decl(input.js, 9, 5), Decl(input.js, 9, 50))
 
 MyComponent.defaultProps = {
->MyComponent.defaultProps : Symbol(defaultProps, Decl(input.js, 4, 23))
+>MyComponent.defaultProps : Symbol(StatelessComponent.defaultProps, Decl(input.js, 4, 23))
 >MyComponent : Symbol(MyComponent, Decl(input.js, 9, 5), Decl(input.js, 9, 50))
->defaultProps : Symbol(defaultProps, Decl(input.js, 4, 23))
+>defaultProps : Symbol(StatelessComponent.defaultProps, Decl(input.js, 4, 23))
 
     color: "red"
 >color : Symbol(color, Decl(input.js, 11, 28))
diff --git a/tests/baselines/reference/for-of58.symbols b/tests/baselines/reference/for-of58.symbols
index 5013b3264dca2..be53b53e5ba46 100644
--- a/tests/baselines/reference/for-of58.symbols
+++ b/tests/baselines/reference/for-of58.symbols
@@ -1,11 +1,11 @@
 === tests/cases/conformance/es6/for-ofStatements/for-of58.ts ===
 type X = { x: 'x' };
 >X : Symbol(X, Decl(for-of58.ts, 0, 0))
->x : Symbol(x, Decl(for-of58.ts, 0, 10))
+>x : Symbol(X.x, Decl(for-of58.ts, 0, 10))
 
 type Y = { y: 'y' };
 >Y : Symbol(Y, Decl(for-of58.ts, 0, 20))
->y : Symbol(y, Decl(for-of58.ts, 1, 10))
+>y : Symbol(Y.y, Decl(for-of58.ts, 1, 10))
 
 declare const arr: X[] & Y[];
 >arr : Symbol(arr, Decl(for-of58.ts, 3, 13))
@@ -17,13 +17,13 @@ for (const item of arr) {
 >arr : Symbol(arr, Decl(for-of58.ts, 3, 13))
 
     item.x;
->item.x : Symbol(x, Decl(for-of58.ts, 0, 10))
+>item.x : Symbol(X.x, Decl(for-of58.ts, 0, 10))
 >item : Symbol(item, Decl(for-of58.ts, 5, 10))
->x : Symbol(x, Decl(for-of58.ts, 0, 10))
+>x : Symbol(X.x, Decl(for-of58.ts, 0, 10))
 
     item.y;
->item.y : Symbol(y, Decl(for-of58.ts, 1, 10))
+>item.y : Symbol(Y.y, Decl(for-of58.ts, 1, 10))
 >item : Symbol(item, Decl(for-of58.ts, 5, 10))
->y : Symbol(y, Decl(for-of58.ts, 1, 10))
+>y : Symbol(Y.y, Decl(for-of58.ts, 1, 10))
 }
 
diff --git a/tests/baselines/reference/forwardRefInTypeDeclaration.symbols b/tests/baselines/reference/forwardRefInTypeDeclaration.symbols
index f8ad803779c73..2740c3df77db2 100644
--- a/tests/baselines/reference/forwardRefInTypeDeclaration.symbols
+++ b/tests/baselines/reference/forwardRefInTypeDeclaration.symbols
@@ -19,7 +19,7 @@ const s2 = "x";
 // or in a type definition
 type Foo3 = { [s3]: number; }
 >Foo3 : Symbol(Foo3, Decl(forwardRefInTypeDeclaration.ts, 6, 15))
->[s3] : Symbol([s3], Decl(forwardRefInTypeDeclaration.ts, 9, 13))
+>[s3] : Symbol(Foo3[s3], Decl(forwardRefInTypeDeclaration.ts, 9, 13))
 >s3 : Symbol(s3, Decl(forwardRefInTypeDeclaration.ts, 10, 5))
 
 const s3 = "x";
diff --git a/tests/baselines/reference/functionCallOnConstrainedTypeVariable.symbols b/tests/baselines/reference/functionCallOnConstrainedTypeVariable.symbols
index e5bdcff342b54..17efb0ef3dddf 100644
--- a/tests/baselines/reference/functionCallOnConstrainedTypeVariable.symbols
+++ b/tests/baselines/reference/functionCallOnConstrainedTypeVariable.symbols
@@ -5,7 +5,7 @@ type A = {
 >A : Symbol(A, Decl(functionCallOnConstrainedTypeVariable.ts, 0, 0))
 
   a: (x: number) => string
->a : Symbol(a, Decl(functionCallOnConstrainedTypeVariable.ts, 2, 10))
+>a : Symbol(A.a, Decl(functionCallOnConstrainedTypeVariable.ts, 2, 10))
 >x : Symbol(x, Decl(functionCallOnConstrainedTypeVariable.ts, 3, 6))
 
 };
@@ -13,7 +13,7 @@ type B = {
 >B : Symbol(B, Decl(functionCallOnConstrainedTypeVariable.ts, 4, 2))
 
   a: (x: boolean) => string
->a : Symbol(a, Decl(functionCallOnConstrainedTypeVariable.ts, 5, 10))
+>a : Symbol(B.a, Decl(functionCallOnConstrainedTypeVariable.ts, 5, 10))
 >x : Symbol(x, Decl(functionCallOnConstrainedTypeVariable.ts, 6, 6))
 
 };
diff --git a/tests/baselines/reference/genericContextualTypes1.symbols b/tests/baselines/reference/genericContextualTypes1.symbols
index c793495e0e373..9937399bd34ee 100644
--- a/tests/baselines/reference/genericContextualTypes1.symbols
+++ b/tests/baselines/reference/genericContextualTypes1.symbols
@@ -2,7 +2,7 @@
 type Box<T> = { value: T };
 >Box : Symbol(Box, Decl(genericContextualTypes1.ts, 0, 0))
 >T : Symbol(T, Decl(genericContextualTypes1.ts, 0, 9))
->value : Symbol(value, Decl(genericContextualTypes1.ts, 0, 15))
+>value : Symbol(Box.value, Decl(genericContextualTypes1.ts, 0, 15))
 >T : Symbol(T, Decl(genericContextualTypes1.ts, 0, 9))
 
 declare function wrap<A, B>(f: (a: A) => B): (a: A) => B;
@@ -284,9 +284,9 @@ const f31: <T extends Box<number>>(a: T[]) => T[] = arrayFilter(x => x.value > 1
 >T : Symbol(T, Decl(genericContextualTypes1.ts, 41, 12))
 >arrayFilter : Symbol(arrayFilter, Decl(genericContextualTypes1.ts, 33, 5))
 >x : Symbol(x, Decl(genericContextualTypes1.ts, 41, 64))
->x.value : Symbol(value, Decl(genericContextualTypes1.ts, 0, 15))
+>x.value : Symbol(Box.value, Decl(genericContextualTypes1.ts, 0, 15))
 >x : Symbol(x, Decl(genericContextualTypes1.ts, 41, 64))
->value : Symbol(value, Decl(genericContextualTypes1.ts, 0, 15))
+>value : Symbol(Box.value, Decl(genericContextualTypes1.ts, 0, 15))
 
 const f40: <A, B>(b: B, a: A) => [A, B] = flip(zip);
 >f40 : Symbol(f40, Decl(genericContextualTypes1.ts, 43, 5))
diff --git a/tests/baselines/reference/genericDefaults.symbols b/tests/baselines/reference/genericDefaults.symbols
index 755a34c7a63be..e7da4e403c4b3 100644
--- a/tests/baselines/reference/genericDefaults.symbols
+++ b/tests/baselines/reference/genericDefaults.symbols
@@ -2162,89 +2162,89 @@ type DerivedProps = keyof Derived03;
 type t00<T = number> = { a: T; }
 >t00 : Symbol(t00, Decl(genericDefaults.ts, 466, 36))
 >T : Symbol(T, Decl(genericDefaults.ts, 468, 9))
->a : Symbol(a, Decl(genericDefaults.ts, 468, 24))
+>a : Symbol(t00.a, Decl(genericDefaults.ts, 468, 24))
 >T : Symbol(T, Decl(genericDefaults.ts, 468, 9))
 
 const t00c00 = (<t00>x).a;
 >t00c00 : Symbol(t00c00, Decl(genericDefaults.ts, 469, 5))
->(<t00>x).a : Symbol(a, Decl(genericDefaults.ts, 468, 24))
+>(<t00>x).a : Symbol(t00.a, Decl(genericDefaults.ts, 468, 24))
 >t00 : Symbol(t00, Decl(genericDefaults.ts, 466, 36))
 >x : Symbol(x, Decl(genericDefaults.ts, 13, 13))
->a : Symbol(a, Decl(genericDefaults.ts, 468, 24))
+>a : Symbol(t00.a, Decl(genericDefaults.ts, 468, 24))
 
 const t00c01 = (<t00<number>>x).a;
 >t00c01 : Symbol(t00c01, Decl(genericDefaults.ts, 470, 5))
->(<t00<number>>x).a : Symbol(a, Decl(genericDefaults.ts, 468, 24))
+>(<t00<number>>x).a : Symbol(t00.a, Decl(genericDefaults.ts, 468, 24))
 >t00 : Symbol(t00, Decl(genericDefaults.ts, 466, 36))
 >x : Symbol(x, Decl(genericDefaults.ts, 13, 13))
->a : Symbol(a, Decl(genericDefaults.ts, 468, 24))
+>a : Symbol(t00.a, Decl(genericDefaults.ts, 468, 24))
 
 type t01<T, U = T> = { a: [T, U]; }
 >t01 : Symbol(t01, Decl(genericDefaults.ts, 470, 34))
 >T : Symbol(T, Decl(genericDefaults.ts, 472, 9))
 >U : Symbol(U, Decl(genericDefaults.ts, 472, 11))
 >T : Symbol(T, Decl(genericDefaults.ts, 472, 9))
->a : Symbol(a, Decl(genericDefaults.ts, 472, 22))
+>a : Symbol(t01.a, Decl(genericDefaults.ts, 472, 22))
 >T : Symbol(T, Decl(genericDefaults.ts, 472, 9))
 >U : Symbol(U, Decl(genericDefaults.ts, 472, 11))
 
 const t01c00 = (<t01<number>>x).a;
 >t01c00 : Symbol(t01c00, Decl(genericDefaults.ts, 473, 5))
->(<t01<number>>x).a : Symbol(a, Decl(genericDefaults.ts, 472, 22))
+>(<t01<number>>x).a : Symbol(t01.a, Decl(genericDefaults.ts, 472, 22))
 >t01 : Symbol(t01, Decl(genericDefaults.ts, 470, 34))
 >x : Symbol(x, Decl(genericDefaults.ts, 13, 13))
->a : Symbol(a, Decl(genericDefaults.ts, 472, 22))
+>a : Symbol(t01.a, Decl(genericDefaults.ts, 472, 22))
 
 const t01c01 = (<t01<number, string>>x).a;
 >t01c01 : Symbol(t01c01, Decl(genericDefaults.ts, 474, 5))
->(<t01<number, string>>x).a : Symbol(a, Decl(genericDefaults.ts, 472, 22))
+>(<t01<number, string>>x).a : Symbol(t01.a, Decl(genericDefaults.ts, 472, 22))
 >t01 : Symbol(t01, Decl(genericDefaults.ts, 470, 34))
 >x : Symbol(x, Decl(genericDefaults.ts, 13, 13))
->a : Symbol(a, Decl(genericDefaults.ts, 472, 22))
+>a : Symbol(t01.a, Decl(genericDefaults.ts, 472, 22))
 
 type t02<T extends number, U = T> = { a: [T, U]; }
 >t02 : Symbol(t02, Decl(genericDefaults.ts, 474, 42))
 >T : Symbol(T, Decl(genericDefaults.ts, 476, 9))
 >U : Symbol(U, Decl(genericDefaults.ts, 476, 26))
 >T : Symbol(T, Decl(genericDefaults.ts, 476, 9))
->a : Symbol(a, Decl(genericDefaults.ts, 476, 37))
+>a : Symbol(t02.a, Decl(genericDefaults.ts, 476, 37))
 >T : Symbol(T, Decl(genericDefaults.ts, 476, 9))
 >U : Symbol(U, Decl(genericDefaults.ts, 476, 26))
 
 const t02c00 = (<t02<number>>x).a;
 >t02c00 : Symbol(t02c00, Decl(genericDefaults.ts, 477, 5))
->(<t02<number>>x).a : Symbol(a, Decl(genericDefaults.ts, 476, 37))
+>(<t02<number>>x).a : Symbol(t02.a, Decl(genericDefaults.ts, 476, 37))
 >t02 : Symbol(t02, Decl(genericDefaults.ts, 474, 42))
 >x : Symbol(x, Decl(genericDefaults.ts, 13, 13))
->a : Symbol(a, Decl(genericDefaults.ts, 476, 37))
+>a : Symbol(t02.a, Decl(genericDefaults.ts, 476, 37))
 
 const t02c01 = (<t02<1>>x).a;
 >t02c01 : Symbol(t02c01, Decl(genericDefaults.ts, 478, 5))
->(<t02<1>>x).a : Symbol(a, Decl(genericDefaults.ts, 476, 37))
+>(<t02<1>>x).a : Symbol(t02.a, Decl(genericDefaults.ts, 476, 37))
 >t02 : Symbol(t02, Decl(genericDefaults.ts, 474, 42))
 >x : Symbol(x, Decl(genericDefaults.ts, 13, 13))
->a : Symbol(a, Decl(genericDefaults.ts, 476, 37))
+>a : Symbol(t02.a, Decl(genericDefaults.ts, 476, 37))
 
 const t02c02 = (<t02<number, number>>x).a;
 >t02c02 : Symbol(t02c02, Decl(genericDefaults.ts, 479, 5))
->(<t02<number, number>>x).a : Symbol(a, Decl(genericDefaults.ts, 476, 37))
+>(<t02<number, number>>x).a : Symbol(t02.a, Decl(genericDefaults.ts, 476, 37))
 >t02 : Symbol(t02, Decl(genericDefaults.ts, 474, 42))
 >x : Symbol(x, Decl(genericDefaults.ts, 13, 13))
->a : Symbol(a, Decl(genericDefaults.ts, 476, 37))
+>a : Symbol(t02.a, Decl(genericDefaults.ts, 476, 37))
 
 const t02c03 = (<t02<1, number>>x).a;
 >t02c03 : Symbol(t02c03, Decl(genericDefaults.ts, 480, 5))
->(<t02<1, number>>x).a : Symbol(a, Decl(genericDefaults.ts, 476, 37))
+>(<t02<1, number>>x).a : Symbol(t02.a, Decl(genericDefaults.ts, 476, 37))
 >t02 : Symbol(t02, Decl(genericDefaults.ts, 474, 42))
 >x : Symbol(x, Decl(genericDefaults.ts, 13, 13))
->a : Symbol(a, Decl(genericDefaults.ts, 476, 37))
+>a : Symbol(t02.a, Decl(genericDefaults.ts, 476, 37))
 
 const t02c04 = (<t02<number, 1>>x).a;
 >t02c04 : Symbol(t02c04, Decl(genericDefaults.ts, 481, 5))
->(<t02<number, 1>>x).a : Symbol(a, Decl(genericDefaults.ts, 476, 37))
+>(<t02<number, 1>>x).a : Symbol(t02.a, Decl(genericDefaults.ts, 476, 37))
 >t02 : Symbol(t02, Decl(genericDefaults.ts, 474, 42))
 >x : Symbol(x, Decl(genericDefaults.ts, 13, 13))
->a : Symbol(a, Decl(genericDefaults.ts, 476, 37))
+>a : Symbol(t02.a, Decl(genericDefaults.ts, 476, 37))
 
 type t03<T extends number, U extends T = T> = { a: [T, U]; }
 >t03 : Symbol(t03, Decl(genericDefaults.ts, 481, 37))
@@ -2252,44 +2252,44 @@ type t03<T extends number, U extends T = T> = { a: [T, U]; }
 >U : Symbol(U, Decl(genericDefaults.ts, 483, 26))
 >T : Symbol(T, Decl(genericDefaults.ts, 483, 9))
 >T : Symbol(T, Decl(genericDefaults.ts, 483, 9))
->a : Symbol(a, Decl(genericDefaults.ts, 483, 47))
+>a : Symbol(t03.a, Decl(genericDefaults.ts, 483, 47))
 >T : Symbol(T, Decl(genericDefaults.ts, 483, 9))
 >U : Symbol(U, Decl(genericDefaults.ts, 483, 26))
 
 const t03c00 = (<t03<number>>x).a;
 >t03c00 : Symbol(t03c00, Decl(genericDefaults.ts, 484, 5))
->(<t03<number>>x).a : Symbol(a, Decl(genericDefaults.ts, 483, 47))
+>(<t03<number>>x).a : Symbol(t03.a, Decl(genericDefaults.ts, 483, 47))
 >t03 : Symbol(t03, Decl(genericDefaults.ts, 481, 37))
 >x : Symbol(x, Decl(genericDefaults.ts, 13, 13))
->a : Symbol(a, Decl(genericDefaults.ts, 483, 47))
+>a : Symbol(t03.a, Decl(genericDefaults.ts, 483, 47))
 
 const t03c01 = (<t03<1>>x).a;
 >t03c01 : Symbol(t03c01, Decl(genericDefaults.ts, 485, 5))
->(<t03<1>>x).a : Symbol(a, Decl(genericDefaults.ts, 483, 47))
+>(<t03<1>>x).a : Symbol(t03.a, Decl(genericDefaults.ts, 483, 47))
 >t03 : Symbol(t03, Decl(genericDefaults.ts, 481, 37))
 >x : Symbol(x, Decl(genericDefaults.ts, 13, 13))
->a : Symbol(a, Decl(genericDefaults.ts, 483, 47))
+>a : Symbol(t03.a, Decl(genericDefaults.ts, 483, 47))
 
 const t03c02 = (<t03<number, number>>x).a;
 >t03c02 : Symbol(t03c02, Decl(genericDefaults.ts, 486, 5))
->(<t03<number, number>>x).a : Symbol(a, Decl(genericDefaults.ts, 483, 47))
+>(<t03<number, number>>x).a : Symbol(t03.a, Decl(genericDefaults.ts, 483, 47))
 >t03 : Symbol(t03, Decl(genericDefaults.ts, 481, 37))
 >x : Symbol(x, Decl(genericDefaults.ts, 13, 13))
->a : Symbol(a, Decl(genericDefaults.ts, 483, 47))
+>a : Symbol(t03.a, Decl(genericDefaults.ts, 483, 47))
 
 const t03c03 = (<t03<1, 1>>x).a;
 >t03c03 : Symbol(t03c03, Decl(genericDefaults.ts, 487, 5))
->(<t03<1, 1>>x).a : Symbol(a, Decl(genericDefaults.ts, 483, 47))
+>(<t03<1, 1>>x).a : Symbol(t03.a, Decl(genericDefaults.ts, 483, 47))
 >t03 : Symbol(t03, Decl(genericDefaults.ts, 481, 37))
 >x : Symbol(x, Decl(genericDefaults.ts, 13, 13))
->a : Symbol(a, Decl(genericDefaults.ts, 483, 47))
+>a : Symbol(t03.a, Decl(genericDefaults.ts, 483, 47))
 
 const t03c04 = (<t03<number, 1>>x).a;
 >t03c04 : Symbol(t03c04, Decl(genericDefaults.ts, 488, 5))
->(<t03<number, 1>>x).a : Symbol(a, Decl(genericDefaults.ts, 483, 47))
+>(<t03<number, 1>>x).a : Symbol(t03.a, Decl(genericDefaults.ts, 483, 47))
 >t03 : Symbol(t03, Decl(genericDefaults.ts, 481, 37))
 >x : Symbol(x, Decl(genericDefaults.ts, 13, 13))
->a : Symbol(a, Decl(genericDefaults.ts, 483, 47))
+>a : Symbol(t03.a, Decl(genericDefaults.ts, 483, 47))
 
 // https://github.com/Microsoft/TypeScript/issues/16221
 interface SelfReference<T = SelfReference<string>> {}
diff --git a/tests/baselines/reference/genericFunctionInference1.symbols b/tests/baselines/reference/genericFunctionInference1.symbols
index 0c2881bb1ce62..20a148f22472d 100644
--- a/tests/baselines/reference/genericFunctionInference1.symbols
+++ b/tests/baselines/reference/genericFunctionInference1.symbols
@@ -631,8 +631,8 @@ declare function myHoc<P>(C: CompClass<P>): CompClass<P>;
 type GenericProps<T> = { foo: number, stuff: T };
 >GenericProps : Symbol(GenericProps, Decl(genericFunctionInference1.ts, 103, 57))
 >T : Symbol(T, Decl(genericFunctionInference1.ts, 105, 18))
->foo : Symbol(foo, Decl(genericFunctionInference1.ts, 105, 24))
->stuff : Symbol(stuff, Decl(genericFunctionInference1.ts, 105, 37))
+>foo : Symbol(GenericProps.foo, Decl(genericFunctionInference1.ts, 105, 24))
+>stuff : Symbol(GenericProps.stuff, Decl(genericFunctionInference1.ts, 105, 37))
 >T : Symbol(T, Decl(genericFunctionInference1.ts, 105, 18))
 
 declare class GenericComp<T> extends Comp<GenericProps<T>> {}
diff --git a/tests/baselines/reference/genericFunctionInference1.types b/tests/baselines/reference/genericFunctionInference1.types
index 9ce0b1b2b24bb..323b10400a663 100644
--- a/tests/baselines/reference/genericFunctionInference1.types
+++ b/tests/baselines/reference/genericFunctionInference1.types
@@ -801,7 +801,7 @@ const fn20 = pipe((_a?: {}) => 1);
 >fn20 : (_a?: {} | undefined) => number
 >pipe((_a?: {}) => 1) : (_a?: {} | undefined) => number
 >pipe : { <A extends any[], B>(ab: (...args: A) => B): (...args: A) => B; <A extends any[], B, C>(ab: (...args: A) => B, bc: (b: B) => C): (...args: A) => C; <A extends any[], B, C, D>(ab: (...args: A) => B, bc: (b: B) => C, cd: (c: C) => D): (...args: A) => D; }
->(_a?: {}) => 1 : (_a?: {} | undefined) => number
+>(_a?: {}) => 1 : (_a?: {}) => number
 >_a : {} | undefined
 >1 : 1
 
@@ -968,7 +968,7 @@ const fn62 = pipe(
 // Repro from #30297
 
 declare function foo2<T, U = T>(fn: T, a?: U, b?: U): [T, U];
->foo2 : <T, U = T>(fn: T, a?: U | undefined, b?: U | undefined) => [T, U]
+>foo2 : <T, U = T>(fn: T, a?: U, b?: U) => [T, U]
 >fn : T
 >a : U | undefined
 >b : U | undefined
diff --git a/tests/baselines/reference/genericFunctionInference2.symbols b/tests/baselines/reference/genericFunctionInference2.symbols
index ca099b062eb43..cd1ce742a889f 100644
--- a/tests/baselines/reference/genericFunctionInference2.symbols
+++ b/tests/baselines/reference/genericFunctionInference2.symbols
@@ -22,7 +22,7 @@ declare function combineReducers<S>(reducers: { [K in keyof S]: Reducer<S[K]> })
 
 type MyState = { combined: { foo: number } };
 >MyState : Symbol(MyState, Decl(genericFunctionInference2.ts, 3, 93))
->combined : Symbol(combined, Decl(genericFunctionInference2.ts, 5, 16))
+>combined : Symbol(MyState.combined, Decl(genericFunctionInference2.ts, 5, 16))
 >foo : Symbol(foo, Decl(genericFunctionInference2.ts, 5, 28))
 
 declare const foo: Reducer<MyState['combined']['foo']>;
@@ -68,7 +68,7 @@ declare function withH<T, U>(handlerCreators: HandleCreatorsFactory<T, U>): U;
 
 type Props = { out: number }
 >Props : Symbol(Props, Decl(genericFunctionInference2.ts, 18, 78))
->out : Symbol(out, Decl(genericFunctionInference2.ts, 20, 14))
+>out : Symbol(Props.out, Decl(genericFunctionInference2.ts, 20, 14))
 
 type HandleCreatorsFactory<T, U> = (initialProps: T) => { [P in keyof U]: (props: T) => U[P] };
 >HandleCreatorsFactory : Symbol(HandleCreatorsFactory, Decl(genericFunctionInference2.ts, 20, 28))
diff --git a/tests/baselines/reference/genericObjectRest.symbols b/tests/baselines/reference/genericObjectRest.symbols
index 1bec7d4b1ed92..7dc24fd1be3bc 100644
--- a/tests/baselines/reference/genericObjectRest.symbols
+++ b/tests/baselines/reference/genericObjectRest.symbols
@@ -98,9 +98,9 @@ function f3<T, K1 extends keyof T, K2 extends keyof T>(obj: T, k1: K1, k2: K2) {
 
 type Item = { a: string, b: number, c: boolean };
 >Item : Symbol(Item, Decl(genericObjectRest.ts, 20, 1))
->a : Symbol(a, Decl(genericObjectRest.ts, 22, 13))
->b : Symbol(b, Decl(genericObjectRest.ts, 22, 24))
->c : Symbol(c, Decl(genericObjectRest.ts, 22, 35))
+>a : Symbol(Item.a, Decl(genericObjectRest.ts, 22, 13))
+>b : Symbol(Item.b, Decl(genericObjectRest.ts, 22, 24))
+>c : Symbol(Item.c, Decl(genericObjectRest.ts, 22, 35))
 
 function f4<K1 extends keyof Item, K2 extends keyof Item>(obj: Item, k1: K1, k2: K2) {
 >f4 : Symbol(f4, Decl(genericObjectRest.ts, 22, 49))
diff --git a/tests/baselines/reference/genericRestParameters1.symbols b/tests/baselines/reference/genericRestParameters1.symbols
index 56f1bc6cf5869..cf29ef024e741 100644
--- a/tests/baselines/reference/genericRestParameters1.symbols
+++ b/tests/baselines/reference/genericRestParameters1.symbols
@@ -554,16 +554,16 @@ type Record1 = {
 >Record1 : Symbol(Record1, Decl(genericRestParameters1.ts, 134, 32))
 
   move: [number, 'left' | 'right'];
->move : Symbol(move, Decl(genericRestParameters1.ts, 136, 16))
+>move : Symbol(Record1.move, Decl(genericRestParameters1.ts, 136, 16))
 
   jump: [number, 'up' | 'down'];
->jump : Symbol(jump, Decl(genericRestParameters1.ts, 137, 35))
+>jump : Symbol(Record1.jump, Decl(genericRestParameters1.ts, 137, 35))
 
   stop: string;
->stop : Symbol(stop, Decl(genericRestParameters1.ts, 138, 32))
+>stop : Symbol(Record1.stop, Decl(genericRestParameters1.ts, 138, 32))
 
   done: [];
->done : Symbol(done, Decl(genericRestParameters1.ts, 139, 15))
+>done : Symbol(Record1.done, Decl(genericRestParameters1.ts, 139, 15))
 }
 
 type EventType<T> = {
@@ -571,7 +571,7 @@ type EventType<T> = {
 >T : Symbol(T, Decl(genericRestParameters1.ts, 143, 15))
 
   emit<K extends keyof T = keyof T>(e: K, ...payload: T[K] extends any[] ? T[K] : [T[K]]): void; 
->emit : Symbol(emit, Decl(genericRestParameters1.ts, 143, 21))
+>emit : Symbol(EventType.emit, Decl(genericRestParameters1.ts, 143, 21))
 >K : Symbol(K, Decl(genericRestParameters1.ts, 144, 7))
 >T : Symbol(T, Decl(genericRestParameters1.ts, 143, 15))
 >T : Symbol(T, Decl(genericRestParameters1.ts, 143, 15))
@@ -592,24 +592,24 @@ declare var events: EventType<Record1>;
 >Record1 : Symbol(Record1, Decl(genericRestParameters1.ts, 134, 32))
 
 events.emit('move', 10, 'left');
->events.emit : Symbol(emit, Decl(genericRestParameters1.ts, 143, 21))
+>events.emit : Symbol(EventType.emit, Decl(genericRestParameters1.ts, 143, 21))
 >events : Symbol(events, Decl(genericRestParameters1.ts, 147, 11))
->emit : Symbol(emit, Decl(genericRestParameters1.ts, 143, 21))
+>emit : Symbol(EventType.emit, Decl(genericRestParameters1.ts, 143, 21))
 
 events.emit('jump', 20, 'up');
->events.emit : Symbol(emit, Decl(genericRestParameters1.ts, 143, 21))
+>events.emit : Symbol(EventType.emit, Decl(genericRestParameters1.ts, 143, 21))
 >events : Symbol(events, Decl(genericRestParameters1.ts, 147, 11))
->emit : Symbol(emit, Decl(genericRestParameters1.ts, 143, 21))
+>emit : Symbol(EventType.emit, Decl(genericRestParameters1.ts, 143, 21))
 
 events.emit('stop', 'Bye!');
->events.emit : Symbol(emit, Decl(genericRestParameters1.ts, 143, 21))
+>events.emit : Symbol(EventType.emit, Decl(genericRestParameters1.ts, 143, 21))
 >events : Symbol(events, Decl(genericRestParameters1.ts, 147, 11))
->emit : Symbol(emit, Decl(genericRestParameters1.ts, 143, 21))
+>emit : Symbol(EventType.emit, Decl(genericRestParameters1.ts, 143, 21))
 
 events.emit('done');
->events.emit : Symbol(emit, Decl(genericRestParameters1.ts, 143, 21))
+>events.emit : Symbol(EventType.emit, Decl(genericRestParameters1.ts, 143, 21))
 >events : Symbol(events, Decl(genericRestParameters1.ts, 147, 11))
->emit : Symbol(emit, Decl(genericRestParameters1.ts, 143, 21))
+>emit : Symbol(EventType.emit, Decl(genericRestParameters1.ts, 143, 21))
 
 // Repro from #25871
 
diff --git a/tests/baselines/reference/genericRestParameters1.types b/tests/baselines/reference/genericRestParameters1.types
index 1e45a3c86621e..c8c15d360c2f8 100644
--- a/tests/baselines/reference/genericRestParameters1.types
+++ b/tests/baselines/reference/genericRestParameters1.types
@@ -570,7 +570,7 @@ f23();
 >f23 : () => string[]
 
 declare const g20: (x: number, y?: string, z?: boolean) => string[];
->g20 : (x: number, y?: string | undefined, z?: boolean | undefined) => string[]
+>g20 : (x: number, y?: string, z?: boolean) => string[]
 >x : number
 >y : string | undefined
 >z : boolean | undefined
diff --git a/tests/baselines/reference/genericRestParameters2.symbols b/tests/baselines/reference/genericRestParameters2.symbols
index 1dd27d4f89089..bda8d90d6eba1 100644
--- a/tests/baselines/reference/genericRestParameters2.symbols
+++ b/tests/baselines/reference/genericRestParameters2.symbols
@@ -290,9 +290,9 @@ type P1<T extends Function> = T extends (head: infer A, ...tail: infer B) => any
 >A : Symbol(A, Decl(genericRestParameters2.ts, 73, 52))
 >tail : Symbol(tail, Decl(genericRestParameters2.ts, 73, 55))
 >B : Symbol(B, Decl(genericRestParameters2.ts, 73, 70))
->head : Symbol(head, Decl(genericRestParameters2.ts, 73, 84))
+>head : Symbol(T10.head, Decl(genericRestParameters2.ts, 73, 84))
 >A : Symbol(A, Decl(genericRestParameters2.ts, 73, 52))
->tail : Symbol(tail, Decl(genericRestParameters2.ts, 73, 93))
+>tail : Symbol(T10.tail, Decl(genericRestParameters2.ts, 73, 93))
 >B : Symbol(B, Decl(genericRestParameters2.ts, 73, 70))
 
 type T10 = P1<(x: number, y: string, ...z: boolean[]) => void>;
diff --git a/tests/baselines/reference/identicalTypesNoDifferByCheckOrder.symbols b/tests/baselines/reference/identicalTypesNoDifferByCheckOrder.symbols
index 6850276d3408e..4958691549084 100644
--- a/tests/baselines/reference/identicalTypesNoDifferByCheckOrder.symbols
+++ b/tests/baselines/reference/identicalTypesNoDifferByCheckOrder.symbols
@@ -48,7 +48,7 @@ type SomePropsCloneX = Required<Pick<SomePropsClone, "x">> & Omit<SomePropsClone
 type Validator<T> = {(): boolean, opt?: T};
 >Validator : Symbol(Validator, Decl(identicalTypesNoDifferByCheckOrder.ts, 14, 87))
 >T : Symbol(T, Decl(identicalTypesNoDifferByCheckOrder.ts, 16, 15))
->opt : Symbol(opt, Decl(identicalTypesNoDifferByCheckOrder.ts, 16, 33))
+>opt : Symbol(Validator.opt, Decl(identicalTypesNoDifferByCheckOrder.ts, 16, 33))
 >T : Symbol(T, Decl(identicalTypesNoDifferByCheckOrder.ts, 16, 15))
 
 type WeakValidationMap<T> = {[K in keyof T]?: null extends T[K] ? Validator<T[K] | null | undefined> : Validator<T[K]>};
diff --git a/tests/baselines/reference/importClause_namedImports.symbols b/tests/baselines/reference/importClause_namedImports.symbols
index ab3d2b2729db0..3ea72b1c4ac7d 100644
--- a/tests/baselines/reference/importClause_namedImports.symbols
+++ b/tests/baselines/reference/importClause_namedImports.symbols
@@ -4,7 +4,7 @@ export class A {}
 
 export type B  = { b: string };
 >B : Symbol(B, Decl(abc.ts, 0, 17))
->b : Symbol(b, Decl(abc.ts, 1, 18))
+>b : Symbol(B.b, Decl(abc.ts, 1, 18))
 
 export const C = "";
 >C : Symbol(C, Decl(abc.ts, 2, 12))
diff --git a/tests/baselines/reference/importShouldNotBeElidedInDeclarationEmit.symbols b/tests/baselines/reference/importShouldNotBeElidedInDeclarationEmit.symbols
index 4ac0f4928b0c1..78c6476102a64 100644
--- a/tests/baselines/reference/importShouldNotBeElidedInDeclarationEmit.symbols
+++ b/tests/baselines/reference/importShouldNotBeElidedInDeclarationEmit.symbols
@@ -6,7 +6,7 @@ export type Thing = {
 >Thing : Symbol(Thing, Decl(umd.d.ts, 0, 24))
 
     a: number;
->a : Symbol(a, Decl(umd.d.ts, 2, 21))
+>a : Symbol(Thing.a, Decl(umd.d.ts, 2, 21))
 }
 
 export declare function makeThing(): Thing;
diff --git a/tests/baselines/reference/importTypeInJSDoc.symbols b/tests/baselines/reference/importTypeInJSDoc.symbols
index d00eab51a1856..c7c386b58be41 100644
--- a/tests/baselines/reference/importTypeInJSDoc.symbols
+++ b/tests/baselines/reference/importTypeInJSDoc.symbols
@@ -49,9 +49,9 @@ a = new Foo({doer: Foo.Bar});
 >a : Symbol(a, Decl(index.js, 4, 3))
 >Foo : Symbol(Foo, Decl(index.js, 1, 3), Decl(externs.d.ts, 11, 9))
 >doer : Symbol(doer, Decl(index.js, 5, 13))
->Foo.Bar : Symbol(MyClass.Bar, Decl(externs.d.ts, 0, 27), Decl(externs.d.ts, 6, 18))
+>Foo.Bar : Symbol(Foo.Bar, Decl(externs.d.ts, 0, 27), Decl(externs.d.ts, 6, 18))
 >Foo : Symbol(Foo, Decl(index.js, 1, 3), Decl(externs.d.ts, 11, 9))
->Bar : Symbol(MyClass.Bar, Decl(externs.d.ts, 0, 27), Decl(externs.d.ts, 6, 18))
+>Bar : Symbol(Foo.Bar, Decl(externs.d.ts, 0, 27), Decl(externs.d.ts, 6, 18))
 
 const q = /** @type {import("./externs").Bar} */({ doer: q => q });
 >q : Symbol(q, Decl(index.js, 6, 5))
diff --git a/tests/baselines/reference/importTypeInJSDoc.types b/tests/baselines/reference/importTypeInJSDoc.types
index ee28f78f97688..478b01638217d 100644
--- a/tests/baselines/reference/importTypeInJSDoc.types
+++ b/tests/baselines/reference/importTypeInJSDoc.types
@@ -37,15 +37,15 @@ export = MyClass;
  */
 
 let a = /** @type {Foo} */(/** @type {*} */(undefined)); 
->a : import("tests/cases/conformance/types/import/externs")
->(/** @type {*} */(undefined)) : import("tests/cases/conformance/types/import/externs")
+>a : Foo
+>(/** @type {*} */(undefined)) : Foo
 >(undefined) : any
 >undefined : undefined
 
 a = new Foo({doer: Foo.Bar});
->a = new Foo({doer: Foo.Bar}) : import("tests/cases/conformance/types/import/externs")
->a : import("tests/cases/conformance/types/import/externs")
->new Foo({doer: Foo.Bar}) : import("tests/cases/conformance/types/import/externs")
+>a = new Foo({doer: Foo.Bar}) : Foo
+>a : Foo
+>new Foo({doer: Foo.Bar}) : Foo
 >Foo : typeof import("tests/cases/conformance/types/import/externs")
 >{doer: Foo.Bar} : { doer: (x: string, y?: number) => void; }
 >doer : (x: string, y?: number) => void
@@ -54,8 +54,8 @@ a = new Foo({doer: Foo.Bar});
 >Bar : (x: string, y?: number) => void
 
 const q = /** @type {import("./externs").Bar} */({ doer: q => q });
->q : import("tests/cases/conformance/types/import/externs").Bar
->({ doer: q => q }) : import("tests/cases/conformance/types/import/externs").Bar
+>q : Foo.Bar
+>({ doer: q => q }) : Foo.Bar
 >{ doer: q => q } : { doer: (q: string) => string; }
 >doer : (q: string) => string
 >q => q : (q: string) => string
diff --git a/tests/baselines/reference/importTypeResolutionJSDocEOF.types b/tests/baselines/reference/importTypeResolutionJSDocEOF.types
index a8a2c44eb3b0a..f2ddf200d27d4 100644
--- a/tests/baselines/reference/importTypeResolutionJSDocEOF.types
+++ b/tests/baselines/reference/importTypeResolutionJSDocEOF.types
@@ -7,6 +7,6 @@ export interface Bar {
 === tests/cases/compiler/usage.js ===
 /** @type {Bar} */
 export let bar;
->bar : import("tests/cases/compiler/interfaces").Bar
+>bar : Bar
 
 /** @typedef {import('./interfaces').Bar} Bar */
diff --git a/tests/baselines/reference/indexSignatures1.symbols b/tests/baselines/reference/indexSignatures1.symbols
index 40d8740b1b7b2..d02e380d264ee 100644
--- a/tests/baselines/reference/indexSignatures1.symbols
+++ b/tests/baselines/reference/indexSignatures1.symbols
@@ -235,11 +235,11 @@ type Invalid<T extends string> = {
 
 type Tag1 = { __tag1__: void };
 >Tag1 : Symbol(Tag1, Decl(indexSignatures1.ts, 90, 1))
->__tag1__ : Symbol(__tag1__, Decl(indexSignatures1.ts, 94, 13))
+>__tag1__ : Symbol(Tag1.__tag1__, Decl(indexSignatures1.ts, 94, 13))
 
 type Tag2 = { __tag2__: void };
 >Tag2 : Symbol(Tag2, Decl(indexSignatures1.ts, 94, 31))
->__tag2__ : Symbol(__tag2__, Decl(indexSignatures1.ts, 95, 13))
+>__tag2__ : Symbol(Tag2.__tag2__, Decl(indexSignatures1.ts, 95, 13))
 
 type TaggedString1 = string & Tag1;
 >TaggedString1 : Symbol(TaggedString1, Decl(indexSignatures1.ts, 95, 31))
diff --git a/tests/baselines/reference/indexedAccessNormalization.types b/tests/baselines/reference/indexedAccessNormalization.types
index 53d57f4319ae7..418be2989a710 100644
--- a/tests/baselines/reference/indexedAccessNormalization.types
+++ b/tests/baselines/reference/indexedAccessNormalization.types
@@ -11,7 +11,7 @@ type MyMap<M extends object> = {
 }
 
 declare function g<T>(value?: T): void;
->g : <T>(value?: T | undefined) => void
+>g : <T>(value?: T) => void
 >value : T | undefined
 
 function f1<M extends object>(mymap: MyMap<M>, k: keyof M) {
diff --git a/tests/baselines/reference/indexedAccessTypeConstraints.symbols b/tests/baselines/reference/indexedAccessTypeConstraints.symbols
index 4937db57f31f2..c5aa639825eea 100644
--- a/tests/baselines/reference/indexedAccessTypeConstraints.symbols
+++ b/tests/baselines/reference/indexedAccessTypeConstraints.symbols
@@ -15,7 +15,7 @@ type Data<T> = {
 >T : Symbol(T, Decl(indexedAccessTypeConstraints.ts, 6, 10))
 
     get: <K extends keyof T>(prop: K) => T[K];
->get : Symbol(get, Decl(indexedAccessTypeConstraints.ts, 6, 16))
+>get : Symbol(Data.get, Decl(indexedAccessTypeConstraints.ts, 6, 16))
 >K : Symbol(K, Decl(indexedAccessTypeConstraints.ts, 7, 10))
 >T : Symbol(T, Decl(indexedAccessTypeConstraints.ts, 6, 10))
 >prop : Symbol(prop, Decl(indexedAccessTypeConstraints.ts, 7, 29))
@@ -58,11 +58,11 @@ export class Foo<C> extends Parent<IData<C>> {
 >C : Symbol(C, Decl(indexedAccessTypeConstraints.ts, 17, 17))
 
         return this.getData().get('content');
->this.getData().get : Symbol(get, Decl(indexedAccessTypeConstraints.ts, 6, 16))
+>this.getData().get : Symbol(Data.get, Decl(indexedAccessTypeConstraints.ts, 6, 16))
 >this.getData : Symbol(Parent.getData, Decl(indexedAccessTypeConstraints.ts, 11, 41))
 >this : Symbol(Foo, Decl(indexedAccessTypeConstraints.ts, 15, 1))
 >getData : Symbol(Parent.getData, Decl(indexedAccessTypeConstraints.ts, 11, 41))
->get : Symbol(get, Decl(indexedAccessTypeConstraints.ts, 6, 16))
+>get : Symbol(Data.get, Decl(indexedAccessTypeConstraints.ts, 6, 16))
     }
 }
 
@@ -80,11 +80,11 @@ export class Bar<C, T extends IData<C>> extends Parent<T> {
 >C : Symbol(C, Decl(indexedAccessTypeConstraints.ts, 23, 17))
 
         return this.getData().get('content');
->this.getData().get : Symbol(get, Decl(indexedAccessTypeConstraints.ts, 6, 16))
+>this.getData().get : Symbol(Data.get, Decl(indexedAccessTypeConstraints.ts, 6, 16))
 >this.getData : Symbol(Parent.getData, Decl(indexedAccessTypeConstraints.ts, 11, 41))
 >this : Symbol(Bar, Decl(indexedAccessTypeConstraints.ts, 21, 1))
 >getData : Symbol(Parent.getData, Decl(indexedAccessTypeConstraints.ts, 11, 41))
->get : Symbol(get, Decl(indexedAccessTypeConstraints.ts, 6, 16))
+>get : Symbol(Data.get, Decl(indexedAccessTypeConstraints.ts, 6, 16))
     }
 }
 
diff --git a/tests/baselines/reference/indexingTypesWithNever.symbols b/tests/baselines/reference/indexingTypesWithNever.symbols
index 9b93d00e50fcf..76e5fbf0ab956 100644
--- a/tests/baselines/reference/indexingTypesWithNever.symbols
+++ b/tests/baselines/reference/indexingTypesWithNever.symbols
@@ -3,10 +3,10 @@ type TestObj = {
 >TestObj : Symbol(TestObj, Decl(indexingTypesWithNever.ts, 0, 0))
 
   a: string;
->a : Symbol(a, Decl(indexingTypesWithNever.ts, 0, 16))
+>a : Symbol(TestObj.a, Decl(indexingTypesWithNever.ts, 0, 16))
 
   b: number;
->b : Symbol(b, Decl(indexingTypesWithNever.ts, 1, 12))
+>b : Symbol(TestObj.b, Decl(indexingTypesWithNever.ts, 1, 12))
 
 };
 
@@ -187,18 +187,18 @@ type ExpectType<Exp, Act> = Match<Exp, Act> extends "Match"
 
 type P3 = { a: string; b: number; c?: boolean };
 >P3 : Symbol(P3, Decl(indexingTypesWithNever.ts, 58, 20))
->a : Symbol(a, Decl(indexingTypesWithNever.ts, 60, 11))
->b : Symbol(b, Decl(indexingTypesWithNever.ts, 60, 22))
->c : Symbol(c, Decl(indexingTypesWithNever.ts, 60, 33))
+>a : Symbol(P3.a, Decl(indexingTypesWithNever.ts, 60, 11))
+>b : Symbol(P3.b, Decl(indexingTypesWithNever.ts, 60, 22))
+>c : Symbol(P3.c, Decl(indexingTypesWithNever.ts, 60, 33))
 
 type P2 = { a: string; c?: boolean };
 >P2 : Symbol(P2, Decl(indexingTypesWithNever.ts, 60, 48))
->a : Symbol(a, Decl(indexingTypesWithNever.ts, 61, 11))
->c : Symbol(c, Decl(indexingTypesWithNever.ts, 61, 22))
+>a : Symbol(P2.a, Decl(indexingTypesWithNever.ts, 61, 11))
+>c : Symbol(P2.c, Decl(indexingTypesWithNever.ts, 61, 22))
 
 type P1 = { c?: boolean };
 >P1 : Symbol(P1, Decl(indexingTypesWithNever.ts, 61, 37))
->c : Symbol(c, Decl(indexingTypesWithNever.ts, 62, 11))
+>c : Symbol(P1.c, Decl(indexingTypesWithNever.ts, 62, 11))
 
 type P0 = {};
 >P0 : Symbol(P0, Decl(indexingTypesWithNever.ts, 62, 26))
@@ -288,18 +288,18 @@ declare const p0Test: ExpectType<{}, P0Props>;
 
 type O3 = { a?: string; b?: number; c: boolean };
 >O3 : Symbol(O3, Decl(indexingTypesWithNever.ts, 83, 46))
->a : Symbol(a, Decl(indexingTypesWithNever.ts, 85, 11))
->b : Symbol(b, Decl(indexingTypesWithNever.ts, 85, 23))
->c : Symbol(c, Decl(indexingTypesWithNever.ts, 85, 35))
+>a : Symbol(O3.a, Decl(indexingTypesWithNever.ts, 85, 11))
+>b : Symbol(O3.b, Decl(indexingTypesWithNever.ts, 85, 23))
+>c : Symbol(O3.c, Decl(indexingTypesWithNever.ts, 85, 35))
 
 type O2 = { a?: string; c: boolean };
 >O2 : Symbol(O2, Decl(indexingTypesWithNever.ts, 85, 49))
->a : Symbol(a, Decl(indexingTypesWithNever.ts, 86, 11))
->c : Symbol(c, Decl(indexingTypesWithNever.ts, 86, 23))
+>a : Symbol(O2.a, Decl(indexingTypesWithNever.ts, 86, 11))
+>c : Symbol(O2.c, Decl(indexingTypesWithNever.ts, 86, 23))
 
 type O1 = { c: boolean };
 >O1 : Symbol(O1, Decl(indexingTypesWithNever.ts, 86, 37))
->c : Symbol(c, Decl(indexingTypesWithNever.ts, 87, 11))
+>c : Symbol(O1.c, Decl(indexingTypesWithNever.ts, 87, 11))
 
 type O0 = {};
 >O0 : Symbol(O0, Decl(indexingTypesWithNever.ts, 87, 25))
diff --git a/tests/baselines/reference/indirectTypeParameterReferences.symbols b/tests/baselines/reference/indirectTypeParameterReferences.symbols
index cf0f3e7bbc910..7dea212403bee 100644
--- a/tests/baselines/reference/indirectTypeParameterReferences.symbols
+++ b/tests/baselines/reference/indirectTypeParameterReferences.symbols
@@ -3,7 +3,7 @@
 
 type B = {b: string}
 >B : Symbol(B, Decl(indirectTypeParameterReferences.ts, 0, 0))
->b : Symbol(b, Decl(indirectTypeParameterReferences.ts, 2, 10))
+>b : Symbol(B.b, Decl(indirectTypeParameterReferences.ts, 2, 10))
 
 const flowtypes = <A>(b: B) => {
 >flowtypes : Symbol(flowtypes, Decl(indirectTypeParameterReferences.ts, 4, 5))
@@ -46,9 +46,9 @@ literal(aPlusB => {
 >aPlusB : Symbol(aPlusB, Decl(indirectTypeParameterReferences.ts, 15, 8))
 
   aPlusB.b
->aPlusB.b : Symbol(b, Decl(indirectTypeParameterReferences.ts, 2, 10))
+>aPlusB.b : Symbol(B.b, Decl(indirectTypeParameterReferences.ts, 2, 10))
 >aPlusB : Symbol(aPlusB, Decl(indirectTypeParameterReferences.ts, 15, 8))
->b : Symbol(b, Decl(indirectTypeParameterReferences.ts, 2, 10))
+>b : Symbol(B.b, Decl(indirectTypeParameterReferences.ts, 2, 10))
 
   aPlusB.a
 >aPlusB.a : Symbol(a, Decl(indirectTypeParameterReferences.ts, 13, 39))
@@ -62,9 +62,9 @@ combined(comb => {
 >comb : Symbol(comb, Decl(indirectTypeParameterReferences.ts, 20, 9))
 
   comb.b
->comb.b : Symbol(b, Decl(indirectTypeParameterReferences.ts, 2, 10))
+>comb.b : Symbol(B.b, Decl(indirectTypeParameterReferences.ts, 2, 10))
 >comb : Symbol(comb, Decl(indirectTypeParameterReferences.ts, 20, 9))
->b : Symbol(b, Decl(indirectTypeParameterReferences.ts, 2, 10))
+>b : Symbol(B.b, Decl(indirectTypeParameterReferences.ts, 2, 10))
 
   comb.a
 >comb.a : Symbol(a, Decl(indirectTypeParameterReferences.ts, 13, 39))
diff --git a/tests/baselines/reference/inferFromBindingPattern.types b/tests/baselines/reference/inferFromBindingPattern.types
index 802fd56f7fcc3..ee217fafa8617 100644
--- a/tests/baselines/reference/inferFromBindingPattern.types
+++ b/tests/baselines/reference/inferFromBindingPattern.types
@@ -60,7 +60,7 @@ interface Person {
 }
 
 declare function selectJohn<K = Person>(props?: SelectProps<Person, K>): SelectResult<Person, K>;
->selectJohn : <K = Person>(props?: SelectProps<Person, K> | undefined) => SelectResult<Person, K>
+>selectJohn : <K = Person>(props?: SelectProps<Person, K>) => SelectResult<Person, K>
 >props : SelectProps<Person, K> | undefined
 
 const [person] = selectJohn();
@@ -91,7 +91,7 @@ declare function makeTuple<T1>(arg: T1): [T1];
 >arg : T1
 
 declare function stringy<T = string>(arg?: T): T;
->stringy : <T = string>(arg?: T | undefined) => T
+>stringy : <T = string>(arg?: T) => T
 >arg : T | undefined
 
 const isStringTuple = makeTuple(stringy());  // [string]
diff --git a/tests/baselines/reference/inferFromGenericFunctionReturnTypes3.symbols b/tests/baselines/reference/inferFromGenericFunctionReturnTypes3.symbols
index 099c5761978d6..ae271dd2a81a5 100644
--- a/tests/baselines/reference/inferFromGenericFunctionReturnTypes3.symbols
+++ b/tests/baselines/reference/inferFromGenericFunctionReturnTypes3.symbols
@@ -252,7 +252,7 @@ function createPerson(): Person {
 type Box<T> = { value: T };
 >Box : Symbol(Box, Decl(inferFromGenericFunctionReturnTypes3.ts, 101, 1))
 >T : Symbol(T, Decl(inferFromGenericFunctionReturnTypes3.ts, 105, 9))
->value : Symbol(value, Decl(inferFromGenericFunctionReturnTypes3.ts, 105, 15))
+>value : Symbol(Box.value, Decl(inferFromGenericFunctionReturnTypes3.ts, 105, 15))
 >T : Symbol(T, Decl(inferFromGenericFunctionReturnTypes3.ts, 105, 9))
 
 declare function box<T>(value: T): Box<T>;
@@ -360,13 +360,13 @@ type Player = {
 >Player : Symbol(Player, Decl(inferFromGenericFunctionReturnTypes3.ts, 145, 3))
 
     name: string;
->name : Symbol(name, Decl(inferFromGenericFunctionReturnTypes3.ts, 149, 15))
+>name : Symbol(Player.name, Decl(inferFromGenericFunctionReturnTypes3.ts, 149, 15))
 
     age: number;
->age : Symbol(age, Decl(inferFromGenericFunctionReturnTypes3.ts, 150, 17))
+>age : Symbol(Player.age, Decl(inferFromGenericFunctionReturnTypes3.ts, 150, 17))
 
     position: "STRIKER" | "GOALKEEPER",
->position : Symbol(position, Decl(inferFromGenericFunctionReturnTypes3.ts, 151, 16))
+>position : Symbol(Player.position, Decl(inferFromGenericFunctionReturnTypes3.ts, 151, 16))
 
 };
  
@@ -436,7 +436,7 @@ enum State { A, B }
 
 type Foo = { state: State }
 >Foo : Symbol(Foo, Decl(inferFromGenericFunctionReturnTypes3.ts, 176, 19))
->state : Symbol(state, Decl(inferFromGenericFunctionReturnTypes3.ts, 177, 12))
+>state : Symbol(Foo.state, Decl(inferFromGenericFunctionReturnTypes3.ts, 177, 12))
 >State : Symbol(State, Decl(inferFromGenericFunctionReturnTypes3.ts, 174, 56))
 
 declare function bar<T>(f: () => T[]): T[];
diff --git a/tests/baselines/reference/inferTypes1.symbols b/tests/baselines/reference/inferTypes1.symbols
index 7e79885184007..b6bf2dd39f376 100644
--- a/tests/baselines/reference/inferTypes1.symbols
+++ b/tests/baselines/reference/inferTypes1.symbols
@@ -59,8 +59,8 @@ function f1(s: string) {
 >s : Symbol(s, Decl(inferTypes1.ts, 14, 12))
 
     return { a: 1, b: s };
->a : Symbol(a, Decl(inferTypes1.ts, 15, 12))
->b : Symbol(b, Decl(inferTypes1.ts, 15, 18))
+>a : Symbol(T14.a, Decl(inferTypes1.ts, 15, 12))
+>b : Symbol(T14.b, Decl(inferTypes1.ts, 15, 18))
 >s : Symbol(s, Decl(inferTypes1.ts, 14, 12))
 }
 
@@ -377,7 +377,7 @@ type T63<T> = T extends (infer A extends infer B ? infer C : infer D) ? string :
 type T70<T extends string> = { x: T };
 >T70 : Symbol(T70, Decl(inferTypes1.ts, 84, 88))
 >T : Symbol(T, Decl(inferTypes1.ts, 86, 9))
->x : Symbol(x, Decl(inferTypes1.ts, 86, 30))
+>x : Symbol(T70.x, Decl(inferTypes1.ts, 86, 30))
 >T : Symbol(T, Decl(inferTypes1.ts, 86, 9))
 
 type T71<T> = T extends T70<infer U> ? T70<U> : never;
@@ -392,7 +392,7 @@ type T71<T> = T extends T70<infer U> ? T70<U> : never;
 type T72<T extends number> = { y: T };
 >T72 : Symbol(T72, Decl(inferTypes1.ts, 87, 54))
 >T : Symbol(T, Decl(inferTypes1.ts, 89, 9))
->y : Symbol(y, Decl(inferTypes1.ts, 89, 30))
+>y : Symbol(T72.y, Decl(inferTypes1.ts, 89, 30))
 >T : Symbol(T, Decl(inferTypes1.ts, 89, 9))
 
 type T73<T> = T extends T72<infer U> ? T70<U> : never;  // Error
@@ -408,9 +408,9 @@ type T74<T extends number, U extends string> = { x: T, y: U };
 >T74 : Symbol(T74, Decl(inferTypes1.ts, 90, 54))
 >T : Symbol(T, Decl(inferTypes1.ts, 92, 9))
 >U : Symbol(U, Decl(inferTypes1.ts, 92, 26))
->x : Symbol(x, Decl(inferTypes1.ts, 92, 48))
+>x : Symbol(T74.x, Decl(inferTypes1.ts, 92, 48))
 >T : Symbol(T, Decl(inferTypes1.ts, 92, 9))
->y : Symbol(y, Decl(inferTypes1.ts, 92, 54))
+>y : Symbol(T74.y, Decl(inferTypes1.ts, 92, 54))
 >U : Symbol(U, Decl(inferTypes1.ts, 92, 26))
 
 type T75<T> = T extends T74<infer U, infer U> ? T70<U> | T72<U> | T74<U, U> : never;
@@ -434,7 +434,7 @@ type T76<T extends T[], U extends T> = { x: T };
 >T : Symbol(T, Decl(inferTypes1.ts, 95, 9))
 >U : Symbol(U, Decl(inferTypes1.ts, 95, 23))
 >T : Symbol(T, Decl(inferTypes1.ts, 95, 9))
->x : Symbol(x, Decl(inferTypes1.ts, 95, 40))
+>x : Symbol(T76.x, Decl(inferTypes1.ts, 95, 40))
 >T : Symbol(T, Decl(inferTypes1.ts, 95, 9))
 
 type T77<T> = T extends T76<infer X, infer Y> ? T76<X, Y> : never;
@@ -539,21 +539,21 @@ type Example = {
 >Example : Symbol(Example, Decl(inferTypes1.ts, 117, 21))
 
     str: "literalstring",
->str : Symbol(str, Decl(inferTypes1.ts, 119, 16))
+>str : Symbol(Example.str, Decl(inferTypes1.ts, 119, 16))
 
     fn: () => void,
->fn : Symbol(fn, Decl(inferTypes1.ts, 120, 25))
+>fn : Symbol(Example.fn, Decl(inferTypes1.ts, 120, 25))
 
     date: Date,
->date : Symbol(date, Decl(inferTypes1.ts, 121, 19))
+>date : Symbol(Example.date, Decl(inferTypes1.ts, 121, 19))
 >Date : Symbol(Date, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.scripthost.d.ts, --, --))
 
     customClass: MyClass,
->customClass : Symbol(customClass, Decl(inferTypes1.ts, 122, 15))
+>customClass : Symbol(Example.customClass, Decl(inferTypes1.ts, 122, 15))
 >MyClass : Symbol(MyClass, Decl(inferTypes1.ts, 129, 1))
 
     obj: {
->obj : Symbol(obj, Decl(inferTypes1.ts, 123, 25))
+>obj : Symbol(Example.obj, Decl(inferTypes1.ts, 123, 25))
 
         prop: "property",
 >prop : Symbol(prop, Decl(inferTypes1.ts, 124, 10))
diff --git a/tests/baselines/reference/inferTypes2.symbols b/tests/baselines/reference/inferTypes2.symbols
index 8d792ea79c225..68493a2ccaf46 100644
--- a/tests/baselines/reference/inferTypes2.symbols
+++ b/tests/baselines/reference/inferTypes2.symbols
@@ -24,7 +24,7 @@ export function bar<T>(obj: T) {
 export type BadNested<T> = { x: T extends number ? T : string };
 >BadNested : Symbol(BadNested, Decl(inferTypes2.ts, 5, 1))
 >T : Symbol(T, Decl(inferTypes2.ts, 7, 22))
->x : Symbol(x, Decl(inferTypes2.ts, 7, 28))
+>x : Symbol(BadNested.x, Decl(inferTypes2.ts, 7, 28))
 >T : Symbol(T, Decl(inferTypes2.ts, 7, 22))
 >T : Symbol(T, Decl(inferTypes2.ts, 7, 22))
 
diff --git a/tests/baselines/reference/inferenceErasedSignatures.types b/tests/baselines/reference/inferenceErasedSignatures.types
index 84f64ffda5682..382cc08394ff8 100644
--- a/tests/baselines/reference/inferenceErasedSignatures.types
+++ b/tests/baselines/reference/inferenceErasedSignatures.types
@@ -15,7 +15,7 @@ abstract class SomeAbstractClass<C, M, R> extends SomeBaseClass {
 >SomeBaseClass : SomeBaseClass
 
     foo!: (r?: R) => void;
->foo : (r?: R | undefined) => void
+>foo : (r?: R) => void
 >r : R | undefined
 
     bar!: (r?: any) => void;
@@ -72,7 +72,7 @@ interface BaseType<T1, T2>  {
 >c : T1
 
     useT2(r?: T2): void;
->useT2 : (r?: T2 | undefined) => void
+>useT2 : (r?: T2) => void
 >r : T2 | undefined
 
     unrelatedButSomehowRelevant(r?: any): void;
@@ -99,7 +99,7 @@ interface StructuralVersion  {
 >c : number
 
     useT2(r?: boolean): void;
->useT2 : (r?: boolean | undefined) => void
+>useT2 : (r?: boolean) => void
 >r : boolean | undefined
 
     unrelatedButSomehowRelevant(r?: any): void;
diff --git a/tests/baselines/reference/initializedParameterBeforeNonoptionalNotOptional.types b/tests/baselines/reference/initializedParameterBeforeNonoptionalNotOptional.types
index 5035da7bcef17..2656522f57e08 100644
--- a/tests/baselines/reference/initializedParameterBeforeNonoptionalNotOptional.types
+++ b/tests/baselines/reference/initializedParameterBeforeNonoptionalNotOptional.types
@@ -1,6 +1,6 @@
 === tests/cases/compiler/index.d.ts ===
 export declare function foo({a}?: {
->foo : ({ a }?: { a?: string | undefined; } | undefined) => void
+>foo : ({ a }?: {    a?: string;}) => void
 >a : string | undefined
 
     a?: string;
diff --git a/tests/baselines/reference/instantiateContextualTypes.symbols b/tests/baselines/reference/instantiateContextualTypes.symbols
index d3e8a7a317c4f..9c43d76a408a8 100644
--- a/tests/baselines/reference/instantiateContextualTypes.symbols
+++ b/tests/baselines/reference/instantiateContextualTypes.symbols
@@ -217,11 +217,11 @@ type R = {
 >R : Symbol(R, Decl(instantiateContextualTypes.ts, 66, 1))
 
   a: (x: number) => void;
->a : Symbol(a, Decl(instantiateContextualTypes.ts, 70, 10))
+>a : Symbol(R.a, Decl(instantiateContextualTypes.ts, 70, 10))
 >x : Symbol(x, Decl(instantiateContextualTypes.ts, 71, 6))
 
   b: (x: string) => void;
->b : Symbol(b, Decl(instantiateContextualTypes.ts, 71, 25))
+>b : Symbol(R.b, Decl(instantiateContextualTypes.ts, 71, 25))
 >x : Symbol(x, Decl(instantiateContextualTypes.ts, 72, 6))
 
 };
@@ -230,7 +230,7 @@ type O = {
 >O : Symbol(O, Decl(instantiateContextualTypes.ts, 73, 2))
 
   on<P extends keyof R>(x: P, callback: R[P]): void;
->on : Symbol(on, Decl(instantiateContextualTypes.ts, 75, 10))
+>on : Symbol(O.on, Decl(instantiateContextualTypes.ts, 75, 10))
 >P : Symbol(P, Decl(instantiateContextualTypes.ts, 76, 5))
 >R : Symbol(R, Decl(instantiateContextualTypes.ts, 66, 1))
 >x : Symbol(x, Decl(instantiateContextualTypes.ts, 76, 24))
@@ -246,9 +246,9 @@ declare var x: O;
 >O : Symbol(O, Decl(instantiateContextualTypes.ts, 73, 2))
 
 x.on('a', a => {});
->x.on : Symbol(on, Decl(instantiateContextualTypes.ts, 75, 10))
+>x.on : Symbol(O.on, Decl(instantiateContextualTypes.ts, 75, 10))
 >x : Symbol(x, Decl(instantiateContextualTypes.ts, 79, 11))
->on : Symbol(on, Decl(instantiateContextualTypes.ts, 75, 10))
+>on : Symbol(O.on, Decl(instantiateContextualTypes.ts, 75, 10))
 >a : Symbol(a, Decl(instantiateContextualTypes.ts, 80, 9))
 
 // #29775
@@ -355,7 +355,7 @@ type InnerBox<T> = {
 >T : Symbol(T, Decl(instantiateContextualTypes.ts, 121, 14))
 
   value: T;
->value : Symbol(value, Decl(instantiateContextualTypes.ts, 121, 20))
+>value : Symbol(InnerBox.value, Decl(instantiateContextualTypes.ts, 121, 20))
 >T : Symbol(T, Decl(instantiateContextualTypes.ts, 121, 14))
 }
 
@@ -364,7 +364,7 @@ type OuterBox<T> = {
 >T : Symbol(T, Decl(instantiateContextualTypes.ts, 125, 14))
 
   inner: InnerBox<T>
->inner : Symbol(inner, Decl(instantiateContextualTypes.ts, 125, 20))
+>inner : Symbol(OuterBox.inner, Decl(instantiateContextualTypes.ts, 125, 20))
 >InnerBox : Symbol(InnerBox, Decl(instantiateContextualTypes.ts, 117, 1))
 >T : Symbol(T, Decl(instantiateContextualTypes.ts, 125, 14))
 
@@ -403,9 +403,9 @@ passContentsToFunc(outerBoxOfString, box => box.value);
 >passContentsToFunc : Symbol(passContentsToFunc, Decl(instantiateContextualTypes.ts, 132, 12))
 >outerBoxOfString : Symbol(outerBoxOfString, Decl(instantiateContextualTypes.ts, 136, 13))
 >box : Symbol(box, Decl(instantiateContextualTypes.ts, 138, 36))
->box.value : Symbol(value, Decl(instantiateContextualTypes.ts, 121, 20))
+>box.value : Symbol(InnerBox.value, Decl(instantiateContextualTypes.ts, 121, 20))
 >box : Symbol(box, Decl(instantiateContextualTypes.ts, 138, 36))
->value : Symbol(value, Decl(instantiateContextualTypes.ts, 121, 20))
+>value : Symbol(InnerBox.value, Decl(instantiateContextualTypes.ts, 121, 20))
 
 // Repro from #32349
 
diff --git a/tests/baselines/reference/instantiationExpressions.symbols b/tests/baselines/reference/instantiationExpressions.symbols
index 3fd52bf485bc2..a565ed5431188 100644
--- a/tests/baselines/reference/instantiationExpressions.symbols
+++ b/tests/baselines/reference/instantiationExpressions.symbols
@@ -522,7 +522,7 @@ function makeBox<T>(value: T) {
 >T : Symbol(T, Decl(instantiationExpressions.ts, 136, 17))
 
     return { value };
->value : Symbol(value, Decl(instantiationExpressions.ts, 137, 12))
+>value : Symbol(Box.value, Decl(instantiationExpressions.ts, 137, 12))
 }
 
 type BoxFunc<T> = typeof makeBox<T>;  // (value: T) => { value: T }
@@ -560,14 +560,14 @@ declare const g1: {
 >T : Symbol(T, Decl(instantiationExpressions.ts, 149, 5))
 >a : Symbol(a, Decl(instantiationExpressions.ts, 149, 8))
 >T : Symbol(T, Decl(instantiationExpressions.ts, 149, 5))
->a : Symbol(a, Decl(instantiationExpressions.ts, 149, 16))
+>a : Symbol(T31.a, Decl(instantiationExpressions.ts, 149, 16))
 >T : Symbol(T, Decl(instantiationExpressions.ts, 149, 5))
 
     new <U>(b: U): { b: U };
 >U : Symbol(U, Decl(instantiationExpressions.ts, 150, 9))
 >b : Symbol(b, Decl(instantiationExpressions.ts, 150, 12))
 >U : Symbol(U, Decl(instantiationExpressions.ts, 150, 9))
->b : Symbol(b, Decl(instantiationExpressions.ts, 150, 20))
+>b : Symbol(T32.b, Decl(instantiationExpressions.ts, 150, 20))
 >U : Symbol(U, Decl(instantiationExpressions.ts, 150, 9))
 }
 
diff --git a/tests/baselines/reference/interfaceExtendsObjectIntersection.symbols b/tests/baselines/reference/interfaceExtendsObjectIntersection.symbols
index df239bba26189..8114ae1489937 100644
--- a/tests/baselines/reference/interfaceExtendsObjectIntersection.symbols
+++ b/tests/baselines/reference/interfaceExtendsObjectIntersection.symbols
@@ -1,7 +1,7 @@
 === tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersection.ts ===
 type T1 = { a: number };
 >T1 : Symbol(T1, Decl(interfaceExtendsObjectIntersection.ts, 0, 0))
->a : Symbol(a, Decl(interfaceExtendsObjectIntersection.ts, 0, 11))
+>a : Symbol(T1.a, Decl(interfaceExtendsObjectIntersection.ts, 0, 11))
 
 type T2 = T1 & { b: number };
 >T2 : Symbol(T2, Decl(interfaceExtendsObjectIntersection.ts, 0, 24))
diff --git a/tests/baselines/reference/interfaceExtendsObjectIntersectionErrors.symbols b/tests/baselines/reference/interfaceExtendsObjectIntersectionErrors.symbols
index 384cfb273ce03..03c90c067fc5e 100644
--- a/tests/baselines/reference/interfaceExtendsObjectIntersectionErrors.symbols
+++ b/tests/baselines/reference/interfaceExtendsObjectIntersectionErrors.symbols
@@ -1,7 +1,7 @@
 === tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts ===
 type T1 = { a: number };
 >T1 : Symbol(T1, Decl(interfaceExtendsObjectIntersectionErrors.ts, 0, 0))
->a : Symbol(a, Decl(interfaceExtendsObjectIntersectionErrors.ts, 0, 11))
+>a : Symbol(T1.a, Decl(interfaceExtendsObjectIntersectionErrors.ts, 0, 11))
 
 type T2 = T1 & { b: number };
 >T2 : Symbol(T2, Decl(interfaceExtendsObjectIntersectionErrors.ts, 0, 24))
diff --git a/tests/baselines/reference/intersectionReduction.symbols b/tests/baselines/reference/intersectionReduction.symbols
index 02cc8c9ff2fc7..32825d9dafae4 100644
--- a/tests/baselines/reference/intersectionReduction.symbols
+++ b/tests/baselines/reference/intersectionReduction.symbols
@@ -61,7 +61,7 @@ type N7 = void & string;
 
 type X = { x: string };
 >X : Symbol(X, Decl(intersectionReduction.ts, 20, 24))
->x : Symbol(x, Decl(intersectionReduction.ts, 22, 10))
+>x : Symbol(X.x, Decl(intersectionReduction.ts, 22, 10))
 
 type X1 = X | 'a' & 'b';
 >X1 : Symbol(X1, Decl(intersectionReduction.ts, 22, 23))
@@ -95,18 +95,18 @@ type X7 = X | void & string;
 
 type A = { kind: 'a', foo: string };
 >A : Symbol(A, Decl(intersectionReduction.ts, 30, 28))
->kind : Symbol(kind, Decl(intersectionReduction.ts, 32, 10))
->foo : Symbol(foo, Decl(intersectionReduction.ts, 32, 21))
+>kind : Symbol(A.kind, Decl(intersectionReduction.ts, 32, 10))
+>foo : Symbol(A.foo, Decl(intersectionReduction.ts, 32, 21))
 
 type B = { kind: 'b', foo: number };
 >B : Symbol(B, Decl(intersectionReduction.ts, 32, 36))
->kind : Symbol(kind, Decl(intersectionReduction.ts, 33, 10))
->foo : Symbol(foo, Decl(intersectionReduction.ts, 33, 21))
+>kind : Symbol(B.kind, Decl(intersectionReduction.ts, 33, 10))
+>foo : Symbol(B.foo, Decl(intersectionReduction.ts, 33, 21))
 
 type C = { kind: 'c', foo: number };
 >C : Symbol(C, Decl(intersectionReduction.ts, 33, 36))
->kind : Symbol(kind, Decl(intersectionReduction.ts, 34, 10))
->foo : Symbol(foo, Decl(intersectionReduction.ts, 34, 21))
+>kind : Symbol(C.kind, Decl(intersectionReduction.ts, 34, 10))
+>foo : Symbol(C.foo, Decl(intersectionReduction.ts, 34, 21))
 
 declare let ab: A & B;
 >ab : Symbol(ab, Decl(intersectionReduction.ts, 36, 11))
@@ -232,13 +232,13 @@ type M3 = Merge2<{ a: 1, b: 2 }, { a: 2, c: 3 }>;  // { a: 1, b: 2, c: 3 }
 
 type D = { kind: 'd', foo: unknown };
 >D : Symbol(D, Decl(intersectionReduction.ts, 59, 49))
->kind : Symbol(kind, Decl(intersectionReduction.ts, 61, 10))
->foo : Symbol(foo, Decl(intersectionReduction.ts, 61, 21))
+>kind : Symbol(D.kind, Decl(intersectionReduction.ts, 61, 10))
+>foo : Symbol(D.foo, Decl(intersectionReduction.ts, 61, 21))
 
 type E = { kind: 'e', foo: unknown };
 >E : Symbol(E, Decl(intersectionReduction.ts, 61, 37))
->kind : Symbol(kind, Decl(intersectionReduction.ts, 62, 10))
->foo : Symbol(foo, Decl(intersectionReduction.ts, 62, 21))
+>kind : Symbol(E.kind, Decl(intersectionReduction.ts, 62, 10))
+>foo : Symbol(E.foo, Decl(intersectionReduction.ts, 62, 21))
 
 declare function f10<T>(x: { foo: T }): T;
 >f10 : Symbol(f10, Decl(intersectionReduction.ts, 62, 37))
@@ -342,7 +342,7 @@ type Container<Type extends string> = {
 >Type : Symbol(Type, Decl(intersectionReduction.ts, 101, 15))
 
     type: Type;
->type : Symbol(type, Decl(intersectionReduction.ts, 101, 39))
+>type : Symbol(Container.type, Decl(intersectionReduction.ts, 101, 39))
 >Type : Symbol(Type, Decl(intersectionReduction.ts, 101, 15))
 }
 
diff --git a/tests/baselines/reference/intersectionReductionStrict.symbols b/tests/baselines/reference/intersectionReductionStrict.symbols
index f2851fb643c2a..0d18e871081bf 100644
--- a/tests/baselines/reference/intersectionReductionStrict.symbols
+++ b/tests/baselines/reference/intersectionReductionStrict.symbols
@@ -61,7 +61,7 @@ type N7 = void & string;
 
 type X = { x: string };
 >X : Symbol(X, Decl(intersectionReductionStrict.ts, 20, 24))
->x : Symbol(x, Decl(intersectionReductionStrict.ts, 22, 10))
+>x : Symbol(X.x, Decl(intersectionReductionStrict.ts, 22, 10))
 
 type X1 = X | 'a' & 'b';
 >X1 : Symbol(X1, Decl(intersectionReductionStrict.ts, 22, 23))
@@ -95,18 +95,18 @@ type X7 = X | void & string;
 
 type A = { kind: 'a', foo: string };
 >A : Symbol(A, Decl(intersectionReductionStrict.ts, 30, 28))
->kind : Symbol(kind, Decl(intersectionReductionStrict.ts, 32, 10))
->foo : Symbol(foo, Decl(intersectionReductionStrict.ts, 32, 21))
+>kind : Symbol(A.kind, Decl(intersectionReductionStrict.ts, 32, 10))
+>foo : Symbol(A.foo, Decl(intersectionReductionStrict.ts, 32, 21))
 
 type B = { kind: 'b', foo: number };
 >B : Symbol(B, Decl(intersectionReductionStrict.ts, 32, 36))
->kind : Symbol(kind, Decl(intersectionReductionStrict.ts, 33, 10))
->foo : Symbol(foo, Decl(intersectionReductionStrict.ts, 33, 21))
+>kind : Symbol(B.kind, Decl(intersectionReductionStrict.ts, 33, 10))
+>foo : Symbol(B.foo, Decl(intersectionReductionStrict.ts, 33, 21))
 
 type C = { kind: 'c', foo: number };
 >C : Symbol(C, Decl(intersectionReductionStrict.ts, 33, 36))
->kind : Symbol(kind, Decl(intersectionReductionStrict.ts, 34, 10))
->foo : Symbol(foo, Decl(intersectionReductionStrict.ts, 34, 21))
+>kind : Symbol(C.kind, Decl(intersectionReductionStrict.ts, 34, 10))
+>foo : Symbol(C.foo, Decl(intersectionReductionStrict.ts, 34, 21))
 
 declare let ab: A & B;
 >ab : Symbol(ab, Decl(intersectionReductionStrict.ts, 36, 11))
@@ -303,7 +303,7 @@ type Container<Type extends string> = {
 >Type : Symbol(Type, Decl(intersectionReductionStrict.ts, 90, 15))
 
     type: Type;
->type : Symbol(type, Decl(intersectionReductionStrict.ts, 90, 39))
+>type : Symbol(Container.type, Decl(intersectionReductionStrict.ts, 90, 39))
 >Type : Symbol(Type, Decl(intersectionReductionStrict.ts, 90, 15))
 }
 
diff --git a/tests/baselines/reference/intersectionTypeNormalization.symbols b/tests/baselines/reference/intersectionTypeNormalization.symbols
index fd81eac6d185e..fc66b3f1302de 100644
--- a/tests/baselines/reference/intersectionTypeNormalization.symbols
+++ b/tests/baselines/reference/intersectionTypeNormalization.symbols
@@ -192,7 +192,7 @@ type ToString = {
 >ToString : Symbol(ToString, Decl(intersectionTypeNormalization.ts, 38, 10))
 
     toString(): string;
->toString : Symbol(toString, Decl(intersectionTypeNormalization.ts, 42, 17))
+>toString : Symbol(ToString.toString, Decl(intersectionTypeNormalization.ts, 42, 17))
 }
 
 type BoxedValue = { kind: 'int',    num: number }
@@ -311,7 +311,7 @@ type Foo = {
 >Foo : Symbol(Foo, Decl(intersectionTypeNormalization.ts, 88, 1))
 
     genreId: enums.Genre;
->genreId : Symbol(genreId, Decl(intersectionTypeNormalization.ts, 90, 12))
+>genreId : Symbol(Foo.genreId, Decl(intersectionTypeNormalization.ts, 90, 12))
 >enums : Symbol(enums, Decl(intersectionTypeNormalization.ts, 59, 1))
 >Genre : Symbol(enums.Genre, Decl(intersectionTypeNormalization.ts, 86, 5))
 
@@ -321,7 +321,7 @@ type Bar = {
 >Bar : Symbol(Bar, Decl(intersectionTypeNormalization.ts, 92, 2))
 
     genreId: enums.Genre;
->genreId : Symbol(genreId, Decl(intersectionTypeNormalization.ts, 94, 12))
+>genreId : Symbol(Bar.genreId, Decl(intersectionTypeNormalization.ts, 94, 12))
 >enums : Symbol(enums, Decl(intersectionTypeNormalization.ts, 59, 1))
 >Genre : Symbol(enums.Genre, Decl(intersectionTypeNormalization.ts, 86, 5))
 
diff --git a/tests/baselines/reference/intersectionWithConflictingPrivates.types b/tests/baselines/reference/intersectionWithConflictingPrivates.types
index 62861bb4ec597..d7f8e4a9dedaa 100644
--- a/tests/baselines/reference/intersectionWithConflictingPrivates.types
+++ b/tests/baselines/reference/intersectionWithConflictingPrivates.types
@@ -138,7 +138,7 @@ class Foo {
 	}
 
   private async bar(node: CommitFileNode | ResultsFileNode | StashFileNode | StatusFileNode, options?: {}) {
->bar : (node: CommitFileNode | ResultsFileNode | StashFileNode | StatusFileNode, options?: {} | undefined) => Promise<undefined>
+>bar : (node: CommitFileNode | ResultsFileNode | StashFileNode | StatusFileNode, options?: {}) => Promise<undefined>
 >node : CommitFileNode | ResultsFileNode | StashFileNode | StatusFileNode
 >options : {} | undefined
 
diff --git a/tests/baselines/reference/intersectionWithIndexSignatures.symbols b/tests/baselines/reference/intersectionWithIndexSignatures.symbols
index 7a247833af68b..7191421c21510 100644
--- a/tests/baselines/reference/intersectionWithIndexSignatures.symbols
+++ b/tests/baselines/reference/intersectionWithIndexSignatures.symbols
@@ -1,11 +1,11 @@
 === tests/cases/conformance/types/intersection/intersectionWithIndexSignatures.ts ===
 type A = { a: string };
 >A : Symbol(A, Decl(intersectionWithIndexSignatures.ts, 0, 0))
->a : Symbol(a, Decl(intersectionWithIndexSignatures.ts, 0, 10))
+>a : Symbol(A.a, Decl(intersectionWithIndexSignatures.ts, 0, 10))
 
 type B = { b: string };
 >B : Symbol(B, Decl(intersectionWithIndexSignatures.ts, 0, 23))
->b : Symbol(b, Decl(intersectionWithIndexSignatures.ts, 1, 10))
+>b : Symbol(B.b, Decl(intersectionWithIndexSignatures.ts, 1, 10))
 
 declare let sa1: { x: A & B };
 >sa1 : Symbol(sa1, Decl(intersectionWithIndexSignatures.ts, 3, 11))
diff --git a/tests/baselines/reference/intersectionsAndEmptyObjects.symbols b/tests/baselines/reference/intersectionsAndEmptyObjects.symbols
index 7cb08ebfb2523..c952866025eaa 100644
--- a/tests/baselines/reference/intersectionsAndEmptyObjects.symbols
+++ b/tests/baselines/reference/intersectionsAndEmptyObjects.symbols
@@ -4,11 +4,11 @@
 
 type A = { a: number };
 >A : Symbol(A, Decl(intersectionsAndEmptyObjects.ts, 0, 0))
->a : Symbol(a, Decl(intersectionsAndEmptyObjects.ts, 3, 10))
+>a : Symbol(A.a, Decl(intersectionsAndEmptyObjects.ts, 3, 10))
 
 type B = { b: string };
 >B : Symbol(B, Decl(intersectionsAndEmptyObjects.ts, 3, 23))
->b : Symbol(b, Decl(intersectionsAndEmptyObjects.ts, 4, 10))
+>b : Symbol(B.b, Decl(intersectionsAndEmptyObjects.ts, 4, 10))
 
 type C = {};
 >C : Symbol(C, Decl(intersectionsAndEmptyObjects.ts, 4, 23))
@@ -211,7 +211,7 @@ type IMyChoiceList = {
 >IMyChoiceList : Symbol(IMyChoiceList, Decl(intersectionsAndEmptyObjects.ts, 60, 2))
 
     car: true
->car : Symbol(car, Decl(intersectionsAndEmptyObjects.ts, 62, 22))
+>car : Symbol(IMyChoiceList.car, Decl(intersectionsAndEmptyObjects.ts, 62, 22))
 
 };
 
diff --git a/tests/baselines/reference/isomorphicMappedTypeInference.symbols b/tests/baselines/reference/isomorphicMappedTypeInference.symbols
index 45d97005e3761..87f96f9366ec5 100644
--- a/tests/baselines/reference/isomorphicMappedTypeInference.symbols
+++ b/tests/baselines/reference/isomorphicMappedTypeInference.symbols
@@ -4,7 +4,7 @@ type Box<T> = {
 >T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 0, 9))
 
     value: T;
->value : Symbol(value, Decl(isomorphicMappedTypeInference.ts, 0, 15))
+>value : Symbol(Box.value, Decl(isomorphicMappedTypeInference.ts, 0, 15))
 >T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 0, 9))
 }
 
@@ -42,9 +42,9 @@ function unbox<T>(x: Box<T>): T {
 >T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 12, 15))
 
     return x.value;
->x.value : Symbol(value, Decl(isomorphicMappedTypeInference.ts, 0, 15))
+>x.value : Symbol(Box.value, Decl(isomorphicMappedTypeInference.ts, 0, 15))
 >x : Symbol(x, Decl(isomorphicMappedTypeInference.ts, 12, 18))
->value : Symbol(value, Decl(isomorphicMappedTypeInference.ts, 0, 15))
+>value : Symbol(Box.value, Decl(isomorphicMappedTypeInference.ts, 0, 15))
 }
 
 function boxify<T>(obj: T): Boxified<T> {
@@ -116,10 +116,10 @@ function assignBoxified<T>(obj: Boxified<T>, values: T) {
 >values : Symbol(values, Decl(isomorphicMappedTypeInference.ts, 32, 44))
 
         obj[k].value = values[k];
->obj[k].value : Symbol(value, Decl(isomorphicMappedTypeInference.ts, 0, 15))
+>obj[k].value : Symbol(Box.value, Decl(isomorphicMappedTypeInference.ts, 0, 15))
 >obj : Symbol(obj, Decl(isomorphicMappedTypeInference.ts, 32, 27))
 >k : Symbol(k, Decl(isomorphicMappedTypeInference.ts, 33, 12))
->value : Symbol(value, Decl(isomorphicMappedTypeInference.ts, 0, 15))
+>value : Symbol(Box.value, Decl(isomorphicMappedTypeInference.ts, 0, 15))
 >values : Symbol(values, Decl(isomorphicMappedTypeInference.ts, 32, 44))
 >k : Symbol(k, Decl(isomorphicMappedTypeInference.ts, 33, 12))
     }
@@ -148,11 +148,11 @@ function f1() {
 
     let x: number = b.a.value;
 >x : Symbol(x, Decl(isomorphicMappedTypeInference.ts, 45, 7))
->b.a.value : Symbol(value, Decl(isomorphicMappedTypeInference.ts, 0, 15))
+>b.a.value : Symbol(Box.value, Decl(isomorphicMappedTypeInference.ts, 0, 15))
 >b.a : Symbol(a, Decl(isomorphicMappedTypeInference.ts, 39, 13))
 >b : Symbol(b, Decl(isomorphicMappedTypeInference.ts, 44, 7))
 >a : Symbol(a, Decl(isomorphicMappedTypeInference.ts, 39, 13))
->value : Symbol(value, Decl(isomorphicMappedTypeInference.ts, 0, 15))
+>value : Symbol(Box.value, Decl(isomorphicMappedTypeInference.ts, 0, 15))
 }
 
 function f2() {
@@ -366,10 +366,10 @@ type Foo = {
 >Foo : Symbol(Foo, Decl(isomorphicMappedTypeInference.ts, 107, 81))
 
     a?: number;
->a : Symbol(a, Decl(isomorphicMappedTypeInference.ts, 109, 12))
+>a : Symbol(Foo.a, Decl(isomorphicMappedTypeInference.ts, 109, 12))
 
     readonly b: string;
->b : Symbol(b, Decl(isomorphicMappedTypeInference.ts, 110, 15))
+>b : Symbol(Foo.b, Decl(isomorphicMappedTypeInference.ts, 110, 15))
 }
 
 function f10(foo: Foo) {
diff --git a/tests/baselines/reference/jsDeclarationsReactComponents.js b/tests/baselines/reference/jsDeclarationsReactComponents.js
index 9c0373e83e739..d95bb73f22f7c 100644
--- a/tests/baselines/reference/jsDeclarationsReactComponents.js
+++ b/tests/baselines/reference/jsDeclarationsReactComponents.js
@@ -190,13 +190,13 @@ export default TabbedShowLayout;
 declare function TabbedShowLayout({}: {}): JSX.Element;
 declare namespace TabbedShowLayout {
     namespace propTypes {
-        const version: PropTypes.Requireable<number>;
+        const version: React.Requireable<number>;
     }
     namespace defaultProps {
         const tabs: undefined;
     }
 }
-import PropTypes from "prop-types";
+import React from "react";
 //// [jsDeclarationsReactComponents2.d.ts]
 /// <reference path="../..react16.d.ts" />
 export default TabbedShowLayout;
@@ -216,7 +216,7 @@ declare const TabbedShowLayout: {
     };
 } & ((props?: {
     elem: string;
-} | undefined) => JSX.Element);
+}) => JSX.Element);
 //// [jsDeclarationsReactComponents4.d.ts]
 export default TabbedShowLayout;
 declare function TabbedShowLayout(prop: {
@@ -235,7 +235,7 @@ declare function Tree({ allowDropOnRoot }: {
 }): JSX.Element;
 declare namespace Tree {
     namespace propTypes {
-        const classes: PropTypes.Requireable<object>;
+        const classes: React.Requireable<object>;
     }
     namespace defaultProps {
         const classes_1: {};
@@ -243,4 +243,4 @@ declare namespace Tree {
         export const parentSource: string;
     }
 }
-import PropTypes from "prop-types";
+import React from "react";
diff --git a/tests/baselines/reference/jsDeclarationsReactComponents.types b/tests/baselines/reference/jsDeclarationsReactComponents.types
index 4934a173b935b..abdd9e4e3d30d 100644
--- a/tests/baselines/reference/jsDeclarationsReactComponents.types
+++ b/tests/baselines/reference/jsDeclarationsReactComponents.types
@@ -7,8 +7,8 @@ import PropTypes from "prop-types"
 >PropTypes : typeof PropTypes
 
 const TabbedShowLayout = ({
->TabbedShowLayout : { ({}: {}): JSX.Element; propTypes: { version: PropTypes.Requireable<number>; }; defaultProps: { tabs: undefined; }; }
->({}) => {    return (        <div />    );} : { ({}: {}): JSX.Element; propTypes: { version: PropTypes.Requireable<number>; }; defaultProps: { tabs: undefined; }; }
+>TabbedShowLayout : { ({}: {}): JSX.Element; propTypes: { version: React.Requireable<number>; }; defaultProps: { tabs: undefined; }; }
+>({}) => {    return (        <div />    );} : { ({}: {}): JSX.Element; propTypes: { version: React.Requireable<number>; }; defaultProps: { tabs: undefined; }; }
 
 }) => {
     return (
@@ -22,24 +22,24 @@ const TabbedShowLayout = ({
 };
 
 TabbedShowLayout.propTypes = {
->TabbedShowLayout.propTypes = {    version: PropTypes.number,} : { version: PropTypes.Requireable<number>; }
->TabbedShowLayout.propTypes : { version: PropTypes.Requireable<number>; }
->TabbedShowLayout : { ({}: {}): JSX.Element; propTypes: { version: PropTypes.Requireable<number>; }; defaultProps: { tabs: undefined; }; }
->propTypes : { version: PropTypes.Requireable<number>; }
->{    version: PropTypes.number,} : { version: PropTypes.Requireable<number>; }
+>TabbedShowLayout.propTypes = {    version: PropTypes.number,} : { version: React.Requireable<number>; }
+>TabbedShowLayout.propTypes : { version: React.Requireable<number>; }
+>TabbedShowLayout : { ({}: {}): JSX.Element; propTypes: { version: React.Requireable<number>; }; defaultProps: { tabs: undefined; }; }
+>propTypes : { version: React.Requireable<number>; }
+>{    version: PropTypes.number,} : { version: React.Requireable<number>; }
 
     version: PropTypes.number,
->version : PropTypes.Requireable<number>
->PropTypes.number : PropTypes.Requireable<number>
+>version : React.Requireable<number>
+>PropTypes.number : React.Requireable<number>
 >PropTypes : typeof PropTypes
->number : PropTypes.Requireable<number>
+>number : React.Requireable<number>
 
 };
 
 TabbedShowLayout.defaultProps = {
 >TabbedShowLayout.defaultProps = {    tabs: undefined} : { tabs: undefined; }
 >TabbedShowLayout.defaultProps : { tabs: undefined; }
->TabbedShowLayout : { ({}: {}): JSX.Element; propTypes: { version: PropTypes.Requireable<number>; }; defaultProps: { tabs: undefined; }; }
+>TabbedShowLayout : { ({}: {}): JSX.Element; propTypes: { version: React.Requireable<number>; }; defaultProps: { tabs: undefined; }; }
 >defaultProps : { tabs: undefined; }
 >{    tabs: undefined} : { tabs: undefined; }
 
@@ -50,7 +50,7 @@ TabbedShowLayout.defaultProps = {
 };
 
 export default TabbedShowLayout;
->TabbedShowLayout : { ({}: {}): JSX.Element; propTypes: { version: PropTypes.Requireable<number>; }; defaultProps: { tabs: undefined; }; }
+>TabbedShowLayout : { ({}: {}): JSX.Element; propTypes: { version: React.Requireable<number>; }; defaultProps: { tabs: undefined; }; }
 
 === tests/cases/conformance/jsdoc/declarations/jsDeclarationsReactComponents2.jsx ===
 import React from "react";
@@ -199,17 +199,17 @@ function Tree({ allowDropOnRoot }) {
 }
 
 Tree.propTypes = {
->Tree.propTypes = {    classes: PropTypes.object,} : { classes: PropTypes.Requireable<object>; }
->Tree.propTypes : { classes: PropTypes.Requireable<object>; }
+>Tree.propTypes = {    classes: PropTypes.object,} : { classes: React.Requireable<object>; }
+>Tree.propTypes : { classes: React.Requireable<object>; }
 >Tree : typeof Tree
->propTypes : { classes: PropTypes.Requireable<object>; }
->{    classes: PropTypes.object,} : { classes: PropTypes.Requireable<object>; }
+>propTypes : { classes: React.Requireable<object>; }
+>{    classes: PropTypes.object,} : { classes: React.Requireable<object>; }
 
     classes: PropTypes.object,
->classes : PropTypes.Requireable<object>
->PropTypes.object : PropTypes.Requireable<object>
+>classes : React.Requireable<object>
+>PropTypes.object : React.Requireable<object>
 >PropTypes : typeof PropTypes
->object : PropTypes.Requireable<object>
+>object : React.Requireable<object>
 
 };
 
diff --git a/tests/baselines/reference/jsDeclarationsTypedefAndImportTypes.types b/tests/baselines/reference/jsDeclarationsTypedefAndImportTypes.types
index 39c4eec9d19f8..c2781062c3c76 100644
--- a/tests/baselines/reference/jsDeclarationsTypedefAndImportTypes.types
+++ b/tests/baselines/reference/jsDeclarationsTypedefAndImportTypes.types
@@ -34,7 +34,7 @@ class Wrap {
      * @param {Conn} c
      */
     constructor(c) {
->c : import("tests/cases/conformance/jsdoc/declarations/conn")
+>c : Conn
 
         this.connItem = c.item;
 >this.connItem = c.item : number
@@ -42,7 +42,7 @@ class Wrap {
 >this : this
 >connItem : any
 >c.item : number
->c : import("tests/cases/conformance/jsdoc/declarations/conn")
+>c : Conn
 >item : number
 
         /** @type {import("./conn").Whatever} */
diff --git a/tests/baselines/reference/jsdocImportTypeReferenceToClassAlias.symbols b/tests/baselines/reference/jsdocImportTypeReferenceToClassAlias.symbols
index 443724ba82558..3416f189d9658 100644
--- a/tests/baselines/reference/jsdocImportTypeReferenceToClassAlias.symbols
+++ b/tests/baselines/reference/jsdocImportTypeReferenceToClassAlias.symbols
@@ -21,8 +21,8 @@ function demo(c) {
 >c : Symbol(c, Decl(test.js, 2, 14))
 
     c.s
->c.s : Symbol(C.s, Decl(mod1.js, 0, 9))
+>c.s : Symbol(X.s, Decl(mod1.js, 0, 9))
 >c : Symbol(c, Decl(test.js, 2, 14))
->s : Symbol(C.s, Decl(mod1.js, 0, 9))
+>s : Symbol(X.s, Decl(mod1.js, 0, 9))
 }
 
diff --git a/tests/baselines/reference/jsdocImportTypeReferenceToClassAlias.types b/tests/baselines/reference/jsdocImportTypeReferenceToClassAlias.types
index d848122724d07..382b8b2febd42 100644
--- a/tests/baselines/reference/jsdocImportTypeReferenceToClassAlias.types
+++ b/tests/baselines/reference/jsdocImportTypeReferenceToClassAlias.types
@@ -19,11 +19,11 @@ module.exports.C = C
 /** @param {X} c */
 function demo(c) {
 >demo : (c: X) => void
->c : import("tests/cases/conformance/jsdoc/mod1").C
+>c : X
 
     c.s
 >c.s : () => void
->c : import("tests/cases/conformance/jsdoc/mod1").C
+>c : X
 >s : () => void
 }
 
diff --git a/tests/baselines/reference/jsdocTypeReferenceToImportOfClassExpression.symbols b/tests/baselines/reference/jsdocTypeReferenceToImportOfClassExpression.symbols
index 26d216ce83ad1..1a15d6c62945e 100644
--- a/tests/baselines/reference/jsdocTypeReferenceToImportOfClassExpression.symbols
+++ b/tests/baselines/reference/jsdocTypeReferenceToImportOfClassExpression.symbols
@@ -10,14 +10,14 @@ module.exports = class MC {
 >module.exports : Symbol(module.exports, Decl(MC.js, 0, 0))
 >module : Symbol(export=, Decl(MC.js, 0, 27))
 >exports : Symbol(export=, Decl(MC.js, 0, 27))
->MC : Symbol(MC, Decl(MC.js, 4, 16))
+>MC : Symbol(MW.MC, Decl(MC.js, 4, 16))
 
   watch() {
->watch : Symbol(MC.watch, Decl(MC.js, 4, 27))
+>watch : Symbol(MW.MC.watch, Decl(MC.js, 4, 27))
 
     return new MW(this);
 >MW : Symbol(MW, Decl(MC.js, 0, 5))
->this : Symbol(MC, Decl(MC.js, 4, 16))
+>this : Symbol(MW.MC, Decl(MC.js, 4, 16))
   }
 };
 
diff --git a/tests/baselines/reference/jsdocTypeReferenceToImportOfClassExpression.types b/tests/baselines/reference/jsdocTypeReferenceToImportOfClassExpression.types
index b42dcf9bc5886..e3bf57976c2e3 100644
--- a/tests/baselines/reference/jsdocTypeReferenceToImportOfClassExpression.types
+++ b/tests/baselines/reference/jsdocTypeReferenceToImportOfClassExpression.types
@@ -35,14 +35,14 @@ class MW {
    * @param {MC} compiler the compiler
    */
   constructor(compiler) {
->compiler : import("tests/cases/conformance/jsdoc/MC")
+>compiler : MC
 
     this.compiler = compiler;
->this.compiler = compiler : import("tests/cases/conformance/jsdoc/MC")
+>this.compiler = compiler : MC
 >this.compiler : any
 >this : this
 >compiler : any
->compiler : import("tests/cases/conformance/jsdoc/MC")
+>compiler : MC
   }
 }
 
diff --git a/tests/baselines/reference/jsxComplexSignatureHasApplicabilityError.symbols b/tests/baselines/reference/jsxComplexSignatureHasApplicabilityError.symbols
index 5898f14113507..53ac2a2b5e0dd 100644
--- a/tests/baselines/reference/jsxComplexSignatureHasApplicabilityError.symbols
+++ b/tests/baselines/reference/jsxComplexSignatureHasApplicabilityError.symbols
@@ -446,7 +446,7 @@ export type Options<TValue = OptionValues> = Array<Option<TValue>>;
 >Options : Symbol(Options, Decl(jsxComplexSignatureHasApplicabilityError.tsx, 100, 1))
 >TValue : Symbol(TValue, Decl(jsxComplexSignatureHasApplicabilityError.tsx, 102, 20))
 >OptionValues : Symbol(OptionValues, Decl(jsxComplexSignatureHasApplicabilityError.tsx, 124, 1))
->Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>Array : Symbol(Options, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >Option : Symbol(Option, Decl(jsxComplexSignatureHasApplicabilityError.tsx, 102, 67))
 >TValue : Symbol(TValue, Decl(jsxComplexSignatureHasApplicabilityError.tsx, 102, 20))
 
@@ -711,7 +711,7 @@ export interface ValueComponentProps<TValue = OptionValues> {
 
     values?: Array<Option<TValue>>;
 >values : Symbol(ValueComponentProps.values, Decl(jsxComplexSignatureHasApplicabilityError.tsx, 251, 26))
->Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>Array : Symbol(Options, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >Option : Symbol(Option, Decl(jsxComplexSignatureHasApplicabilityError.tsx, 102, 67))
 >TValue : Symbol(TValue, Decl(jsxComplexSignatureHasApplicabilityError.tsx, 244, 37))
 }
diff --git a/tests/baselines/reference/jsxFragmentFactoryNoUnusedLocals.symbols b/tests/baselines/reference/jsxFragmentFactoryNoUnusedLocals.symbols
index ad5eefe8a8a02..5af00d13f412b 100644
--- a/tests/baselines/reference/jsxFragmentFactoryNoUnusedLocals.symbols
+++ b/tests/baselines/reference/jsxFragmentFactoryNoUnusedLocals.symbols
@@ -8,7 +8,7 @@ type CounterProps = {
 >CounterProps : Symbol(CounterProps, Decl(jsxFragmentFactoryNoUnusedLocals.tsx, 1, 47))
 
     count?: number
->count : Symbol(count, Decl(jsxFragmentFactoryNoUnusedLocals.tsx, 3, 21))
+>count : Symbol(CounterProps.count, Decl(jsxFragmentFactoryNoUnusedLocals.tsx, 3, 21))
 }
 
 export function Counter({ count = 0 }: CounterProps) {
diff --git a/tests/baselines/reference/jsxLibraryManagedAttributesUnusedGeneric.symbols b/tests/baselines/reference/jsxLibraryManagedAttributesUnusedGeneric.symbols
index 648be8bafaef1..174236d7858af 100644
--- a/tests/baselines/reference/jsxLibraryManagedAttributesUnusedGeneric.symbols
+++ b/tests/baselines/reference/jsxLibraryManagedAttributesUnusedGeneric.symbols
@@ -36,7 +36,7 @@ namespace jsx {
 >IntrinsicElements : Symbol(IntrinsicElements, Decl(jsxLibraryManagedAttributesUnusedGeneric.tsx, 11, 55))
 
             div: { className: string }
->div : Symbol(div, Decl(jsxLibraryManagedAttributesUnusedGeneric.tsx, 12, 41))
+>div : Symbol(IntrinsicElements.div, Decl(jsxLibraryManagedAttributesUnusedGeneric.tsx, 12, 41))
 >className : Symbol(className, Decl(jsxLibraryManagedAttributesUnusedGeneric.tsx, 13, 18))
         }
         // Works
diff --git a/tests/baselines/reference/jsxNamespaceGlobalReexport.types b/tests/baselines/reference/jsxNamespaceGlobalReexport.types
index 85fc07e3497e3..5727b784ec9ac 100644
--- a/tests/baselines/reference/jsxNamespaceGlobalReexport.types
+++ b/tests/baselines/reference/jsxNamespaceGlobalReexport.types
@@ -90,7 +90,7 @@ import { JSXInternal } from '..';
 >JSXInternal : any
 
 export function jsx(
->jsx : { (type: string, props: JSXInternal.HTMLAttributes & JSXInternal.SVGAttributes & Record<string, any> & {    children?: ComponentChild;}, key?: string | undefined): VNode<any>; <P>(type: ComponentType<P>, props: P & { children?: ComponentChild | undefined; }, key?: string | undefined): VNode<any>; }
+>jsx : { (type: string, props: JSXInternal.HTMLAttributes & JSXInternal.SVGAttributes & Record<string, any> & {    children?: ComponentChild;}, key?: string): VNode<any>; <P>(type: ComponentType<P>, props: P & { children?: ComponentChild | undefined; }, key?: string | undefined): VNode<any>; }
 
     type: string,
 >type : string
@@ -110,7 +110,7 @@ export function jsx(
 
 ): VNode<any>;
 export function jsx<P>(
->jsx : { (type: string, props: JSXInternal.HTMLAttributes<{}> & JSXInternal.SVGAttributes<{}> & Record<string, any> & { children?: ComponentChild | undefined; }, key?: string | undefined): VNode<any>; <P>(type: ComponentType<P>, props: Attributes & P & {    children?: ComponentChild;}, key?: string | undefined): VNode<any>; }
+>jsx : { (type: string, props: JSXInternal.HTMLAttributes<{}> & JSXInternal.SVGAttributes<{}> & Record<string, any> & { children?: ComponentChild | undefined; }, key?: string | undefined): VNode<any>; <P>(type: ComponentType<P>, props: Attributes & P & {    children?: ComponentChild;}, key?: string): VNode<any>; }
 
     type: ComponentType<P>,
 >type : ComponentType<P>
@@ -125,7 +125,7 @@ export function jsx<P>(
 ): VNode<any>;
 
 export function jsxs(
->jsxs : { (type: string, props: JSXInternal.HTMLAttributes & JSXInternal.SVGAttributes & Record<string, any> & {    children?: ComponentChild[];}, key?: string | undefined): VNode<any>; <P>(type: ComponentType<P>, props: P & { children?: ComponentChild[] | undefined; }, key?: string | undefined): VNode<any>; }
+>jsxs : { (type: string, props: JSXInternal.HTMLAttributes & JSXInternal.SVGAttributes & Record<string, any> & {    children?: ComponentChild[];}, key?: string): VNode<any>; <P>(type: ComponentType<P>, props: P & { children?: ComponentChild[] | undefined; }, key?: string | undefined): VNode<any>; }
 
     type: string,
 >type : string
@@ -145,7 +145,7 @@ export function jsxs(
 
 ): VNode<any>;
 export function jsxs<P>(
->jsxs : { (type: string, props: JSXInternal.HTMLAttributes<{}> & JSXInternal.SVGAttributes<{}> & Record<string, any> & { children?: ComponentChild[] | undefined; }, key?: string | undefined): VNode<any>; <P>(type: ComponentType<P>, props: Attributes & P & {    children?: ComponentChild[];}, key?: string | undefined): VNode<any>; }
+>jsxs : { (type: string, props: JSXInternal.HTMLAttributes<{}> & JSXInternal.SVGAttributes<{}> & Record<string, any> & { children?: ComponentChild[] | undefined; }, key?: string | undefined): VNode<any>; <P>(type: ComponentType<P>, props: Attributes & P & {    children?: ComponentChild[];}, key?: string): VNode<any>; }
 
     type: ComponentType<P>,
 >type : ComponentType<P>
@@ -160,7 +160,7 @@ export function jsxs<P>(
 ): VNode<any>;
 
 export function jsxDEV(
->jsxDEV : { (type: string, props: JSXInternal.HTMLAttributes & JSXInternal.SVGAttributes & Record<string, any> & {    children?: ComponentChildren;}, key?: string | undefined): VNode<any>; <P>(type: ComponentType<P>, props: P & { children?: ComponentChildren | undefined; }, key?: string | undefined): VNode<any>; }
+>jsxDEV : { (type: string, props: JSXInternal.HTMLAttributes & JSXInternal.SVGAttributes & Record<string, any> & {    children?: ComponentChildren;}, key?: string): VNode<any>; <P>(type: ComponentType<P>, props: P & { children?: ComponentChildren | undefined; }, key?: string | undefined): VNode<any>; }
 
     type: string,
 >type : string
@@ -180,7 +180,7 @@ export function jsxDEV(
 
 ): VNode<any>;
 export function jsxDEV<P>(
->jsxDEV : { (type: string, props: JSXInternal.HTMLAttributes<{}> & JSXInternal.SVGAttributes<{}> & Record<string, any> & { children?: ComponentChildren | undefined; }, key?: string | undefined): VNode<any>; <P>(type: ComponentType<P>, props: Attributes & P & {    children?: ComponentChildren;}, key?: string | undefined): VNode<any>; }
+>jsxDEV : { (type: string, props: JSXInternal.HTMLAttributes<{}> & JSXInternal.SVGAttributes<{}> & Record<string, any> & { children?: ComponentChildren | undefined; }, key?: string | undefined): VNode<any>; <P>(type: ComponentType<P>, props: Attributes & P & {    children?: ComponentChildren;}, key?: string): VNode<any>; }
 
     type: ComponentType<P>,
 >type : ComponentType<P>
diff --git a/tests/baselines/reference/jsxNamespaceGlobalReexportMissingAliasTarget.types b/tests/baselines/reference/jsxNamespaceGlobalReexportMissingAliasTarget.types
index 7cc6f7937322c..98a3cce7a83c6 100644
--- a/tests/baselines/reference/jsxNamespaceGlobalReexportMissingAliasTarget.types
+++ b/tests/baselines/reference/jsxNamespaceGlobalReexportMissingAliasTarget.types
@@ -90,7 +90,7 @@ import { JSXInternal } from '..';
 >JSXInternal : any
 
 export function jsx(
->jsx : { (type: string, props: JSXInternal.HTMLAttributes & JSXInternal.SVGAttributes & Record<string, any> & {    children?: ComponentChild;}, key?: string | undefined): VNode<any>; <P>(type: ComponentType<P>, props: P & { children?: ComponentChild | undefined; }, key?: string | undefined): VNode<any>; }
+>jsx : { (type: string, props: JSXInternal.HTMLAttributes & JSXInternal.SVGAttributes & Record<string, any> & {    children?: ComponentChild;}, key?: string): VNode<any>; <P>(type: ComponentType<P>, props: P & { children?: ComponentChild | undefined; }, key?: string | undefined): VNode<any>; }
 
     type: string,
 >type : string
@@ -110,7 +110,7 @@ export function jsx(
 
 ): VNode<any>;
 export function jsx<P>(
->jsx : { (type: string, props: JSXInternal.HTMLAttributes<{}> & JSXInternal.SVGAttributes<{}> & Record<string, any> & { children?: ComponentChild | undefined; }, key?: string | undefined): VNode<any>; <P>(type: ComponentType<P>, props: Attributes & P & {    children?: ComponentChild;}, key?: string | undefined): VNode<any>; }
+>jsx : { (type: string, props: JSXInternal.HTMLAttributes<{}> & JSXInternal.SVGAttributes<{}> & Record<string, any> & { children?: ComponentChild | undefined; }, key?: string | undefined): VNode<any>; <P>(type: ComponentType<P>, props: Attributes & P & {    children?: ComponentChild;}, key?: string): VNode<any>; }
 
     type: ComponentType<P>,
 >type : ComponentType<P>
@@ -125,7 +125,7 @@ export function jsx<P>(
 ): VNode<any>;
 
 export function jsxs(
->jsxs : { (type: string, props: JSXInternal.HTMLAttributes & JSXInternal.SVGAttributes & Record<string, any> & {    children?: ComponentChild[];}, key?: string | undefined): VNode<any>; <P>(type: ComponentType<P>, props: P & { children?: ComponentChild[] | undefined; }, key?: string | undefined): VNode<any>; }
+>jsxs : { (type: string, props: JSXInternal.HTMLAttributes & JSXInternal.SVGAttributes & Record<string, any> & {    children?: ComponentChild[];}, key?: string): VNode<any>; <P>(type: ComponentType<P>, props: P & { children?: ComponentChild[] | undefined; }, key?: string | undefined): VNode<any>; }
 
     type: string,
 >type : string
@@ -145,7 +145,7 @@ export function jsxs(
 
 ): VNode<any>;
 export function jsxs<P>(
->jsxs : { (type: string, props: JSXInternal.HTMLAttributes<{}> & JSXInternal.SVGAttributes<{}> & Record<string, any> & { children?: ComponentChild[] | undefined; }, key?: string | undefined): VNode<any>; <P>(type: ComponentType<P>, props: Attributes & P & {    children?: ComponentChild[];}, key?: string | undefined): VNode<any>; }
+>jsxs : { (type: string, props: JSXInternal.HTMLAttributes<{}> & JSXInternal.SVGAttributes<{}> & Record<string, any> & { children?: ComponentChild[] | undefined; }, key?: string | undefined): VNode<any>; <P>(type: ComponentType<P>, props: Attributes & P & {    children?: ComponentChild[];}, key?: string): VNode<any>; }
 
     type: ComponentType<P>,
 >type : ComponentType<P>
@@ -160,7 +160,7 @@ export function jsxs<P>(
 ): VNode<any>;
 
 export function jsxDEV(
->jsxDEV : { (type: string, props: JSXInternal.HTMLAttributes & JSXInternal.SVGAttributes & Record<string, any> & {    children?: ComponentChildren;}, key?: string | undefined): VNode<any>; <P>(type: ComponentType<P>, props: P & { children?: ComponentChildren | undefined; }, key?: string | undefined): VNode<any>; }
+>jsxDEV : { (type: string, props: JSXInternal.HTMLAttributes & JSXInternal.SVGAttributes & Record<string, any> & {    children?: ComponentChildren;}, key?: string): VNode<any>; <P>(type: ComponentType<P>, props: P & { children?: ComponentChildren | undefined; }, key?: string | undefined): VNode<any>; }
 
     type: string,
 >type : string
@@ -180,7 +180,7 @@ export function jsxDEV(
 
 ): VNode<any>;
 export function jsxDEV<P>(
->jsxDEV : { (type: string, props: JSXInternal.HTMLAttributes<{}> & JSXInternal.SVGAttributes<{}> & Record<string, any> & { children?: ComponentChildren | undefined; }, key?: string | undefined): VNode<any>; <P>(type: ComponentType<P>, props: Attributes & P & {    children?: ComponentChildren;}, key?: string | undefined): VNode<any>; }
+>jsxDEV : { (type: string, props: JSXInternal.HTMLAttributes<{}> & JSXInternal.SVGAttributes<{}> & Record<string, any> & { children?: ComponentChildren | undefined; }, key?: string | undefined): VNode<any>; <P>(type: ComponentType<P>, props: Attributes & P & {    children?: ComponentChildren;}, key?: string): VNode<any>; }
 
     type: ComponentType<P>,
 >type : ComponentType<P>
diff --git a/tests/baselines/reference/jsxNamespaceImplicitImportJSXNamespace.types b/tests/baselines/reference/jsxNamespaceImplicitImportJSXNamespace.types
index 8869f10731bb5..d67635e9ef92e 100644
--- a/tests/baselines/reference/jsxNamespaceImplicitImportJSXNamespace.types
+++ b/tests/baselines/reference/jsxNamespaceImplicitImportJSXNamespace.types
@@ -90,7 +90,7 @@ import { JSXInternal } from '..';
 >JSXInternal : any
 
 export function jsx(
->jsx : { (type: string, props: JSXInternal.HTMLAttributes & JSXInternal.SVGAttributes & Record<string, any> & {    children?: ComponentChild;}, key?: string | undefined): VNode<any>; <P>(type: ComponentType<P>, props: P & { children?: ComponentChild | undefined; }, key?: string | undefined): VNode<any>; }
+>jsx : { (type: string, props: JSXInternal.HTMLAttributes & JSXInternal.SVGAttributes & Record<string, any> & {    children?: ComponentChild;}, key?: string): VNode<any>; <P>(type: ComponentType<P>, props: P & { children?: ComponentChild | undefined; }, key?: string | undefined): VNode<any>; }
 
     type: string,
 >type : string
@@ -110,7 +110,7 @@ export function jsx(
 
 ): VNode<any>;
 export function jsx<P>(
->jsx : { (type: string, props: JSXInternal.HTMLAttributes<{}> & JSXInternal.SVGAttributes<{}> & Record<string, any> & { children?: ComponentChild | undefined; }, key?: string | undefined): VNode<any>; <P>(type: ComponentType<P>, props: Attributes & P & {    children?: ComponentChild;}, key?: string | undefined): VNode<any>; }
+>jsx : { (type: string, props: JSXInternal.HTMLAttributes<{}> & JSXInternal.SVGAttributes<{}> & Record<string, any> & { children?: ComponentChild | undefined; }, key?: string | undefined): VNode<any>; <P>(type: ComponentType<P>, props: Attributes & P & {    children?: ComponentChild;}, key?: string): VNode<any>; }
 
     type: ComponentType<P>,
 >type : ComponentType<P>
@@ -126,7 +126,7 @@ export function jsx<P>(
 
 
 export function jsxs(
->jsxs : { (type: string, props: JSXInternal.HTMLAttributes & JSXInternal.SVGAttributes & Record<string, any> & {    children?: ComponentChild[];}, key?: string | undefined): VNode<any>; <P>(type: ComponentType<P>, props: P & { children?: ComponentChild[] | undefined; }, key?: string | undefined): VNode<any>; }
+>jsxs : { (type: string, props: JSXInternal.HTMLAttributes & JSXInternal.SVGAttributes & Record<string, any> & {    children?: ComponentChild[];}, key?: string): VNode<any>; <P>(type: ComponentType<P>, props: P & { children?: ComponentChild[] | undefined; }, key?: string | undefined): VNode<any>; }
 
     type: string,
 >type : string
@@ -146,7 +146,7 @@ export function jsxs(
 
 ): VNode<any>;
 export function jsxs<P>(
->jsxs : { (type: string, props: JSXInternal.HTMLAttributes<{}> & JSXInternal.SVGAttributes<{}> & Record<string, any> & { children?: ComponentChild[] | undefined; }, key?: string | undefined): VNode<any>; <P>(type: ComponentType<P>, props: Attributes & P & {    children?: ComponentChild[];}, key?: string | undefined): VNode<any>; }
+>jsxs : { (type: string, props: JSXInternal.HTMLAttributes<{}> & JSXInternal.SVGAttributes<{}> & Record<string, any> & { children?: ComponentChild[] | undefined; }, key?: string | undefined): VNode<any>; <P>(type: ComponentType<P>, props: Attributes & P & {    children?: ComponentChild[];}, key?: string): VNode<any>; }
 
     type: ComponentType<P>,
 >type : ComponentType<P>
@@ -162,7 +162,7 @@ export function jsxs<P>(
 
 
 export function jsxDEV(
->jsxDEV : { (type: string, props: JSXInternal.HTMLAttributes & JSXInternal.SVGAttributes & Record<string, any> & {    children?: ComponentChildren;}, key?: string | undefined): VNode<any>; <P>(type: ComponentType<P>, props: P & { children?: ComponentChildren | undefined; }, key?: string | undefined): VNode<any>; }
+>jsxDEV : { (type: string, props: JSXInternal.HTMLAttributes & JSXInternal.SVGAttributes & Record<string, any> & {    children?: ComponentChildren;}, key?: string): VNode<any>; <P>(type: ComponentType<P>, props: P & { children?: ComponentChildren | undefined; }, key?: string | undefined): VNode<any>; }
 
     type: string,
 >type : string
@@ -182,7 +182,7 @@ export function jsxDEV(
 
 ): VNode<any>;
 export function jsxDEV<P>(
->jsxDEV : { (type: string, props: JSXInternal.HTMLAttributes<{}> & JSXInternal.SVGAttributes<{}> & Record<string, any> & { children?: ComponentChildren | undefined; }, key?: string | undefined): VNode<any>; <P>(type: ComponentType<P>, props: Attributes & P & {    children?: ComponentChildren;}, key?: string | undefined): VNode<any>; }
+>jsxDEV : { (type: string, props: JSXInternal.HTMLAttributes<{}> & JSXInternal.SVGAttributes<{}> & Record<string, any> & { children?: ComponentChildren | undefined; }, key?: string | undefined): VNode<any>; <P>(type: ComponentType<P>, props: Attributes & P & {    children?: ComponentChildren;}, key?: string): VNode<any>; }
 
     type: ComponentType<P>,
 >type : ComponentType<P>
diff --git a/tests/baselines/reference/jsxNamespaceImplicitImportJSXNamespaceFromConfigPickedOverGlobalOne(jsx=preserve).symbols b/tests/baselines/reference/jsxNamespaceImplicitImportJSXNamespaceFromConfigPickedOverGlobalOne(jsx=preserve).symbols
index b7fff94cf86e6..9748cbec6072c 100644
--- a/tests/baselines/reference/jsxNamespaceImplicitImportJSXNamespaceFromConfigPickedOverGlobalOne(jsx=preserve).symbols
+++ b/tests/baselines/reference/jsxNamespaceImplicitImportJSXNamespaceFromConfigPickedOverGlobalOne(jsx=preserve).symbols
@@ -72,22 +72,22 @@ type WithConditionalCSSProp<P> = 'className' extends keyof P
 type ReactJSXElement = JSX.Element
 >ReactJSXElement : Symbol(ReactJSXElement, Decl(jsx-namespace.d.ts, 4, 5))
 >JSX : Symbol(JSX, Decl(index.d.ts, 5, 16))
->Element : Symbol(JSX.Element, Decl(index.d.ts, 6, 17))
+>Element : Symbol(ReactJSXElement, Decl(index.d.ts, 6, 17))
 
 type ReactJSXElementClass = JSX.ElementClass
 >ReactJSXElementClass : Symbol(ReactJSXElementClass, Decl(jsx-namespace.d.ts, 6, 34))
 >JSX : Symbol(JSX, Decl(index.d.ts, 5, 16))
->ElementClass : Symbol(JSX.ElementClass, Decl(index.d.ts, 7, 24))
+>ElementClass : Symbol(ReactJSXElementClass, Decl(index.d.ts, 7, 24))
 
 type ReactJSXElementAttributesProperty = JSX.ElementAttributesProperty
 >ReactJSXElementAttributesProperty : Symbol(ReactJSXElementAttributesProperty, Decl(jsx-namespace.d.ts, 7, 44))
 >JSX : Symbol(JSX, Decl(index.d.ts, 5, 16))
->ElementAttributesProperty : Symbol(JSX.ElementAttributesProperty, Decl(index.d.ts, 8, 29))
+>ElementAttributesProperty : Symbol(ReactJSXElementAttributesProperty, Decl(index.d.ts, 8, 29))
 
 type ReactJSXElementChildrenAttribute = JSX.ElementChildrenAttribute
 >ReactJSXElementChildrenAttribute : Symbol(ReactJSXElementChildrenAttribute, Decl(jsx-namespace.d.ts, 8, 70))
 >JSX : Symbol(JSX, Decl(index.d.ts, 5, 16))
->ElementChildrenAttribute : Symbol(JSX.ElementChildrenAttribute, Decl(index.d.ts, 9, 42))
+>ElementChildrenAttribute : Symbol(ReactJSXElementChildrenAttribute, Decl(index.d.ts, 9, 42))
 
 type ReactJSXLibraryManagedAttributes<C, P> = JSX.LibraryManagedAttributes<C, P>
 >ReactJSXLibraryManagedAttributes : Symbol(ReactJSXLibraryManagedAttributes, Decl(jsx-namespace.d.ts, 9, 68))
@@ -101,19 +101,19 @@ type ReactJSXLibraryManagedAttributes<C, P> = JSX.LibraryManagedAttributes<C, P>
 type ReactJSXIntrinsicAttributes = JSX.IntrinsicAttributes
 >ReactJSXIntrinsicAttributes : Symbol(ReactJSXIntrinsicAttributes, Decl(jsx-namespace.d.ts, 10, 80))
 >JSX : Symbol(JSX, Decl(index.d.ts, 5, 16))
->IntrinsicAttributes : Symbol(JSX.IntrinsicAttributes, Decl(index.d.ts, 11, 44))
+>IntrinsicAttributes : Symbol(ReactJSXIntrinsicAttributes, Decl(index.d.ts, 11, 44))
 
 type ReactJSXIntrinsicClassAttributes<T> = JSX.IntrinsicClassAttributes<T>
 >ReactJSXIntrinsicClassAttributes : Symbol(ReactJSXIntrinsicClassAttributes, Decl(jsx-namespace.d.ts, 11, 58))
 >T : Symbol(T, Decl(jsx-namespace.d.ts, 12, 38))
 >JSX : Symbol(JSX, Decl(index.d.ts, 5, 16))
->IntrinsicClassAttributes : Symbol(JSX.IntrinsicClassAttributes, Decl(index.d.ts, 12, 36))
+>IntrinsicClassAttributes : Symbol(ReactJSXIntrinsicClassAttributes, Decl(index.d.ts, 12, 36))
 >T : Symbol(T, Decl(jsx-namespace.d.ts, 12, 38))
 
 type ReactJSXIntrinsicElements = JSX.IntrinsicElements
 >ReactJSXIntrinsicElements : Symbol(ReactJSXIntrinsicElements, Decl(jsx-namespace.d.ts, 12, 74))
 >JSX : Symbol(JSX, Decl(index.d.ts, 5, 16))
->IntrinsicElements : Symbol(JSX.IntrinsicElements, Decl(index.d.ts, 13, 44))
+>IntrinsicElements : Symbol(ReactJSXIntrinsicElements, Decl(index.d.ts, 13, 44))
 
 export namespace EmotionJSX {
 >EmotionJSX : Symbol(EmotionJSX, Decl(jsx-namespace.d.ts, 13, 54))
diff --git a/tests/baselines/reference/jsxNamespaceImplicitImportJSXNamespaceFromConfigPickedOverGlobalOne(jsx=preserve).types b/tests/baselines/reference/jsxNamespaceImplicitImportJSXNamespaceFromConfigPickedOverGlobalOne(jsx=preserve).types
index 56cc97e6cea9a..8bb983f13ee3a 100644
--- a/tests/baselines/reference/jsxNamespaceImplicitImportJSXNamespaceFromConfigPickedOverGlobalOne(jsx=preserve).types
+++ b/tests/baselines/reference/jsxNamespaceImplicitImportJSXNamespaceFromConfigPickedOverGlobalOne(jsx=preserve).types
@@ -44,19 +44,19 @@ type WithConditionalCSSProp<P> = 'className' extends keyof P
   : P
 
 type ReactJSXElement = JSX.Element
->ReactJSXElement : JSX.Element
+>ReactJSXElement : ReactJSXElement
 >JSX : any
 
 type ReactJSXElementClass = JSX.ElementClass
->ReactJSXElementClass : JSX.ElementClass
+>ReactJSXElementClass : ReactJSXElementClass
 >JSX : any
 
 type ReactJSXElementAttributesProperty = JSX.ElementAttributesProperty
->ReactJSXElementAttributesProperty : JSX.ElementAttributesProperty
+>ReactJSXElementAttributesProperty : ReactJSXElementAttributesProperty
 >JSX : any
 
 type ReactJSXElementChildrenAttribute = JSX.ElementChildrenAttribute
->ReactJSXElementChildrenAttribute : JSX.ElementChildrenAttribute
+>ReactJSXElementChildrenAttribute : ReactJSXElementChildrenAttribute
 >JSX : any
 
 type ReactJSXLibraryManagedAttributes<C, P> = JSX.LibraryManagedAttributes<C, P>
@@ -64,7 +64,7 @@ type ReactJSXLibraryManagedAttributes<C, P> = JSX.LibraryManagedAttributes<C, P>
 >JSX : any
 
 type ReactJSXIntrinsicAttributes = JSX.IntrinsicAttributes
->ReactJSXIntrinsicAttributes : JSX.IntrinsicAttributes
+>ReactJSXIntrinsicAttributes : ReactJSXIntrinsicAttributes
 >JSX : any
 
 type ReactJSXIntrinsicClassAttributes<T> = JSX.IntrinsicClassAttributes<T>
@@ -72,7 +72,7 @@ type ReactJSXIntrinsicClassAttributes<T> = JSX.IntrinsicClassAttributes<T>
 >JSX : any
 
 type ReactJSXIntrinsicElements = JSX.IntrinsicElements
->ReactJSXIntrinsicElements : JSX.IntrinsicElements
+>ReactJSXIntrinsicElements : ReactJSXIntrinsicElements
 >JSX : any
 
 export namespace EmotionJSX {
diff --git a/tests/baselines/reference/jsxNamespaceImplicitImportJSXNamespaceFromConfigPickedOverGlobalOne(jsx=react-jsx).symbols b/tests/baselines/reference/jsxNamespaceImplicitImportJSXNamespaceFromConfigPickedOverGlobalOne(jsx=react-jsx).symbols
index b7fff94cf86e6..9748cbec6072c 100644
--- a/tests/baselines/reference/jsxNamespaceImplicitImportJSXNamespaceFromConfigPickedOverGlobalOne(jsx=react-jsx).symbols
+++ b/tests/baselines/reference/jsxNamespaceImplicitImportJSXNamespaceFromConfigPickedOverGlobalOne(jsx=react-jsx).symbols
@@ -72,22 +72,22 @@ type WithConditionalCSSProp<P> = 'className' extends keyof P
 type ReactJSXElement = JSX.Element
 >ReactJSXElement : Symbol(ReactJSXElement, Decl(jsx-namespace.d.ts, 4, 5))
 >JSX : Symbol(JSX, Decl(index.d.ts, 5, 16))
->Element : Symbol(JSX.Element, Decl(index.d.ts, 6, 17))
+>Element : Symbol(ReactJSXElement, Decl(index.d.ts, 6, 17))
 
 type ReactJSXElementClass = JSX.ElementClass
 >ReactJSXElementClass : Symbol(ReactJSXElementClass, Decl(jsx-namespace.d.ts, 6, 34))
 >JSX : Symbol(JSX, Decl(index.d.ts, 5, 16))
->ElementClass : Symbol(JSX.ElementClass, Decl(index.d.ts, 7, 24))
+>ElementClass : Symbol(ReactJSXElementClass, Decl(index.d.ts, 7, 24))
 
 type ReactJSXElementAttributesProperty = JSX.ElementAttributesProperty
 >ReactJSXElementAttributesProperty : Symbol(ReactJSXElementAttributesProperty, Decl(jsx-namespace.d.ts, 7, 44))
 >JSX : Symbol(JSX, Decl(index.d.ts, 5, 16))
->ElementAttributesProperty : Symbol(JSX.ElementAttributesProperty, Decl(index.d.ts, 8, 29))
+>ElementAttributesProperty : Symbol(ReactJSXElementAttributesProperty, Decl(index.d.ts, 8, 29))
 
 type ReactJSXElementChildrenAttribute = JSX.ElementChildrenAttribute
 >ReactJSXElementChildrenAttribute : Symbol(ReactJSXElementChildrenAttribute, Decl(jsx-namespace.d.ts, 8, 70))
 >JSX : Symbol(JSX, Decl(index.d.ts, 5, 16))
->ElementChildrenAttribute : Symbol(JSX.ElementChildrenAttribute, Decl(index.d.ts, 9, 42))
+>ElementChildrenAttribute : Symbol(ReactJSXElementChildrenAttribute, Decl(index.d.ts, 9, 42))
 
 type ReactJSXLibraryManagedAttributes<C, P> = JSX.LibraryManagedAttributes<C, P>
 >ReactJSXLibraryManagedAttributes : Symbol(ReactJSXLibraryManagedAttributes, Decl(jsx-namespace.d.ts, 9, 68))
@@ -101,19 +101,19 @@ type ReactJSXLibraryManagedAttributes<C, P> = JSX.LibraryManagedAttributes<C, P>
 type ReactJSXIntrinsicAttributes = JSX.IntrinsicAttributes
 >ReactJSXIntrinsicAttributes : Symbol(ReactJSXIntrinsicAttributes, Decl(jsx-namespace.d.ts, 10, 80))
 >JSX : Symbol(JSX, Decl(index.d.ts, 5, 16))
->IntrinsicAttributes : Symbol(JSX.IntrinsicAttributes, Decl(index.d.ts, 11, 44))
+>IntrinsicAttributes : Symbol(ReactJSXIntrinsicAttributes, Decl(index.d.ts, 11, 44))
 
 type ReactJSXIntrinsicClassAttributes<T> = JSX.IntrinsicClassAttributes<T>
 >ReactJSXIntrinsicClassAttributes : Symbol(ReactJSXIntrinsicClassAttributes, Decl(jsx-namespace.d.ts, 11, 58))
 >T : Symbol(T, Decl(jsx-namespace.d.ts, 12, 38))
 >JSX : Symbol(JSX, Decl(index.d.ts, 5, 16))
->IntrinsicClassAttributes : Symbol(JSX.IntrinsicClassAttributes, Decl(index.d.ts, 12, 36))
+>IntrinsicClassAttributes : Symbol(ReactJSXIntrinsicClassAttributes, Decl(index.d.ts, 12, 36))
 >T : Symbol(T, Decl(jsx-namespace.d.ts, 12, 38))
 
 type ReactJSXIntrinsicElements = JSX.IntrinsicElements
 >ReactJSXIntrinsicElements : Symbol(ReactJSXIntrinsicElements, Decl(jsx-namespace.d.ts, 12, 74))
 >JSX : Symbol(JSX, Decl(index.d.ts, 5, 16))
->IntrinsicElements : Symbol(JSX.IntrinsicElements, Decl(index.d.ts, 13, 44))
+>IntrinsicElements : Symbol(ReactJSXIntrinsicElements, Decl(index.d.ts, 13, 44))
 
 export namespace EmotionJSX {
 >EmotionJSX : Symbol(EmotionJSX, Decl(jsx-namespace.d.ts, 13, 54))
diff --git a/tests/baselines/reference/jsxNamespaceImplicitImportJSXNamespaceFromConfigPickedOverGlobalOne(jsx=react-jsx).types b/tests/baselines/reference/jsxNamespaceImplicitImportJSXNamespaceFromConfigPickedOverGlobalOne(jsx=react-jsx).types
index 56cc97e6cea9a..8bb983f13ee3a 100644
--- a/tests/baselines/reference/jsxNamespaceImplicitImportJSXNamespaceFromConfigPickedOverGlobalOne(jsx=react-jsx).types
+++ b/tests/baselines/reference/jsxNamespaceImplicitImportJSXNamespaceFromConfigPickedOverGlobalOne(jsx=react-jsx).types
@@ -44,19 +44,19 @@ type WithConditionalCSSProp<P> = 'className' extends keyof P
   : P
 
 type ReactJSXElement = JSX.Element
->ReactJSXElement : JSX.Element
+>ReactJSXElement : ReactJSXElement
 >JSX : any
 
 type ReactJSXElementClass = JSX.ElementClass
->ReactJSXElementClass : JSX.ElementClass
+>ReactJSXElementClass : ReactJSXElementClass
 >JSX : any
 
 type ReactJSXElementAttributesProperty = JSX.ElementAttributesProperty
->ReactJSXElementAttributesProperty : JSX.ElementAttributesProperty
+>ReactJSXElementAttributesProperty : ReactJSXElementAttributesProperty
 >JSX : any
 
 type ReactJSXElementChildrenAttribute = JSX.ElementChildrenAttribute
->ReactJSXElementChildrenAttribute : JSX.ElementChildrenAttribute
+>ReactJSXElementChildrenAttribute : ReactJSXElementChildrenAttribute
 >JSX : any
 
 type ReactJSXLibraryManagedAttributes<C, P> = JSX.LibraryManagedAttributes<C, P>
@@ -64,7 +64,7 @@ type ReactJSXLibraryManagedAttributes<C, P> = JSX.LibraryManagedAttributes<C, P>
 >JSX : any
 
 type ReactJSXIntrinsicAttributes = JSX.IntrinsicAttributes
->ReactJSXIntrinsicAttributes : JSX.IntrinsicAttributes
+>ReactJSXIntrinsicAttributes : ReactJSXIntrinsicAttributes
 >JSX : any
 
 type ReactJSXIntrinsicClassAttributes<T> = JSX.IntrinsicClassAttributes<T>
@@ -72,7 +72,7 @@ type ReactJSXIntrinsicClassAttributes<T> = JSX.IntrinsicClassAttributes<T>
 >JSX : any
 
 type ReactJSXIntrinsicElements = JSX.IntrinsicElements
->ReactJSXIntrinsicElements : JSX.IntrinsicElements
+>ReactJSXIntrinsicElements : ReactJSXIntrinsicElements
 >JSX : any
 
 export namespace EmotionJSX {
diff --git a/tests/baselines/reference/jsxNamespaceImplicitImportJSXNamespaceFromPragmaPickedOverGlobalOne.symbols b/tests/baselines/reference/jsxNamespaceImplicitImportJSXNamespaceFromPragmaPickedOverGlobalOne.symbols
index 95969edc9f3df..5ed2c9184293f 100644
--- a/tests/baselines/reference/jsxNamespaceImplicitImportJSXNamespaceFromPragmaPickedOverGlobalOne.symbols
+++ b/tests/baselines/reference/jsxNamespaceImplicitImportJSXNamespaceFromPragmaPickedOverGlobalOne.symbols
@@ -72,22 +72,22 @@ type WithConditionalCSSProp<P> = 'className' extends keyof P
 type ReactJSXElement = JSX.Element
 >ReactJSXElement : Symbol(ReactJSXElement, Decl(jsx-namespace.d.ts, 4, 7))
 >JSX : Symbol(JSX, Decl(index.d.ts, 5, 16))
->Element : Symbol(JSX.Element, Decl(index.d.ts, 6, 19))
+>Element : Symbol(ReactJSXElement, Decl(index.d.ts, 6, 19))
 
 type ReactJSXElementClass = JSX.ElementClass
 >ReactJSXElementClass : Symbol(ReactJSXElementClass, Decl(jsx-namespace.d.ts, 6, 34))
 >JSX : Symbol(JSX, Decl(index.d.ts, 5, 16))
->ElementClass : Symbol(JSX.ElementClass, Decl(index.d.ts, 7, 29))
+>ElementClass : Symbol(ReactJSXElementClass, Decl(index.d.ts, 7, 29))
 
 type ReactJSXElementAttributesProperty = JSX.ElementAttributesProperty
 >ReactJSXElementAttributesProperty : Symbol(ReactJSXElementAttributesProperty, Decl(jsx-namespace.d.ts, 7, 44))
 >JSX : Symbol(JSX, Decl(index.d.ts, 5, 16))
->ElementAttributesProperty : Symbol(JSX.ElementAttributesProperty, Decl(index.d.ts, 8, 34))
+>ElementAttributesProperty : Symbol(ReactJSXElementAttributesProperty, Decl(index.d.ts, 8, 34))
 
 type ReactJSXElementChildrenAttribute = JSX.ElementChildrenAttribute
 >ReactJSXElementChildrenAttribute : Symbol(ReactJSXElementChildrenAttribute, Decl(jsx-namespace.d.ts, 8, 70))
 >JSX : Symbol(JSX, Decl(index.d.ts, 5, 16))
->ElementChildrenAttribute : Symbol(JSX.ElementChildrenAttribute, Decl(index.d.ts, 9, 47))
+>ElementChildrenAttribute : Symbol(ReactJSXElementChildrenAttribute, Decl(index.d.ts, 9, 47))
 
 type ReactJSXLibraryManagedAttributes<C, P> = JSX.LibraryManagedAttributes<C, P>
 >ReactJSXLibraryManagedAttributes : Symbol(ReactJSXLibraryManagedAttributes, Decl(jsx-namespace.d.ts, 9, 68))
@@ -101,19 +101,19 @@ type ReactJSXLibraryManagedAttributes<C, P> = JSX.LibraryManagedAttributes<C, P>
 type ReactJSXIntrinsicAttributes = JSX.IntrinsicAttributes
 >ReactJSXIntrinsicAttributes : Symbol(ReactJSXIntrinsicAttributes, Decl(jsx-namespace.d.ts, 10, 80))
 >JSX : Symbol(JSX, Decl(index.d.ts, 5, 16))
->IntrinsicAttributes : Symbol(JSX.IntrinsicAttributes, Decl(index.d.ts, 11, 48))
+>IntrinsicAttributes : Symbol(ReactJSXIntrinsicAttributes, Decl(index.d.ts, 11, 48))
 
 type ReactJSXIntrinsicClassAttributes<T> = JSX.IntrinsicClassAttributes<T>
 >ReactJSXIntrinsicClassAttributes : Symbol(ReactJSXIntrinsicClassAttributes, Decl(jsx-namespace.d.ts, 11, 58))
 >T : Symbol(T, Decl(jsx-namespace.d.ts, 12, 38))
 >JSX : Symbol(JSX, Decl(index.d.ts, 5, 16))
->IntrinsicClassAttributes : Symbol(JSX.IntrinsicClassAttributes, Decl(index.d.ts, 12, 41))
+>IntrinsicClassAttributes : Symbol(ReactJSXIntrinsicClassAttributes, Decl(index.d.ts, 12, 41))
 >T : Symbol(T, Decl(jsx-namespace.d.ts, 12, 38))
 
 type ReactJSXIntrinsicElements = JSX.IntrinsicElements
 >ReactJSXIntrinsicElements : Symbol(ReactJSXIntrinsicElements, Decl(jsx-namespace.d.ts, 12, 74))
 >JSX : Symbol(JSX, Decl(index.d.ts, 5, 16))
->IntrinsicElements : Symbol(JSX.IntrinsicElements, Decl(index.d.ts, 13, 49))
+>IntrinsicElements : Symbol(ReactJSXIntrinsicElements, Decl(index.d.ts, 13, 49))
 
 export namespace EmotionJSX {
 >EmotionJSX : Symbol(EmotionJSX, Decl(jsx-namespace.d.ts, 13, 54))
diff --git a/tests/baselines/reference/jsxNamespaceImplicitImportJSXNamespaceFromPragmaPickedOverGlobalOne.types b/tests/baselines/reference/jsxNamespaceImplicitImportJSXNamespaceFromPragmaPickedOverGlobalOne.types
index eec34dc7517e7..233f0778a4729 100644
--- a/tests/baselines/reference/jsxNamespaceImplicitImportJSXNamespaceFromPragmaPickedOverGlobalOne.types
+++ b/tests/baselines/reference/jsxNamespaceImplicitImportJSXNamespaceFromPragmaPickedOverGlobalOne.types
@@ -44,19 +44,19 @@ type WithConditionalCSSProp<P> = 'className' extends keyof P
     : P
 
 type ReactJSXElement = JSX.Element
->ReactJSXElement : JSX.Element
+>ReactJSXElement : ReactJSXElement
 >JSX : any
 
 type ReactJSXElementClass = JSX.ElementClass
->ReactJSXElementClass : JSX.ElementClass
+>ReactJSXElementClass : ReactJSXElementClass
 >JSX : any
 
 type ReactJSXElementAttributesProperty = JSX.ElementAttributesProperty
->ReactJSXElementAttributesProperty : JSX.ElementAttributesProperty
+>ReactJSXElementAttributesProperty : ReactJSXElementAttributesProperty
 >JSX : any
 
 type ReactJSXElementChildrenAttribute = JSX.ElementChildrenAttribute
->ReactJSXElementChildrenAttribute : JSX.ElementChildrenAttribute
+>ReactJSXElementChildrenAttribute : ReactJSXElementChildrenAttribute
 >JSX : any
 
 type ReactJSXLibraryManagedAttributes<C, P> = JSX.LibraryManagedAttributes<C, P>
@@ -64,7 +64,7 @@ type ReactJSXLibraryManagedAttributes<C, P> = JSX.LibraryManagedAttributes<C, P>
 >JSX : any
 
 type ReactJSXIntrinsicAttributes = JSX.IntrinsicAttributes
->ReactJSXIntrinsicAttributes : JSX.IntrinsicAttributes
+>ReactJSXIntrinsicAttributes : ReactJSXIntrinsicAttributes
 >JSX : any
 
 type ReactJSXIntrinsicClassAttributes<T> = JSX.IntrinsicClassAttributes<T>
@@ -72,7 +72,7 @@ type ReactJSXIntrinsicClassAttributes<T> = JSX.IntrinsicClassAttributes<T>
 >JSX : any
 
 type ReactJSXIntrinsicElements = JSX.IntrinsicElements
->ReactJSXIntrinsicElements : JSX.IntrinsicElements
+>ReactJSXIntrinsicElements : ReactJSXIntrinsicElements
 >JSX : any
 
 export namespace EmotionJSX {
diff --git a/tests/baselines/reference/keyRemappingKeyofResult.symbols b/tests/baselines/reference/keyRemappingKeyofResult.symbols
index fb306f96b72d0..457e531ec42e3 100644
--- a/tests/baselines/reference/keyRemappingKeyofResult.symbols
+++ b/tests/baselines/reference/keyRemappingKeyofResult.symbols
@@ -6,8 +6,8 @@ const sym = Symbol("")
 type Orig = { [k: string]: any, str: any, [sym]: any }
 >Orig : Symbol(Orig, Decl(keyRemappingKeyofResult.ts, 0, 22))
 >k : Symbol(k, Decl(keyRemappingKeyofResult.ts, 1, 15))
->str : Symbol(str, Decl(keyRemappingKeyofResult.ts, 1, 31))
->[sym] : Symbol([sym], Decl(keyRemappingKeyofResult.ts, 1, 41))
+>str : Symbol(Orig.str, Decl(keyRemappingKeyofResult.ts, 1, 31))
+>[sym] : Symbol(Orig[sym], Decl(keyRemappingKeyofResult.ts, 1, 41))
 >sym : Symbol(sym, Decl(keyRemappingKeyofResult.ts, 0, 5))
 
 type Okay = Exclude<keyof Orig, never>
diff --git a/tests/baselines/reference/keyofAndIndexedAccess.symbols b/tests/baselines/reference/keyofAndIndexedAccess.symbols
index 277a012517b16..601477364e395 100644
--- a/tests/baselines/reference/keyofAndIndexedAccess.symbols
+++ b/tests/baselines/reference/keyofAndIndexedAccess.symbols
@@ -1142,10 +1142,10 @@ type S2 = {
 >S2 : Symbol(S2, Decl(keyofAndIndexedAccess.ts, 294, 1))
 
     a: string;
->a : Symbol(a, Decl(keyofAndIndexedAccess.ts, 296, 11))
+>a : Symbol(S2.a, Decl(keyofAndIndexedAccess.ts, 296, 11))
 
     b: string;
->b : Symbol(b, Decl(keyofAndIndexedAccess.ts, 297, 14))
+>b : Symbol(S2.b, Decl(keyofAndIndexedAccess.ts, 297, 14))
 
 };
 
@@ -1435,12 +1435,12 @@ type Thing = {
 >Thing : Symbol(Thing, Decl(keyofAndIndexedAccess.ts, 371, 1))
 
     a: { x: number, y: string },
->a : Symbol(a, Decl(keyofAndIndexedAccess.ts, 373, 14))
+>a : Symbol(Thing.a, Decl(keyofAndIndexedAccess.ts, 373, 14))
 >x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 374, 8))
 >y : Symbol(y, Decl(keyofAndIndexedAccess.ts, 374, 19))
 
     b: boolean
->b : Symbol(b, Decl(keyofAndIndexedAccess.ts, 374, 32))
+>b : Symbol(Thing.b, Decl(keyofAndIndexedAccess.ts, 374, 32))
 
 };
 
@@ -1665,13 +1665,13 @@ type MethodDescriptor = {
 >MethodDescriptor : Symbol(MethodDescriptor, Decl(keyofAndIndexedAccess.ts, 442, 1))
 
 	name: string;
->name : Symbol(name, Decl(keyofAndIndexedAccess.ts, 446, 25))
+>name : Symbol(MethodDescriptor.name, Decl(keyofAndIndexedAccess.ts, 446, 25))
 
 	args: any[];
->args : Symbol(args, Decl(keyofAndIndexedAccess.ts, 447, 14))
+>args : Symbol(MethodDescriptor.args, Decl(keyofAndIndexedAccess.ts, 447, 14))
 
 	returnValue: any;
->returnValue : Symbol(returnValue, Decl(keyofAndIndexedAccess.ts, 448, 13))
+>returnValue : Symbol(MethodDescriptor.returnValue, Decl(keyofAndIndexedAccess.ts, 448, 13))
 }
 
 declare function dispatchMethod<M extends MethodDescriptor>(name: M['name'], args: M['args']): M['returnValue'];
@@ -1688,13 +1688,13 @@ type SomeMethodDescriptor = {
 >SomeMethodDescriptor : Symbol(SomeMethodDescriptor, Decl(keyofAndIndexedAccess.ts, 452, 112))
 
 	name: "someMethod";
->name : Symbol(name, Decl(keyofAndIndexedAccess.ts, 454, 29))
+>name : Symbol(SomeMethodDescriptor.name, Decl(keyofAndIndexedAccess.ts, 454, 29))
 
 	args: [string, number];
->args : Symbol(args, Decl(keyofAndIndexedAccess.ts, 455, 20))
+>args : Symbol(SomeMethodDescriptor.args, Decl(keyofAndIndexedAccess.ts, 455, 20))
 
 	returnValue: string[];
->returnValue : Symbol(returnValue, Decl(keyofAndIndexedAccess.ts, 456, 24))
+>returnValue : Symbol(SomeMethodDescriptor.returnValue, Decl(keyofAndIndexedAccess.ts, 456, 24))
 }
 
 let result = dispatchMethod<SomeMethodDescriptor>("someMethod", ["hello", 35]);
@@ -1733,7 +1733,7 @@ type Handler<T> = {
 >T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 473, 13))
 
     onChange: (name: keyof T) => void;
->onChange : Symbol(onChange, Decl(keyofAndIndexedAccess.ts, 473, 19))
+>onChange : Symbol(Handler.onChange, Decl(keyofAndIndexedAccess.ts, 473, 19))
 >name : Symbol(name, Decl(keyofAndIndexedAccess.ts, 474, 15))
 >T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 473, 13))
 
@@ -1748,9 +1748,9 @@ function onChangeGenericFunction<T>(handler: Handler<T & {preset: number}>) {
 >preset : Symbol(preset, Decl(keyofAndIndexedAccess.ts, 477, 58))
 
     handler.onChange('preset')
->handler.onChange : Symbol(onChange, Decl(keyofAndIndexedAccess.ts, 473, 19))
+>handler.onChange : Symbol(Handler.onChange, Decl(keyofAndIndexedAccess.ts, 473, 19))
 >handler : Symbol(handler, Decl(keyofAndIndexedAccess.ts, 477, 36))
->onChange : Symbol(onChange, Decl(keyofAndIndexedAccess.ts, 473, 19))
+>onChange : Symbol(Handler.onChange, Decl(keyofAndIndexedAccess.ts, 473, 19))
 }
 
 // Repro from #13285
diff --git a/tests/baselines/reference/keyofAndIndexedAccess2.symbols b/tests/baselines/reference/keyofAndIndexedAccess2.symbols
index a17aafe571aa5..5fc663c78031e 100644
--- a/tests/baselines/reference/keyofAndIndexedAccess2.symbols
+++ b/tests/baselines/reference/keyofAndIndexedAccess2.symbols
@@ -182,8 +182,8 @@ function f4<K extends string>(a: { [key: string]: number }[K], b: number) {
 
 type Item = { a: string, b: number };
 >Item : Symbol(Item, Decl(keyofAndIndexedAccess2.ts, 44, 1))
->a : Symbol(a, Decl(keyofAndIndexedAccess2.ts, 46, 13))
->b : Symbol(b, Decl(keyofAndIndexedAccess2.ts, 46, 24))
+>a : Symbol(Item.a, Decl(keyofAndIndexedAccess2.ts, 46, 13))
+>b : Symbol(Item.b, Decl(keyofAndIndexedAccess2.ts, 46, 24))
 
 function f10<T extends Item, K extends keyof T>(obj: T, k1: string, k2: keyof Item, k3: keyof T, k4: K) {
 >f10 : Symbol(f10, Decl(keyofAndIndexedAccess2.ts, 46, 37))
diff --git a/tests/baselines/reference/keyofAndIndexedAccessErrors.symbols b/tests/baselines/reference/keyofAndIndexedAccessErrors.symbols
index 973e68dccd2f9..55cb7a2fea70d 100644
--- a/tests/baselines/reference/keyofAndIndexedAccessErrors.symbols
+++ b/tests/baselines/reference/keyofAndIndexedAccessErrors.symbols
@@ -447,8 +447,8 @@ type UndefinedKeys<T extends Record<string, any>> = {
 
 type MyType = {a: string, b: string | undefined}
 >MyType : Symbol(MyType, Decl(keyofAndIndexedAccessErrors.ts, 129, 2))
->a : Symbol(a, Decl(keyofAndIndexedAccessErrors.ts, 131, 15))
->b : Symbol(b, Decl(keyofAndIndexedAccessErrors.ts, 131, 25))
+>a : Symbol(MyType.a, Decl(keyofAndIndexedAccessErrors.ts, 131, 15))
+>b : Symbol(MyType.b, Decl(keyofAndIndexedAccessErrors.ts, 131, 25))
 
 type Result1 = UndefinedKeys<MyType>;
 >Result1 : Symbol(Result1, Decl(keyofAndIndexedAccessErrors.ts, 131, 48))
diff --git a/tests/baselines/reference/keyofIntersection.symbols b/tests/baselines/reference/keyofIntersection.symbols
index ba141ef96d4b4..c8c5233290406 100644
--- a/tests/baselines/reference/keyofIntersection.symbols
+++ b/tests/baselines/reference/keyofIntersection.symbols
@@ -1,11 +1,11 @@
 === tests/cases/conformance/types/keyof/keyofIntersection.ts ===
 type A = { a: string };
 >A : Symbol(A, Decl(keyofIntersection.ts, 0, 0))
->a : Symbol(a, Decl(keyofIntersection.ts, 0, 10))
+>a : Symbol(A.a, Decl(keyofIntersection.ts, 0, 10))
 
 type B = { b: string };
 >B : Symbol(B, Decl(keyofIntersection.ts, 0, 23))
->b : Symbol(b, Decl(keyofIntersection.ts, 1, 10))
+>b : Symbol(B.b, Decl(keyofIntersection.ts, 1, 10))
 
 type T01 = keyof (A & B);  // "a" | "b"
 >T01 : Symbol(T01, Decl(keyofIntersection.ts, 1, 23))
diff --git a/tests/baselines/reference/keyofObjectWithGlobalSymbolIncluded.symbols b/tests/baselines/reference/keyofObjectWithGlobalSymbolIncluded.symbols
index afbd9aac084b1..d3282b1e6beea 100644
--- a/tests/baselines/reference/keyofObjectWithGlobalSymbolIncluded.symbols
+++ b/tests/baselines/reference/keyofObjectWithGlobalSymbolIncluded.symbols
@@ -4,9 +4,9 @@ const obj = {
 
     [Symbol.species]: Array
 >[Symbol.species] : Symbol([Symbol.species], Decl(keyofObjectWithGlobalSymbolIncluded.ts, 0, 13))
->Symbol.species : Symbol(SymbolConstructor.species, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.species : Symbol(Q, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
 >Symbol : Symbol(Symbol, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->species : Symbol(SymbolConstructor.species, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>species : Symbol(Q, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
 >Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
 
 };
diff --git a/tests/baselines/reference/leaveOptionalParameterAsWritten.js b/tests/baselines/reference/leaveOptionalParameterAsWritten.js
new file mode 100644
index 0000000000000..b2fbbe87f246d
--- /dev/null
+++ b/tests/baselines/reference/leaveOptionalParameterAsWritten.js
@@ -0,0 +1,44 @@
+//// [tests/cases/conformance/declarationEmit/leaveOptionalParameterAsWritten.ts] ////
+
+//// [a.ts]
+export interface Foo {}
+
+//// [b.ts]
+import * as a from "./a";
+declare global {
+  namespace teams {
+    export namespace calling {
+      export import Foo = a.Foo;
+    }
+  }
+}
+
+//// [c.ts]
+type Foo = teams.calling.Foo;
+export const f = (p?: Foo) => {}
+export const o = {
+  p: undefined! as Foo
+};
+
+
+
+
+//// [a.d.ts]
+export interface Foo {
+}
+//// [b.d.ts]
+import * as a from "./a";
+declare global {
+    namespace teams {
+        namespace calling {
+            export import Foo = a.Foo;
+        }
+    }
+}
+//// [c.d.ts]
+declare type Foo = teams.calling.Foo;
+export declare const f: (p?: Foo) => void;
+export declare const o: {
+    p: Foo;
+};
+export {};
diff --git a/tests/baselines/reference/leaveOptionalParameterAsWritten.symbols b/tests/baselines/reference/leaveOptionalParameterAsWritten.symbols
new file mode 100644
index 0000000000000..24c6959ba4e3e
--- /dev/null
+++ b/tests/baselines/reference/leaveOptionalParameterAsWritten.symbols
@@ -0,0 +1,47 @@
+=== tests/cases/conformance/declarationEmit/a.ts ===
+export interface Foo {}
+>Foo : Symbol(Foo, Decl(a.ts, 0, 0))
+
+=== tests/cases/conformance/declarationEmit/b.ts ===
+import * as a from "./a";
+>a : Symbol(a, Decl(b.ts, 0, 6))
+
+declare global {
+>global : Symbol(global, Decl(b.ts, 0, 25))
+
+  namespace teams {
+>teams : Symbol(teams, Decl(b.ts, 1, 16))
+
+    export namespace calling {
+>calling : Symbol(calling, Decl(b.ts, 2, 19))
+
+      export import Foo = a.Foo;
+>Foo : Symbol(Foo, Decl(b.ts, 3, 30))
+>a : Symbol(a, Decl(b.ts, 0, 6))
+>Foo : Symbol(Foo, Decl(a.ts, 0, 0))
+    }
+  }
+}
+
+=== tests/cases/conformance/declarationEmit/c.ts ===
+type Foo = teams.calling.Foo;
+>Foo : Symbol(Foo, Decl(c.ts, 0, 0))
+>teams : Symbol(teams, Decl(b.ts, 1, 16))
+>calling : Symbol(teams.calling, Decl(b.ts, 2, 19))
+>Foo : Symbol(teams.calling.Foo, Decl(b.ts, 3, 30))
+
+export const f = (p?: Foo) => {}
+>f : Symbol(f, Decl(c.ts, 1, 12))
+>p : Symbol(p, Decl(c.ts, 1, 18))
+>Foo : Symbol(Foo, Decl(c.ts, 0, 0))
+
+export const o = {
+>o : Symbol(o, Decl(c.ts, 2, 12))
+
+  p: undefined! as Foo
+>p : Symbol(p, Decl(c.ts, 2, 18))
+>undefined : Symbol(undefined)
+>Foo : Symbol(Foo, Decl(c.ts, 0, 0))
+
+};
+
diff --git a/tests/baselines/reference/leaveOptionalParameterAsWritten.types b/tests/baselines/reference/leaveOptionalParameterAsWritten.types
new file mode 100644
index 0000000000000..5ebd6caf85bf3
--- /dev/null
+++ b/tests/baselines/reference/leaveOptionalParameterAsWritten.types
@@ -0,0 +1,47 @@
+=== tests/cases/conformance/declarationEmit/a.ts ===
+export interface Foo {}
+No type information for this code.
+No type information for this code.=== tests/cases/conformance/declarationEmit/b.ts ===
+import * as a from "./a";
+>a : typeof a
+
+declare global {
+>global : typeof global
+
+  namespace teams {
+>teams : typeof teams
+
+    export namespace calling {
+>calling : typeof calling
+
+      export import Foo = a.Foo;
+>Foo : any
+>a : typeof a
+>Foo : Foo
+    }
+  }
+}
+
+=== tests/cases/conformance/declarationEmit/c.ts ===
+type Foo = teams.calling.Foo;
+>Foo : Foo
+>teams : any
+>calling : any
+
+export const f = (p?: Foo) => {}
+>f : (p?: Foo) => void
+>(p?: Foo) => {} : (p?: Foo) => void
+>p : Foo | undefined
+
+export const o = {
+>o : { p: Foo; }
+>{  p: undefined! as Foo} : { p: Foo; }
+
+  p: undefined! as Foo
+>p : Foo
+>undefined! as Foo : Foo
+>undefined! : never
+>undefined : undefined
+
+};
+
diff --git a/tests/baselines/reference/literalTypeWidening.symbols b/tests/baselines/reference/literalTypeWidening.symbols
index c51210337f9b5..038412eda25c7 100644
--- a/tests/baselines/reference/literalTypeWidening.symbols
+++ b/tests/baselines/reference/literalTypeWidening.symbols
@@ -375,7 +375,7 @@ export function keys<K extends string, V>(obj: Record<K, V>): K[] {
 
 type Obj = { code: LangCode }
 >Obj : Symbol(Obj, Decl(literalTypeWidening.ts, 120, 1))
->code : Symbol(code, Decl(literalTypeWidening.ts, 122, 12))
+>code : Symbol(Obj.code, Decl(literalTypeWidening.ts, 122, 12))
 >LangCode : Symbol(LangCode, Decl(literalTypeWidening.ts, 124, 53))
 
 const langCodeSet = Set('fr', 'en', 'es', 'it', 'nl')
diff --git a/tests/baselines/reference/mappedTypeAsClauses.symbols b/tests/baselines/reference/mappedTypeAsClauses.symbols
index 834020f61eea8..cfe9d23343886 100644
--- a/tests/baselines/reference/mappedTypeAsClauses.symbols
+++ b/tests/baselines/reference/mappedTypeAsClauses.symbols
@@ -25,9 +25,9 @@ type PropDef<K extends keyof any, T> = { name: K, type: T };
 >PropDef : Symbol(PropDef, Decl(mappedTypeAsClauses.ts, 3, 70))
 >K : Symbol(K, Decl(mappedTypeAsClauses.ts, 7, 13))
 >T : Symbol(T, Decl(mappedTypeAsClauses.ts, 7, 33))
->name : Symbol(name, Decl(mappedTypeAsClauses.ts, 7, 40))
+>name : Symbol(PropDef.name, Decl(mappedTypeAsClauses.ts, 7, 40))
 >K : Symbol(K, Decl(mappedTypeAsClauses.ts, 7, 13))
->type : Symbol(type, Decl(mappedTypeAsClauses.ts, 7, 49))
+>type : Symbol(PropDef.type, Decl(mappedTypeAsClauses.ts, 7, 49))
 >T : Symbol(T, Decl(mappedTypeAsClauses.ts, 7, 33))
 
 type TypeFromDefs<T extends PropDef<keyof any, any>> = { [P in T as P['name']]: P['type'] };
@@ -147,8 +147,8 @@ type LazyPerson = Lazyify<Person>;
 
 type Example = {foo: string, bar: number};
 >Example : Symbol(Example, Decl(mappedTypeAsClauses.ts, 42, 34))
->foo : Symbol(foo, Decl(mappedTypeAsClauses.ts, 46, 16))
->bar : Symbol(bar, Decl(mappedTypeAsClauses.ts, 46, 28))
+>foo : Symbol(Example.foo, Decl(mappedTypeAsClauses.ts, 46, 16))
+>bar : Symbol(Example.bar, Decl(mappedTypeAsClauses.ts, 46, 28))
 
 type PickByValueType<T, U> = {
 >PickByValueType : Symbol(PickByValueType, Decl(mappedTypeAsClauses.ts, 46, 42))
@@ -328,7 +328,7 @@ type Task = {
 >Task : Symbol(Task, Decl(mappedTypeAsClauses.ts, 98, 85))
 
   isDone: boolean;
->isDone : Symbol(isDone, Decl(mappedTypeAsClauses.ts, 100, 13))
+>isDone : Symbol(Task.isDone, Decl(mappedTypeAsClauses.ts, 100, 13))
 
 };
 
@@ -336,7 +336,7 @@ type Schema = {
 >Schema : Symbol(Schema, Decl(mappedTypeAsClauses.ts, 102, 2))
 
   root: {
->root : Symbol(root, Decl(mappedTypeAsClauses.ts, 104, 15))
+>root : Symbol(Schema.root, Decl(mappedTypeAsClauses.ts, 104, 15))
 
     title: string;
 >title : Symbol(title, Decl(mappedTypeAsClauses.ts, 105, 9))
@@ -346,7 +346,7 @@ type Schema = {
 >Task : Symbol(Task, Decl(mappedTypeAsClauses.ts, 98, 85))
   }
   Task: Task;
->Task : Symbol(Task, Decl(mappedTypeAsClauses.ts, 108, 3))
+>Task : Symbol(Schema.Task, Decl(mappedTypeAsClauses.ts, 108, 3))
 >Task : Symbol(Task, Decl(mappedTypeAsClauses.ts, 98, 85))
 
 };
@@ -409,9 +409,9 @@ f("a");  // Error, should allow only "b"
 
 type NameMap = { 'a': 'x', 'b': 'y', 'c': 'z' };
 >NameMap : Symbol(NameMap, Decl(mappedTypeAsClauses.ts, 129, 7))
->'a' : Symbol('a', Decl(mappedTypeAsClauses.ts, 131, 16))
->'b' : Symbol('b', Decl(mappedTypeAsClauses.ts, 131, 26))
->'c' : Symbol('c', Decl(mappedTypeAsClauses.ts, 131, 36))
+>'a' : Symbol(NameMap['a'], Decl(mappedTypeAsClauses.ts, 131, 16))
+>'b' : Symbol(NameMap['b'], Decl(mappedTypeAsClauses.ts, 131, 26))
+>'c' : Symbol(NameMap['c'], Decl(mappedTypeAsClauses.ts, 131, 36))
 
 // Distributive, will be simplified
 
diff --git a/tests/baselines/reference/mappedTypeConstraints.symbols b/tests/baselines/reference/mappedTypeConstraints.symbols
index 3601ffc3de848..45d93e2d6bee6 100644
--- a/tests/baselines/reference/mappedTypeConstraints.symbols
+++ b/tests/baselines/reference/mappedTypeConstraints.symbols
@@ -112,10 +112,10 @@ type TargetProps = {
 >TargetProps : Symbol(TargetProps, Decl(mappedTypeConstraints.ts, 21, 1))
 
     foo: string,
->foo : Symbol(foo, Decl(mappedTypeConstraints.ts, 25, 20))
+>foo : Symbol(TargetProps.foo, Decl(mappedTypeConstraints.ts, 25, 20))
 
     bar: string
->bar : Symbol(bar, Decl(mappedTypeConstraints.ts, 26, 16))
+>bar : Symbol(TargetProps.bar, Decl(mappedTypeConstraints.ts, 26, 16))
 
 };
 
diff --git a/tests/baselines/reference/mappedTypeErrors.symbols b/tests/baselines/reference/mappedTypeErrors.symbols
index e2f3b57750606..f9e7f74422d36 100644
--- a/tests/baselines/reference/mappedTypeErrors.symbols
+++ b/tests/baselines/reference/mappedTypeErrors.symbols
@@ -468,7 +468,7 @@ c.setState({ c: true });  // Error
 
 type T2 = { a?: number, [key: string]: any };
 >T2 : Symbol(T2, Decl(mappedTypeErrors.ts, 123, 24))
->a : Symbol(a, Decl(mappedTypeErrors.ts, 125, 11))
+>a : Symbol(T2.a, Decl(mappedTypeErrors.ts, 125, 11))
 >key : Symbol(key, Decl(mappedTypeErrors.ts, 125, 25))
 
 let x1: T2 = { a: 'no' };  // Error
@@ -499,14 +499,14 @@ type Foo2<T, F extends keyof T> = {
 >T : Symbol(T, Decl(mappedTypeErrors.ts, 133, 10))
 
     pf: {[P in F]?: T[P]},
->pf : Symbol(pf, Decl(mappedTypeErrors.ts, 133, 35))
+>pf : Symbol(Foo2.pf, Decl(mappedTypeErrors.ts, 133, 35))
 >P : Symbol(P, Decl(mappedTypeErrors.ts, 134, 10))
 >F : Symbol(F, Decl(mappedTypeErrors.ts, 133, 12))
 >T : Symbol(T, Decl(mappedTypeErrors.ts, 133, 10))
 >P : Symbol(P, Decl(mappedTypeErrors.ts, 134, 10))
 
     pt: {[P in T]?: T[P]}, // note: should be in keyof T
->pt : Symbol(pt, Decl(mappedTypeErrors.ts, 134, 26))
+>pt : Symbol(Foo2.pt, Decl(mappedTypeErrors.ts, 134, 26))
 >P : Symbol(P, Decl(mappedTypeErrors.ts, 135, 10))
 >T : Symbol(T, Decl(mappedTypeErrors.ts, 133, 10))
 >T : Symbol(T, Decl(mappedTypeErrors.ts, 133, 10))
@@ -515,8 +515,8 @@ type Foo2<T, F extends keyof T> = {
 };
 type O = {x: number, y: boolean};
 >O : Symbol(O, Decl(mappedTypeErrors.ts, 136, 2))
->x : Symbol(x, Decl(mappedTypeErrors.ts, 137, 10))
->y : Symbol(y, Decl(mappedTypeErrors.ts, 137, 20))
+>x : Symbol(O.x, Decl(mappedTypeErrors.ts, 137, 10))
+>y : Symbol(O.y, Decl(mappedTypeErrors.ts, 137, 20))
 
 let o: O = {x: 5, y: false};
 >o : Symbol(o, Decl(mappedTypeErrors.ts, 138, 3))
diff --git a/tests/baselines/reference/mappedTypeErrors2.symbols b/tests/baselines/reference/mappedTypeErrors2.symbols
index 5ceb8255ff40c..7acb695e30dda 100644
--- a/tests/baselines/reference/mappedTypeErrors2.symbols
+++ b/tests/baselines/reference/mappedTypeErrors2.symbols
@@ -5,10 +5,10 @@ type AB = {
 >AB : Symbol(AB, Decl(mappedTypeErrors2.ts, 0, 0))
 
     a: 'a'
->a : Symbol(a, Decl(mappedTypeErrors2.ts, 2, 11))
+>a : Symbol(AB.a, Decl(mappedTypeErrors2.ts, 2, 11))
 
     b: 'a'
->b : Symbol(b, Decl(mappedTypeErrors2.ts, 3, 10))
+>b : Symbol(AB.b, Decl(mappedTypeErrors2.ts, 3, 10))
 
 };
 
diff --git a/tests/baselines/reference/mappedTypeIndexedAccess.symbols b/tests/baselines/reference/mappedTypeIndexedAccess.symbols
index 6611d4483ba68..a298b6e4e7b46 100644
--- a/tests/baselines/reference/mappedTypeIndexedAccess.symbols
+++ b/tests/baselines/reference/mappedTypeIndexedAccess.symbols
@@ -32,10 +32,10 @@ type FooBar = {
 >FooBar : Symbol(FooBar, Decl(mappedTypeIndexedAccess.ts, 9, 33))
 
     foo: string;
->foo : Symbol(foo, Decl(mappedTypeIndexedAccess.ts, 11, 15))
+>foo : Symbol(FooBar.foo, Decl(mappedTypeIndexedAccess.ts, 11, 15))
 
     bar: number;
->bar : Symbol(bar, Decl(mappedTypeIndexedAccess.ts, 12, 16))
+>bar : Symbol(FooBar.bar, Decl(mappedTypeIndexedAccess.ts, 12, 16))
 
 };
 
diff --git a/tests/baselines/reference/mappedTypeModifiers.symbols b/tests/baselines/reference/mappedTypeModifiers.symbols
index 90e9171b8c23f..baf036268f89b 100644
--- a/tests/baselines/reference/mappedTypeModifiers.symbols
+++ b/tests/baselines/reference/mappedTypeModifiers.symbols
@@ -1,23 +1,23 @@
 === tests/cases/conformance/types/mapped/mappedTypeModifiers.ts ===
 type T = { a: number, b: string };
 >T : Symbol(T, Decl(mappedTypeModifiers.ts, 0, 0))
->a : Symbol(a, Decl(mappedTypeModifiers.ts, 0, 10))
->b : Symbol(b, Decl(mappedTypeModifiers.ts, 0, 21))
+>a : Symbol(T.a, Decl(mappedTypeModifiers.ts, 0, 10))
+>b : Symbol(T.b, Decl(mappedTypeModifiers.ts, 0, 21))
 
 type TP = { a?: number, b?: string };
 >TP : Symbol(TP, Decl(mappedTypeModifiers.ts, 0, 34))
->a : Symbol(a, Decl(mappedTypeModifiers.ts, 1, 11))
->b : Symbol(b, Decl(mappedTypeModifiers.ts, 1, 23))
+>a : Symbol(TP.a, Decl(mappedTypeModifiers.ts, 1, 11))
+>b : Symbol(TP.b, Decl(mappedTypeModifiers.ts, 1, 23))
 
 type TR = { readonly a: number, readonly b: string };
 >TR : Symbol(TR, Decl(mappedTypeModifiers.ts, 1, 37))
->a : Symbol(a, Decl(mappedTypeModifiers.ts, 2, 11))
->b : Symbol(b, Decl(mappedTypeModifiers.ts, 2, 31))
+>a : Symbol(TR.a, Decl(mappedTypeModifiers.ts, 2, 11))
+>b : Symbol(TR.b, Decl(mappedTypeModifiers.ts, 2, 31))
 
 type TPR = { readonly a?: number, readonly b?: string };
 >TPR : Symbol(TPR, Decl(mappedTypeModifiers.ts, 2, 53))
->a : Symbol(a, Decl(mappedTypeModifiers.ts, 3, 12))
->b : Symbol(b, Decl(mappedTypeModifiers.ts, 3, 33))
+>a : Symbol(TPR.a, Decl(mappedTypeModifiers.ts, 3, 12))
+>b : Symbol(TPR.b, Decl(mappedTypeModifiers.ts, 3, 33))
 
 var v00: "a" | "b";
 >v00 : Symbol(v00, Decl(mappedTypeModifiers.ts, 5, 3), Decl(mappedTypeModifiers.ts, 6, 3), Decl(mappedTypeModifiers.ts, 7, 3), Decl(mappedTypeModifiers.ts, 8, 3), Decl(mappedTypeModifiers.ts, 9, 3))
@@ -178,30 +178,30 @@ type Boxified<T> = { [P in keyof T]: { x: T[P] } };
 
 type B = { a: { x: number }, b: { x: string } };
 >B : Symbol(B, Decl(mappedTypeModifiers.ts, 37, 51))
->a : Symbol(a, Decl(mappedTypeModifiers.ts, 39, 10))
+>a : Symbol(B.a, Decl(mappedTypeModifiers.ts, 39, 10))
 >x : Symbol(x, Decl(mappedTypeModifiers.ts, 39, 15))
->b : Symbol(b, Decl(mappedTypeModifiers.ts, 39, 28))
+>b : Symbol(B.b, Decl(mappedTypeModifiers.ts, 39, 28))
 >x : Symbol(x, Decl(mappedTypeModifiers.ts, 39, 33))
 
 type BP = { a?: { x: number }, b?: { x: string } };
 >BP : Symbol(BP, Decl(mappedTypeModifiers.ts, 39, 48))
->a : Symbol(a, Decl(mappedTypeModifiers.ts, 40, 11))
+>a : Symbol(BP.a, Decl(mappedTypeModifiers.ts, 40, 11))
 >x : Symbol(x, Decl(mappedTypeModifiers.ts, 40, 17))
->b : Symbol(b, Decl(mappedTypeModifiers.ts, 40, 30))
+>b : Symbol(BP.b, Decl(mappedTypeModifiers.ts, 40, 30))
 >x : Symbol(x, Decl(mappedTypeModifiers.ts, 40, 36))
 
 type BR = { readonly a: { x: number }, readonly b: { x: string } };
 >BR : Symbol(BR, Decl(mappedTypeModifiers.ts, 40, 51))
->a : Symbol(a, Decl(mappedTypeModifiers.ts, 41, 11))
+>a : Symbol(BR.a, Decl(mappedTypeModifiers.ts, 41, 11))
 >x : Symbol(x, Decl(mappedTypeModifiers.ts, 41, 25))
->b : Symbol(b, Decl(mappedTypeModifiers.ts, 41, 38))
+>b : Symbol(BR.b, Decl(mappedTypeModifiers.ts, 41, 38))
 >x : Symbol(x, Decl(mappedTypeModifiers.ts, 41, 52))
 
 type BPR = { readonly a?: { x: number }, readonly b?: { x: string } };
 >BPR : Symbol(BPR, Decl(mappedTypeModifiers.ts, 41, 67))
->a : Symbol(a, Decl(mappedTypeModifiers.ts, 42, 12))
+>a : Symbol(BPR.a, Decl(mappedTypeModifiers.ts, 42, 12))
 >x : Symbol(x, Decl(mappedTypeModifiers.ts, 42, 27))
->b : Symbol(b, Decl(mappedTypeModifiers.ts, 42, 40))
+>b : Symbol(BPR.b, Decl(mappedTypeModifiers.ts, 42, 40))
 >x : Symbol(x, Decl(mappedTypeModifiers.ts, 42, 55))
 
 var b00: "a" | "b";
@@ -354,7 +354,7 @@ var b04: Pick<BPR, keyof BPR>;
 
 type Foo = { prop: number, [x: string]: number };
 >Foo : Symbol(Foo, Decl(mappedTypeModifiers.ts, 74, 30))
->prop : Symbol(prop, Decl(mappedTypeModifiers.ts, 76, 12))
+>prop : Symbol(Foo.prop, Decl(mappedTypeModifiers.ts, 76, 12))
 >x : Symbol(x, Decl(mappedTypeModifiers.ts, 76, 28))
 
 function f1(x: Partial<Foo>) {
diff --git a/tests/baselines/reference/mappedTypeProperties.symbols b/tests/baselines/reference/mappedTypeProperties.symbols
index a38d36c24067d..1bbf0b62e06f0 100644
--- a/tests/baselines/reference/mappedTypeProperties.symbols
+++ b/tests/baselines/reference/mappedTypeProperties.symbols
@@ -6,10 +6,10 @@ type Before = {
 >Before : Symbol(Before, Decl(mappedTypeProperties.ts, 0, 55))
 
     model: 'hour' | 'day';
->model : Symbol(model, Decl(mappedTypeProperties.ts, 1, 15))
+>model : Symbol(Before.model, Decl(mappedTypeProperties.ts, 1, 15))
 
     [placeType in PlaceType]: void;
->[placeType in PlaceType] : Symbol([placeType in PlaceType], Decl(mappedTypeProperties.ts, 2, 26))
+>[placeType in PlaceType] : Symbol(Before[placeType in PlaceType], Decl(mappedTypeProperties.ts, 2, 26))
 }
 
 type After = {
diff --git a/tests/baselines/reference/mappedTypeRelationships.symbols b/tests/baselines/reference/mappedTypeRelationships.symbols
index f50d49cde3a03..0b556d646aba9 100644
--- a/tests/baselines/reference/mappedTypeRelationships.symbols
+++ b/tests/baselines/reference/mappedTypeRelationships.symbols
@@ -341,8 +341,8 @@ function f23<T, U extends T, K extends keyof T>(x: T, y: Readonly<U>, k: K) {
 
 type Thing = { a: string, b: string };
 >Thing : Symbol(Thing, Decl(mappedTypeRelationships.ts, 66, 1))
->a : Symbol(a, Decl(mappedTypeRelationships.ts, 68, 14))
->b : Symbol(b, Decl(mappedTypeRelationships.ts, 68, 25))
+>a : Symbol(Thing.a, Decl(mappedTypeRelationships.ts, 68, 14))
+>b : Symbol(Thing.b, Decl(mappedTypeRelationships.ts, 68, 25))
 
 function f30<T>(x: T, y: Partial<T>) {
 >f30 : Symbol(f30, Decl(mappedTypeRelationships.ts, 68, 38))
@@ -424,7 +424,7 @@ type Item = {
 >Item : Symbol(Item, Decl(mappedTypeRelationships.ts, 88, 1))
 
     name: string;
->name : Symbol(name, Decl(mappedTypeRelationships.ts, 90, 13))
+>name : Symbol(Item.name, Decl(mappedTypeRelationships.ts, 90, 13))
 }
 
 type ItemMap = {
@@ -451,10 +451,10 @@ function f50<T extends ItemMap>(obj: T, key: keyof T) {
 >key : Symbol(key, Decl(mappedTypeRelationships.ts, 98, 39))
 
     return obj[key].name;
->obj[key].name : Symbol(name, Decl(mappedTypeRelationships.ts, 90, 13))
+>obj[key].name : Symbol(Item.name, Decl(mappedTypeRelationships.ts, 90, 13))
 >obj : Symbol(obj, Decl(mappedTypeRelationships.ts, 98, 32))
 >key : Symbol(key, Decl(mappedTypeRelationships.ts, 98, 39))
->name : Symbol(name, Decl(mappedTypeRelationships.ts, 90, 13))
+>name : Symbol(Item.name, Decl(mappedTypeRelationships.ts, 90, 13))
 }
 
 function f51<T extends ItemMap, K extends keyof T>(obj: T, key: K) {
@@ -475,10 +475,10 @@ function f51<T extends ItemMap, K extends keyof T>(obj: T, key: K) {
 >key : Symbol(key, Decl(mappedTypeRelationships.ts, 103, 58))
 
     return obj[key].name;
->obj[key].name : Symbol(name, Decl(mappedTypeRelationships.ts, 90, 13))
+>obj[key].name : Symbol(Item.name, Decl(mappedTypeRelationships.ts, 90, 13))
 >obj : Symbol(obj, Decl(mappedTypeRelationships.ts, 103, 51))
 >key : Symbol(key, Decl(mappedTypeRelationships.ts, 103, 58))
->name : Symbol(name, Decl(mappedTypeRelationships.ts, 90, 13))
+>name : Symbol(Item.name, Decl(mappedTypeRelationships.ts, 90, 13))
 }
 
 type T1<T> = {
diff --git a/tests/baselines/reference/mappedTypeWithAny.symbols b/tests/baselines/reference/mappedTypeWithAny.symbols
index b3a5fe6b0e1ed..d945980e9a09f 100644
--- a/tests/baselines/reference/mappedTypeWithAny.symbols
+++ b/tests/baselines/reference/mappedTypeWithAny.symbols
@@ -1,7 +1,7 @@
 === tests/cases/conformance/types/mapped/mappedTypeWithAny.ts ===
 type Item = { value: string };
 >Item : Symbol(Item, Decl(mappedTypeWithAny.ts, 0, 0))
->value : Symbol(value, Decl(mappedTypeWithAny.ts, 0, 13))
+>value : Symbol(Item.value, Decl(mappedTypeWithAny.ts, 0, 13))
 
 type ItemMap<T> = { [P in keyof T]: Item };
 >ItemMap : Symbol(ItemMap, Decl(mappedTypeWithAny.ts, 0, 30))
@@ -38,7 +38,7 @@ type Data = {
 >Data : Symbol(Data, Decl(mappedTypeWithAny.ts, 7, 29))
 
   value: string;
->value : Symbol(value, Decl(mappedTypeWithAny.ts, 11, 13))
+>value : Symbol(Data.value, Decl(mappedTypeWithAny.ts, 11, 13))
 }
 
 type StrictDataMap<T> = {
diff --git a/tests/baselines/reference/mappedTypes1.symbols b/tests/baselines/reference/mappedTypes1.symbols
index f7e6818aa58dd..96e9e107a967a 100644
--- a/tests/baselines/reference/mappedTypes1.symbols
+++ b/tests/baselines/reference/mappedTypes1.symbols
@@ -1,9 +1,9 @@
 === tests/cases/conformance/types/mapped/mappedTypes1.ts ===
 type Item = { a: string, b: number, c: boolean };
 >Item : Symbol(Item, Decl(mappedTypes1.ts, 0, 0))
->a : Symbol(a, Decl(mappedTypes1.ts, 0, 13))
->b : Symbol(b, Decl(mappedTypes1.ts, 0, 24))
->c : Symbol(c, Decl(mappedTypes1.ts, 0, 35))
+>a : Symbol(Item.a, Decl(mappedTypes1.ts, 0, 13))
+>b : Symbol(Item.b, Decl(mappedTypes1.ts, 0, 24))
+>c : Symbol(Item.c, Decl(mappedTypes1.ts, 0, 35))
 
 type T00 = { [P in "x" | "y"]: number };
 >T00 : Symbol(T00, Decl(mappedTypes1.ts, 0, 49))
diff --git a/tests/baselines/reference/mappedTypes2.symbols b/tests/baselines/reference/mappedTypes2.symbols
index bf89682dbae50..bf590f815a018 100644
--- a/tests/baselines/reference/mappedTypes2.symbols
+++ b/tests/baselines/reference/mappedTypes2.symbols
@@ -61,11 +61,11 @@ type Proxy<T> = {
 >T : Symbol(T, Decl(mappedTypes2.ts, 11, 11))
 
     get(): T;
->get : Symbol(get, Decl(mappedTypes2.ts, 11, 17))
+>get : Symbol(Proxy.get, Decl(mappedTypes2.ts, 11, 17))
 >T : Symbol(T, Decl(mappedTypes2.ts, 11, 11))
 
     set(value: T): void;
->set : Symbol(set, Decl(mappedTypes2.ts, 12, 13))
+>set : Symbol(Proxy.set, Decl(mappedTypes2.ts, 12, 13))
 >value : Symbol(value, Decl(mappedTypes2.ts, 13, 8))
 >T : Symbol(T, Decl(mappedTypes2.ts, 11, 11))
 }
@@ -312,18 +312,18 @@ function f5(shape: Shape) {
 
     let name = p.name.get();
 >name : Symbol(name, Decl(mappedTypes2.ts, 84, 7))
->p.name.get : Symbol(get, Decl(mappedTypes2.ts, 11, 17))
+>p.name.get : Symbol(Proxy.get, Decl(mappedTypes2.ts, 11, 17))
 >p.name : Symbol(name, Decl(mappedTypes2.ts, 35, 17))
 >p : Symbol(p, Decl(mappedTypes2.ts, 83, 9))
 >name : Symbol(name, Decl(mappedTypes2.ts, 35, 17))
->get : Symbol(get, Decl(mappedTypes2.ts, 11, 17))
+>get : Symbol(Proxy.get, Decl(mappedTypes2.ts, 11, 17))
 
     p.width.set(42);
->p.width.set : Symbol(set, Decl(mappedTypes2.ts, 12, 13))
+>p.width.set : Symbol(Proxy.set, Decl(mappedTypes2.ts, 12, 13))
 >p.width : Symbol(width, Decl(mappedTypes2.ts, 36, 17))
 >p : Symbol(p, Decl(mappedTypes2.ts, 83, 9))
 >width : Symbol(width, Decl(mappedTypes2.ts, 36, 17))
->set : Symbol(set, Decl(mappedTypes2.ts, 12, 13))
+>set : Symbol(Proxy.set, Decl(mappedTypes2.ts, 12, 13))
 }
 
 function f6(shape: DeepReadonly<Shape>) {
diff --git a/tests/baselines/reference/mappedTypes4.symbols b/tests/baselines/reference/mappedTypes4.symbols
index 487f91c214e7b..8f15dd32219ff 100644
--- a/tests/baselines/reference/mappedTypes4.symbols
+++ b/tests/baselines/reference/mappedTypes4.symbols
@@ -54,15 +54,15 @@ function boxify<T>(obj: T): Boxified<T> {
 
 type A = { a: string };
 >A : Symbol(A, Decl(mappedTypes4.ts, 16, 1))
->a : Symbol(a, Decl(mappedTypes4.ts, 18, 10))
+>a : Symbol(A.a, Decl(mappedTypes4.ts, 18, 10))
 
 type B = { b: string };
 >B : Symbol(B, Decl(mappedTypes4.ts, 18, 23))
->b : Symbol(b, Decl(mappedTypes4.ts, 19, 10))
+>b : Symbol(B.b, Decl(mappedTypes4.ts, 19, 10))
 
 type C = { c: string };
 >C : Symbol(C, Decl(mappedTypes4.ts, 19, 23))
->c : Symbol(c, Decl(mappedTypes4.ts, 20, 10))
+>c : Symbol(C.c, Decl(mappedTypes4.ts, 20, 10))
 
 function f1(x: A | B | C | undefined) {
 >f1 : Symbol(f1, Decl(mappedTypes4.ts, 20, 23))
@@ -158,15 +158,15 @@ type Foo = {
 >Foo : Symbol(Foo, Decl(mappedTypes4.ts, 43, 2))
 
     x: number;
->x : Symbol(x, Decl(mappedTypes4.ts, 45, 12))
+>x : Symbol(Foo.x, Decl(mappedTypes4.ts, 45, 12))
 
     y: { a: string, b: number };
->y : Symbol(y, Decl(mappedTypes4.ts, 46, 14))
+>y : Symbol(Foo.y, Decl(mappedTypes4.ts, 46, 14))
 >a : Symbol(a, Decl(mappedTypes4.ts, 47, 8))
 >b : Symbol(b, Decl(mappedTypes4.ts, 47, 19))
 
     z: boolean;
->z : Symbol(z, Decl(mappedTypes4.ts, 47, 32))
+>z : Symbol(Foo.z, Decl(mappedTypes4.ts, 47, 32))
 
 };
 
@@ -174,15 +174,15 @@ type DeepReadonlyFoo = {
 >DeepReadonlyFoo : Symbol(DeepReadonlyFoo, Decl(mappedTypes4.ts, 49, 2))
 
     readonly x: number;
->x : Symbol(x, Decl(mappedTypes4.ts, 51, 24))
+>x : Symbol(DeepReadonlyFoo.x, Decl(mappedTypes4.ts, 51, 24))
 
     readonly y: { readonly a: string, readonly b: number };
->y : Symbol(y, Decl(mappedTypes4.ts, 52, 23))
+>y : Symbol(DeepReadonlyFoo.y, Decl(mappedTypes4.ts, 52, 23))
 >a : Symbol(a, Decl(mappedTypes4.ts, 53, 17))
 >b : Symbol(b, Decl(mappedTypes4.ts, 53, 37))
 
     readonly z: boolean;
->z : Symbol(z, Decl(mappedTypes4.ts, 53, 59))
+>z : Symbol(DeepReadonlyFoo.z, Decl(mappedTypes4.ts, 53, 59))
 
 };
 
@@ -199,7 +199,7 @@ var x1: DeepReadonlyFoo;
 
 type Z = { a: number };
 >Z : Symbol(Z, Decl(mappedTypes4.ts, 58, 24))
->a : Symbol(a, Decl(mappedTypes4.ts, 62, 10))
+>a : Symbol(Z.a, Decl(mappedTypes4.ts, 62, 10))
 
 type Clone<T> = {
 >Clone : Symbol(Clone, Decl(mappedTypes4.ts, 62, 23))
diff --git a/tests/baselines/reference/mappedTypes5.symbols b/tests/baselines/reference/mappedTypes5.symbols
index edbd1ae503135..04ec4ffa9cb32 100644
--- a/tests/baselines/reference/mappedTypes5.symbols
+++ b/tests/baselines/reference/mappedTypes5.symbols
@@ -138,13 +138,13 @@ type Args1<T extends State> = {
 >State : Symbol(State, Decl(mappedTypes5.ts, 17, 1))
 
     readonly previous: Readonly<Partial<T>>;
->previous : Symbol(previous, Decl(mappedTypes5.ts, 25, 31))
+>previous : Symbol(Args1.previous, Decl(mappedTypes5.ts, 25, 31))
 >Readonly : Symbol(Readonly, Decl(lib.es5.d.ts, --, --))
 >Partial : Symbol(Partial, Decl(lib.es5.d.ts, --, --))
 >T : Symbol(T, Decl(mappedTypes5.ts, 25, 11))
 
     readonly current: Readonly<Partial<T>>;
->current : Symbol(current, Decl(mappedTypes5.ts, 26, 44))
+>current : Symbol(Args1.current, Decl(mappedTypes5.ts, 26, 44))
 >Readonly : Symbol(Readonly, Decl(lib.es5.d.ts, --, --))
 >Partial : Symbol(Partial, Decl(lib.es5.d.ts, --, --))
 >T : Symbol(T, Decl(mappedTypes5.ts, 25, 11))
@@ -157,13 +157,13 @@ type Args2<T extends State> = {
 >State : Symbol(State, Decl(mappedTypes5.ts, 17, 1))
 
     readonly previous: Partial<Readonly<T>>;
->previous : Symbol(previous, Decl(mappedTypes5.ts, 30, 31))
+>previous : Symbol(Args2.previous, Decl(mappedTypes5.ts, 30, 31))
 >Partial : Symbol(Partial, Decl(lib.es5.d.ts, --, --))
 >Readonly : Symbol(Readonly, Decl(lib.es5.d.ts, --, --))
 >T : Symbol(T, Decl(mappedTypes5.ts, 30, 11))
 
     readonly current: Partial<Readonly<T>>;
->current : Symbol(current, Decl(mappedTypes5.ts, 31, 44))
+>current : Symbol(Args2.current, Decl(mappedTypes5.ts, 31, 44))
 >Partial : Symbol(Partial, Decl(lib.es5.d.ts, --, --))
 >Readonly : Symbol(Readonly, Decl(lib.es5.d.ts, --, --))
 >T : Symbol(T, Decl(mappedTypes5.ts, 30, 11))
@@ -208,20 +208,20 @@ function doit<T extends State>() {
 
 type State2 = { foo: number, bar: string };
 >State2 : Symbol(State2, Decl(mappedTypes5.ts, 40, 1))
->foo : Symbol(foo, Decl(mappedTypes5.ts, 42, 15))
->bar : Symbol(bar, Decl(mappedTypes5.ts, 42, 28))
+>foo : Symbol(State2.foo, Decl(mappedTypes5.ts, 42, 15))
+>bar : Symbol(State2.bar, Decl(mappedTypes5.ts, 42, 28))
 
 type Args3 = {
 >Args3 : Symbol(Args3, Decl(mappedTypes5.ts, 42, 43))
 
     readonly previous: Readonly<Partial<State2>>;
->previous : Symbol(previous, Decl(mappedTypes5.ts, 44, 14))
+>previous : Symbol(Args3.previous, Decl(mappedTypes5.ts, 44, 14))
 >Readonly : Symbol(Readonly, Decl(lib.es5.d.ts, --, --))
 >Partial : Symbol(Partial, Decl(lib.es5.d.ts, --, --))
 >State2 : Symbol(State2, Decl(mappedTypes5.ts, 40, 1))
 
     readonly current: Readonly<Partial<State2>>;
->current : Symbol(current, Decl(mappedTypes5.ts, 45, 49))
+>current : Symbol(Args3.current, Decl(mappedTypes5.ts, 45, 49))
 >Readonly : Symbol(Readonly, Decl(lib.es5.d.ts, --, --))
 >Partial : Symbol(Partial, Decl(lib.es5.d.ts, --, --))
 >State2 : Symbol(State2, Decl(mappedTypes5.ts, 40, 1))
@@ -232,13 +232,13 @@ type Args4 = {
 >Args4 : Symbol(Args4, Decl(mappedTypes5.ts, 47, 2))
 
     readonly previous: Partial<Readonly<State2>>;
->previous : Symbol(previous, Decl(mappedTypes5.ts, 49, 14))
+>previous : Symbol(Args4.previous, Decl(mappedTypes5.ts, 49, 14))
 >Partial : Symbol(Partial, Decl(lib.es5.d.ts, --, --))
 >Readonly : Symbol(Readonly, Decl(lib.es5.d.ts, --, --))
 >State2 : Symbol(State2, Decl(mappedTypes5.ts, 40, 1))
 
     readonly current: Partial<Readonly<State2>>;
->current : Symbol(current, Decl(mappedTypes5.ts, 50, 49))
+>current : Symbol(Args4.current, Decl(mappedTypes5.ts, 50, 49))
 >Partial : Symbol(Partial, Decl(lib.es5.d.ts, --, --))
 >Readonly : Symbol(Readonly, Decl(lib.es5.d.ts, --, --))
 >State2 : Symbol(State2, Decl(mappedTypes5.ts, 40, 1))
diff --git a/tests/baselines/reference/mappedTypes6.symbols b/tests/baselines/reference/mappedTypes6.symbols
index 4e03fe359b7bb..cdf06552805a8 100644
--- a/tests/baselines/reference/mappedTypes6.symbols
+++ b/tests/baselines/reference/mappedTypes6.symbols
@@ -358,16 +358,16 @@ type Foo = {
 >Foo : Symbol(Foo, Decl(mappedTypes6.ts, 75, 1))
 
     a: number;
->a : Symbol(a, Decl(mappedTypes6.ts, 77, 12))
+>a : Symbol(Foo.a, Decl(mappedTypes6.ts, 77, 12))
 
     b: number | undefined;
->b : Symbol(b, Decl(mappedTypes6.ts, 78, 14))
+>b : Symbol(Foo.b, Decl(mappedTypes6.ts, 78, 14))
 
     c?: number;
->c : Symbol(c, Decl(mappedTypes6.ts, 79, 26))
+>c : Symbol(Foo.c, Decl(mappedTypes6.ts, 79, 26))
 
     d?: number | undefined;
->d : Symbol(d, Decl(mappedTypes6.ts, 80, 15))
+>d : Symbol(Foo.d, Decl(mappedTypes6.ts, 80, 15))
 }
 
 declare let x1: Foo;
@@ -375,24 +375,24 @@ declare let x1: Foo;
 >Foo : Symbol(Foo, Decl(mappedTypes6.ts, 75, 1))
 
 x1.a;  // number
->x1.a : Symbol(a, Decl(mappedTypes6.ts, 77, 12))
+>x1.a : Symbol(Foo.a, Decl(mappedTypes6.ts, 77, 12))
 >x1 : Symbol(x1, Decl(mappedTypes6.ts, 84, 11))
->a : Symbol(a, Decl(mappedTypes6.ts, 77, 12))
+>a : Symbol(Foo.a, Decl(mappedTypes6.ts, 77, 12))
 
 x1.b;  // number | undefined
->x1.b : Symbol(b, Decl(mappedTypes6.ts, 78, 14))
+>x1.b : Symbol(Foo.b, Decl(mappedTypes6.ts, 78, 14))
 >x1 : Symbol(x1, Decl(mappedTypes6.ts, 84, 11))
->b : Symbol(b, Decl(mappedTypes6.ts, 78, 14))
+>b : Symbol(Foo.b, Decl(mappedTypes6.ts, 78, 14))
 
 x1.c;  // number | undefined
->x1.c : Symbol(c, Decl(mappedTypes6.ts, 79, 26))
+>x1.c : Symbol(Foo.c, Decl(mappedTypes6.ts, 79, 26))
 >x1 : Symbol(x1, Decl(mappedTypes6.ts, 84, 11))
->c : Symbol(c, Decl(mappedTypes6.ts, 79, 26))
+>c : Symbol(Foo.c, Decl(mappedTypes6.ts, 79, 26))
 
 x1.d;  // number | undefined
->x1.d : Symbol(d, Decl(mappedTypes6.ts, 80, 15))
+>x1.d : Symbol(Foo.d, Decl(mappedTypes6.ts, 80, 15))
 >x1 : Symbol(x1, Decl(mappedTypes6.ts, 84, 11))
->d : Symbol(d, Decl(mappedTypes6.ts, 80, 15))
+>d : Symbol(Foo.d, Decl(mappedTypes6.ts, 80, 15))
 
 x1 = { a: 1 };  // Error
 >x1 : Symbol(x1, Decl(mappedTypes6.ts, 84, 11))
@@ -422,24 +422,24 @@ declare let x2: Required<Foo>;
 >Foo : Symbol(Foo, Decl(mappedTypes6.ts, 75, 1))
 
 x1.a;  // number
->x1.a : Symbol(a, Decl(mappedTypes6.ts, 77, 12))
+>x1.a : Symbol(Foo.a, Decl(mappedTypes6.ts, 77, 12))
 >x1 : Symbol(x1, Decl(mappedTypes6.ts, 84, 11))
->a : Symbol(a, Decl(mappedTypes6.ts, 77, 12))
+>a : Symbol(Foo.a, Decl(mappedTypes6.ts, 77, 12))
 
 x1.b;  // number | undefined
->x1.b : Symbol(b, Decl(mappedTypes6.ts, 78, 14))
+>x1.b : Symbol(Foo.b, Decl(mappedTypes6.ts, 78, 14))
 >x1 : Symbol(x1, Decl(mappedTypes6.ts, 84, 11))
->b : Symbol(b, Decl(mappedTypes6.ts, 78, 14))
+>b : Symbol(Foo.b, Decl(mappedTypes6.ts, 78, 14))
 
 x1.c;  // number
->x1.c : Symbol(c, Decl(mappedTypes6.ts, 79, 26))
+>x1.c : Symbol(Foo.c, Decl(mappedTypes6.ts, 79, 26))
 >x1 : Symbol(x1, Decl(mappedTypes6.ts, 84, 11))
->c : Symbol(c, Decl(mappedTypes6.ts, 79, 26))
+>c : Symbol(Foo.c, Decl(mappedTypes6.ts, 79, 26))
 
 x1.d;  // number
->x1.d : Symbol(d, Decl(mappedTypes6.ts, 80, 15))
+>x1.d : Symbol(Foo.d, Decl(mappedTypes6.ts, 80, 15))
 >x1 : Symbol(x1, Decl(mappedTypes6.ts, 84, 11))
->d : Symbol(d, Decl(mappedTypes6.ts, 80, 15))
+>d : Symbol(Foo.d, Decl(mappedTypes6.ts, 80, 15))
 
 x2 = { a: 1 };  // Error
 >x2 : Symbol(x2, Decl(mappedTypes6.ts, 96, 11))
@@ -467,10 +467,10 @@ type Bar = {
 >Bar : Symbol(Bar, Decl(mappedTypes6.ts, 106, 32))
 
     a: number;
->a : Symbol(a, Decl(mappedTypes6.ts, 108, 12))
+>a : Symbol(Bar.a, Decl(mappedTypes6.ts, 108, 12))
 
     readonly b: number;
->b : Symbol(b, Decl(mappedTypes6.ts, 109, 14))
+>b : Symbol(Bar.b, Decl(mappedTypes6.ts, 109, 14))
 }
 
 declare let x3: Bar;
@@ -478,14 +478,14 @@ declare let x3: Bar;
 >Bar : Symbol(Bar, Decl(mappedTypes6.ts, 106, 32))
 
 x3.a = 1;
->x3.a : Symbol(a, Decl(mappedTypes6.ts, 108, 12))
+>x3.a : Symbol(Bar.a, Decl(mappedTypes6.ts, 108, 12))
 >x3 : Symbol(x3, Decl(mappedTypes6.ts, 113, 11))
->a : Symbol(a, Decl(mappedTypes6.ts, 108, 12))
+>a : Symbol(Bar.a, Decl(mappedTypes6.ts, 108, 12))
 
 x3.b = 1;  // Error
->x3.b : Symbol(b, Decl(mappedTypes6.ts, 109, 14))
+>x3.b : Symbol(Bar.b, Decl(mappedTypes6.ts, 109, 14))
 >x3 : Symbol(x3, Decl(mappedTypes6.ts, 113, 11))
->b : Symbol(b, Decl(mappedTypes6.ts, 109, 14))
+>b : Symbol(Bar.b, Decl(mappedTypes6.ts, 109, 14))
 
 declare let x4: Readonly<Bar>;
 >x4 : Symbol(x4, Decl(mappedTypes6.ts, 117, 11))
diff --git a/tests/baselines/reference/mappedTypesArraysTuples.symbols b/tests/baselines/reference/mappedTypesArraysTuples.symbols
index ac3ec26462200..f51bfe05d4070 100644
--- a/tests/baselines/reference/mappedTypesArraysTuples.symbols
+++ b/tests/baselines/reference/mappedTypesArraysTuples.symbols
@@ -2,7 +2,7 @@
 type Box<T> = { value: T };
 >Box : Symbol(Box, Decl(mappedTypesArraysTuples.ts, 0, 0))
 >T : Symbol(T, Decl(mappedTypesArraysTuples.ts, 0, 9))
->value : Symbol(value, Decl(mappedTypesArraysTuples.ts, 0, 15))
+>value : Symbol(Box.value, Decl(mappedTypesArraysTuples.ts, 0, 15))
 >T : Symbol(T, Decl(mappedTypesArraysTuples.ts, 0, 9))
 
 type Boxified<T> = { [P in keyof T]: Box<T[P]> };
@@ -92,11 +92,11 @@ type T31 = Partial<Boxified<string[]>>;
 
 type A = { a: string };
 >A : Symbol(A, Decl(mappedTypesArraysTuples.ts, 22, 39))
->a : Symbol(a, Decl(mappedTypesArraysTuples.ts, 24, 10))
+>a : Symbol(A.a, Decl(mappedTypesArraysTuples.ts, 24, 10))
 
 type B = { b: string };
 >B : Symbol(B, Decl(mappedTypesArraysTuples.ts, 24, 23))
->b : Symbol(b, Decl(mappedTypesArraysTuples.ts, 25, 10))
+>b : Symbol(B.b, Decl(mappedTypesArraysTuples.ts, 25, 10))
 
 type T40 = Boxified<A | A[] | ReadonlyArray<A> | [A, B] | string | string[]>;
 >T40 : Symbol(T40, Decl(mappedTypesArraysTuples.ts, 25, 23))
diff --git a/tests/baselines/reference/mixinOverMappedTypeNoCrash.symbols b/tests/baselines/reference/mixinOverMappedTypeNoCrash.symbols
index 01fff6cbf4fe0..66bce2fb0984a 100644
--- a/tests/baselines/reference/mixinOverMappedTypeNoCrash.symbols
+++ b/tests/baselines/reference/mixinOverMappedTypeNoCrash.symbols
@@ -19,7 +19,7 @@ type InstanceInterface<I> = {
 >I : Symbol(I, Decl(mixinOverMappedTypeNoCrash.ts, 4, 23))
 
     prototype: I
->prototype : Symbol(prototype, Decl(mixinOverMappedTypeNoCrash.ts, 5, 26))
+>prototype : Symbol(InstanceInterface.prototype, Decl(mixinOverMappedTypeNoCrash.ts, 5, 26))
 >I : Symbol(I, Decl(mixinOverMappedTypeNoCrash.ts, 4, 23))
 }
 
diff --git a/tests/baselines/reference/namespaceDisambiguationInUnion.symbols b/tests/baselines/reference/namespaceDisambiguationInUnion.symbols
index 7f2a6dfb69aa5..41634ae06f127 100644
--- a/tests/baselines/reference/namespaceDisambiguationInUnion.symbols
+++ b/tests/baselines/reference/namespaceDisambiguationInUnion.symbols
@@ -4,7 +4,7 @@ namespace Foo {
 
   export type Yep = { type: "foo.yep" };
 >Yep : Symbol(Yep, Decl(namespaceDisambiguationInUnion.ts, 0, 15))
->type : Symbol(type, Decl(namespaceDisambiguationInUnion.ts, 1, 21))
+>type : Symbol(Yep.type, Decl(namespaceDisambiguationInUnion.ts, 1, 21))
 }
 
 namespace Bar {
@@ -12,7 +12,7 @@ namespace Bar {
 
   export type Yep = { type: "bar.yep" };
 >Yep : Symbol(Yep, Decl(namespaceDisambiguationInUnion.ts, 4, 15))
->type : Symbol(type, Decl(namespaceDisambiguationInUnion.ts, 5, 21))
+>type : Symbol(Yep.type, Decl(namespaceDisambiguationInUnion.ts, 5, 21))
 }
 
 const x = { type: "wat.nup" };
diff --git a/tests/baselines/reference/namespaceMergedWithImportAliasNoCrash.symbols b/tests/baselines/reference/namespaceMergedWithImportAliasNoCrash.symbols
index bb522af48fc28..25e67066c84ff 100644
--- a/tests/baselines/reference/namespaceMergedWithImportAliasNoCrash.symbols
+++ b/tests/baselines/reference/namespaceMergedWithImportAliasNoCrash.symbols
@@ -4,7 +4,7 @@ export namespace Library {
 
     export type Bar = { a: number };
 >Bar : Symbol(Bar, Decl(file1.ts, 0, 26))
->a : Symbol(a, Decl(file1.ts, 1, 23))
+>a : Symbol(Bar.a, Decl(file1.ts, 1, 23))
 }
 var x: Library.Bar; // should work
 >x : Symbol(x, Decl(file1.ts, 3, 3))
diff --git a/tests/baselines/reference/narrowingByTypeofInSwitch.symbols b/tests/baselines/reference/narrowingByTypeofInSwitch.symbols
index 0fae3d9f31cc8..d4d419919520e 100644
--- a/tests/baselines/reference/narrowingByTypeofInSwitch.symbols
+++ b/tests/baselines/reference/narrowingByTypeofInSwitch.symbols
@@ -362,8 +362,8 @@ type L = (x: number) => string;
 
 type R = { x: string, y: number }
 >R : Symbol(R, Decl(narrowingByTypeofInSwitch.ts, 134, 31))
->x : Symbol(x, Decl(narrowingByTypeofInSwitch.ts, 135, 10))
->y : Symbol(y, Decl(narrowingByTypeofInSwitch.ts, 135, 21))
+>x : Symbol(R.x, Decl(narrowingByTypeofInSwitch.ts, 135, 10))
+>y : Symbol(R.y, Decl(narrowingByTypeofInSwitch.ts, 135, 21))
 
 function exhaustiveChecks(x: number | string | L | R): string {
 >exhaustiveChecks : Symbol(exhaustiveChecks, Decl(narrowingByTypeofInSwitch.ts, 135, 33))
@@ -386,9 +386,9 @@ function exhaustiveChecks(x: number | string | L | R): string {
 >x : Symbol(x, Decl(narrowingByTypeofInSwitch.ts, 137, 26))
 
         case 'object': return x.x;
->x.x : Symbol(x, Decl(narrowingByTypeofInSwitch.ts, 135, 10))
+>x.x : Symbol(R.x, Decl(narrowingByTypeofInSwitch.ts, 135, 10))
 >x : Symbol(x, Decl(narrowingByTypeofInSwitch.ts, 137, 26))
->x : Symbol(x, Decl(narrowingByTypeofInSwitch.ts, 135, 10))
+>x : Symbol(R.x, Decl(narrowingByTypeofInSwitch.ts, 135, 10))
     }
 }
 
@@ -416,10 +416,10 @@ function exhaustiveChecksGenerics<T extends L | R | number | string>(x: T): stri
 >L : Symbol(L, Decl(narrowingByTypeofInSwitch.ts, 132, 1))
 
         case 'object': return (x as R).x;            // Can't narrow generic
->(x as R).x : Symbol(x, Decl(narrowingByTypeofInSwitch.ts, 135, 10))
+>(x as R).x : Symbol(R.x, Decl(narrowingByTypeofInSwitch.ts, 135, 10))
 >x : Symbol(x, Decl(narrowingByTypeofInSwitch.ts, 146, 69))
 >R : Symbol(R, Decl(narrowingByTypeofInSwitch.ts, 134, 31))
->x : Symbol(x, Decl(narrowingByTypeofInSwitch.ts, 135, 10))
+>x : Symbol(R.x, Decl(narrowingByTypeofInSwitch.ts, 135, 10))
     }
 }
 
@@ -444,9 +444,9 @@ function multipleGeneric<X extends L, Y extends R>(xy: X | Y): [X, string] | [Y,
 
         case 'object': return [xy, xy.y];
 >xy : Symbol(xy, Decl(narrowingByTypeofInSwitch.ts, 155, 51))
->xy.y : Symbol(y, Decl(narrowingByTypeofInSwitch.ts, 135, 21))
+>xy.y : Symbol(R.y, Decl(narrowingByTypeofInSwitch.ts, 135, 21))
 >xy : Symbol(xy, Decl(narrowingByTypeofInSwitch.ts, 155, 51))
->y : Symbol(y, Decl(narrowingByTypeofInSwitch.ts, 135, 21))
+>y : Symbol(R.y, Decl(narrowingByTypeofInSwitch.ts, 135, 21))
 
         default: return assertNever(xy);
 >assertNever : Symbol(assertNever, Decl(narrowingByTypeofInSwitch.ts, 0, 0))
@@ -499,9 +499,9 @@ function multipleGenericExhaustive<X extends L, Y extends R>(xy: X | Y): [X, str
 
         case 'object': return [xy, xy.y];
 >xy : Symbol(xy, Decl(narrowingByTypeofInSwitch.ts, 171, 61))
->xy.y : Symbol(y, Decl(narrowingByTypeofInSwitch.ts, 135, 21))
+>xy.y : Symbol(R.y, Decl(narrowingByTypeofInSwitch.ts, 135, 21))
 >xy : Symbol(xy, Decl(narrowingByTypeofInSwitch.ts, 171, 61))
->y : Symbol(y, Decl(narrowingByTypeofInSwitch.ts, 135, 21))
+>y : Symbol(R.y, Decl(narrowingByTypeofInSwitch.ts, 135, 21))
 
         case 'function': return [xy, xy(42)];
 >xy : Symbol(xy, Decl(narrowingByTypeofInSwitch.ts, 171, 61))
diff --git a/tests/baselines/reference/narrowingOfQualifiedNames.symbols b/tests/baselines/reference/narrowingOfQualifiedNames.symbols
index f7a4e26d71385..0508d1559cc89 100644
--- a/tests/baselines/reference/narrowingOfQualifiedNames.symbols
+++ b/tests/baselines/reference/narrowingOfQualifiedNames.symbols
@@ -86,20 +86,20 @@ function init2(foo: DeepOptional) {
 
         type B = typeof foo.a.b;
 >B : Symbol(B, Decl(narrowingOfQualifiedNames.ts, 30, 30))
->foo.a.b : Symbol(b, Decl(narrowingOfQualifiedNames.ts, 21, 9))
+>foo.a.b : Symbol(A.b, Decl(narrowingOfQualifiedNames.ts, 21, 9))
 >foo.a : Symbol(DeepOptional.a, Decl(narrowingOfQualifiedNames.ts, 20, 24))
 >foo : Symbol(foo, Decl(narrowingOfQualifiedNames.ts, 28, 15))
 >a : Symbol(DeepOptional.a, Decl(narrowingOfQualifiedNames.ts, 20, 24))
->b : Symbol(b, Decl(narrowingOfQualifiedNames.ts, 21, 9))
+>b : Symbol(A.b, Decl(narrowingOfQualifiedNames.ts, 21, 9))
 
         type C = typeof foo.a.b.c;
 >C : Symbol(C, Decl(narrowingOfQualifiedNames.ts, 31, 32))
 >foo.a.b.c : Symbol(c, Decl(narrowingOfQualifiedNames.ts, 22, 13))
->foo.a.b : Symbol(b, Decl(narrowingOfQualifiedNames.ts, 21, 9))
+>foo.a.b : Symbol(A.b, Decl(narrowingOfQualifiedNames.ts, 21, 9))
 >foo.a : Symbol(DeepOptional.a, Decl(narrowingOfQualifiedNames.ts, 20, 24))
 >foo : Symbol(foo, Decl(narrowingOfQualifiedNames.ts, 28, 15))
 >a : Symbol(DeepOptional.a, Decl(narrowingOfQualifiedNames.ts, 20, 24))
->b : Symbol(b, Decl(narrowingOfQualifiedNames.ts, 21, 9))
+>b : Symbol(A.b, Decl(narrowingOfQualifiedNames.ts, 21, 9))
 >c : Symbol(c, Decl(narrowingOfQualifiedNames.ts, 22, 13))
 
         for(const _ of [1]) {
@@ -113,28 +113,28 @@ function init2(foo: DeepOptional) {
 
             type B = typeof foo.a.b;
 >B : Symbol(B, Decl(narrowingOfQualifiedNames.ts, 35, 34))
->foo.a.b : Symbol(b, Decl(narrowingOfQualifiedNames.ts, 21, 9))
+>foo.a.b : Symbol(A.b, Decl(narrowingOfQualifiedNames.ts, 21, 9))
 >foo.a : Symbol(DeepOptional.a, Decl(narrowingOfQualifiedNames.ts, 20, 24))
 >foo : Symbol(foo, Decl(narrowingOfQualifiedNames.ts, 28, 15))
 >a : Symbol(DeepOptional.a, Decl(narrowingOfQualifiedNames.ts, 20, 24))
->b : Symbol(b, Decl(narrowingOfQualifiedNames.ts, 21, 9))
+>b : Symbol(A.b, Decl(narrowingOfQualifiedNames.ts, 21, 9))
 
             type C = typeof foo.a.b.c;
 >C : Symbol(C, Decl(narrowingOfQualifiedNames.ts, 36, 36))
 >foo.a.b.c : Symbol(c, Decl(narrowingOfQualifiedNames.ts, 22, 13))
->foo.a.b : Symbol(b, Decl(narrowingOfQualifiedNames.ts, 21, 9))
+>foo.a.b : Symbol(A.b, Decl(narrowingOfQualifiedNames.ts, 21, 9))
 >foo.a : Symbol(DeepOptional.a, Decl(narrowingOfQualifiedNames.ts, 20, 24))
 >foo : Symbol(foo, Decl(narrowingOfQualifiedNames.ts, 28, 15))
 >a : Symbol(DeepOptional.a, Decl(narrowingOfQualifiedNames.ts, 20, 24))
->b : Symbol(b, Decl(narrowingOfQualifiedNames.ts, 21, 9))
+>b : Symbol(A.b, Decl(narrowingOfQualifiedNames.ts, 21, 9))
 >c : Symbol(c, Decl(narrowingOfQualifiedNames.ts, 22, 13))
 
             if (foo.a.b) {
->foo.a.b : Symbol(b, Decl(narrowingOfQualifiedNames.ts, 21, 9))
+>foo.a.b : Symbol(A.b, Decl(narrowingOfQualifiedNames.ts, 21, 9))
 >foo.a : Symbol(DeepOptional.a, Decl(narrowingOfQualifiedNames.ts, 20, 24))
 >foo : Symbol(foo, Decl(narrowingOfQualifiedNames.ts, 28, 15))
 >a : Symbol(DeepOptional.a, Decl(narrowingOfQualifiedNames.ts, 20, 24))
->b : Symbol(b, Decl(narrowingOfQualifiedNames.ts, 21, 9))
+>b : Symbol(A.b, Decl(narrowingOfQualifiedNames.ts, 21, 9))
 
                 type A = typeof foo.a;
 >A : Symbol(A, Decl(narrowingOfQualifiedNames.ts, 39, 26))
@@ -144,21 +144,21 @@ function init2(foo: DeepOptional) {
 
                 type B = typeof foo.a.b;
 >B : Symbol(B, Decl(narrowingOfQualifiedNames.ts, 40, 38))
->foo.a.b : Symbol(b, Decl(narrowingOfQualifiedNames.ts, 21, 9))
+>foo.a.b : Symbol(A.b, Decl(narrowingOfQualifiedNames.ts, 21, 9))
 >foo.a : Symbol(DeepOptional.a, Decl(narrowingOfQualifiedNames.ts, 20, 24))
 >foo : Symbol(foo, Decl(narrowingOfQualifiedNames.ts, 28, 15))
 >a : Symbol(DeepOptional.a, Decl(narrowingOfQualifiedNames.ts, 20, 24))
->b : Symbol(b, Decl(narrowingOfQualifiedNames.ts, 21, 9))
+>b : Symbol(A.b, Decl(narrowingOfQualifiedNames.ts, 21, 9))
 
                 type C = typeof foo.a.b.c;
 >C : Symbol(C, Decl(narrowingOfQualifiedNames.ts, 41, 40))
->foo.a.b.c : Symbol(c, Decl(narrowingOfQualifiedNames.ts, 22, 13))
->foo.a.b : Symbol(b, Decl(narrowingOfQualifiedNames.ts, 21, 9))
+>foo.a.b.c : Symbol(B.c, Decl(narrowingOfQualifiedNames.ts, 22, 13))
+>foo.a.b : Symbol(A.b, Decl(narrowingOfQualifiedNames.ts, 21, 9))
 >foo.a : Symbol(DeepOptional.a, Decl(narrowingOfQualifiedNames.ts, 20, 24))
 >foo : Symbol(foo, Decl(narrowingOfQualifiedNames.ts, 28, 15))
 >a : Symbol(DeepOptional.a, Decl(narrowingOfQualifiedNames.ts, 20, 24))
->b : Symbol(b, Decl(narrowingOfQualifiedNames.ts, 21, 9))
->c : Symbol(c, Decl(narrowingOfQualifiedNames.ts, 22, 13))
+>b : Symbol(A.b, Decl(narrowingOfQualifiedNames.ts, 21, 9))
+>c : Symbol(B.c, Decl(narrowingOfQualifiedNames.ts, 22, 13))
 
                 for(const _ of [1]) {
 >_ : Symbol(_, Decl(narrowingOfQualifiedNames.ts, 44, 25))
@@ -171,30 +171,30 @@ function init2(foo: DeepOptional) {
 
                     type B = typeof foo.a.b;
 >B : Symbol(B, Decl(narrowingOfQualifiedNames.ts, 45, 42))
->foo.a.b : Symbol(b, Decl(narrowingOfQualifiedNames.ts, 21, 9))
+>foo.a.b : Symbol(A.b, Decl(narrowingOfQualifiedNames.ts, 21, 9))
 >foo.a : Symbol(DeepOptional.a, Decl(narrowingOfQualifiedNames.ts, 20, 24))
 >foo : Symbol(foo, Decl(narrowingOfQualifiedNames.ts, 28, 15))
 >a : Symbol(DeepOptional.a, Decl(narrowingOfQualifiedNames.ts, 20, 24))
->b : Symbol(b, Decl(narrowingOfQualifiedNames.ts, 21, 9))
+>b : Symbol(A.b, Decl(narrowingOfQualifiedNames.ts, 21, 9))
 
                     type C = typeof foo.a.b.c;
 >C : Symbol(C, Decl(narrowingOfQualifiedNames.ts, 46, 44))
->foo.a.b.c : Symbol(c, Decl(narrowingOfQualifiedNames.ts, 22, 13))
->foo.a.b : Symbol(b, Decl(narrowingOfQualifiedNames.ts, 21, 9))
+>foo.a.b.c : Symbol(B.c, Decl(narrowingOfQualifiedNames.ts, 22, 13))
+>foo.a.b : Symbol(A.b, Decl(narrowingOfQualifiedNames.ts, 21, 9))
 >foo.a : Symbol(DeepOptional.a, Decl(narrowingOfQualifiedNames.ts, 20, 24))
 >foo : Symbol(foo, Decl(narrowingOfQualifiedNames.ts, 28, 15))
 >a : Symbol(DeepOptional.a, Decl(narrowingOfQualifiedNames.ts, 20, 24))
->b : Symbol(b, Decl(narrowingOfQualifiedNames.ts, 21, 9))
->c : Symbol(c, Decl(narrowingOfQualifiedNames.ts, 22, 13))
+>b : Symbol(A.b, Decl(narrowingOfQualifiedNames.ts, 21, 9))
+>c : Symbol(B.c, Decl(narrowingOfQualifiedNames.ts, 22, 13))
 
                     if (foo.a.b.c) {
->foo.a.b.c : Symbol(c, Decl(narrowingOfQualifiedNames.ts, 22, 13))
->foo.a.b : Symbol(b, Decl(narrowingOfQualifiedNames.ts, 21, 9))
+>foo.a.b.c : Symbol(B.c, Decl(narrowingOfQualifiedNames.ts, 22, 13))
+>foo.a.b : Symbol(A.b, Decl(narrowingOfQualifiedNames.ts, 21, 9))
 >foo.a : Symbol(DeepOptional.a, Decl(narrowingOfQualifiedNames.ts, 20, 24))
 >foo : Symbol(foo, Decl(narrowingOfQualifiedNames.ts, 28, 15))
 >a : Symbol(DeepOptional.a, Decl(narrowingOfQualifiedNames.ts, 20, 24))
->b : Symbol(b, Decl(narrowingOfQualifiedNames.ts, 21, 9))
->c : Symbol(c, Decl(narrowingOfQualifiedNames.ts, 22, 13))
+>b : Symbol(A.b, Decl(narrowingOfQualifiedNames.ts, 21, 9))
+>c : Symbol(B.c, Decl(narrowingOfQualifiedNames.ts, 22, 13))
 
                         type A = typeof foo.a;
 >A : Symbol(A, Decl(narrowingOfQualifiedNames.ts, 49, 36))
@@ -204,21 +204,21 @@ function init2(foo: DeepOptional) {
 
                         type B = typeof foo.a.b;
 >B : Symbol(B, Decl(narrowingOfQualifiedNames.ts, 50, 46))
->foo.a.b : Symbol(b, Decl(narrowingOfQualifiedNames.ts, 21, 9))
+>foo.a.b : Symbol(A.b, Decl(narrowingOfQualifiedNames.ts, 21, 9))
 >foo.a : Symbol(DeepOptional.a, Decl(narrowingOfQualifiedNames.ts, 20, 24))
 >foo : Symbol(foo, Decl(narrowingOfQualifiedNames.ts, 28, 15))
 >a : Symbol(DeepOptional.a, Decl(narrowingOfQualifiedNames.ts, 20, 24))
->b : Symbol(b, Decl(narrowingOfQualifiedNames.ts, 21, 9))
+>b : Symbol(A.b, Decl(narrowingOfQualifiedNames.ts, 21, 9))
 
                         type C = typeof foo.a.b.c;
 >C : Symbol(C, Decl(narrowingOfQualifiedNames.ts, 51, 48))
->foo.a.b.c : Symbol(c, Decl(narrowingOfQualifiedNames.ts, 22, 13))
->foo.a.b : Symbol(b, Decl(narrowingOfQualifiedNames.ts, 21, 9))
+>foo.a.b.c : Symbol(B.c, Decl(narrowingOfQualifiedNames.ts, 22, 13))
+>foo.a.b : Symbol(A.b, Decl(narrowingOfQualifiedNames.ts, 21, 9))
 >foo.a : Symbol(DeepOptional.a, Decl(narrowingOfQualifiedNames.ts, 20, 24))
 >foo : Symbol(foo, Decl(narrowingOfQualifiedNames.ts, 28, 15))
 >a : Symbol(DeepOptional.a, Decl(narrowingOfQualifiedNames.ts, 20, 24))
->b : Symbol(b, Decl(narrowingOfQualifiedNames.ts, 21, 9))
->c : Symbol(c, Decl(narrowingOfQualifiedNames.ts, 22, 13))
+>b : Symbol(A.b, Decl(narrowingOfQualifiedNames.ts, 21, 9))
+>c : Symbol(B.c, Decl(narrowingOfQualifiedNames.ts, 22, 13))
 
                         for(const _ of [1]) {
 >_ : Symbol(_, Decl(narrowingOfQualifiedNames.ts, 54, 33))
@@ -231,21 +231,21 @@ function init2(foo: DeepOptional) {
 
                             type B = typeof foo.a.b;
 >B : Symbol(B, Decl(narrowingOfQualifiedNames.ts, 55, 50))
->foo.a.b : Symbol(b, Decl(narrowingOfQualifiedNames.ts, 21, 9))
+>foo.a.b : Symbol(A.b, Decl(narrowingOfQualifiedNames.ts, 21, 9))
 >foo.a : Symbol(DeepOptional.a, Decl(narrowingOfQualifiedNames.ts, 20, 24))
 >foo : Symbol(foo, Decl(narrowingOfQualifiedNames.ts, 28, 15))
 >a : Symbol(DeepOptional.a, Decl(narrowingOfQualifiedNames.ts, 20, 24))
->b : Symbol(b, Decl(narrowingOfQualifiedNames.ts, 21, 9))
+>b : Symbol(A.b, Decl(narrowingOfQualifiedNames.ts, 21, 9))
 
                             type C = typeof foo.a.b.c;
 >C : Symbol(C, Decl(narrowingOfQualifiedNames.ts, 56, 52))
->foo.a.b.c : Symbol(c, Decl(narrowingOfQualifiedNames.ts, 22, 13))
->foo.a.b : Symbol(b, Decl(narrowingOfQualifiedNames.ts, 21, 9))
+>foo.a.b.c : Symbol(B.c, Decl(narrowingOfQualifiedNames.ts, 22, 13))
+>foo.a.b : Symbol(A.b, Decl(narrowingOfQualifiedNames.ts, 21, 9))
 >foo.a : Symbol(DeepOptional.a, Decl(narrowingOfQualifiedNames.ts, 20, 24))
 >foo : Symbol(foo, Decl(narrowingOfQualifiedNames.ts, 28, 15))
 >a : Symbol(DeepOptional.a, Decl(narrowingOfQualifiedNames.ts, 20, 24))
->b : Symbol(b, Decl(narrowingOfQualifiedNames.ts, 21, 9))
->c : Symbol(c, Decl(narrowingOfQualifiedNames.ts, 22, 13))
+>b : Symbol(A.b, Decl(narrowingOfQualifiedNames.ts, 21, 9))
+>c : Symbol(B.c, Decl(narrowingOfQualifiedNames.ts, 22, 13))
                         }
                     }
                 }
diff --git a/tests/baselines/reference/narrowingTypeofFunction.symbols b/tests/baselines/reference/narrowingTypeofFunction.symbols
index 21ce3c4435995..82659d924e33d 100644
--- a/tests/baselines/reference/narrowingTypeofFunction.symbols
+++ b/tests/baselines/reference/narrowingTypeofFunction.symbols
@@ -1,7 +1,7 @@
 === tests/cases/compiler/narrowingTypeofFunction.ts ===
 type Meta = { foo: string }
 >Meta : Symbol(Meta, Decl(narrowingTypeofFunction.ts, 0, 0))
->foo : Symbol(foo, Decl(narrowingTypeofFunction.ts, 0, 13))
+>foo : Symbol(Meta.foo, Decl(narrowingTypeofFunction.ts, 0, 13))
 
 interface F { (): string }
 >F : Symbol(F, Decl(narrowingTypeofFunction.ts, 0, 27))
diff --git a/tests/baselines/reference/neverReturningFunctions1.types b/tests/baselines/reference/neverReturningFunctions1.types
index c832fa660dd88..49ec260ad2053 100644
--- a/tests/baselines/reference/neverReturningFunctions1.types
+++ b/tests/baselines/reference/neverReturningFunctions1.types
@@ -1,6 +1,6 @@
 === tests/cases/conformance/controlFlow/neverReturningFunctions1.ts ===
 function fail(message?: string): never {
->fail : (message?: string | undefined) => never
+>fail : (message?: string) => never
 >message : string | undefined
 
     throw new Error(message);
@@ -62,9 +62,9 @@ function f03(x: string) {
 }
 
 function f11(x: string | undefined, fail: (message?: string) => never) {
->f11 : (x: string | undefined, fail: (message?: string | undefined) => never) => void
+>f11 : (x: string | undefined, fail: (message?: string) => never) => void
 >x : string | undefined
->fail : (message?: string | undefined) => never
+>fail : (message?: string) => never
 >message : string | undefined
 
     if (x === undefined) fail("undefined argument");
@@ -82,9 +82,9 @@ function f11(x: string | undefined, fail: (message?: string) => never) {
 }
 
 function f12(x: number, fail: (message?: string) => never): number {
->f12 : (x: number, fail: (message?: string | undefined) => never) => number
+>f12 : (x: number, fail: (message?: string) => never) => number
 >x : number
->fail : (message?: string | undefined) => never
+>fail : (message?: string) => never
 >message : string | undefined
 
     if (x >= 0) return x;
@@ -103,9 +103,9 @@ function f12(x: number, fail: (message?: string) => never): number {
 }
 
 function f13(x: string, fail: (message?: string) => never) {
->f13 : (x: string, fail: (message?: string | undefined) => never) => void
+>f13 : (x: string, fail: (message?: string) => never) => void
 >x : string
->fail : (message?: string | undefined) => never
+>fail : (message?: string) => never
 >message : string | undefined
 
     x;  // string
@@ -123,7 +123,7 @@ namespace Debug {
 >Debug : typeof Debug
 
     export declare function fail(message?: string): never;
->fail : (message?: string | undefined) => never
+>fail : (message?: string) => never
 >message : string | undefined
 }
 
@@ -208,7 +208,7 @@ class Test {
 >Test : Test
 
     fail(message?: string): never {
->fail : (message?: string | undefined) => never
+>fail : (message?: string) => never
 >message : string | undefined
 
         throw new Error(message);
@@ -496,7 +496,7 @@ export interface Component<T extends object = any> {
 >system : any
 
 	init(data?: T): void;
->init : (data?: T | undefined) => void
+>init : (data?: T) => void
 >data : T | undefined
 
 	pause(): void;
diff --git a/tests/baselines/reference/neverUnionIntersection.symbols b/tests/baselines/reference/neverUnionIntersection.symbols
index 0f56c1b3157ab..bedc5724e825b 100644
--- a/tests/baselines/reference/neverUnionIntersection.symbols
+++ b/tests/baselines/reference/neverUnionIntersection.symbols
@@ -31,7 +31,7 @@ type T10 = null & never;
 
 type T11 = { a: string } | never;
 >T11 : Symbol(T11, Decl(neverUnionIntersection.ts, 9, 24))
->a : Symbol(a, Decl(neverUnionIntersection.ts, 10, 12))
+>a : Symbol(T11.a, Decl(neverUnionIntersection.ts, 10, 12))
 
 type T12 = { a: string } & never;
 >T12 : Symbol(T12, Decl(neverUnionIntersection.ts, 10, 33))
diff --git a/tests/baselines/reference/noAsConstNameLookup.symbols b/tests/baselines/reference/noAsConstNameLookup.symbols
index fe5c8d34354cc..f3db0d6aab863 100644
--- a/tests/baselines/reference/noAsConstNameLookup.symbols
+++ b/tests/baselines/reference/noAsConstNameLookup.symbols
@@ -3,7 +3,7 @@
 
 type Store = { a: 123 }
 >Store : Symbol(Store, Decl(noAsConstNameLookup.ts, 0, 0))
->a : Symbol(a, Decl(noAsConstNameLookup.ts, 2, 14))
+>a : Symbol(Store.a, Decl(noAsConstNameLookup.ts, 2, 14))
 
 export type Cleaner = <W extends Store>(runner: FeatureRunner<W>) => Promise<any>
 >Cleaner : Symbol(Cleaner, Decl(noAsConstNameLookup.ts, 2, 23))
diff --git a/tests/baselines/reference/noCrashOnThisTypeUsage.types b/tests/baselines/reference/noCrashOnThisTypeUsage.types
index d0d3048cabf3b..6be36b9174ddd 100644
--- a/tests/baselines/reference/noCrashOnThisTypeUsage.types
+++ b/tests/baselines/reference/noCrashOnThisTypeUsage.types
@@ -5,7 +5,7 @@ interface IListenable {
 >null : null
 
     observe(handler: (change: any, oldValue?: any) => void, fireImmediately?: boolean): void
->observe : (handler: (change: any, oldValue?: any) => void, fireImmediately?: boolean | undefined) => void
+>observe : (handler: (change: any, oldValue?: any) => void, fireImmediately?: boolean) => void
 >handler : (change: any, oldValue?: any) => void
 >change : any
 >oldValue : any
@@ -62,7 +62,7 @@ export class ObservableValue<T> {
 >[] : never[]
 
     observe(handler: (change: any, oldValue?: any) => void, fireImmediately?: boolean) {}
->observe : (handler: (change: any, oldValue?: any) => void, fireImmediately?: boolean | undefined) => void
+>observe : (handler: (change: any, oldValue?: any) => void, fireImmediately?: boolean) => void
 >handler : (change: any, oldValue?: any) => void
 >change : any
 >oldValue : any
diff --git a/tests/baselines/reference/noErrorTruncation.symbols b/tests/baselines/reference/noErrorTruncation.symbols
index 75dd700063295..b48c4b70d1dc2 100644
--- a/tests/baselines/reference/noErrorTruncation.symbols
+++ b/tests/baselines/reference/noErrorTruncation.symbols
@@ -3,27 +3,27 @@
 
 type SomeLongOptionA = { someLongOptionA: string }
 >SomeLongOptionA : Symbol(SomeLongOptionA, Decl(noErrorTruncation.ts, 0, 0))
->someLongOptionA : Symbol(someLongOptionA, Decl(noErrorTruncation.ts, 2, 24))
+>someLongOptionA : Symbol(SomeLongOptionA.someLongOptionA, Decl(noErrorTruncation.ts, 2, 24))
 
 type SomeLongOptionB = { someLongOptionB: string }
 >SomeLongOptionB : Symbol(SomeLongOptionB, Decl(noErrorTruncation.ts, 2, 50))
->someLongOptionB : Symbol(someLongOptionB, Decl(noErrorTruncation.ts, 3, 24))
+>someLongOptionB : Symbol(SomeLongOptionB.someLongOptionB, Decl(noErrorTruncation.ts, 3, 24))
 
 type SomeLongOptionC = { someLongOptionC: string }
 >SomeLongOptionC : Symbol(SomeLongOptionC, Decl(noErrorTruncation.ts, 3, 50))
->someLongOptionC : Symbol(someLongOptionC, Decl(noErrorTruncation.ts, 4, 24))
+>someLongOptionC : Symbol(SomeLongOptionC.someLongOptionC, Decl(noErrorTruncation.ts, 4, 24))
 
 type SomeLongOptionD = { someLongOptionD: string }
 >SomeLongOptionD : Symbol(SomeLongOptionD, Decl(noErrorTruncation.ts, 4, 50))
->someLongOptionD : Symbol(someLongOptionD, Decl(noErrorTruncation.ts, 5, 24))
+>someLongOptionD : Symbol(SomeLongOptionD.someLongOptionD, Decl(noErrorTruncation.ts, 5, 24))
 
 type SomeLongOptionE = { someLongOptionE: string }
 >SomeLongOptionE : Symbol(SomeLongOptionE, Decl(noErrorTruncation.ts, 5, 50))
->someLongOptionE : Symbol(someLongOptionE, Decl(noErrorTruncation.ts, 6, 24))
+>someLongOptionE : Symbol(SomeLongOptionE.someLongOptionE, Decl(noErrorTruncation.ts, 6, 24))
 
 type SomeLongOptionF = { someLongOptionF: string }
 >SomeLongOptionF : Symbol(SomeLongOptionF, Decl(noErrorTruncation.ts, 6, 50))
->someLongOptionF : Symbol(someLongOptionF, Decl(noErrorTruncation.ts, 7, 24))
+>someLongOptionF : Symbol(SomeLongOptionF.someLongOptionF, Decl(noErrorTruncation.ts, 7, 24))
 
 const x: SomeLongOptionA
 >x : Symbol(x, Decl(noErrorTruncation.ts, 9, 5))
diff --git a/tests/baselines/reference/noImplicitAnyDestructuringInPrivateMethod.symbols b/tests/baselines/reference/noImplicitAnyDestructuringInPrivateMethod.symbols
index 0b1ce5cfe48ed..0494b71225452 100644
--- a/tests/baselines/reference/noImplicitAnyDestructuringInPrivateMethod.symbols
+++ b/tests/baselines/reference/noImplicitAnyDestructuringInPrivateMethod.symbols
@@ -3,7 +3,7 @@ type Arg = {
 >Arg : Symbol(Arg, Decl(noImplicitAnyDestructuringInPrivateMethod.ts, 0, 0))
 
     a: number;
->a : Symbol(a, Decl(noImplicitAnyDestructuringInPrivateMethod.ts, 0, 12))
+>a : Symbol(Arg.a, Decl(noImplicitAnyDestructuringInPrivateMethod.ts, 0, 12))
 
 };
 export class Bar {
diff --git a/tests/baselines/reference/noMappedGetSet.symbols b/tests/baselines/reference/noMappedGetSet.symbols
index 520eb2f8b4b5a..181064eac4c97 100644
--- a/tests/baselines/reference/noMappedGetSet.symbols
+++ b/tests/baselines/reference/noMappedGetSet.symbols
@@ -3,7 +3,7 @@ type OH_NO = {
 >OH_NO : Symbol(OH_NO, Decl(noMappedGetSet.ts, 0, 0))
 
     get [K in WAT](): string
->[K in WAT] : Symbol([K in WAT], Decl(noMappedGetSet.ts, 0, 14))
+>[K in WAT] : Symbol(OH_NO[K in WAT], Decl(noMappedGetSet.ts, 0, 14))
 
 };
 
diff --git a/tests/baselines/reference/noUnusedLocals_selfReference.symbols b/tests/baselines/reference/noUnusedLocals_selfReference.symbols
index 5074fb840a4e6..4d980354570c2 100644
--- a/tests/baselines/reference/noUnusedLocals_selfReference.symbols
+++ b/tests/baselines/reference/noUnusedLocals_selfReference.symbols
@@ -36,7 +36,7 @@ interface I { x: I };
 
 type T = { x: T };
 >T : Symbol(T, Decl(noUnusedLocals_selfReference.ts, 12, 21))
->x : Symbol(x, Decl(noUnusedLocals_selfReference.ts, 13, 10))
+>x : Symbol(T.x, Decl(noUnusedLocals_selfReference.ts, 13, 10))
 >T : Symbol(T, Decl(noUnusedLocals_selfReference.ts, 12, 21))
 
 namespace N { N; }
diff --git a/tests/baselines/reference/nodeModulesImportTypeModeDeclarationEmitErrors1(module=node12).symbols b/tests/baselines/reference/nodeModulesImportTypeModeDeclarationEmitErrors1(module=node12).symbols
index 71b67ec81d607..9e948746cfc18 100644
--- a/tests/baselines/reference/nodeModulesImportTypeModeDeclarationEmitErrors1(module=node12).symbols
+++ b/tests/baselines/reference/nodeModulesImportTypeModeDeclarationEmitErrors1(module=node12).symbols
@@ -81,12 +81,12 @@ export const b = (null as any as import("pkg", [ {"resolution-mode": "import"} ]
 // Indirected assertion objecty-thing - not allowed
 type Asserts1 = { assert: {"resolution-mode": "require"} };
 >Asserts1 : Symbol(Asserts1, Decl(other4.ts, 0, 0), Decl(other4.ts, 8, 46))
->assert : Symbol(assert, Decl(other4.ts, 1, 17))
+>assert : Symbol(Asserts1.assert, Decl(other4.ts, 1, 17))
 >"resolution-mode" : Symbol("resolution-mode", Decl(other4.ts, 1, 27))
 
 type Asserts2 = { assert: {"resolution-mode": "import"} };
 >Asserts2 : Symbol(Asserts2, Decl(other4.ts, 1, 59), Decl(other4.ts, 9, 46))
->assert : Symbol(assert, Decl(other4.ts, 2, 17))
+>assert : Symbol(Asserts2.assert, Decl(other4.ts, 2, 17))
 >"resolution-mode" : Symbol("resolution-mode", Decl(other4.ts, 2, 27))
 
 export type LocalInterface =
diff --git a/tests/baselines/reference/nodeModulesImportTypeModeDeclarationEmitErrors1(module=nodenext).symbols b/tests/baselines/reference/nodeModulesImportTypeModeDeclarationEmitErrors1(module=nodenext).symbols
index 71b67ec81d607..9e948746cfc18 100644
--- a/tests/baselines/reference/nodeModulesImportTypeModeDeclarationEmitErrors1(module=nodenext).symbols
+++ b/tests/baselines/reference/nodeModulesImportTypeModeDeclarationEmitErrors1(module=nodenext).symbols
@@ -81,12 +81,12 @@ export const b = (null as any as import("pkg", [ {"resolution-mode": "import"} ]
 // Indirected assertion objecty-thing - not allowed
 type Asserts1 = { assert: {"resolution-mode": "require"} };
 >Asserts1 : Symbol(Asserts1, Decl(other4.ts, 0, 0), Decl(other4.ts, 8, 46))
->assert : Symbol(assert, Decl(other4.ts, 1, 17))
+>assert : Symbol(Asserts1.assert, Decl(other4.ts, 1, 17))
 >"resolution-mode" : Symbol("resolution-mode", Decl(other4.ts, 1, 27))
 
 type Asserts2 = { assert: {"resolution-mode": "import"} };
 >Asserts2 : Symbol(Asserts2, Decl(other4.ts, 1, 59), Decl(other4.ts, 9, 46))
->assert : Symbol(assert, Decl(other4.ts, 2, 17))
+>assert : Symbol(Asserts2.assert, Decl(other4.ts, 2, 17))
 >"resolution-mode" : Symbol("resolution-mode", Decl(other4.ts, 2, 27))
 
 export type LocalInterface =
diff --git a/tests/baselines/reference/nonNullReferenceMatching.symbols b/tests/baselines/reference/nonNullReferenceMatching.symbols
index ee9c608cea498..ad5276f5bd2b6 100644
--- a/tests/baselines/reference/nonNullReferenceMatching.symbols
+++ b/tests/baselines/reference/nonNullReferenceMatching.symbols
@@ -8,7 +8,7 @@ type ThumbProps = {
 >ThumbProps : Symbol(ThumbProps, Decl(nonNullReferenceMatching.ts, 0, 56))
 
     elementRef?: ElementRef;
->elementRef : Symbol(elementRef, Decl(nonNullReferenceMatching.ts, 2, 19))
+>elementRef : Symbol(ThumbProps.elementRef, Decl(nonNullReferenceMatching.ts, 2, 19))
 >ElementRef : Symbol(ElementRef, Decl(nonNullReferenceMatching.ts, 0, 0))
 }
 
@@ -16,11 +16,11 @@ type ComponentProps = {
 >ComponentProps : Symbol(ComponentProps, Decl(nonNullReferenceMatching.ts, 4, 1))
 
     thumbYProps?: ThumbProps;
->thumbYProps : Symbol(thumbYProps, Decl(nonNullReferenceMatching.ts, 6, 23))
+>thumbYProps : Symbol(ComponentProps.thumbYProps, Decl(nonNullReferenceMatching.ts, 6, 23))
 >ThumbProps : Symbol(ThumbProps, Decl(nonNullReferenceMatching.ts, 0, 56))
 
     thumbXProps: ThumbProps;
->thumbXProps : Symbol(thumbXProps, Decl(nonNullReferenceMatching.ts, 7, 29))
+>thumbXProps : Symbol(ComponentProps.thumbXProps, Decl(nonNullReferenceMatching.ts, 7, 29))
 >ThumbProps : Symbol(ThumbProps, Decl(nonNullReferenceMatching.ts, 0, 56))
 }
 
@@ -37,156 +37,156 @@ class Component {
 >HTMLElement : Symbol(HTMLElement, Decl(lib.dom.d.ts, --, --), Decl(lib.dom.d.ts, --, --))
 
         typeof this.props.thumbYProps!.elementRef === 'function' && this.props.thumbYProps!.elementRef(ref);
->this.props.thumbYProps!.elementRef : Symbol(elementRef, Decl(nonNullReferenceMatching.ts, 2, 19))
->this.props.thumbYProps : Symbol(thumbYProps, Decl(nonNullReferenceMatching.ts, 6, 23))
+>this.props.thumbYProps!.elementRef : Symbol(ThumbProps.elementRef, Decl(nonNullReferenceMatching.ts, 2, 19))
+>this.props.thumbYProps : Symbol(ComponentProps.thumbYProps, Decl(nonNullReferenceMatching.ts, 6, 23))
 >this.props : Symbol(Component.props, Decl(nonNullReferenceMatching.ts, 11, 17))
 >this : Symbol(Component, Decl(nonNullReferenceMatching.ts, 9, 1))
 >props : Symbol(Component.props, Decl(nonNullReferenceMatching.ts, 11, 17))
->thumbYProps : Symbol(thumbYProps, Decl(nonNullReferenceMatching.ts, 6, 23))
->elementRef : Symbol(elementRef, Decl(nonNullReferenceMatching.ts, 2, 19))
->this.props.thumbYProps!.elementRef : Symbol(elementRef, Decl(nonNullReferenceMatching.ts, 2, 19))
->this.props.thumbYProps : Symbol(thumbYProps, Decl(nonNullReferenceMatching.ts, 6, 23))
+>thumbYProps : Symbol(ComponentProps.thumbYProps, Decl(nonNullReferenceMatching.ts, 6, 23))
+>elementRef : Symbol(ThumbProps.elementRef, Decl(nonNullReferenceMatching.ts, 2, 19))
+>this.props.thumbYProps!.elementRef : Symbol(ThumbProps.elementRef, Decl(nonNullReferenceMatching.ts, 2, 19))
+>this.props.thumbYProps : Symbol(ComponentProps.thumbYProps, Decl(nonNullReferenceMatching.ts, 6, 23))
 >this.props : Symbol(Component.props, Decl(nonNullReferenceMatching.ts, 11, 17))
 >this : Symbol(Component, Decl(nonNullReferenceMatching.ts, 9, 1))
 >props : Symbol(Component.props, Decl(nonNullReferenceMatching.ts, 11, 17))
->thumbYProps : Symbol(thumbYProps, Decl(nonNullReferenceMatching.ts, 6, 23))
->elementRef : Symbol(elementRef, Decl(nonNullReferenceMatching.ts, 2, 19))
+>thumbYProps : Symbol(ComponentProps.thumbYProps, Decl(nonNullReferenceMatching.ts, 6, 23))
+>elementRef : Symbol(ThumbProps.elementRef, Decl(nonNullReferenceMatching.ts, 2, 19))
 >ref : Symbol(ref, Decl(nonNullReferenceMatching.ts, 13, 31))
 
         typeof (this.props.thumbYProps!.elementRef) === 'function' && this.props.thumbYProps!.elementRef(ref);
->this.props.thumbYProps!.elementRef : Symbol(elementRef, Decl(nonNullReferenceMatching.ts, 2, 19))
->this.props.thumbYProps : Symbol(thumbYProps, Decl(nonNullReferenceMatching.ts, 6, 23))
+>this.props.thumbYProps!.elementRef : Symbol(ThumbProps.elementRef, Decl(nonNullReferenceMatching.ts, 2, 19))
+>this.props.thumbYProps : Symbol(ComponentProps.thumbYProps, Decl(nonNullReferenceMatching.ts, 6, 23))
 >this.props : Symbol(Component.props, Decl(nonNullReferenceMatching.ts, 11, 17))
 >this : Symbol(Component, Decl(nonNullReferenceMatching.ts, 9, 1))
 >props : Symbol(Component.props, Decl(nonNullReferenceMatching.ts, 11, 17))
->thumbYProps : Symbol(thumbYProps, Decl(nonNullReferenceMatching.ts, 6, 23))
->elementRef : Symbol(elementRef, Decl(nonNullReferenceMatching.ts, 2, 19))
->this.props.thumbYProps!.elementRef : Symbol(elementRef, Decl(nonNullReferenceMatching.ts, 2, 19))
->this.props.thumbYProps : Symbol(thumbYProps, Decl(nonNullReferenceMatching.ts, 6, 23))
+>thumbYProps : Symbol(ComponentProps.thumbYProps, Decl(nonNullReferenceMatching.ts, 6, 23))
+>elementRef : Symbol(ThumbProps.elementRef, Decl(nonNullReferenceMatching.ts, 2, 19))
+>this.props.thumbYProps!.elementRef : Symbol(ThumbProps.elementRef, Decl(nonNullReferenceMatching.ts, 2, 19))
+>this.props.thumbYProps : Symbol(ComponentProps.thumbYProps, Decl(nonNullReferenceMatching.ts, 6, 23))
 >this.props : Symbol(Component.props, Decl(nonNullReferenceMatching.ts, 11, 17))
 >this : Symbol(Component, Decl(nonNullReferenceMatching.ts, 9, 1))
 >props : Symbol(Component.props, Decl(nonNullReferenceMatching.ts, 11, 17))
->thumbYProps : Symbol(thumbYProps, Decl(nonNullReferenceMatching.ts, 6, 23))
->elementRef : Symbol(elementRef, Decl(nonNullReferenceMatching.ts, 2, 19))
+>thumbYProps : Symbol(ComponentProps.thumbYProps, Decl(nonNullReferenceMatching.ts, 6, 23))
+>elementRef : Symbol(ThumbProps.elementRef, Decl(nonNullReferenceMatching.ts, 2, 19))
 >ref : Symbol(ref, Decl(nonNullReferenceMatching.ts, 13, 31))
 
         typeof ((this.props).thumbYProps!.elementRef)! === 'function' && this.props.thumbYProps!.elementRef(ref);
->(this.props).thumbYProps!.elementRef : Symbol(elementRef, Decl(nonNullReferenceMatching.ts, 2, 19))
->(this.props).thumbYProps : Symbol(thumbYProps, Decl(nonNullReferenceMatching.ts, 6, 23))
+>(this.props).thumbYProps!.elementRef : Symbol(ThumbProps.elementRef, Decl(nonNullReferenceMatching.ts, 2, 19))
+>(this.props).thumbYProps : Symbol(ComponentProps.thumbYProps, Decl(nonNullReferenceMatching.ts, 6, 23))
 >this.props : Symbol(Component.props, Decl(nonNullReferenceMatching.ts, 11, 17))
 >this : Symbol(Component, Decl(nonNullReferenceMatching.ts, 9, 1))
 >props : Symbol(Component.props, Decl(nonNullReferenceMatching.ts, 11, 17))
->thumbYProps : Symbol(thumbYProps, Decl(nonNullReferenceMatching.ts, 6, 23))
->elementRef : Symbol(elementRef, Decl(nonNullReferenceMatching.ts, 2, 19))
->this.props.thumbYProps!.elementRef : Symbol(elementRef, Decl(nonNullReferenceMatching.ts, 2, 19))
->this.props.thumbYProps : Symbol(thumbYProps, Decl(nonNullReferenceMatching.ts, 6, 23))
+>thumbYProps : Symbol(ComponentProps.thumbYProps, Decl(nonNullReferenceMatching.ts, 6, 23))
+>elementRef : Symbol(ThumbProps.elementRef, Decl(nonNullReferenceMatching.ts, 2, 19))
+>this.props.thumbYProps!.elementRef : Symbol(ThumbProps.elementRef, Decl(nonNullReferenceMatching.ts, 2, 19))
+>this.props.thumbYProps : Symbol(ComponentProps.thumbYProps, Decl(nonNullReferenceMatching.ts, 6, 23))
 >this.props : Symbol(Component.props, Decl(nonNullReferenceMatching.ts, 11, 17))
 >this : Symbol(Component, Decl(nonNullReferenceMatching.ts, 9, 1))
 >props : Symbol(Component.props, Decl(nonNullReferenceMatching.ts, 11, 17))
->thumbYProps : Symbol(thumbYProps, Decl(nonNullReferenceMatching.ts, 6, 23))
->elementRef : Symbol(elementRef, Decl(nonNullReferenceMatching.ts, 2, 19))
+>thumbYProps : Symbol(ComponentProps.thumbYProps, Decl(nonNullReferenceMatching.ts, 6, 23))
+>elementRef : Symbol(ThumbProps.elementRef, Decl(nonNullReferenceMatching.ts, 2, 19))
 >ref : Symbol(ref, Decl(nonNullReferenceMatching.ts, 13, 31))
 
         typeof this.props.thumbXProps.elementRef === 'function' && this.props.thumbXProps.elementRef(ref);
->this.props.thumbXProps.elementRef : Symbol(elementRef, Decl(nonNullReferenceMatching.ts, 2, 19))
->this.props.thumbXProps : Symbol(thumbXProps, Decl(nonNullReferenceMatching.ts, 7, 29))
+>this.props.thumbXProps.elementRef : Symbol(ThumbProps.elementRef, Decl(nonNullReferenceMatching.ts, 2, 19))
+>this.props.thumbXProps : Symbol(ComponentProps.thumbXProps, Decl(nonNullReferenceMatching.ts, 7, 29))
 >this.props : Symbol(Component.props, Decl(nonNullReferenceMatching.ts, 11, 17))
 >this : Symbol(Component, Decl(nonNullReferenceMatching.ts, 9, 1))
 >props : Symbol(Component.props, Decl(nonNullReferenceMatching.ts, 11, 17))
->thumbXProps : Symbol(thumbXProps, Decl(nonNullReferenceMatching.ts, 7, 29))
->elementRef : Symbol(elementRef, Decl(nonNullReferenceMatching.ts, 2, 19))
->this.props.thumbXProps.elementRef : Symbol(elementRef, Decl(nonNullReferenceMatching.ts, 2, 19))
->this.props.thumbXProps : Symbol(thumbXProps, Decl(nonNullReferenceMatching.ts, 7, 29))
+>thumbXProps : Symbol(ComponentProps.thumbXProps, Decl(nonNullReferenceMatching.ts, 7, 29))
+>elementRef : Symbol(ThumbProps.elementRef, Decl(nonNullReferenceMatching.ts, 2, 19))
+>this.props.thumbXProps.elementRef : Symbol(ThumbProps.elementRef, Decl(nonNullReferenceMatching.ts, 2, 19))
+>this.props.thumbXProps : Symbol(ComponentProps.thumbXProps, Decl(nonNullReferenceMatching.ts, 7, 29))
 >this.props : Symbol(Component.props, Decl(nonNullReferenceMatching.ts, 11, 17))
 >this : Symbol(Component, Decl(nonNullReferenceMatching.ts, 9, 1))
 >props : Symbol(Component.props, Decl(nonNullReferenceMatching.ts, 11, 17))
->thumbXProps : Symbol(thumbXProps, Decl(nonNullReferenceMatching.ts, 7, 29))
->elementRef : Symbol(elementRef, Decl(nonNullReferenceMatching.ts, 2, 19))
+>thumbXProps : Symbol(ComponentProps.thumbXProps, Decl(nonNullReferenceMatching.ts, 7, 29))
+>elementRef : Symbol(ThumbProps.elementRef, Decl(nonNullReferenceMatching.ts, 2, 19))
 >ref : Symbol(ref, Decl(nonNullReferenceMatching.ts, 13, 31))
 
         typeof this.props.thumbXProps.elementRef === 'function' && (this.props).thumbXProps.elementRef(ref);
->this.props.thumbXProps.elementRef : Symbol(elementRef, Decl(nonNullReferenceMatching.ts, 2, 19))
->this.props.thumbXProps : Symbol(thumbXProps, Decl(nonNullReferenceMatching.ts, 7, 29))
+>this.props.thumbXProps.elementRef : Symbol(ThumbProps.elementRef, Decl(nonNullReferenceMatching.ts, 2, 19))
+>this.props.thumbXProps : Symbol(ComponentProps.thumbXProps, Decl(nonNullReferenceMatching.ts, 7, 29))
 >this.props : Symbol(Component.props, Decl(nonNullReferenceMatching.ts, 11, 17))
 >this : Symbol(Component, Decl(nonNullReferenceMatching.ts, 9, 1))
 >props : Symbol(Component.props, Decl(nonNullReferenceMatching.ts, 11, 17))
->thumbXProps : Symbol(thumbXProps, Decl(nonNullReferenceMatching.ts, 7, 29))
->elementRef : Symbol(elementRef, Decl(nonNullReferenceMatching.ts, 2, 19))
->(this.props).thumbXProps.elementRef : Symbol(elementRef, Decl(nonNullReferenceMatching.ts, 2, 19))
->(this.props).thumbXProps : Symbol(thumbXProps, Decl(nonNullReferenceMatching.ts, 7, 29))
+>thumbXProps : Symbol(ComponentProps.thumbXProps, Decl(nonNullReferenceMatching.ts, 7, 29))
+>elementRef : Symbol(ThumbProps.elementRef, Decl(nonNullReferenceMatching.ts, 2, 19))
+>(this.props).thumbXProps.elementRef : Symbol(ThumbProps.elementRef, Decl(nonNullReferenceMatching.ts, 2, 19))
+>(this.props).thumbXProps : Symbol(ComponentProps.thumbXProps, Decl(nonNullReferenceMatching.ts, 7, 29))
 >this.props : Symbol(Component.props, Decl(nonNullReferenceMatching.ts, 11, 17))
 >this : Symbol(Component, Decl(nonNullReferenceMatching.ts, 9, 1))
 >props : Symbol(Component.props, Decl(nonNullReferenceMatching.ts, 11, 17))
->thumbXProps : Symbol(thumbXProps, Decl(nonNullReferenceMatching.ts, 7, 29))
->elementRef : Symbol(elementRef, Decl(nonNullReferenceMatching.ts, 2, 19))
+>thumbXProps : Symbol(ComponentProps.thumbXProps, Decl(nonNullReferenceMatching.ts, 7, 29))
+>elementRef : Symbol(ThumbProps.elementRef, Decl(nonNullReferenceMatching.ts, 2, 19))
 >ref : Symbol(ref, Decl(nonNullReferenceMatching.ts, 13, 31))
 
         typeof this.props.thumbXProps.elementRef === 'function' && (this.props.thumbXProps).elementRef(ref);
->this.props.thumbXProps.elementRef : Symbol(elementRef, Decl(nonNullReferenceMatching.ts, 2, 19))
->this.props.thumbXProps : Symbol(thumbXProps, Decl(nonNullReferenceMatching.ts, 7, 29))
+>this.props.thumbXProps.elementRef : Symbol(ThumbProps.elementRef, Decl(nonNullReferenceMatching.ts, 2, 19))
+>this.props.thumbXProps : Symbol(ComponentProps.thumbXProps, Decl(nonNullReferenceMatching.ts, 7, 29))
 >this.props : Symbol(Component.props, Decl(nonNullReferenceMatching.ts, 11, 17))
 >this : Symbol(Component, Decl(nonNullReferenceMatching.ts, 9, 1))
 >props : Symbol(Component.props, Decl(nonNullReferenceMatching.ts, 11, 17))
->thumbXProps : Symbol(thumbXProps, Decl(nonNullReferenceMatching.ts, 7, 29))
->elementRef : Symbol(elementRef, Decl(nonNullReferenceMatching.ts, 2, 19))
->(this.props.thumbXProps).elementRef : Symbol(elementRef, Decl(nonNullReferenceMatching.ts, 2, 19))
->this.props.thumbXProps : Symbol(thumbXProps, Decl(nonNullReferenceMatching.ts, 7, 29))
+>thumbXProps : Symbol(ComponentProps.thumbXProps, Decl(nonNullReferenceMatching.ts, 7, 29))
+>elementRef : Symbol(ThumbProps.elementRef, Decl(nonNullReferenceMatching.ts, 2, 19))
+>(this.props.thumbXProps).elementRef : Symbol(ThumbProps.elementRef, Decl(nonNullReferenceMatching.ts, 2, 19))
+>this.props.thumbXProps : Symbol(ComponentProps.thumbXProps, Decl(nonNullReferenceMatching.ts, 7, 29))
 >this.props : Symbol(Component.props, Decl(nonNullReferenceMatching.ts, 11, 17))
 >this : Symbol(Component, Decl(nonNullReferenceMatching.ts, 9, 1))
 >props : Symbol(Component.props, Decl(nonNullReferenceMatching.ts, 11, 17))
->thumbXProps : Symbol(thumbXProps, Decl(nonNullReferenceMatching.ts, 7, 29))
->elementRef : Symbol(elementRef, Decl(nonNullReferenceMatching.ts, 2, 19))
+>thumbXProps : Symbol(ComponentProps.thumbXProps, Decl(nonNullReferenceMatching.ts, 7, 29))
+>elementRef : Symbol(ThumbProps.elementRef, Decl(nonNullReferenceMatching.ts, 2, 19))
 >ref : Symbol(ref, Decl(nonNullReferenceMatching.ts, 13, 31))
 
         typeof this.props.thumbXProps.elementRef === 'function' && ((this.props)!.thumbXProps)!.elementRef(ref);
->this.props.thumbXProps.elementRef : Symbol(elementRef, Decl(nonNullReferenceMatching.ts, 2, 19))
->this.props.thumbXProps : Symbol(thumbXProps, Decl(nonNullReferenceMatching.ts, 7, 29))
+>this.props.thumbXProps.elementRef : Symbol(ThumbProps.elementRef, Decl(nonNullReferenceMatching.ts, 2, 19))
+>this.props.thumbXProps : Symbol(ComponentProps.thumbXProps, Decl(nonNullReferenceMatching.ts, 7, 29))
 >this.props : Symbol(Component.props, Decl(nonNullReferenceMatching.ts, 11, 17))
 >this : Symbol(Component, Decl(nonNullReferenceMatching.ts, 9, 1))
 >props : Symbol(Component.props, Decl(nonNullReferenceMatching.ts, 11, 17))
->thumbXProps : Symbol(thumbXProps, Decl(nonNullReferenceMatching.ts, 7, 29))
->elementRef : Symbol(elementRef, Decl(nonNullReferenceMatching.ts, 2, 19))
->((this.props)!.thumbXProps)!.elementRef : Symbol(elementRef, Decl(nonNullReferenceMatching.ts, 2, 19))
->(this.props)!.thumbXProps : Symbol(thumbXProps, Decl(nonNullReferenceMatching.ts, 7, 29))
+>thumbXProps : Symbol(ComponentProps.thumbXProps, Decl(nonNullReferenceMatching.ts, 7, 29))
+>elementRef : Symbol(ThumbProps.elementRef, Decl(nonNullReferenceMatching.ts, 2, 19))
+>((this.props)!.thumbXProps)!.elementRef : Symbol(ThumbProps.elementRef, Decl(nonNullReferenceMatching.ts, 2, 19))
+>(this.props)!.thumbXProps : Symbol(ComponentProps.thumbXProps, Decl(nonNullReferenceMatching.ts, 7, 29))
 >this.props : Symbol(Component.props, Decl(nonNullReferenceMatching.ts, 11, 17))
 >this : Symbol(Component, Decl(nonNullReferenceMatching.ts, 9, 1))
 >props : Symbol(Component.props, Decl(nonNullReferenceMatching.ts, 11, 17))
->thumbXProps : Symbol(thumbXProps, Decl(nonNullReferenceMatching.ts, 7, 29))
->elementRef : Symbol(elementRef, Decl(nonNullReferenceMatching.ts, 2, 19))
+>thumbXProps : Symbol(ComponentProps.thumbXProps, Decl(nonNullReferenceMatching.ts, 7, 29))
+>elementRef : Symbol(ThumbProps.elementRef, Decl(nonNullReferenceMatching.ts, 2, 19))
 >ref : Symbol(ref, Decl(nonNullReferenceMatching.ts, 13, 31))
 
         typeof (this.props.thumbXProps).elementRef === 'function' && ((this.props)!.thumbXProps)!.elementRef(ref);
->(this.props.thumbXProps).elementRef : Symbol(elementRef, Decl(nonNullReferenceMatching.ts, 2, 19))
->this.props.thumbXProps : Symbol(thumbXProps, Decl(nonNullReferenceMatching.ts, 7, 29))
+>(this.props.thumbXProps).elementRef : Symbol(ThumbProps.elementRef, Decl(nonNullReferenceMatching.ts, 2, 19))
+>this.props.thumbXProps : Symbol(ComponentProps.thumbXProps, Decl(nonNullReferenceMatching.ts, 7, 29))
 >this.props : Symbol(Component.props, Decl(nonNullReferenceMatching.ts, 11, 17))
 >this : Symbol(Component, Decl(nonNullReferenceMatching.ts, 9, 1))
 >props : Symbol(Component.props, Decl(nonNullReferenceMatching.ts, 11, 17))
->thumbXProps : Symbol(thumbXProps, Decl(nonNullReferenceMatching.ts, 7, 29))
->elementRef : Symbol(elementRef, Decl(nonNullReferenceMatching.ts, 2, 19))
->((this.props)!.thumbXProps)!.elementRef : Symbol(elementRef, Decl(nonNullReferenceMatching.ts, 2, 19))
->(this.props)!.thumbXProps : Symbol(thumbXProps, Decl(nonNullReferenceMatching.ts, 7, 29))
+>thumbXProps : Symbol(ComponentProps.thumbXProps, Decl(nonNullReferenceMatching.ts, 7, 29))
+>elementRef : Symbol(ThumbProps.elementRef, Decl(nonNullReferenceMatching.ts, 2, 19))
+>((this.props)!.thumbXProps)!.elementRef : Symbol(ThumbProps.elementRef, Decl(nonNullReferenceMatching.ts, 2, 19))
+>(this.props)!.thumbXProps : Symbol(ComponentProps.thumbXProps, Decl(nonNullReferenceMatching.ts, 7, 29))
 >this.props : Symbol(Component.props, Decl(nonNullReferenceMatching.ts, 11, 17))
 >this : Symbol(Component, Decl(nonNullReferenceMatching.ts, 9, 1))
 >props : Symbol(Component.props, Decl(nonNullReferenceMatching.ts, 11, 17))
->thumbXProps : Symbol(thumbXProps, Decl(nonNullReferenceMatching.ts, 7, 29))
->elementRef : Symbol(elementRef, Decl(nonNullReferenceMatching.ts, 2, 19))
+>thumbXProps : Symbol(ComponentProps.thumbXProps, Decl(nonNullReferenceMatching.ts, 7, 29))
+>elementRef : Symbol(ThumbProps.elementRef, Decl(nonNullReferenceMatching.ts, 2, 19))
 >ref : Symbol(ref, Decl(nonNullReferenceMatching.ts, 13, 31))
 
         typeof this.props!.thumbXProps!.elementRef === 'function' && ((this.props)!.thumbXProps)!.elementRef(ref);
->this.props!.thumbXProps!.elementRef : Symbol(elementRef, Decl(nonNullReferenceMatching.ts, 2, 19))
->this.props!.thumbXProps : Symbol(thumbXProps, Decl(nonNullReferenceMatching.ts, 7, 29))
+>this.props!.thumbXProps!.elementRef : Symbol(ThumbProps.elementRef, Decl(nonNullReferenceMatching.ts, 2, 19))
+>this.props!.thumbXProps : Symbol(ComponentProps.thumbXProps, Decl(nonNullReferenceMatching.ts, 7, 29))
 >this.props : Symbol(Component.props, Decl(nonNullReferenceMatching.ts, 11, 17))
 >this : Symbol(Component, Decl(nonNullReferenceMatching.ts, 9, 1))
 >props : Symbol(Component.props, Decl(nonNullReferenceMatching.ts, 11, 17))
->thumbXProps : Symbol(thumbXProps, Decl(nonNullReferenceMatching.ts, 7, 29))
->elementRef : Symbol(elementRef, Decl(nonNullReferenceMatching.ts, 2, 19))
->((this.props)!.thumbXProps)!.elementRef : Symbol(elementRef, Decl(nonNullReferenceMatching.ts, 2, 19))
->(this.props)!.thumbXProps : Symbol(thumbXProps, Decl(nonNullReferenceMatching.ts, 7, 29))
+>thumbXProps : Symbol(ComponentProps.thumbXProps, Decl(nonNullReferenceMatching.ts, 7, 29))
+>elementRef : Symbol(ThumbProps.elementRef, Decl(nonNullReferenceMatching.ts, 2, 19))
+>((this.props)!.thumbXProps)!.elementRef : Symbol(ThumbProps.elementRef, Decl(nonNullReferenceMatching.ts, 2, 19))
+>(this.props)!.thumbXProps : Symbol(ComponentProps.thumbXProps, Decl(nonNullReferenceMatching.ts, 7, 29))
 >this.props : Symbol(Component.props, Decl(nonNullReferenceMatching.ts, 11, 17))
 >this : Symbol(Component, Decl(nonNullReferenceMatching.ts, 9, 1))
 >props : Symbol(Component.props, Decl(nonNullReferenceMatching.ts, 11, 17))
->thumbXProps : Symbol(thumbXProps, Decl(nonNullReferenceMatching.ts, 7, 29))
->elementRef : Symbol(elementRef, Decl(nonNullReferenceMatching.ts, 2, 19))
+>thumbXProps : Symbol(ComponentProps.thumbXProps, Decl(nonNullReferenceMatching.ts, 7, 29))
+>elementRef : Symbol(ThumbProps.elementRef, Decl(nonNullReferenceMatching.ts, 2, 19))
 >ref : Symbol(ref, Decl(nonNullReferenceMatching.ts, 13, 31))
 
     };
diff --git a/tests/baselines/reference/objectLiteralEnumPropertyNames.symbols b/tests/baselines/reference/objectLiteralEnumPropertyNames.symbols
index 2b4d20c146caf..cbf1bda8f1feb 100644
--- a/tests/baselines/reference/objectLiteralEnumPropertyNames.symbols
+++ b/tests/baselines/reference/objectLiteralEnumPropertyNames.symbols
@@ -98,8 +98,8 @@ enum Nums {
 }
 type TestNums = { 0: number, 1: number }
 >TestNums : Symbol(TestNums, Decl(objectLiteralEnumPropertyNames.ts, 32, 1))
->0 : Symbol(0, Decl(objectLiteralEnumPropertyNames.ts, 33, 17))
->1 : Symbol(1, Decl(objectLiteralEnumPropertyNames.ts, 33, 28))
+>0 : Symbol(TestNums[0], Decl(objectLiteralEnumPropertyNames.ts, 33, 17))
+>1 : Symbol(TestNums[1], Decl(objectLiteralEnumPropertyNames.ts, 33, 28))
 
 const n: TestNums = {
 >n : Symbol(n, Decl(objectLiteralEnumPropertyNames.ts, 34, 5))
diff --git a/tests/baselines/reference/objectRestReadonly.symbols b/tests/baselines/reference/objectRestReadonly.symbols
index f2a7504e9b59e..067ad6addc389 100644
--- a/tests/baselines/reference/objectRestReadonly.symbols
+++ b/tests/baselines/reference/objectRestReadonly.symbols
@@ -4,13 +4,13 @@ type ObjType = {
 >ObjType : Symbol(ObjType, Decl(objectRestReadonly.ts, 0, 0))
 
   foo: string
->foo : Symbol(foo, Decl(objectRestReadonly.ts, 1, 16))
+>foo : Symbol(ObjType.foo, Decl(objectRestReadonly.ts, 1, 16))
 
   baz: string
->baz : Symbol(baz, Decl(objectRestReadonly.ts, 2, 13))
+>baz : Symbol(ObjType.baz, Decl(objectRestReadonly.ts, 2, 13))
 
   quux: string
->quux : Symbol(quux, Decl(objectRestReadonly.ts, 3, 13))
+>quux : Symbol(ObjType.quux, Decl(objectRestReadonly.ts, 3, 13))
 }
 
 const obj: Readonly<ObjType> = {
diff --git a/tests/baselines/reference/objectSpread.symbols b/tests/baselines/reference/objectSpread.symbols
index c663cb4f58098..4318c036df16e 100644
--- a/tests/baselines/reference/objectSpread.symbols
+++ b/tests/baselines/reference/objectSpread.symbols
@@ -124,9 +124,9 @@ let spreadFunc = { ...(function () { }) };
 
 type Header = { head: string, body: string, authToken: string }
 >Header : Symbol(Header, Decl(objectSpread.ts, 28, 42))
->head : Symbol(head, Decl(objectSpread.ts, 30, 15))
->body : Symbol(body, Decl(objectSpread.ts, 30, 29))
->authToken : Symbol(authToken, Decl(objectSpread.ts, 30, 43))
+>head : Symbol(Header.head, Decl(objectSpread.ts, 30, 15))
+>body : Symbol(Header.body, Decl(objectSpread.ts, 30, 29))
+>authToken : Symbol(Header.authToken, Decl(objectSpread.ts, 30, 43))
 
 function from16326(this: { header: Header }, header: Header, authToken: string): Header {
 >from16326 : Symbol(from16326, Decl(objectSpread.ts, 30, 63))
diff --git a/tests/baselines/reference/objectSpreadStrictNull.symbols b/tests/baselines/reference/objectSpreadStrictNull.symbols
index a5b1082cc17b3..d52ac4bd5dc1c 100644
--- a/tests/baselines/reference/objectSpreadStrictNull.symbols
+++ b/tests/baselines/reference/objectSpreadStrictNull.symbols
@@ -82,10 +82,10 @@ type Movie = {
 >Movie : Symbol(Movie, Decl(objectSpreadStrictNull.ts, 18, 1))
 
     title: string;
->title : Symbol(title, Decl(objectSpreadStrictNull.ts, 20, 14))
+>title : Symbol(Movie.title, Decl(objectSpreadStrictNull.ts, 20, 14))
 
     yearReleased: number;
->yearReleased : Symbol(yearReleased, Decl(objectSpreadStrictNull.ts, 21, 18))
+>yearReleased : Symbol(Movie.yearReleased, Decl(objectSpreadStrictNull.ts, 21, 18))
 }
 
 const m = { title: "The Matrix", yearReleased: 1999 };
diff --git a/tests/baselines/reference/observableInferenceCanBeMade.types b/tests/baselines/reference/observableInferenceCanBeMade.types
index 6931e042adb5b..6bc2aaf43749f 100644
--- a/tests/baselines/reference/observableInferenceCanBeMade.types
+++ b/tests/baselines/reference/observableInferenceCanBeMade.types
@@ -14,7 +14,7 @@ type ObservedValueOf<O> = O extends ObservableInput<infer T> ? T : never;
 
 interface Subscribable<T> {
     subscribe(next?: (value: T) => void, error?: (error: any) => void, complete?: () => void): void;
->subscribe : (next?: ((value: T) => void) | undefined, error?: ((error: any) => void) | undefined, complete?: (() => void) | undefined) => void
+>subscribe : (next?: ((value: T) => void) | undefined, error?: ((error: any) => void) | undefined, complete?: () => void) => void
 >next : ((value: T) => void) | undefined
 >value : T
 >error : ((error: any) => void) | undefined
@@ -29,7 +29,7 @@ declare class Observable<T> implements Subscribable<T> {
 >Observable : Observable<T>
 
     subscribe(next?: (value: T) => void, error?: (error: any) => void, complete?: () => void): void;
->subscribe : (next?: ((value: T) => void) | undefined, error?: ((error: any) => void) | undefined, complete?: (() => void) | undefined) => void
+>subscribe : (next?: ((value: T) => void) | undefined, error?: ((error: any) => void) | undefined, complete?: () => void) => void
 >next : ((value: T) => void) | undefined
 >value : T
 >error : ((error: any) => void) | undefined
diff --git a/tests/baselines/reference/omitTypeHelperModifiers01.symbols b/tests/baselines/reference/omitTypeHelperModifiers01.symbols
index 39a3360678138..7709cc40ad27b 100644
--- a/tests/baselines/reference/omitTypeHelperModifiers01.symbols
+++ b/tests/baselines/reference/omitTypeHelperModifiers01.symbols
@@ -3,16 +3,16 @@ type A = {
 >A : Symbol(A, Decl(omitTypeHelperModifiers01.ts, 0, 0))
 
     a: number;
->a : Symbol(a, Decl(omitTypeHelperModifiers01.ts, 0, 10))
+>a : Symbol(A.a, Decl(omitTypeHelperModifiers01.ts, 0, 10))
 
     b?: string;
->b : Symbol(b, Decl(omitTypeHelperModifiers01.ts, 1, 14))
+>b : Symbol(A.b, Decl(omitTypeHelperModifiers01.ts, 1, 14))
 
     readonly c: boolean;
->c : Symbol(c, Decl(omitTypeHelperModifiers01.ts, 2, 15))
+>c : Symbol(A.c, Decl(omitTypeHelperModifiers01.ts, 2, 15))
 
     d: unknown;
->d : Symbol(d, Decl(omitTypeHelperModifiers01.ts, 3, 24))
+>d : Symbol(A.d, Decl(omitTypeHelperModifiers01.ts, 3, 24))
 
 };
 
diff --git a/tests/baselines/reference/optionalParameterRetainsNull.types b/tests/baselines/reference/optionalParameterRetainsNull.types
index 94bf71a6f3d42..f1b8f58184195 100644
--- a/tests/baselines/reference/optionalParameterRetainsNull.types
+++ b/tests/baselines/reference/optionalParameterRetainsNull.types
@@ -9,7 +9,7 @@ let a = {
 >{  test<K extends keyof Bar> (a: K,  b?: Bar[K]  |  null)  { }} : { test<K extends keyof Bar>(a: K, b?: Bar[K] | null | undefined): void; }
 
   test<K extends keyof Bar> (a: K,  b?: Bar[K]  |  null)  { }
->test : <K extends keyof Bar>(a: K, b?: Bar[K] | null | undefined) => void
+>test : <K extends keyof Bar>(a: K, b?: Bar[K] | null) => void
 >a : K
 >b : Bar[K] | null | undefined
 >null : null
diff --git a/tests/baselines/reference/parenthesizedContexualTyping1.symbols b/tests/baselines/reference/parenthesizedContexualTyping1.symbols
index 96f314bda60c7..de71a49a98e6f 100644
--- a/tests/baselines/reference/parenthesizedContexualTyping1.symbols
+++ b/tests/baselines/reference/parenthesizedContexualTyping1.symbols
@@ -160,9 +160,9 @@ var lambda2: (x: number) => number = (x => x);
 
 type ObjType = { x: (p: number) => string; y: (p: string) => number };
 >ObjType : Symbol(ObjType, Decl(parenthesizedContexualTyping1.ts, 23, 46))
->x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 25, 16))
+>x : Symbol(ObjType.x, Decl(parenthesizedContexualTyping1.ts, 25, 16))
 >p : Symbol(p, Decl(parenthesizedContexualTyping1.ts, 25, 21))
->y : Symbol(y, Decl(parenthesizedContexualTyping1.ts, 25, 42))
+>y : Symbol(ObjType.y, Decl(parenthesizedContexualTyping1.ts, 25, 42))
 >p : Symbol(p, Decl(parenthesizedContexualTyping1.ts, 25, 47))
 
 var obj1: ObjType = { x: x => (x, undefined), y: y => (y, undefined) };
diff --git a/tests/baselines/reference/parenthesizedContexualTyping2.symbols b/tests/baselines/reference/parenthesizedContexualTyping2.symbols
index ead4285a471cc..eab139f3b3373 100644
--- a/tests/baselines/reference/parenthesizedContexualTyping2.symbols
+++ b/tests/baselines/reference/parenthesizedContexualTyping2.symbols
@@ -203,9 +203,9 @@ var lambda2: FuncType = (x => { x<number>(undefined); return x; });
 
 type ObjType = { x: (p: number) => string; y: (p: string) => number };
 >ObjType : Symbol(ObjType, Decl(parenthesizedContexualTyping2.ts, 31, 67))
->x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 33, 16))
+>x : Symbol(ObjType.x, Decl(parenthesizedContexualTyping2.ts, 33, 16))
 >p : Symbol(p, Decl(parenthesizedContexualTyping2.ts, 33, 21))
->y : Symbol(y, Decl(parenthesizedContexualTyping2.ts, 33, 42))
+>y : Symbol(ObjType.y, Decl(parenthesizedContexualTyping2.ts, 33, 42))
 >p : Symbol(p, Decl(parenthesizedContexualTyping2.ts, 33, 47))
 
 var obj1: ObjType = { x: x => (x, undefined), y: y => (y, undefined) };
diff --git a/tests/baselines/reference/partialTypeNarrowedToByTypeGuard.symbols b/tests/baselines/reference/partialTypeNarrowedToByTypeGuard.symbols
index b810e1c4501c5..4903076e1a60e 100644
--- a/tests/baselines/reference/partialTypeNarrowedToByTypeGuard.symbols
+++ b/tests/baselines/reference/partialTypeNarrowedToByTypeGuard.symbols
@@ -6,10 +6,10 @@ type User = {
 >User : Symbol(User, Decl(partialTypeNarrowedToByTypeGuard.ts, 0, 26))
 
     email: string;
->email : Symbol(email, Decl(partialTypeNarrowedToByTypeGuard.ts, 2, 13))
+>email : Symbol(User.email, Decl(partialTypeNarrowedToByTypeGuard.ts, 2, 13))
 
     name: string;
->name : Symbol(name, Decl(partialTypeNarrowedToByTypeGuard.ts, 3, 18))
+>name : Symbol(User.name, Decl(partialTypeNarrowedToByTypeGuard.ts, 3, 18))
 
 };
 
diff --git a/tests/baselines/reference/primitiveUnionDetection.types b/tests/baselines/reference/primitiveUnionDetection.types
index ac2243d80d4aa..1db3023a56c25 100644
--- a/tests/baselines/reference/primitiveUnionDetection.types
+++ b/tests/baselines/reference/primitiveUnionDetection.types
@@ -5,7 +5,7 @@ type Kind = "one" | "two" | "three";
 >Kind : Kind
 
 declare function getInterfaceFromString<T extends Kind>(options?: { type?: T } & { type?: Kind }): T;
->getInterfaceFromString : <T extends Kind>(options?: ({ type?: T | undefined; } & { type?: Kind | undefined; }) | undefined) => T
+>getInterfaceFromString : <T extends Kind>(options?: {    type?: T;} & {    type?: Kind;}) => T
 >options : ({ type?: T | undefined; } & { type?: Kind | undefined; }) | undefined
 >type : T | undefined
 >type : Kind | undefined
diff --git a/tests/baselines/reference/privateNameAndPropertySignature.symbols b/tests/baselines/reference/privateNameAndPropertySignature.symbols
index 1e270e73a839b..8bece3d78f80b 100644
--- a/tests/baselines/reference/privateNameAndPropertySignature.symbols
+++ b/tests/baselines/reference/privateNameAndPropertySignature.symbols
@@ -3,10 +3,10 @@ type A = {
 >A : Symbol(A, Decl(privateNameAndPropertySignature.ts, 0, 0))
 
     #foo: string;
->#foo : Symbol(#foo, Decl(privateNameAndPropertySignature.ts, 0, 10))
+>#foo : Symbol(A.#foo, Decl(privateNameAndPropertySignature.ts, 0, 10))
 
     #bar(): string;
->#bar : Symbol(#bar, Decl(privateNameAndPropertySignature.ts, 1, 17))
+>#bar : Symbol(A.#bar, Decl(privateNameAndPropertySignature.ts, 1, 17))
 }
 
 interface B {
diff --git a/tests/baselines/reference/propertyAccessWidening.types b/tests/baselines/reference/propertyAccessWidening.types
index 244b43be69fce..7185b28f4ca8d 100644
--- a/tests/baselines/reference/propertyAccessWidening.types
+++ b/tests/baselines/reference/propertyAccessWidening.types
@@ -54,7 +54,7 @@ function g2(headerNames: any) {
 // Object in property or element access is widened when target of assignment
 
 function foo(options?: { a: string, b: number }) {
->foo : (options?: { a: string; b: number; } | undefined) => void
+>foo : (options?: {    a: string;    b: number;}) => void
 >options : { a: string; b: number; } | undefined
 >a : string
 >b : number
diff --git a/tests/baselines/reference/quickInfoForJSDocWithHttpLinks.baseline b/tests/baselines/reference/quickInfoForJSDocWithHttpLinks.baseline
index 7c8ced57be803..08eebb0035bfb 100644
--- a/tests/baselines/reference/quickInfoForJSDocWithHttpLinks.baseline
+++ b/tests/baselines/reference/quickInfoForJSDocWithHttpLinks.baseline
@@ -80,6 +80,14 @@
           "text": " ",
           "kind": "space"
         },
+        {
+          "text": "Oops",
+          "kind": "aliasName"
+        },
+        {
+          "text": ".",
+          "kind": "punctuation"
+        },
         {
           "text": "https",
           "kind": "propertyName"
diff --git a/tests/baselines/reference/ramdaToolsNoInfinite.symbols b/tests/baselines/reference/ramdaToolsNoInfinite.symbols
index 096b6ae9788e1..a987f442791b7 100644
--- a/tests/baselines/reference/ramdaToolsNoInfinite.symbols
+++ b/tests/baselines/reference/ramdaToolsNoInfinite.symbols
@@ -255,7 +255,7 @@ declare namespace R {
 
     export type Placeholder = { __placeholder: void };
 >Placeholder : Symbol(Placeholder, Decl(ramdaToolsNoInfinite.ts, 83, 21))
->__placeholder : Symbol(__placeholder, Decl(ramdaToolsNoInfinite.ts, 84, 31))
+>__placeholder : Symbol(Placeholder.__placeholder, Decl(ramdaToolsNoInfinite.ts, 84, 31))
 }
 
 declare namespace Curry {
diff --git a/tests/baselines/reference/ramdaToolsNoInfinite2.symbols b/tests/baselines/reference/ramdaToolsNoInfinite2.symbols
index c0a34baea3fb5..802773c398392 100644
--- a/tests/baselines/reference/ramdaToolsNoInfinite2.symbols
+++ b/tests/baselines/reference/ramdaToolsNoInfinite2.symbols
@@ -719,7 +719,7 @@ declare module "Number/_Internal" {
 >Numbers : Symbol(Numbers, Decl(ramdaToolsNoInfinite2.ts, 205, 342))
 
         'string': {
->'string' : Symbol('string', Decl(ramdaToolsNoInfinite2.ts, 207, 27))
+>'string' : Symbol(Numbers['string'], Decl(ramdaToolsNoInfinite2.ts, 207, 27))
 
             'all': Format<IterationMap[KnownIterationMapKeys], 's'>;
 >'all' : Symbol('all', Decl(ramdaToolsNoInfinite2.ts, 208, 19))
@@ -746,7 +746,7 @@ declare module "Number/_Internal" {
 
         };
         'number': {
->'number' : Symbol('number', Decl(ramdaToolsNoInfinite2.ts, 213, 10))
+>'number' : Symbol(Numbers['number'], Decl(ramdaToolsNoInfinite2.ts, 213, 10))
 
             'all': Format<IterationMap[KnownIterationMapKeys], 'n'>;
 >'all' : Symbol('all', Decl(ramdaToolsNoInfinite2.ts, 214, 19))
@@ -1373,250 +1373,250 @@ declare module "Iteration/IterationOf" {
 >IterationMap : Symbol(IterationMap, Decl(ramdaToolsNoInfinite2.ts, 387, 43))
 
         '-40': ['__', '-39', '-40', -40, '-'];
->'-40' : Symbol('-40', Decl(ramdaToolsNoInfinite2.ts, 389, 32))
+>'-40' : Symbol(IterationMap['-40'], Decl(ramdaToolsNoInfinite2.ts, 389, 32))
 
         '-39': ['-40', '-38', '-39', -39, '-'];
->'-39' : Symbol('-39', Decl(ramdaToolsNoInfinite2.ts, 390, 46))
+>'-39' : Symbol(IterationMap['-39'], Decl(ramdaToolsNoInfinite2.ts, 390, 46))
 
         '-38': ['-39', '-37', '-38', -38, '-'];
->'-38' : Symbol('-38', Decl(ramdaToolsNoInfinite2.ts, 391, 47))
+>'-38' : Symbol(IterationMap['-38'], Decl(ramdaToolsNoInfinite2.ts, 391, 47))
 
         '-37': ['-38', '-36', '-37', -37, '-'];
->'-37' : Symbol('-37', Decl(ramdaToolsNoInfinite2.ts, 392, 47))
+>'-37' : Symbol(IterationMap['-37'], Decl(ramdaToolsNoInfinite2.ts, 392, 47))
 
         '-36': ['-37', '-35', '-36', -36, '-'];
->'-36' : Symbol('-36', Decl(ramdaToolsNoInfinite2.ts, 393, 47))
+>'-36' : Symbol(IterationMap['-36'], Decl(ramdaToolsNoInfinite2.ts, 393, 47))
 
         '-35': ['-36', '-34', '-35', -35, '-'];
->'-35' : Symbol('-35', Decl(ramdaToolsNoInfinite2.ts, 394, 47))
+>'-35' : Symbol(IterationMap['-35'], Decl(ramdaToolsNoInfinite2.ts, 394, 47))
 
         '-34': ['-35', '-33', '-34', -34, '-'];
->'-34' : Symbol('-34', Decl(ramdaToolsNoInfinite2.ts, 395, 47))
+>'-34' : Symbol(IterationMap['-34'], Decl(ramdaToolsNoInfinite2.ts, 395, 47))
 
         '-33': ['-34', '-32', '-33', -33, '-'];
->'-33' : Symbol('-33', Decl(ramdaToolsNoInfinite2.ts, 396, 47))
+>'-33' : Symbol(IterationMap['-33'], Decl(ramdaToolsNoInfinite2.ts, 396, 47))
 
         '-32': ['-33', '-31', '-32', -32, '-'];
->'-32' : Symbol('-32', Decl(ramdaToolsNoInfinite2.ts, 397, 47))
+>'-32' : Symbol(IterationMap['-32'], Decl(ramdaToolsNoInfinite2.ts, 397, 47))
 
         '-31': ['-32', '-30', '-31', -31, '-'];
->'-31' : Symbol('-31', Decl(ramdaToolsNoInfinite2.ts, 398, 47))
+>'-31' : Symbol(IterationMap['-31'], Decl(ramdaToolsNoInfinite2.ts, 398, 47))
 
         '-30': ['-31', '-29', '-30', -30, '-'];
->'-30' : Symbol('-30', Decl(ramdaToolsNoInfinite2.ts, 399, 47))
+>'-30' : Symbol(IterationMap['-30'], Decl(ramdaToolsNoInfinite2.ts, 399, 47))
 
         '-29': ['-30', '-28', '-29', -29, '-'];
->'-29' : Symbol('-29', Decl(ramdaToolsNoInfinite2.ts, 400, 47))
+>'-29' : Symbol(IterationMap['-29'], Decl(ramdaToolsNoInfinite2.ts, 400, 47))
 
         '-28': ['-29', '-27', '-28', -28, '-'];
->'-28' : Symbol('-28', Decl(ramdaToolsNoInfinite2.ts, 401, 47))
+>'-28' : Symbol(IterationMap['-28'], Decl(ramdaToolsNoInfinite2.ts, 401, 47))
 
         '-27': ['-28', '-26', '-27', -27, '-'];
->'-27' : Symbol('-27', Decl(ramdaToolsNoInfinite2.ts, 402, 47))
+>'-27' : Symbol(IterationMap['-27'], Decl(ramdaToolsNoInfinite2.ts, 402, 47))
 
         '-26': ['-27', '-25', '-26', -26, '-'];
->'-26' : Symbol('-26', Decl(ramdaToolsNoInfinite2.ts, 403, 47))
+>'-26' : Symbol(IterationMap['-26'], Decl(ramdaToolsNoInfinite2.ts, 403, 47))
 
         '-25': ['-26', '-24', '-25', -25, '-'];
->'-25' : Symbol('-25', Decl(ramdaToolsNoInfinite2.ts, 404, 47))
+>'-25' : Symbol(IterationMap['-25'], Decl(ramdaToolsNoInfinite2.ts, 404, 47))
 
         '-24': ['-25', '-23', '-24', -24, '-'];
->'-24' : Symbol('-24', Decl(ramdaToolsNoInfinite2.ts, 405, 47))
+>'-24' : Symbol(IterationMap['-24'], Decl(ramdaToolsNoInfinite2.ts, 405, 47))
 
         '-23': ['-24', '-22', '-23', -23, '-'];
->'-23' : Symbol('-23', Decl(ramdaToolsNoInfinite2.ts, 406, 47))
+>'-23' : Symbol(IterationMap['-23'], Decl(ramdaToolsNoInfinite2.ts, 406, 47))
 
         '-22': ['-23', '-21', '-22', -22, '-'];
->'-22' : Symbol('-22', Decl(ramdaToolsNoInfinite2.ts, 407, 47))
+>'-22' : Symbol(IterationMap['-22'], Decl(ramdaToolsNoInfinite2.ts, 407, 47))
 
         '-21': ['-22', '-20', '-21', -21, '-'];
->'-21' : Symbol('-21', Decl(ramdaToolsNoInfinite2.ts, 408, 47))
+>'-21' : Symbol(IterationMap['-21'], Decl(ramdaToolsNoInfinite2.ts, 408, 47))
 
         '-20': ['-21', '-19', '-20', -20, '-'];
->'-20' : Symbol('-20', Decl(ramdaToolsNoInfinite2.ts, 409, 47))
+>'-20' : Symbol(IterationMap['-20'], Decl(ramdaToolsNoInfinite2.ts, 409, 47))
 
         '-19': ['-20', '-18', '-19', -19, '-'];
->'-19' : Symbol('-19', Decl(ramdaToolsNoInfinite2.ts, 410, 47))
+>'-19' : Symbol(IterationMap['-19'], Decl(ramdaToolsNoInfinite2.ts, 410, 47))
 
         '-18': ['-19', '-17', '-18', -18, '-'];
->'-18' : Symbol('-18', Decl(ramdaToolsNoInfinite2.ts, 411, 47))
+>'-18' : Symbol(IterationMap['-18'], Decl(ramdaToolsNoInfinite2.ts, 411, 47))
 
         '-17': ['-18', '-16', '-17', -17, '-'];
->'-17' : Symbol('-17', Decl(ramdaToolsNoInfinite2.ts, 412, 47))
+>'-17' : Symbol(IterationMap['-17'], Decl(ramdaToolsNoInfinite2.ts, 412, 47))
 
         '-16': ['-17', '-15', '-16', -16, '-'];
->'-16' : Symbol('-16', Decl(ramdaToolsNoInfinite2.ts, 413, 47))
+>'-16' : Symbol(IterationMap['-16'], Decl(ramdaToolsNoInfinite2.ts, 413, 47))
 
         '-15': ['-16', '-14', '-15', -15, '-'];
->'-15' : Symbol('-15', Decl(ramdaToolsNoInfinite2.ts, 414, 47))
+>'-15' : Symbol(IterationMap['-15'], Decl(ramdaToolsNoInfinite2.ts, 414, 47))
 
         '-14': ['-15', '-13', '-14', -14, '-'];
->'-14' : Symbol('-14', Decl(ramdaToolsNoInfinite2.ts, 415, 47))
+>'-14' : Symbol(IterationMap['-14'], Decl(ramdaToolsNoInfinite2.ts, 415, 47))
 
         '-13': ['-14', '-12', '-13', -13, '-'];
->'-13' : Symbol('-13', Decl(ramdaToolsNoInfinite2.ts, 416, 47))
+>'-13' : Symbol(IterationMap['-13'], Decl(ramdaToolsNoInfinite2.ts, 416, 47))
 
         '-12': ['-13', '-11', '-12', -12, '-'];
->'-12' : Symbol('-12', Decl(ramdaToolsNoInfinite2.ts, 417, 47))
+>'-12' : Symbol(IterationMap['-12'], Decl(ramdaToolsNoInfinite2.ts, 417, 47))
 
         '-11': ['-12', '-10', '-11', -11, '-'];
->'-11' : Symbol('-11', Decl(ramdaToolsNoInfinite2.ts, 418, 47))
+>'-11' : Symbol(IterationMap['-11'], Decl(ramdaToolsNoInfinite2.ts, 418, 47))
 
         '-10': ['-11', '-9', '-10', -10, '-'];
->'-10' : Symbol('-10', Decl(ramdaToolsNoInfinite2.ts, 419, 47))
+>'-10' : Symbol(IterationMap['-10'], Decl(ramdaToolsNoInfinite2.ts, 419, 47))
 
         '-9': ['-10', '-8', '-9', -9, '-'];
->'-9' : Symbol('-9', Decl(ramdaToolsNoInfinite2.ts, 420, 46))
+>'-9' : Symbol(IterationMap['-9'], Decl(ramdaToolsNoInfinite2.ts, 420, 46))
 
         '-8': ['-9', '-7', '-8', -8, '-'];
->'-8' : Symbol('-8', Decl(ramdaToolsNoInfinite2.ts, 421, 43))
+>'-8' : Symbol(IterationMap['-8'], Decl(ramdaToolsNoInfinite2.ts, 421, 43))
 
         '-7': ['-8', '-6', '-7', -7, '-'];
->'-7' : Symbol('-7', Decl(ramdaToolsNoInfinite2.ts, 422, 42))
+>'-7' : Symbol(IterationMap['-7'], Decl(ramdaToolsNoInfinite2.ts, 422, 42))
 
         '-6': ['-7', '-5', '-6', -6, '-'];
->'-6' : Symbol('-6', Decl(ramdaToolsNoInfinite2.ts, 423, 42))
+>'-6' : Symbol(IterationMap['-6'], Decl(ramdaToolsNoInfinite2.ts, 423, 42))
 
         '-5': ['-6', '-4', '-5', -5, '-'];
->'-5' : Symbol('-5', Decl(ramdaToolsNoInfinite2.ts, 424, 42))
+>'-5' : Symbol(IterationMap['-5'], Decl(ramdaToolsNoInfinite2.ts, 424, 42))
 
         '-4': ['-5', '-3', '-4', -4, '-'];
->'-4' : Symbol('-4', Decl(ramdaToolsNoInfinite2.ts, 425, 42))
+>'-4' : Symbol(IterationMap['-4'], Decl(ramdaToolsNoInfinite2.ts, 425, 42))
 
         '-3': ['-4', '-2', '-3', -3, '-'];
->'-3' : Symbol('-3', Decl(ramdaToolsNoInfinite2.ts, 426, 42))
+>'-3' : Symbol(IterationMap['-3'], Decl(ramdaToolsNoInfinite2.ts, 426, 42))
 
         '-2': ['-3', '-1', '-2', -2, '-'];
->'-2' : Symbol('-2', Decl(ramdaToolsNoInfinite2.ts, 427, 42))
+>'-2' : Symbol(IterationMap['-2'], Decl(ramdaToolsNoInfinite2.ts, 427, 42))
 
         '-1': ['-2', '0', '-1', -1, '-'];
->'-1' : Symbol('-1', Decl(ramdaToolsNoInfinite2.ts, 428, 42))
+>'-1' : Symbol(IterationMap['-1'], Decl(ramdaToolsNoInfinite2.ts, 428, 42))
 
         '0': ['-1', '1', '0', 0, '0'];
->'0' : Symbol('0', Decl(ramdaToolsNoInfinite2.ts, 429, 41))
+>'0' : Symbol(IterationMap['0'], Decl(ramdaToolsNoInfinite2.ts, 429, 41))
 
         '1': ['0', '2', '1', 1, '+'];
->'1' : Symbol('1', Decl(ramdaToolsNoInfinite2.ts, 430, 38))
+>'1' : Symbol(IterationMap['1'], Decl(ramdaToolsNoInfinite2.ts, 430, 38))
 
         '2': ['1', '3', '2', 2, '+'];
->'2' : Symbol('2', Decl(ramdaToolsNoInfinite2.ts, 431, 37))
+>'2' : Symbol(IterationMap['2'], Decl(ramdaToolsNoInfinite2.ts, 431, 37))
 
         '3': ['2', '4', '3', 3, '+'];
->'3' : Symbol('3', Decl(ramdaToolsNoInfinite2.ts, 432, 37))
+>'3' : Symbol(IterationMap['3'], Decl(ramdaToolsNoInfinite2.ts, 432, 37))
 
         '4': ['3', '5', '4', 4, '+'];
->'4' : Symbol('4', Decl(ramdaToolsNoInfinite2.ts, 433, 37))
+>'4' : Symbol(IterationMap['4'], Decl(ramdaToolsNoInfinite2.ts, 433, 37))
 
         '5': ['4', '6', '5', 5, '+'];
->'5' : Symbol('5', Decl(ramdaToolsNoInfinite2.ts, 434, 37))
+>'5' : Symbol(IterationMap['5'], Decl(ramdaToolsNoInfinite2.ts, 434, 37))
 
         '6': ['5', '7', '6', 6, '+'];
->'6' : Symbol('6', Decl(ramdaToolsNoInfinite2.ts, 435, 37))
+>'6' : Symbol(IterationMap['6'], Decl(ramdaToolsNoInfinite2.ts, 435, 37))
 
         '7': ['6', '8', '7', 7, '+'];
->'7' : Symbol('7', Decl(ramdaToolsNoInfinite2.ts, 436, 37))
+>'7' : Symbol(IterationMap['7'], Decl(ramdaToolsNoInfinite2.ts, 436, 37))
 
         '8': ['7', '9', '8', 8, '+'];
->'8' : Symbol('8', Decl(ramdaToolsNoInfinite2.ts, 437, 37))
+>'8' : Symbol(IterationMap['8'], Decl(ramdaToolsNoInfinite2.ts, 437, 37))
 
         '9': ['8', '10', '9', 9, '+'];
->'9' : Symbol('9', Decl(ramdaToolsNoInfinite2.ts, 438, 37))
+>'9' : Symbol(IterationMap['9'], Decl(ramdaToolsNoInfinite2.ts, 438, 37))
 
         '10': ['9', '11', '10', 10, '+'];
->'10' : Symbol('10', Decl(ramdaToolsNoInfinite2.ts, 439, 38))
+>'10' : Symbol(IterationMap['10'], Decl(ramdaToolsNoInfinite2.ts, 439, 38))
 
         '11': ['10', '12', '11', 11, '+'];
->'11' : Symbol('11', Decl(ramdaToolsNoInfinite2.ts, 440, 41))
+>'11' : Symbol(IterationMap['11'], Decl(ramdaToolsNoInfinite2.ts, 440, 41))
 
         '12': ['11', '13', '12', 12, '+'];
->'12' : Symbol('12', Decl(ramdaToolsNoInfinite2.ts, 441, 42))
+>'12' : Symbol(IterationMap['12'], Decl(ramdaToolsNoInfinite2.ts, 441, 42))
 
         '13': ['12', '14', '13', 13, '+'];
->'13' : Symbol('13', Decl(ramdaToolsNoInfinite2.ts, 442, 42))
+>'13' : Symbol(IterationMap['13'], Decl(ramdaToolsNoInfinite2.ts, 442, 42))
 
         '14': ['13', '15', '14', 14, '+'];
->'14' : Symbol('14', Decl(ramdaToolsNoInfinite2.ts, 443, 42))
+>'14' : Symbol(IterationMap['14'], Decl(ramdaToolsNoInfinite2.ts, 443, 42))
 
         '15': ['14', '16', '15', 15, '+'];
->'15' : Symbol('15', Decl(ramdaToolsNoInfinite2.ts, 444, 42))
+>'15' : Symbol(IterationMap['15'], Decl(ramdaToolsNoInfinite2.ts, 444, 42))
 
         '16': ['15', '17', '16', 16, '+'];
->'16' : Symbol('16', Decl(ramdaToolsNoInfinite2.ts, 445, 42))
+>'16' : Symbol(IterationMap['16'], Decl(ramdaToolsNoInfinite2.ts, 445, 42))
 
         '17': ['16', '18', '17', 17, '+'];
->'17' : Symbol('17', Decl(ramdaToolsNoInfinite2.ts, 446, 42))
+>'17' : Symbol(IterationMap['17'], Decl(ramdaToolsNoInfinite2.ts, 446, 42))
 
         '18': ['17', '19', '18', 18, '+'];
->'18' : Symbol('18', Decl(ramdaToolsNoInfinite2.ts, 447, 42))
+>'18' : Symbol(IterationMap['18'], Decl(ramdaToolsNoInfinite2.ts, 447, 42))
 
         '19': ['18', '20', '19', 19, '+'];
->'19' : Symbol('19', Decl(ramdaToolsNoInfinite2.ts, 448, 42))
+>'19' : Symbol(IterationMap['19'], Decl(ramdaToolsNoInfinite2.ts, 448, 42))
 
         '20': ['19', '21', '20', 20, '+'];
->'20' : Symbol('20', Decl(ramdaToolsNoInfinite2.ts, 449, 42))
+>'20' : Symbol(IterationMap['20'], Decl(ramdaToolsNoInfinite2.ts, 449, 42))
 
         '21': ['20', '22', '21', 21, '+'];
->'21' : Symbol('21', Decl(ramdaToolsNoInfinite2.ts, 450, 42))
+>'21' : Symbol(IterationMap['21'], Decl(ramdaToolsNoInfinite2.ts, 450, 42))
 
         '22': ['21', '23', '22', 22, '+'];
->'22' : Symbol('22', Decl(ramdaToolsNoInfinite2.ts, 451, 42))
+>'22' : Symbol(IterationMap['22'], Decl(ramdaToolsNoInfinite2.ts, 451, 42))
 
         '23': ['22', '24', '23', 23, '+'];
->'23' : Symbol('23', Decl(ramdaToolsNoInfinite2.ts, 452, 42))
+>'23' : Symbol(IterationMap['23'], Decl(ramdaToolsNoInfinite2.ts, 452, 42))
 
         '24': ['23', '25', '24', 24, '+'];
->'24' : Symbol('24', Decl(ramdaToolsNoInfinite2.ts, 453, 42))
+>'24' : Symbol(IterationMap['24'], Decl(ramdaToolsNoInfinite2.ts, 453, 42))
 
         '25': ['24', '26', '25', 25, '+'];
->'25' : Symbol('25', Decl(ramdaToolsNoInfinite2.ts, 454, 42))
+>'25' : Symbol(IterationMap['25'], Decl(ramdaToolsNoInfinite2.ts, 454, 42))
 
         '26': ['25', '27', '26', 26, '+'];
->'26' : Symbol('26', Decl(ramdaToolsNoInfinite2.ts, 455, 42))
+>'26' : Symbol(IterationMap['26'], Decl(ramdaToolsNoInfinite2.ts, 455, 42))
 
         '27': ['26', '28', '27', 27, '+'];
->'27' : Symbol('27', Decl(ramdaToolsNoInfinite2.ts, 456, 42))
+>'27' : Symbol(IterationMap['27'], Decl(ramdaToolsNoInfinite2.ts, 456, 42))
 
         '28': ['27', '29', '28', 28, '+'];
->'28' : Symbol('28', Decl(ramdaToolsNoInfinite2.ts, 457, 42))
+>'28' : Symbol(IterationMap['28'], Decl(ramdaToolsNoInfinite2.ts, 457, 42))
 
         '29': ['28', '30', '29', 29, '+'];
->'29' : Symbol('29', Decl(ramdaToolsNoInfinite2.ts, 458, 42))
+>'29' : Symbol(IterationMap['29'], Decl(ramdaToolsNoInfinite2.ts, 458, 42))
 
         '30': ['29', '31', '30', 30, '+'];
->'30' : Symbol('30', Decl(ramdaToolsNoInfinite2.ts, 459, 42))
+>'30' : Symbol(IterationMap['30'], Decl(ramdaToolsNoInfinite2.ts, 459, 42))
 
         '31': ['30', '32', '31', 31, '+'];
->'31' : Symbol('31', Decl(ramdaToolsNoInfinite2.ts, 460, 42))
+>'31' : Symbol(IterationMap['31'], Decl(ramdaToolsNoInfinite2.ts, 460, 42))
 
         '32': ['31', '33', '32', 32, '+'];
->'32' : Symbol('32', Decl(ramdaToolsNoInfinite2.ts, 461, 42))
+>'32' : Symbol(IterationMap['32'], Decl(ramdaToolsNoInfinite2.ts, 461, 42))
 
         '33': ['32', '34', '33', 33, '+'];
->'33' : Symbol('33', Decl(ramdaToolsNoInfinite2.ts, 462, 42))
+>'33' : Symbol(IterationMap['33'], Decl(ramdaToolsNoInfinite2.ts, 462, 42))
 
         '34': ['33', '35', '34', 34, '+'];
->'34' : Symbol('34', Decl(ramdaToolsNoInfinite2.ts, 463, 42))
+>'34' : Symbol(IterationMap['34'], Decl(ramdaToolsNoInfinite2.ts, 463, 42))
 
         '35': ['34', '36', '35', 35, '+'];
->'35' : Symbol('35', Decl(ramdaToolsNoInfinite2.ts, 464, 42))
+>'35' : Symbol(IterationMap['35'], Decl(ramdaToolsNoInfinite2.ts, 464, 42))
 
         '36': ['35', '37', '36', 36, '+'];
->'36' : Symbol('36', Decl(ramdaToolsNoInfinite2.ts, 465, 42))
+>'36' : Symbol(IterationMap['36'], Decl(ramdaToolsNoInfinite2.ts, 465, 42))
 
         '37': ['36', '38', '37', 37, '+'];
->'37' : Symbol('37', Decl(ramdaToolsNoInfinite2.ts, 466, 42))
+>'37' : Symbol(IterationMap['37'], Decl(ramdaToolsNoInfinite2.ts, 466, 42))
 
         '38': ['37', '39', '38', 38, '+'];
->'38' : Symbol('38', Decl(ramdaToolsNoInfinite2.ts, 467, 42))
+>'38' : Symbol(IterationMap['38'], Decl(ramdaToolsNoInfinite2.ts, 467, 42))
 
         '39': ['38', '40', '39', 39, '+'];
->'39' : Symbol('39', Decl(ramdaToolsNoInfinite2.ts, 468, 42))
+>'39' : Symbol(IterationMap['39'], Decl(ramdaToolsNoInfinite2.ts, 468, 42))
 
         '40': ['39', '__', '40', 40, '+'];
->'40' : Symbol('40', Decl(ramdaToolsNoInfinite2.ts, 469, 42))
+>'40' : Symbol(IterationMap['40'], Decl(ramdaToolsNoInfinite2.ts, 469, 42))
 
         '__': ['__', '__', string, number, '-' | '0' | '+'];
->'__' : Symbol('__', Decl(ramdaToolsNoInfinite2.ts, 470, 42))
+>'__' : Symbol(IterationMap['__'], Decl(ramdaToolsNoInfinite2.ts, 470, 42))
 
     };
 
@@ -1761,7 +1761,7 @@ declare module "List/List" {
     export type List<A = any> = ReadonlyArray<A>;
 >List : Symbol(List, Decl(ramdaToolsNoInfinite2.ts, 516, 28))
 >A : Symbol(A, Decl(ramdaToolsNoInfinite2.ts, 518, 21))
->ReadonlyArray : Symbol(ReadonlyArray, Decl(lib.es5.d.ts, --, --))
+>ReadonlyArray : Symbol(List, Decl(lib.es5.d.ts, --, --))
 >A : Symbol(A, Decl(ramdaToolsNoInfinite2.ts, 518, 21))
 }
 declare module "Function/Function" {
diff --git a/tests/baselines/reference/recursiveConditionalCrash2.symbols b/tests/baselines/reference/recursiveConditionalCrash2.symbols
index e7d047021094c..78bcf4da9a3f5 100644
--- a/tests/baselines/reference/recursiveConditionalCrash2.symbols
+++ b/tests/baselines/reference/recursiveConditionalCrash2.symbols
@@ -6,7 +6,7 @@ export type CanBeExpanded<T extends object> = {
 >T : Symbol(T, Decl(recursiveConditionalCrash2.ts, 2, 26))
 
   value: T
->value : Symbol(value, Decl(recursiveConditionalCrash2.ts, 2, 47))
+>value : Symbol(CanBeExpanded.value, Decl(recursiveConditionalCrash2.ts, 2, 47))
 >T : Symbol(T, Decl(recursiveConditionalCrash2.ts, 2, 26))
 }
 
diff --git a/tests/baselines/reference/recursiveConditionalCrash3.symbols b/tests/baselines/reference/recursiveConditionalCrash3.symbols
index d4c100a63753e..afaaf59a470eb 100644
--- a/tests/baselines/reference/recursiveConditionalCrash3.symbols
+++ b/tests/baselines/reference/recursiveConditionalCrash3.symbols
@@ -14,11 +14,11 @@ export type CanBeExpanded<T extends object = object, D = string> = {
 >D : Symbol(D, Decl(recursiveConditionalCrash3.ts, 9, 52))
 
     value: T
->value : Symbol(value, Decl(recursiveConditionalCrash3.ts, 9, 68))
+>value : Symbol(CanBeExpanded.value, Decl(recursiveConditionalCrash3.ts, 9, 68))
 >T : Symbol(T, Decl(recursiveConditionalCrash3.ts, 9, 26))
 
     default: D
->default : Symbol(default, Decl(recursiveConditionalCrash3.ts, 10, 12))
+>default : Symbol(CanBeExpanded.default, Decl(recursiveConditionalCrash3.ts, 10, 12))
 >D : Symbol(D, Decl(recursiveConditionalCrash3.ts, 9, 52))
 }
 
diff --git a/tests/baselines/reference/recursiveConditionalTypes.symbols b/tests/baselines/reference/recursiveConditionalTypes.symbols
index e9b58df3c28a3..23d466d47539b 100644
--- a/tests/baselines/reference/recursiveConditionalTypes.symbols
+++ b/tests/baselines/reference/recursiveConditionalTypes.symbols
@@ -24,7 +24,7 @@ type MyPromise<T> = {
 >T : Symbol(T, Decl(recursiveConditionalTypes.ts, 7, 15))
 
     then<U>(f: ((value: T) => U | PromiseLike<U>) | null | undefined): MyPromise<U>;
->then : Symbol(then, Decl(recursiveConditionalTypes.ts, 7, 21))
+>then : Symbol(MyPromise.then, Decl(recursiveConditionalTypes.ts, 7, 21))
 >U : Symbol(U, Decl(recursiveConditionalTypes.ts, 8, 9))
 >f : Symbol(f, Decl(recursiveConditionalTypes.ts, 8, 12))
 >value : Symbol(value, Decl(recursiveConditionalTypes.ts, 8, 17))
@@ -339,13 +339,13 @@ unbox({ value: { value: { get value() { return this; } }}});  // { readonly valu
 type Box1<T> = { value: T };
 >Box1 : Symbol(Box1, Decl(recursiveConditionalTypes.ts, 82, 60))
 >T : Symbol(T, Decl(recursiveConditionalTypes.ts, 86, 10))
->value : Symbol(value, Decl(recursiveConditionalTypes.ts, 86, 16))
+>value : Symbol(Box1.value, Decl(recursiveConditionalTypes.ts, 86, 16))
 >T : Symbol(T, Decl(recursiveConditionalTypes.ts, 86, 10))
 
 type Box2<T> = { value: T };
 >Box2 : Symbol(Box2, Decl(recursiveConditionalTypes.ts, 86, 28))
 >T : Symbol(T, Decl(recursiveConditionalTypes.ts, 87, 10))
->value : Symbol(value, Decl(recursiveConditionalTypes.ts, 87, 16))
+>value : Symbol(Box2.value, Decl(recursiveConditionalTypes.ts, 87, 16))
 >T : Symbol(T, Decl(recursiveConditionalTypes.ts, 87, 10))
 
 declare function foo<T>(x: Box1<Box1<T>>): T;
@@ -474,7 +474,7 @@ function f21<T extends number>(x: Grow1<[], T>, y: Grow2<[], T>) {
 type ParseSuccess<R extends string> = { rest: R };
 >ParseSuccess : Symbol(ParseSuccess, Decl(recursiveConditionalTypes.ts, 117, 1))
 >R : Symbol(R, Decl(recursiveConditionalTypes.ts, 121, 18))
->rest : Symbol(rest, Decl(recursiveConditionalTypes.ts, 121, 39))
+>rest : Symbol(ParseSuccess.rest, Decl(recursiveConditionalTypes.ts, 121, 39))
 >R : Symbol(R, Decl(recursiveConditionalTypes.ts, 121, 18))
 
 type ParseManyWhitespace<S extends string> =
diff --git a/tests/baselines/reference/reverseMappedPartiallyInferableTypes.symbols b/tests/baselines/reference/reverseMappedPartiallyInferableTypes.symbols
index 6ababcbb9f1e2..26cd01d789a5e 100644
--- a/tests/baselines/reference/reverseMappedPartiallyInferableTypes.symbols
+++ b/tests/baselines/reference/reverseMappedPartiallyInferableTypes.symbols
@@ -36,20 +36,20 @@ export type PropOptions<T> = {
 >T : Symbol(T, Decl(reverseMappedPartiallyInferableTypes.ts, 11, 24))
 
     type: PropType<T>;
->type : Symbol(type, Decl(reverseMappedPartiallyInferableTypes.ts, 11, 30))
+>type : Symbol(PropValidator.type, Decl(reverseMappedPartiallyInferableTypes.ts, 11, 30))
 >PropType : Symbol(PropType, Decl(reverseMappedPartiallyInferableTypes.ts, 2, 31))
 >T : Symbol(T, Decl(reverseMappedPartiallyInferableTypes.ts, 11, 24))
 
     value?: PropDefaultValue<T>,
->value : Symbol(value, Decl(reverseMappedPartiallyInferableTypes.ts, 12, 22))
+>value : Symbol(PropValidator.value, Decl(reverseMappedPartiallyInferableTypes.ts, 12, 22))
 >PropDefaultValue : Symbol(PropDefaultValue, Decl(reverseMappedPartiallyInferableTypes.ts, 3, 34))
 >T : Symbol(T, Decl(reverseMappedPartiallyInferableTypes.ts, 11, 24))
 
     required?: boolean;
->required : Symbol(required, Decl(reverseMappedPartiallyInferableTypes.ts, 14, 32))
+>required : Symbol(PropValidator.required, Decl(reverseMappedPartiallyInferableTypes.ts, 14, 32))
 
     validator?: PropValidatorFunction<T>;
->validator : Symbol(validator, Decl(reverseMappedPartiallyInferableTypes.ts, 15, 23))
+>validator : Symbol(PropValidator.validator, Decl(reverseMappedPartiallyInferableTypes.ts, 15, 23))
 >PropValidatorFunction : Symbol(PropValidatorFunction, Decl(reverseMappedPartiallyInferableTypes.ts, 4, 36))
 >T : Symbol(T, Decl(reverseMappedPartiallyInferableTypes.ts, 11, 24))
 }
@@ -149,18 +149,18 @@ r.notResolved
 >notResolved : Symbol(notResolved, Decl(reverseMappedPartiallyInferableTypes.ts, 32, 12))
 
 r.explicit.required
->r.explicit.required : Symbol(required, Decl(reverseMappedPartiallyInferableTypes.ts, 14, 32))
+>r.explicit.required : Symbol(PropValidator.required, Decl(reverseMappedPartiallyInferableTypes.ts, 14, 32))
 >r.explicit : Symbol(explicit, Decl(reverseMappedPartiallyInferableTypes.ts, 38, 10))
 >r : Symbol(r, Decl(reverseMappedPartiallyInferableTypes.ts, 31, 5))
 >explicit : Symbol(explicit, Decl(reverseMappedPartiallyInferableTypes.ts, 38, 10))
->required : Symbol(required, Decl(reverseMappedPartiallyInferableTypes.ts, 14, 32))
+>required : Symbol(PropValidator.required, Decl(reverseMappedPartiallyInferableTypes.ts, 14, 32))
 
 r.notResolved.required
->r.notResolved.required : Symbol(required, Decl(reverseMappedPartiallyInferableTypes.ts, 14, 32))
+>r.notResolved.required : Symbol(PropValidator.required, Decl(reverseMappedPartiallyInferableTypes.ts, 14, 32))
 >r.notResolved : Symbol(notResolved, Decl(reverseMappedPartiallyInferableTypes.ts, 32, 12))
 >r : Symbol(r, Decl(reverseMappedPartiallyInferableTypes.ts, 31, 5))
 >notResolved : Symbol(notResolved, Decl(reverseMappedPartiallyInferableTypes.ts, 32, 12))
->required : Symbol(required, Decl(reverseMappedPartiallyInferableTypes.ts, 14, 32))
+>required : Symbol(PropValidator.required, Decl(reverseMappedPartiallyInferableTypes.ts, 14, 32))
 
 // Modified repro from #30505
 
@@ -169,11 +169,11 @@ type Box<T> = {
 >T : Symbol(T, Decl(reverseMappedPartiallyInferableTypes.ts, 55, 9))
 
     contents?: T;
->contents : Symbol(contents, Decl(reverseMappedPartiallyInferableTypes.ts, 55, 15))
+>contents : Symbol(Box.contents, Decl(reverseMappedPartiallyInferableTypes.ts, 55, 15))
 >T : Symbol(T, Decl(reverseMappedPartiallyInferableTypes.ts, 55, 9))
 
     contains?(content: T): boolean;
->contains : Symbol(contains, Decl(reverseMappedPartiallyInferableTypes.ts, 56, 17))
+>contains : Symbol(Box.contains, Decl(reverseMappedPartiallyInferableTypes.ts, 56, 17))
 >content : Symbol(content, Decl(reverseMappedPartiallyInferableTypes.ts, 57, 14))
 >T : Symbol(T, Decl(reverseMappedPartiallyInferableTypes.ts, 55, 9))
 
diff --git a/tests/baselines/reference/reverseMappedTypeAssignableToIndex.symbols b/tests/baselines/reference/reverseMappedTypeAssignableToIndex.symbols
index 38ed9ff039f0e..163462180b76a 100644
--- a/tests/baselines/reference/reverseMappedTypeAssignableToIndex.symbols
+++ b/tests/baselines/reference/reverseMappedTypeAssignableToIndex.symbols
@@ -23,20 +23,20 @@ type LiteralType = {
 >LiteralType : Symbol(LiteralType, Decl(reverseMappedTypeAssignableToIndex.ts, 2, 64))
 
 	first: "first";
->first : Symbol(first, Decl(reverseMappedTypeAssignableToIndex.ts, 6, 20))
+>first : Symbol(LiteralType.first, Decl(reverseMappedTypeAssignableToIndex.ts, 6, 20))
 
 	second: "second";
->second : Symbol(second, Decl(reverseMappedTypeAssignableToIndex.ts, 7, 16))
+>second : Symbol(LiteralType.second, Decl(reverseMappedTypeAssignableToIndex.ts, 7, 16))
 }
 type MappedLiteralType = {
 >MappedLiteralType : Symbol(MappedLiteralType, Decl(reverseMappedTypeAssignableToIndex.ts, 9, 1))
 
 	first: { name: "first" },
->first : Symbol(first, Decl(reverseMappedTypeAssignableToIndex.ts, 10, 26))
+>first : Symbol(MappedLiteralType.first, Decl(reverseMappedTypeAssignableToIndex.ts, 10, 26))
 >name : Symbol(name, Decl(reverseMappedTypeAssignableToIndex.ts, 11, 9))
 
 	second: { name: "second" },
->second : Symbol(second, Decl(reverseMappedTypeAssignableToIndex.ts, 11, 26))
+>second : Symbol(MappedLiteralType.second, Decl(reverseMappedTypeAssignableToIndex.ts, 11, 26))
 >name : Symbol(name, Decl(reverseMappedTypeAssignableToIndex.ts, 12, 10))
 
 };
diff --git a/tests/baselines/reference/silentNeverPropagation.symbols b/tests/baselines/reference/silentNeverPropagation.symbols
index d52a2436fa4d4..bd074e7528e4b 100644
--- a/tests/baselines/reference/silentNeverPropagation.symbols
+++ b/tests/baselines/reference/silentNeverPropagation.symbols
@@ -6,7 +6,7 @@ type ModuleWithState<TState> = {
 >TState : Symbol(TState, Decl(silentNeverPropagation.ts, 2, 21))
 
     state: TState;
->state : Symbol(state, Decl(silentNeverPropagation.ts, 2, 32))
+>state : Symbol(ModuleWithState.state, Decl(silentNeverPropagation.ts, 2, 32))
 >TState : Symbol(TState, Decl(silentNeverPropagation.ts, 2, 21))
 
 };
@@ -15,7 +15,7 @@ type State = {
 >State : Symbol(State, Decl(silentNeverPropagation.ts, 4, 2))
 
     a: number;
->a : Symbol(a, Decl(silentNeverPropagation.ts, 6, 14))
+>a : Symbol(State.a, Decl(silentNeverPropagation.ts, 6, 14))
 
 };
 
@@ -23,7 +23,7 @@ type MoreState = {
 >MoreState : Symbol(MoreState, Decl(silentNeverPropagation.ts, 8, 2))
 
     z: string;
->z : Symbol(z, Decl(silentNeverPropagation.ts, 10, 18))
+>z : Symbol(MoreState.z, Decl(silentNeverPropagation.ts, 10, 18))
 
 };
 
@@ -65,17 +65,17 @@ const breaks = convert(
 
 breaks.state.a
 >breaks.state.a : Symbol(a, Decl(silentNeverPropagation.ts, 19, 18))
->breaks.state : Symbol(state, Decl(silentNeverPropagation.ts, 2, 32), Decl(silentNeverPropagation.ts, 2, 32))
+>breaks.state : Symbol(ModuleWithState.state, Decl(silentNeverPropagation.ts, 2, 32), Decl(silentNeverPropagation.ts, 2, 32))
 >breaks : Symbol(breaks, Decl(silentNeverPropagation.ts, 18, 5))
->state : Symbol(state, Decl(silentNeverPropagation.ts, 2, 32), Decl(silentNeverPropagation.ts, 2, 32))
+>state : Symbol(ModuleWithState.state, Decl(silentNeverPropagation.ts, 2, 32), Decl(silentNeverPropagation.ts, 2, 32))
 >a : Symbol(a, Decl(silentNeverPropagation.ts, 19, 18))
 
 breaks.state.z
->breaks.state.z : Symbol(z, Decl(silentNeverPropagation.ts, 10, 18))
->breaks.state : Symbol(state, Decl(silentNeverPropagation.ts, 2, 32), Decl(silentNeverPropagation.ts, 2, 32))
+>breaks.state.z : Symbol(MoreState.z, Decl(silentNeverPropagation.ts, 10, 18))
+>breaks.state : Symbol(ModuleWithState.state, Decl(silentNeverPropagation.ts, 2, 32), Decl(silentNeverPropagation.ts, 2, 32))
 >breaks : Symbol(breaks, Decl(silentNeverPropagation.ts, 18, 5))
->state : Symbol(state, Decl(silentNeverPropagation.ts, 2, 32), Decl(silentNeverPropagation.ts, 2, 32))
->z : Symbol(z, Decl(silentNeverPropagation.ts, 10, 18))
+>state : Symbol(ModuleWithState.state, Decl(silentNeverPropagation.ts, 2, 32), Decl(silentNeverPropagation.ts, 2, 32))
+>z : Symbol(MoreState.z, Decl(silentNeverPropagation.ts, 10, 18))
 
 breaks.foo()
 >breaks.foo : Symbol(foo, Decl(silentNeverPropagation.ts, 19, 29))
diff --git a/tests/baselines/reference/specedNoStackBlown.symbols b/tests/baselines/reference/specedNoStackBlown.symbols
index 299e31e98082c..e6d22027f04f6 100644
--- a/tests/baselines/reference/specedNoStackBlown.symbols
+++ b/tests/baselines/reference/specedNoStackBlown.symbols
@@ -56,7 +56,7 @@ export type SpecArray<INPUT, ROOTINPUT = any> = Array<Spec<INPUT, ROOTINPUT>>;
 >SpecArray : Symbol(SpecArray, Decl(specedNoStackBlown.ts, 14, 90))
 >INPUT : Symbol(INPUT, Decl(specedNoStackBlown.ts, 16, 22))
 >ROOTINPUT : Symbol(ROOTINPUT, Decl(specedNoStackBlown.ts, 16, 28))
->Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>Array : Symbol(SpecArray, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >Spec : Symbol(Spec, Decl(specedNoStackBlown.ts, 12, 45))
 >INPUT : Symbol(INPUT, Decl(specedNoStackBlown.ts, 16, 22))
 >ROOTINPUT : Symbol(ROOTINPUT, Decl(specedNoStackBlown.ts, 16, 28))
diff --git a/tests/baselines/reference/spreadExcessProperty.symbols b/tests/baselines/reference/spreadExcessProperty.symbols
index bc4ef20664398..bde07f037cd03 100644
--- a/tests/baselines/reference/spreadExcessProperty.symbols
+++ b/tests/baselines/reference/spreadExcessProperty.symbols
@@ -1,8 +1,8 @@
 === tests/cases/conformance/types/spread/spreadExcessProperty.ts ===
 type A = { a: string, b: string };
 >A : Symbol(A, Decl(spreadExcessProperty.ts, 0, 0))
->a : Symbol(a, Decl(spreadExcessProperty.ts, 0, 10))
->b : Symbol(b, Decl(spreadExcessProperty.ts, 0, 21))
+>a : Symbol(A.a, Decl(spreadExcessProperty.ts, 0, 10))
+>b : Symbol(A.b, Decl(spreadExcessProperty.ts, 0, 21))
 
 const extra1 = { a: "a", b: "b", extra: "extra" };
 >extra1 : Symbol(extra1, Decl(spreadExcessProperty.ts, 1, 5))
diff --git a/tests/baselines/reference/spreadIdenticalTypesRemoved.types b/tests/baselines/reference/spreadIdenticalTypesRemoved.types
index 6695770ccc3ed..693b73ef23c4d 100644
--- a/tests/baselines/reference/spreadIdenticalTypesRemoved.types
+++ b/tests/baselines/reference/spreadIdenticalTypesRemoved.types
@@ -17,7 +17,7 @@ interface Animal {
 }
 
 function clonePet(pet: Animal, fullCopy?: boolean) {
->clonePet : (pet: Animal, fullCopy?: boolean | undefined) => { name: string; kind: string; age?: number | undefined; location?: string | undefined; owner?: object | undefined; }
+>clonePet : (pet: Animal, fullCopy?: boolean) => { name: string; kind: string; age?: number | undefined; location?: string | undefined; owner?: object | undefined; }
 >pet : Animal
 >fullCopy : boolean | undefined
 
diff --git a/tests/baselines/reference/spreadUnion3.types b/tests/baselines/reference/spreadUnion3.types
index 62a2fa2da733c..8c4b955ff1a38 100644
--- a/tests/baselines/reference/spreadUnion3.types
+++ b/tests/baselines/reference/spreadUnion3.types
@@ -18,7 +18,7 @@ f(undefined)
 
 
 function g(t?: { a: number } | null): void {
->g : (t?: { a: number; } | null | undefined) => void
+>g : (t?: {    a: number;} | null) => void
 >t : { a: number; } | null | undefined
 >a : number
 >null : null
diff --git a/tests/baselines/reference/stackDepthLimitCastingType.types b/tests/baselines/reference/stackDepthLimitCastingType.types
index 27d09998e3010..76d08fdd570bd 100644
--- a/tests/baselines/reference/stackDepthLimitCastingType.types
+++ b/tests/baselines/reference/stackDepthLimitCastingType.types
@@ -7,7 +7,7 @@ declare global {
 >Model : Model<T, E>
 
         initialize(attributes?: T, options?: CombinedModelConstructorOptions<E, this>): void;
->initialize : (attributes?: T | undefined, options?: CombinedModelConstructorOptions<E, this> | undefined) => void
+>initialize : (attributes?: T, options?: CombinedModelConstructorOptions<E, this>) => void
 >attributes : T | undefined
 >options : CombinedModelConstructorOptions<E, this> | undefined
 
diff --git a/tests/baselines/reference/strictFunctionTypesErrors.symbols b/tests/baselines/reference/strictFunctionTypesErrors.symbols
index f887f15aeaceb..3c96e8bf801ad 100644
--- a/tests/baselines/reference/strictFunctionTypesErrors.symbols
+++ b/tests/baselines/reference/strictFunctionTypesErrors.symbols
@@ -475,7 +475,7 @@ namespace n2 {
 >BivariantHack : Symbol(BivariantHack, Decl(strictFunctionTypesErrors.ts, 149, 14))
 >Input : Symbol(Input, Decl(strictFunctionTypesErrors.ts, 150, 23))
 >Output : Symbol(Output, Decl(strictFunctionTypesErrors.ts, 150, 29))
->foo : Symbol(foo, Decl(strictFunctionTypesErrors.ts, 150, 41))
+>foo : Symbol(BivariantHack, Decl(strictFunctionTypesErrors.ts, 150, 41))
 >x : Symbol(x, Decl(strictFunctionTypesErrors.ts, 150, 46))
 >Input : Symbol(Input, Decl(strictFunctionTypesErrors.ts, 150, 23))
 >Output : Symbol(Output, Decl(strictFunctionTypesErrors.ts, 150, 29))
diff --git a/tests/baselines/reference/strictNullLogicalAndOr.types b/tests/baselines/reference/strictNullLogicalAndOr.types
index 33881b5d9d72c..6c6cba3356165 100644
--- a/tests/baselines/reference/strictNullLogicalAndOr.types
+++ b/tests/baselines/reference/strictNullLogicalAndOr.types
@@ -30,7 +30,7 @@ choice(Math.PI);
 >PI : number
 
 function sq(n?: number): number {
->sq : (n?: number | undefined) => number
+>sq : (n?: number) => number
 >n : number | undefined
 
   const r = n !== undefined && n*n || 0;
diff --git a/tests/baselines/reference/strictOptionalProperties1.symbols b/tests/baselines/reference/strictOptionalProperties1.symbols
index 66550fd3e3b50..fc3b56fcec5c9 100644
--- a/tests/baselines/reference/strictOptionalProperties1.symbols
+++ b/tests/baselines/reference/strictOptionalProperties1.symbols
@@ -323,20 +323,20 @@ type Props = {
 >Props : Symbol(Props, Decl(strictOptionalProperties1.ts, 83, 1))
 
     foo: string;
->foo : Symbol(foo, Decl(strictOptionalProperties1.ts, 87, 14))
+>foo : Symbol(Props.foo, Decl(strictOptionalProperties1.ts, 87, 14))
 
     bar: string
->bar : Symbol(bar, Decl(strictOptionalProperties1.ts, 88, 16))
+>bar : Symbol(Props.bar, Decl(strictOptionalProperties1.ts, 88, 16))
 }
 
 type InputProps = {
 >InputProps : Symbol(InputProps, Decl(strictOptionalProperties1.ts, 90, 1))
 
     foo?: string;
->foo : Symbol(foo, Decl(strictOptionalProperties1.ts, 92, 19))
+>foo : Symbol(InputProps.foo, Decl(strictOptionalProperties1.ts, 92, 19))
 
     bar: string;
->bar : Symbol(bar, Decl(strictOptionalProperties1.ts, 93, 17))
+>bar : Symbol(InputProps.bar, Decl(strictOptionalProperties1.ts, 93, 17))
 }
 
 const defaultProps: Pick<Props, 'foo'> = { foo: 'foo' };
diff --git a/tests/baselines/reference/stringEnumLiteralTypes3.symbols b/tests/baselines/reference/stringEnumLiteralTypes3.symbols
index 1a780b6e716af..e649a893ae882 100644
--- a/tests/baselines/reference/stringEnumLiteralTypes3.symbols
+++ b/tests/baselines/reference/stringEnumLiteralTypes3.symbols
@@ -2,18 +2,18 @@
 const enum Choice { Unknown = "", Yes = "yes", No = "no" };
 >Choice : Symbol(Choice, Decl(stringEnumLiteralTypes3.ts, 0, 0))
 >Unknown : Symbol(Choice.Unknown, Decl(stringEnumLiteralTypes3.ts, 0, 19))
->Yes : Symbol(Choice.Yes, Decl(stringEnumLiteralTypes3.ts, 0, 33))
+>Yes : Symbol(Yes, Decl(stringEnumLiteralTypes3.ts, 0, 33))
 >No : Symbol(Choice.No, Decl(stringEnumLiteralTypes3.ts, 0, 46))
 
 type Yes = Choice.Yes;
 >Yes : Symbol(Yes, Decl(stringEnumLiteralTypes3.ts, 0, 59))
 >Choice : Symbol(Choice, Decl(stringEnumLiteralTypes3.ts, 0, 0))
->Yes : Symbol(Choice.Yes, Decl(stringEnumLiteralTypes3.ts, 0, 33))
+>Yes : Symbol(Yes, Decl(stringEnumLiteralTypes3.ts, 0, 33))
 
 type YesNo = Choice.Yes | Choice.No;
 >YesNo : Symbol(YesNo, Decl(stringEnumLiteralTypes3.ts, 2, 22))
 >Choice : Symbol(Choice, Decl(stringEnumLiteralTypes3.ts, 0, 0))
->Yes : Symbol(Choice.Yes, Decl(stringEnumLiteralTypes3.ts, 0, 33))
+>Yes : Symbol(Yes, Decl(stringEnumLiteralTypes3.ts, 0, 33))
 >Choice : Symbol(Choice, Decl(stringEnumLiteralTypes3.ts, 0, 0))
 >No : Symbol(Choice.No, Decl(stringEnumLiteralTypes3.ts, 0, 46))
 
@@ -22,14 +22,14 @@ type NoYes = Choice.No | Choice.Yes;
 >Choice : Symbol(Choice, Decl(stringEnumLiteralTypes3.ts, 0, 0))
 >No : Symbol(Choice.No, Decl(stringEnumLiteralTypes3.ts, 0, 46))
 >Choice : Symbol(Choice, Decl(stringEnumLiteralTypes3.ts, 0, 0))
->Yes : Symbol(Choice.Yes, Decl(stringEnumLiteralTypes3.ts, 0, 33))
+>Yes : Symbol(Yes, Decl(stringEnumLiteralTypes3.ts, 0, 33))
 
 type UnknownYesNo = Choice.Unknown | Choice.Yes | Choice.No;
 >UnknownYesNo : Symbol(UnknownYesNo, Decl(stringEnumLiteralTypes3.ts, 4, 36))
 >Choice : Symbol(Choice, Decl(stringEnumLiteralTypes3.ts, 0, 0))
 >Unknown : Symbol(Choice.Unknown, Decl(stringEnumLiteralTypes3.ts, 0, 19))
 >Choice : Symbol(Choice, Decl(stringEnumLiteralTypes3.ts, 0, 0))
->Yes : Symbol(Choice.Yes, Decl(stringEnumLiteralTypes3.ts, 0, 33))
+>Yes : Symbol(Yes, Decl(stringEnumLiteralTypes3.ts, 0, 33))
 >Choice : Symbol(Choice, Decl(stringEnumLiteralTypes3.ts, 0, 0))
 >No : Symbol(Choice.No, Decl(stringEnumLiteralTypes3.ts, 0, 46))
 
@@ -164,9 +164,9 @@ function f5(a: Yes, b: YesNo, c: UnknownYesNo, d: Choice) {
 
     a = Choice.Yes;
 >a : Symbol(a, Decl(stringEnumLiteralTypes3.ts, 35, 12))
->Choice.Yes : Symbol(Choice.Yes, Decl(stringEnumLiteralTypes3.ts, 0, 33))
+>Choice.Yes : Symbol(Yes, Decl(stringEnumLiteralTypes3.ts, 0, 33))
 >Choice : Symbol(Choice, Decl(stringEnumLiteralTypes3.ts, 0, 0))
->Yes : Symbol(Choice.Yes, Decl(stringEnumLiteralTypes3.ts, 0, 33))
+>Yes : Symbol(Yes, Decl(stringEnumLiteralTypes3.ts, 0, 33))
 
     a = Choice.No;
 >a : Symbol(a, Decl(stringEnumLiteralTypes3.ts, 35, 12))
@@ -182,9 +182,9 @@ function f5(a: Yes, b: YesNo, c: UnknownYesNo, d: Choice) {
 
     b = Choice.Yes;
 >b : Symbol(b, Decl(stringEnumLiteralTypes3.ts, 35, 19))
->Choice.Yes : Symbol(Choice.Yes, Decl(stringEnumLiteralTypes3.ts, 0, 33))
+>Choice.Yes : Symbol(Yes, Decl(stringEnumLiteralTypes3.ts, 0, 33))
 >Choice : Symbol(Choice, Decl(stringEnumLiteralTypes3.ts, 0, 0))
->Yes : Symbol(Choice.Yes, Decl(stringEnumLiteralTypes3.ts, 0, 33))
+>Yes : Symbol(Yes, Decl(stringEnumLiteralTypes3.ts, 0, 33))
 
     b = Choice.No;
 >b : Symbol(b, Decl(stringEnumLiteralTypes3.ts, 35, 19))
@@ -200,9 +200,9 @@ function f5(a: Yes, b: YesNo, c: UnknownYesNo, d: Choice) {
 
     c = Choice.Yes;
 >c : Symbol(c, Decl(stringEnumLiteralTypes3.ts, 35, 29))
->Choice.Yes : Symbol(Choice.Yes, Decl(stringEnumLiteralTypes3.ts, 0, 33))
+>Choice.Yes : Symbol(Yes, Decl(stringEnumLiteralTypes3.ts, 0, 33))
 >Choice : Symbol(Choice, Decl(stringEnumLiteralTypes3.ts, 0, 0))
->Yes : Symbol(Choice.Yes, Decl(stringEnumLiteralTypes3.ts, 0, 33))
+>Yes : Symbol(Yes, Decl(stringEnumLiteralTypes3.ts, 0, 33))
 
     c = Choice.No;
 >c : Symbol(c, Decl(stringEnumLiteralTypes3.ts, 35, 29))
@@ -218,9 +218,9 @@ function f5(a: Yes, b: YesNo, c: UnknownYesNo, d: Choice) {
 
     d = Choice.Yes;
 >d : Symbol(d, Decl(stringEnumLiteralTypes3.ts, 35, 46))
->Choice.Yes : Symbol(Choice.Yes, Decl(stringEnumLiteralTypes3.ts, 0, 33))
+>Choice.Yes : Symbol(Yes, Decl(stringEnumLiteralTypes3.ts, 0, 33))
 >Choice : Symbol(Choice, Decl(stringEnumLiteralTypes3.ts, 0, 0))
->Yes : Symbol(Choice.Yes, Decl(stringEnumLiteralTypes3.ts, 0, 33))
+>Yes : Symbol(Yes, Decl(stringEnumLiteralTypes3.ts, 0, 33))
 
     d = Choice.No;
 >d : Symbol(d, Decl(stringEnumLiteralTypes3.ts, 35, 46))
@@ -248,9 +248,9 @@ function f6(a: Yes, b: YesNo, c: UnknownYesNo, d: Choice) {
 
     a === Choice.Yes;
 >a : Symbol(a, Decl(stringEnumLiteralTypes3.ts, 50, 12))
->Choice.Yes : Symbol(Choice.Yes, Decl(stringEnumLiteralTypes3.ts, 0, 33))
+>Choice.Yes : Symbol(Yes, Decl(stringEnumLiteralTypes3.ts, 0, 33))
 >Choice : Symbol(Choice, Decl(stringEnumLiteralTypes3.ts, 0, 0))
->Yes : Symbol(Choice.Yes, Decl(stringEnumLiteralTypes3.ts, 0, 33))
+>Yes : Symbol(Yes, Decl(stringEnumLiteralTypes3.ts, 0, 33))
 
     a === Choice.No;
 >a : Symbol(a, Decl(stringEnumLiteralTypes3.ts, 50, 12))
@@ -266,9 +266,9 @@ function f6(a: Yes, b: YesNo, c: UnknownYesNo, d: Choice) {
 
     b === Choice.Yes;
 >b : Symbol(b, Decl(stringEnumLiteralTypes3.ts, 50, 19))
->Choice.Yes : Symbol(Choice.Yes, Decl(stringEnumLiteralTypes3.ts, 0, 33))
+>Choice.Yes : Symbol(Yes, Decl(stringEnumLiteralTypes3.ts, 0, 33))
 >Choice : Symbol(Choice, Decl(stringEnumLiteralTypes3.ts, 0, 0))
->Yes : Symbol(Choice.Yes, Decl(stringEnumLiteralTypes3.ts, 0, 33))
+>Yes : Symbol(Yes, Decl(stringEnumLiteralTypes3.ts, 0, 33))
 
     b === Choice.No;
 >b : Symbol(b, Decl(stringEnumLiteralTypes3.ts, 50, 19))
@@ -284,9 +284,9 @@ function f6(a: Yes, b: YesNo, c: UnknownYesNo, d: Choice) {
 
     c === Choice.Yes;
 >c : Symbol(c, Decl(stringEnumLiteralTypes3.ts, 50, 29))
->Choice.Yes : Symbol(Choice.Yes, Decl(stringEnumLiteralTypes3.ts, 0, 33))
+>Choice.Yes : Symbol(Yes, Decl(stringEnumLiteralTypes3.ts, 0, 33))
 >Choice : Symbol(Choice, Decl(stringEnumLiteralTypes3.ts, 0, 0))
->Yes : Symbol(Choice.Yes, Decl(stringEnumLiteralTypes3.ts, 0, 33))
+>Yes : Symbol(Yes, Decl(stringEnumLiteralTypes3.ts, 0, 33))
 
     c === Choice.No;
 >c : Symbol(c, Decl(stringEnumLiteralTypes3.ts, 50, 29))
@@ -302,9 +302,9 @@ function f6(a: Yes, b: YesNo, c: UnknownYesNo, d: Choice) {
 
     d === Choice.Yes;
 >d : Symbol(d, Decl(stringEnumLiteralTypes3.ts, 50, 46))
->Choice.Yes : Symbol(Choice.Yes, Decl(stringEnumLiteralTypes3.ts, 0, 33))
+>Choice.Yes : Symbol(Yes, Decl(stringEnumLiteralTypes3.ts, 0, 33))
 >Choice : Symbol(Choice, Decl(stringEnumLiteralTypes3.ts, 0, 0))
->Yes : Symbol(Choice.Yes, Decl(stringEnumLiteralTypes3.ts, 0, 33))
+>Yes : Symbol(Yes, Decl(stringEnumLiteralTypes3.ts, 0, 33))
 
     d === Choice.No;
 >d : Symbol(d, Decl(stringEnumLiteralTypes3.ts, 50, 46))
@@ -405,9 +405,9 @@ function f10(x: Yes): Yes {
 >x : Symbol(x, Decl(stringEnumLiteralTypes3.ts, 84, 13))
 
         case Choice.Yes: return x;
->Choice.Yes : Symbol(Choice.Yes, Decl(stringEnumLiteralTypes3.ts, 0, 33))
+>Choice.Yes : Symbol(Yes, Decl(stringEnumLiteralTypes3.ts, 0, 33))
 >Choice : Symbol(Choice, Decl(stringEnumLiteralTypes3.ts, 0, 0))
->Yes : Symbol(Choice.Yes, Decl(stringEnumLiteralTypes3.ts, 0, 33))
+>Yes : Symbol(Yes, Decl(stringEnumLiteralTypes3.ts, 0, 33))
 >x : Symbol(x, Decl(stringEnumLiteralTypes3.ts, 84, 13))
 
         case Choice.No: return x;
@@ -436,9 +436,9 @@ function f11(x: YesNo): YesNo {
 >x : Symbol(x, Decl(stringEnumLiteralTypes3.ts, 93, 13))
 
         case Choice.Yes: return x;
->Choice.Yes : Symbol(Choice.Yes, Decl(stringEnumLiteralTypes3.ts, 0, 33))
+>Choice.Yes : Symbol(Yes, Decl(stringEnumLiteralTypes3.ts, 0, 33))
 >Choice : Symbol(Choice, Decl(stringEnumLiteralTypes3.ts, 0, 0))
->Yes : Symbol(Choice.Yes, Decl(stringEnumLiteralTypes3.ts, 0, 33))
+>Yes : Symbol(Yes, Decl(stringEnumLiteralTypes3.ts, 0, 33))
 >x : Symbol(x, Decl(stringEnumLiteralTypes3.ts, 93, 13))
 
         case Choice.No: return x;
@@ -467,9 +467,9 @@ function f12(x: UnknownYesNo): UnknownYesNo {
 >x : Symbol(x, Decl(stringEnumLiteralTypes3.ts, 102, 13))
 
         case Choice.Yes: return x;
->Choice.Yes : Symbol(Choice.Yes, Decl(stringEnumLiteralTypes3.ts, 0, 33))
+>Choice.Yes : Symbol(Yes, Decl(stringEnumLiteralTypes3.ts, 0, 33))
 >Choice : Symbol(Choice, Decl(stringEnumLiteralTypes3.ts, 0, 0))
->Yes : Symbol(Choice.Yes, Decl(stringEnumLiteralTypes3.ts, 0, 33))
+>Yes : Symbol(Yes, Decl(stringEnumLiteralTypes3.ts, 0, 33))
 >x : Symbol(x, Decl(stringEnumLiteralTypes3.ts, 102, 13))
 
         case Choice.No: return x;
@@ -498,9 +498,9 @@ function f13(x: Choice): Choice {
 >x : Symbol(x, Decl(stringEnumLiteralTypes3.ts, 111, 13))
 
         case Choice.Yes: return x;
->Choice.Yes : Symbol(Choice.Yes, Decl(stringEnumLiteralTypes3.ts, 0, 33))
+>Choice.Yes : Symbol(Yes, Decl(stringEnumLiteralTypes3.ts, 0, 33))
 >Choice : Symbol(Choice, Decl(stringEnumLiteralTypes3.ts, 0, 0))
->Yes : Symbol(Choice.Yes, Decl(stringEnumLiteralTypes3.ts, 0, 33))
+>Yes : Symbol(Yes, Decl(stringEnumLiteralTypes3.ts, 0, 33))
 >x : Symbol(x, Decl(stringEnumLiteralTypes3.ts, 111, 13))
 
         case Choice.No: return x;
diff --git a/tests/baselines/reference/substituteReturnTypeSatisfiesConstraint.symbols b/tests/baselines/reference/substituteReturnTypeSatisfiesConstraint.symbols
index 804313beba991..9a9b9f7034624 100644
--- a/tests/baselines/reference/substituteReturnTypeSatisfiesConstraint.symbols
+++ b/tests/baselines/reference/substituteReturnTypeSatisfiesConstraint.symbols
@@ -1,11 +1,11 @@
 === tests/cases/compiler/substituteReturnTypeSatisfiesConstraint.ts ===
 type M = { p: string };
 >M : Symbol(M, Decl(substituteReturnTypeSatisfiesConstraint.ts, 0, 0))
->p : Symbol(p, Decl(substituteReturnTypeSatisfiesConstraint.ts, 0, 10))
+>p : Symbol(M.p, Decl(substituteReturnTypeSatisfiesConstraint.ts, 0, 10))
 
 type O = { m: () => M };
 >O : Symbol(O, Decl(substituteReturnTypeSatisfiesConstraint.ts, 0, 23))
->m : Symbol(m, Decl(substituteReturnTypeSatisfiesConstraint.ts, 1, 10))
+>m : Symbol(O.m, Decl(substituteReturnTypeSatisfiesConstraint.ts, 1, 10))
 >M : Symbol(M, Decl(substituteReturnTypeSatisfiesConstraint.ts, 0, 0))
 
 type X<T extends M> = T;
diff --git a/tests/baselines/reference/substitutionTypesInIndexedAccessTypes.symbols b/tests/baselines/reference/substitutionTypesInIndexedAccessTypes.symbols
index a0633c2320ec1..738348921543b 100644
--- a/tests/baselines/reference/substitutionTypesInIndexedAccessTypes.symbols
+++ b/tests/baselines/reference/substitutionTypesInIndexedAccessTypes.symbols
@@ -5,7 +5,7 @@ type UserArgs = {
 >UserArgs : Symbol(UserArgs, Decl(substitutionTypesInIndexedAccessTypes.ts, 0, 0))
 
   select?: boolean
->select : Symbol(select, Decl(substitutionTypesInIndexedAccessTypes.ts, 2, 17))
+>select : Symbol(UserArgs.select, Decl(substitutionTypesInIndexedAccessTypes.ts, 2, 17))
 
 };
 
diff --git a/tests/baselines/reference/substitutionTypesInIndexedAccessTypes.types b/tests/baselines/reference/substitutionTypesInIndexedAccessTypes.types
index df7e4af01e618..2f866bc5fa5ba 100644
--- a/tests/baselines/reference/substitutionTypesInIndexedAccessTypes.types
+++ b/tests/baselines/reference/substitutionTypesInIndexedAccessTypes.types
@@ -13,11 +13,11 @@ type Subset<T, U> = { [key in keyof T]: key extends keyof U ? T[key] : never };
 >Subset : Subset<T, U>
 
 declare function withBoundary<T extends UserArgs>(args?: Subset<T, UserArgs>): T;
->withBoundary : <T extends UserArgs>(args?: Subset<T, UserArgs> | undefined) => T
+>withBoundary : <T extends UserArgs>(args?: Subset<T, UserArgs>) => T
 >args : Subset<T, UserArgs> | undefined
 
 declare function withoutBoundary<T extends UserArgs>(args?: T): T;
->withoutBoundary : <T extends UserArgs>(args?: T | undefined) => T
+>withoutBoundary : <T extends UserArgs>(args?: T) => T
 >args : T | undefined
 
 const boundaryResult = withBoundary({
diff --git a/tests/baselines/reference/symbolProperty61.symbols b/tests/baselines/reference/symbolProperty61.symbols
index a4d45d7c1b9ee..e89e3f6b38789 100644
--- a/tests/baselines/reference/symbolProperty61.symbols
+++ b/tests/baselines/reference/symbolProperty61.symbols
@@ -54,7 +54,7 @@ type InteropObservable<T> = {
 >T : Symbol(T, Decl(symbolProperty61.ts, 20, 23))
 
     [Symbol.obs]: () => { subscribe(next: (val: T) => void): void }
->[Symbol.obs] : Symbol([Symbol.obs], Decl(symbolProperty61.ts, 20, 29))
+>[Symbol.obs] : Symbol(InteropObservable[Symbol.obs], Decl(symbolProperty61.ts, 20, 29))
 >Symbol.obs : Symbol(SymbolConstructor.obs, Decl(symbolProperty61.ts, 1, 31))
 >Symbol : Symbol(Symbol, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
 >obs : Symbol(SymbolConstructor.obs, Decl(symbolProperty61.ts, 1, 31))
diff --git a/tests/baselines/reference/templateLiteralTypes3.symbols b/tests/baselines/reference/templateLiteralTypes3.symbols
index 47f4ee7fe6e53..b2903774eeb10 100644
--- a/tests/baselines/reference/templateLiteralTypes3.symbols
+++ b/tests/baselines/reference/templateLiteralTypes3.symbols
@@ -389,7 +389,7 @@ interface ITest<P extends Prefixes, E extends AllPrefixData = PrefixData<P>> {
 
 type Schema = { a: { b: { c: number } } };
 >Schema : Symbol(Schema, Decl(templateLiteralTypes3.ts, 116, 1))
->a : Symbol(a, Decl(templateLiteralTypes3.ts, 120, 15))
+>a : Symbol(Schema.a, Decl(templateLiteralTypes3.ts, 120, 15))
 >b : Symbol(b, Decl(templateLiteralTypes3.ts, 120, 20))
 >c : Symbol(c, Decl(templateLiteralTypes3.ts, 120, 25))
 
diff --git a/tests/baselines/reference/templateLiteralTypesPatterns.symbols b/tests/baselines/reference/templateLiteralTypesPatterns.symbols
index 95d25249747b3..f4cea05c894b6 100644
--- a/tests/baselines/reference/templateLiteralTypesPatterns.symbols
+++ b/tests/baselines/reference/templateLiteralTypesPatterns.symbols
@@ -363,7 +363,7 @@ anyish = `aok`
 type AGen<T extends string | number> = {field: `a${T}`};
 >AGen : Symbol(AGen, Decl(templateLiteralTypesPatterns.ts, 148, 14))
 >T : Symbol(T, Decl(templateLiteralTypesPatterns.ts, 152, 10))
->field : Symbol(field, Decl(templateLiteralTypesPatterns.ts, 152, 40))
+>field : Symbol(AGen.field, Decl(templateLiteralTypesPatterns.ts, 152, 40))
 >T : Symbol(T, Decl(templateLiteralTypesPatterns.ts, 152, 10))
 
 const shouldWork1: AGen<string> = null as any as AGen<"yes">;
diff --git a/tests/baselines/reference/thisInObjectLiterals.symbols b/tests/baselines/reference/thisInObjectLiterals.symbols
index 7e3eeea52e801..4b857a9451ccc 100644
--- a/tests/baselines/reference/thisInObjectLiterals.symbols
+++ b/tests/baselines/reference/thisInObjectLiterals.symbols
@@ -6,7 +6,7 @@ class MyClass {
 >t : Symbol(MyClass.t, Decl(thisInObjectLiterals.ts, 0, 15))
 
     fn() {
->fn : Symbol(MyClass.fn, Decl(thisInObjectLiterals.ts, 1, 14))
+>fn : Symbol(ContainingThis.fn, Decl(thisInObjectLiterals.ts, 1, 14))
 
         type ContainingThis = this;
 >ContainingThis : Symbol(ContainingThis, Decl(thisInObjectLiterals.ts, 3, 10))
@@ -15,11 +15,11 @@ class MyClass {
         var t = { x: this, y: this.t };
 >t : Symbol(t, Decl(thisInObjectLiterals.ts, 6, 11), Decl(thisInObjectLiterals.ts, 7, 11))
 >x : Symbol(x, Decl(thisInObjectLiterals.ts, 6, 17))
->this : Symbol(MyClass, Decl(thisInObjectLiterals.ts, 0, 0))
+>this : Symbol(ContainingThis, Decl(thisInObjectLiterals.ts, 0, 0))
 >y : Symbol(y, Decl(thisInObjectLiterals.ts, 6, 26))
->this.t : Symbol(MyClass.t, Decl(thisInObjectLiterals.ts, 0, 15))
->this : Symbol(MyClass, Decl(thisInObjectLiterals.ts, 0, 0))
->t : Symbol(MyClass.t, Decl(thisInObjectLiterals.ts, 0, 15))
+>this.t : Symbol(ContainingThis.t, Decl(thisInObjectLiterals.ts, 0, 15))
+>this : Symbol(ContainingThis, Decl(thisInObjectLiterals.ts, 0, 0))
+>t : Symbol(ContainingThis.t, Decl(thisInObjectLiterals.ts, 0, 15))
 
         var t: { x: ContainingThis; y: number };
 >t : Symbol(t, Decl(thisInObjectLiterals.ts, 6, 11), Decl(thisInObjectLiterals.ts, 7, 11))
diff --git a/tests/baselines/reference/thisTypeInObjectLiterals2.symbols b/tests/baselines/reference/thisTypeInObjectLiterals2.symbols
index 0ed97b942f1c5..5135b7be068d8 100644
--- a/tests/baselines/reference/thisTypeInObjectLiterals2.symbols
+++ b/tests/baselines/reference/thisTypeInObjectLiterals2.symbols
@@ -69,16 +69,16 @@ type Point = {
 >Point : Symbol(Point, Decl(thisTypeInObjectLiterals2.ts, 23, 2))
 
     x: number;
->x : Symbol(x, Decl(thisTypeInObjectLiterals2.ts, 28, 14))
+>x : Symbol(Point.x, Decl(thisTypeInObjectLiterals2.ts, 28, 14))
 
     y: number;
->y : Symbol(y, Decl(thisTypeInObjectLiterals2.ts, 29, 14))
+>y : Symbol(Point.y, Decl(thisTypeInObjectLiterals2.ts, 29, 14))
 
     z?: number;
->z : Symbol(z, Decl(thisTypeInObjectLiterals2.ts, 30, 14))
+>z : Symbol(Point.z, Decl(thisTypeInObjectLiterals2.ts, 30, 14))
 
     moveBy(dx: number, dy: number, dz?: number): void;
->moveBy : Symbol(moveBy, Decl(thisTypeInObjectLiterals2.ts, 31, 15))
+>moveBy : Symbol(Point.moveBy, Decl(thisTypeInObjectLiterals2.ts, 31, 15))
 >dx : Symbol(dx, Decl(thisTypeInObjectLiterals2.ts, 32, 11))
 >dy : Symbol(dy, Decl(thisTypeInObjectLiterals2.ts, 32, 22))
 >dz : Symbol(dz, Decl(thisTypeInObjectLiterals2.ts, 32, 34))
@@ -101,27 +101,27 @@ let p1: Point = {
 >dz : Symbol(dz, Decl(thisTypeInObjectLiterals2.ts, 38, 18))
 
         this.x += dx;
->this.x : Symbol(x, Decl(thisTypeInObjectLiterals2.ts, 28, 14))
->this : Symbol(__type, Decl(thisTypeInObjectLiterals2.ts, 28, 12))
->x : Symbol(x, Decl(thisTypeInObjectLiterals2.ts, 28, 14))
+>this.x : Symbol(Point.x, Decl(thisTypeInObjectLiterals2.ts, 28, 14))
+>this : Symbol(Point, Decl(thisTypeInObjectLiterals2.ts, 28, 12))
+>x : Symbol(Point.x, Decl(thisTypeInObjectLiterals2.ts, 28, 14))
 >dx : Symbol(dx, Decl(thisTypeInObjectLiterals2.ts, 38, 11))
 
         this.y += dy;
->this.y : Symbol(y, Decl(thisTypeInObjectLiterals2.ts, 29, 14))
->this : Symbol(__type, Decl(thisTypeInObjectLiterals2.ts, 28, 12))
->y : Symbol(y, Decl(thisTypeInObjectLiterals2.ts, 29, 14))
+>this.y : Symbol(Point.y, Decl(thisTypeInObjectLiterals2.ts, 29, 14))
+>this : Symbol(Point, Decl(thisTypeInObjectLiterals2.ts, 28, 12))
+>y : Symbol(Point.y, Decl(thisTypeInObjectLiterals2.ts, 29, 14))
 >dy : Symbol(dy, Decl(thisTypeInObjectLiterals2.ts, 38, 14))
 
         if (this.z && dz) {
->this.z : Symbol(z, Decl(thisTypeInObjectLiterals2.ts, 30, 14))
->this : Symbol(__type, Decl(thisTypeInObjectLiterals2.ts, 28, 12))
->z : Symbol(z, Decl(thisTypeInObjectLiterals2.ts, 30, 14))
+>this.z : Symbol(Point.z, Decl(thisTypeInObjectLiterals2.ts, 30, 14))
+>this : Symbol(Point, Decl(thisTypeInObjectLiterals2.ts, 28, 12))
+>z : Symbol(Point.z, Decl(thisTypeInObjectLiterals2.ts, 30, 14))
 >dz : Symbol(dz, Decl(thisTypeInObjectLiterals2.ts, 38, 18))
 
             this.z += dz;
->this.z : Symbol(z, Decl(thisTypeInObjectLiterals2.ts, 30, 14))
->this : Symbol(__type, Decl(thisTypeInObjectLiterals2.ts, 28, 12))
->z : Symbol(z, Decl(thisTypeInObjectLiterals2.ts, 30, 14))
+>this.z : Symbol(Point.z, Decl(thisTypeInObjectLiterals2.ts, 30, 14))
+>this : Symbol(Point, Decl(thisTypeInObjectLiterals2.ts, 28, 12))
+>z : Symbol(Point.z, Decl(thisTypeInObjectLiterals2.ts, 30, 14))
 >dz : Symbol(dz, Decl(thisTypeInObjectLiterals2.ts, 38, 18))
         }
     }
@@ -144,27 +144,27 @@ let p2: Point | null = {
 >dz : Symbol(dz, Decl(thisTypeInObjectLiterals2.ts, 50, 18))
 
         this.x += dx;
->this.x : Symbol(x, Decl(thisTypeInObjectLiterals2.ts, 28, 14))
->this : Symbol(__type, Decl(thisTypeInObjectLiterals2.ts, 28, 12))
->x : Symbol(x, Decl(thisTypeInObjectLiterals2.ts, 28, 14))
+>this.x : Symbol(Point.x, Decl(thisTypeInObjectLiterals2.ts, 28, 14))
+>this : Symbol(Point, Decl(thisTypeInObjectLiterals2.ts, 28, 12))
+>x : Symbol(Point.x, Decl(thisTypeInObjectLiterals2.ts, 28, 14))
 >dx : Symbol(dx, Decl(thisTypeInObjectLiterals2.ts, 50, 11))
 
         this.y += dy;
->this.y : Symbol(y, Decl(thisTypeInObjectLiterals2.ts, 29, 14))
->this : Symbol(__type, Decl(thisTypeInObjectLiterals2.ts, 28, 12))
->y : Symbol(y, Decl(thisTypeInObjectLiterals2.ts, 29, 14))
+>this.y : Symbol(Point.y, Decl(thisTypeInObjectLiterals2.ts, 29, 14))
+>this : Symbol(Point, Decl(thisTypeInObjectLiterals2.ts, 28, 12))
+>y : Symbol(Point.y, Decl(thisTypeInObjectLiterals2.ts, 29, 14))
 >dy : Symbol(dy, Decl(thisTypeInObjectLiterals2.ts, 50, 14))
 
         if (this.z && dz) {
->this.z : Symbol(z, Decl(thisTypeInObjectLiterals2.ts, 30, 14))
->this : Symbol(__type, Decl(thisTypeInObjectLiterals2.ts, 28, 12))
->z : Symbol(z, Decl(thisTypeInObjectLiterals2.ts, 30, 14))
+>this.z : Symbol(Point.z, Decl(thisTypeInObjectLiterals2.ts, 30, 14))
+>this : Symbol(Point, Decl(thisTypeInObjectLiterals2.ts, 28, 12))
+>z : Symbol(Point.z, Decl(thisTypeInObjectLiterals2.ts, 30, 14))
 >dz : Symbol(dz, Decl(thisTypeInObjectLiterals2.ts, 50, 18))
 
             this.z += dz;
->this.z : Symbol(z, Decl(thisTypeInObjectLiterals2.ts, 30, 14))
->this : Symbol(__type, Decl(thisTypeInObjectLiterals2.ts, 28, 12))
->z : Symbol(z, Decl(thisTypeInObjectLiterals2.ts, 30, 14))
+>this.z : Symbol(Point.z, Decl(thisTypeInObjectLiterals2.ts, 30, 14))
+>this : Symbol(Point, Decl(thisTypeInObjectLiterals2.ts, 28, 12))
+>z : Symbol(Point.z, Decl(thisTypeInObjectLiterals2.ts, 30, 14))
 >dz : Symbol(dz, Decl(thisTypeInObjectLiterals2.ts, 50, 18))
         }
     }
@@ -187,27 +187,27 @@ let p3: Point | undefined = {
 >dz : Symbol(dz, Decl(thisTypeInObjectLiterals2.ts, 62, 18))
 
         this.x += dx;
->this.x : Symbol(x, Decl(thisTypeInObjectLiterals2.ts, 28, 14))
->this : Symbol(__type, Decl(thisTypeInObjectLiterals2.ts, 28, 12))
->x : Symbol(x, Decl(thisTypeInObjectLiterals2.ts, 28, 14))
+>this.x : Symbol(Point.x, Decl(thisTypeInObjectLiterals2.ts, 28, 14))
+>this : Symbol(Point, Decl(thisTypeInObjectLiterals2.ts, 28, 12))
+>x : Symbol(Point.x, Decl(thisTypeInObjectLiterals2.ts, 28, 14))
 >dx : Symbol(dx, Decl(thisTypeInObjectLiterals2.ts, 62, 11))
 
         this.y += dy;
->this.y : Symbol(y, Decl(thisTypeInObjectLiterals2.ts, 29, 14))
->this : Symbol(__type, Decl(thisTypeInObjectLiterals2.ts, 28, 12))
->y : Symbol(y, Decl(thisTypeInObjectLiterals2.ts, 29, 14))
+>this.y : Symbol(Point.y, Decl(thisTypeInObjectLiterals2.ts, 29, 14))
+>this : Symbol(Point, Decl(thisTypeInObjectLiterals2.ts, 28, 12))
+>y : Symbol(Point.y, Decl(thisTypeInObjectLiterals2.ts, 29, 14))
 >dy : Symbol(dy, Decl(thisTypeInObjectLiterals2.ts, 62, 14))
 
         if (this.z && dz) {
->this.z : Symbol(z, Decl(thisTypeInObjectLiterals2.ts, 30, 14))
->this : Symbol(__type, Decl(thisTypeInObjectLiterals2.ts, 28, 12))
->z : Symbol(z, Decl(thisTypeInObjectLiterals2.ts, 30, 14))
+>this.z : Symbol(Point.z, Decl(thisTypeInObjectLiterals2.ts, 30, 14))
+>this : Symbol(Point, Decl(thisTypeInObjectLiterals2.ts, 28, 12))
+>z : Symbol(Point.z, Decl(thisTypeInObjectLiterals2.ts, 30, 14))
 >dz : Symbol(dz, Decl(thisTypeInObjectLiterals2.ts, 62, 18))
 
             this.z += dz;
->this.z : Symbol(z, Decl(thisTypeInObjectLiterals2.ts, 30, 14))
->this : Symbol(__type, Decl(thisTypeInObjectLiterals2.ts, 28, 12))
->z : Symbol(z, Decl(thisTypeInObjectLiterals2.ts, 30, 14))
+>this.z : Symbol(Point.z, Decl(thisTypeInObjectLiterals2.ts, 30, 14))
+>this : Symbol(Point, Decl(thisTypeInObjectLiterals2.ts, 28, 12))
+>z : Symbol(Point.z, Decl(thisTypeInObjectLiterals2.ts, 30, 14))
 >dz : Symbol(dz, Decl(thisTypeInObjectLiterals2.ts, 62, 18))
         }
     }
@@ -230,27 +230,27 @@ let p4: Point | null | undefined = {
 >dz : Symbol(dz, Decl(thisTypeInObjectLiterals2.ts, 74, 18))
 
         this.x += dx;
->this.x : Symbol(x, Decl(thisTypeInObjectLiterals2.ts, 28, 14))
->this : Symbol(__type, Decl(thisTypeInObjectLiterals2.ts, 28, 12))
->x : Symbol(x, Decl(thisTypeInObjectLiterals2.ts, 28, 14))
+>this.x : Symbol(Point.x, Decl(thisTypeInObjectLiterals2.ts, 28, 14))
+>this : Symbol(Point, Decl(thisTypeInObjectLiterals2.ts, 28, 12))
+>x : Symbol(Point.x, Decl(thisTypeInObjectLiterals2.ts, 28, 14))
 >dx : Symbol(dx, Decl(thisTypeInObjectLiterals2.ts, 74, 11))
 
         this.y += dy;
->this.y : Symbol(y, Decl(thisTypeInObjectLiterals2.ts, 29, 14))
->this : Symbol(__type, Decl(thisTypeInObjectLiterals2.ts, 28, 12))
->y : Symbol(y, Decl(thisTypeInObjectLiterals2.ts, 29, 14))
+>this.y : Symbol(Point.y, Decl(thisTypeInObjectLiterals2.ts, 29, 14))
+>this : Symbol(Point, Decl(thisTypeInObjectLiterals2.ts, 28, 12))
+>y : Symbol(Point.y, Decl(thisTypeInObjectLiterals2.ts, 29, 14))
 >dy : Symbol(dy, Decl(thisTypeInObjectLiterals2.ts, 74, 14))
 
         if (this.z && dz) {
->this.z : Symbol(z, Decl(thisTypeInObjectLiterals2.ts, 30, 14))
->this : Symbol(__type, Decl(thisTypeInObjectLiterals2.ts, 28, 12))
->z : Symbol(z, Decl(thisTypeInObjectLiterals2.ts, 30, 14))
+>this.z : Symbol(Point.z, Decl(thisTypeInObjectLiterals2.ts, 30, 14))
+>this : Symbol(Point, Decl(thisTypeInObjectLiterals2.ts, 28, 12))
+>z : Symbol(Point.z, Decl(thisTypeInObjectLiterals2.ts, 30, 14))
 >dz : Symbol(dz, Decl(thisTypeInObjectLiterals2.ts, 74, 18))
 
             this.z += dz;
->this.z : Symbol(z, Decl(thisTypeInObjectLiterals2.ts, 30, 14))
->this : Symbol(__type, Decl(thisTypeInObjectLiterals2.ts, 28, 12))
->z : Symbol(z, Decl(thisTypeInObjectLiterals2.ts, 30, 14))
+>this.z : Symbol(Point.z, Decl(thisTypeInObjectLiterals2.ts, 30, 14))
+>this : Symbol(Point, Decl(thisTypeInObjectLiterals2.ts, 28, 12))
+>z : Symbol(Point.z, Decl(thisTypeInObjectLiterals2.ts, 30, 14))
 >dz : Symbol(dz, Decl(thisTypeInObjectLiterals2.ts, 74, 18))
         }
     }
@@ -277,27 +277,27 @@ f1({
 >dz : Symbol(dz, Decl(thisTypeInObjectLiterals2.ts, 88, 18))
 
         this.x += dx;
->this.x : Symbol(x, Decl(thisTypeInObjectLiterals2.ts, 28, 14))
->this : Symbol(__type, Decl(thisTypeInObjectLiterals2.ts, 28, 12))
->x : Symbol(x, Decl(thisTypeInObjectLiterals2.ts, 28, 14))
+>this.x : Symbol(Point.x, Decl(thisTypeInObjectLiterals2.ts, 28, 14))
+>this : Symbol(Point, Decl(thisTypeInObjectLiterals2.ts, 28, 12))
+>x : Symbol(Point.x, Decl(thisTypeInObjectLiterals2.ts, 28, 14))
 >dx : Symbol(dx, Decl(thisTypeInObjectLiterals2.ts, 88, 11))
 
         this.y += dy;
->this.y : Symbol(y, Decl(thisTypeInObjectLiterals2.ts, 29, 14))
->this : Symbol(__type, Decl(thisTypeInObjectLiterals2.ts, 28, 12))
->y : Symbol(y, Decl(thisTypeInObjectLiterals2.ts, 29, 14))
+>this.y : Symbol(Point.y, Decl(thisTypeInObjectLiterals2.ts, 29, 14))
+>this : Symbol(Point, Decl(thisTypeInObjectLiterals2.ts, 28, 12))
+>y : Symbol(Point.y, Decl(thisTypeInObjectLiterals2.ts, 29, 14))
 >dy : Symbol(dy, Decl(thisTypeInObjectLiterals2.ts, 88, 14))
 
         if (this.z && dz) {
->this.z : Symbol(z, Decl(thisTypeInObjectLiterals2.ts, 30, 14))
->this : Symbol(__type, Decl(thisTypeInObjectLiterals2.ts, 28, 12))
->z : Symbol(z, Decl(thisTypeInObjectLiterals2.ts, 30, 14))
+>this.z : Symbol(Point.z, Decl(thisTypeInObjectLiterals2.ts, 30, 14))
+>this : Symbol(Point, Decl(thisTypeInObjectLiterals2.ts, 28, 12))
+>z : Symbol(Point.z, Decl(thisTypeInObjectLiterals2.ts, 30, 14))
 >dz : Symbol(dz, Decl(thisTypeInObjectLiterals2.ts, 88, 18))
 
             this.z += dz;
->this.z : Symbol(z, Decl(thisTypeInObjectLiterals2.ts, 30, 14))
->this : Symbol(__type, Decl(thisTypeInObjectLiterals2.ts, 28, 12))
->z : Symbol(z, Decl(thisTypeInObjectLiterals2.ts, 30, 14))
+>this.z : Symbol(Point.z, Decl(thisTypeInObjectLiterals2.ts, 30, 14))
+>this : Symbol(Point, Decl(thisTypeInObjectLiterals2.ts, 28, 12))
+>z : Symbol(Point.z, Decl(thisTypeInObjectLiterals2.ts, 30, 14))
 >dz : Symbol(dz, Decl(thisTypeInObjectLiterals2.ts, 88, 18))
         }
     }
@@ -324,27 +324,27 @@ f2({
 >dz : Symbol(dz, Decl(thisTypeInObjectLiterals2.ts, 102, 18))
 
         this.x += dx;
->this.x : Symbol(x, Decl(thisTypeInObjectLiterals2.ts, 28, 14))
->this : Symbol(__type, Decl(thisTypeInObjectLiterals2.ts, 28, 12))
->x : Symbol(x, Decl(thisTypeInObjectLiterals2.ts, 28, 14))
+>this.x : Symbol(Point.x, Decl(thisTypeInObjectLiterals2.ts, 28, 14))
+>this : Symbol(Point, Decl(thisTypeInObjectLiterals2.ts, 28, 12))
+>x : Symbol(Point.x, Decl(thisTypeInObjectLiterals2.ts, 28, 14))
 >dx : Symbol(dx, Decl(thisTypeInObjectLiterals2.ts, 102, 11))
 
         this.y += dy;
->this.y : Symbol(y, Decl(thisTypeInObjectLiterals2.ts, 29, 14))
->this : Symbol(__type, Decl(thisTypeInObjectLiterals2.ts, 28, 12))
->y : Symbol(y, Decl(thisTypeInObjectLiterals2.ts, 29, 14))
+>this.y : Symbol(Point.y, Decl(thisTypeInObjectLiterals2.ts, 29, 14))
+>this : Symbol(Point, Decl(thisTypeInObjectLiterals2.ts, 28, 12))
+>y : Symbol(Point.y, Decl(thisTypeInObjectLiterals2.ts, 29, 14))
 >dy : Symbol(dy, Decl(thisTypeInObjectLiterals2.ts, 102, 14))
 
         if (this.z && dz) {
->this.z : Symbol(z, Decl(thisTypeInObjectLiterals2.ts, 30, 14))
->this : Symbol(__type, Decl(thisTypeInObjectLiterals2.ts, 28, 12))
->z : Symbol(z, Decl(thisTypeInObjectLiterals2.ts, 30, 14))
+>this.z : Symbol(Point.z, Decl(thisTypeInObjectLiterals2.ts, 30, 14))
+>this : Symbol(Point, Decl(thisTypeInObjectLiterals2.ts, 28, 12))
+>z : Symbol(Point.z, Decl(thisTypeInObjectLiterals2.ts, 30, 14))
 >dz : Symbol(dz, Decl(thisTypeInObjectLiterals2.ts, 102, 18))
 
             this.z += dz;
->this.z : Symbol(z, Decl(thisTypeInObjectLiterals2.ts, 30, 14))
->this : Symbol(__type, Decl(thisTypeInObjectLiterals2.ts, 28, 12))
->z : Symbol(z, Decl(thisTypeInObjectLiterals2.ts, 30, 14))
+>this.z : Symbol(Point.z, Decl(thisTypeInObjectLiterals2.ts, 30, 14))
+>this : Symbol(Point, Decl(thisTypeInObjectLiterals2.ts, 28, 12))
+>z : Symbol(Point.z, Decl(thisTypeInObjectLiterals2.ts, 30, 14))
 >dz : Symbol(dz, Decl(thisTypeInObjectLiterals2.ts, 102, 18))
         }
     }
@@ -359,11 +359,11 @@ type ObjectDescriptor<D, M> = {
 >M : Symbol(M, Decl(thisTypeInObjectLiterals2.ts, 114, 24))
 
     data?: D;
->data : Symbol(data, Decl(thisTypeInObjectLiterals2.ts, 114, 31))
+>data : Symbol(ObjectDescriptor.data, Decl(thisTypeInObjectLiterals2.ts, 114, 31))
 >D : Symbol(D, Decl(thisTypeInObjectLiterals2.ts, 114, 22))
 
     methods?: M & ThisType<D & M>;  // Type of 'this' in methods is D & M
->methods : Symbol(methods, Decl(thisTypeInObjectLiterals2.ts, 115, 13))
+>methods : Symbol(ObjectDescriptor.methods, Decl(thisTypeInObjectLiterals2.ts, 115, 13))
 >M : Symbol(M, Decl(thisTypeInObjectLiterals2.ts, 114, 24))
 >ThisType : Symbol(ThisType, Decl(lib.es5.d.ts, --, --))
 >D : Symbol(D, Decl(thisTypeInObjectLiterals2.ts, 114, 22))
@@ -479,15 +479,15 @@ type PropDesc<T> = {
 >T : Symbol(T, Decl(thisTypeInObjectLiterals2.ts, 153, 14))
 
     value?: T;
->value : Symbol(value, Decl(thisTypeInObjectLiterals2.ts, 153, 20))
+>value : Symbol(PropDesc.value, Decl(thisTypeInObjectLiterals2.ts, 153, 20))
 >T : Symbol(T, Decl(thisTypeInObjectLiterals2.ts, 153, 14))
 
     get?(): T;
->get : Symbol(get, Decl(thisTypeInObjectLiterals2.ts, 154, 14))
+>get : Symbol(PropDesc.get, Decl(thisTypeInObjectLiterals2.ts, 154, 14))
 >T : Symbol(T, Decl(thisTypeInObjectLiterals2.ts, 153, 14))
 
     set?(value: T): void;
->set : Symbol(set, Decl(thisTypeInObjectLiterals2.ts, 155, 14))
+>set : Symbol(PropDesc.set, Decl(thisTypeInObjectLiterals2.ts, 155, 14))
 >value : Symbol(value, Decl(thisTypeInObjectLiterals2.ts, 156, 9))
 >T : Symbol(T, Decl(thisTypeInObjectLiterals2.ts, 153, 14))
 }
@@ -560,9 +560,9 @@ let p11 = defineProp(p1, "bar", {
 >get : Symbol(get, Decl(thisTypeInObjectLiterals2.ts, 170, 33))
 
         return this.x;
->this.x : Symbol(x, Decl(thisTypeInObjectLiterals2.ts, 28, 14))
->this : Symbol(__type, Decl(thisTypeInObjectLiterals2.ts, 28, 12))
->x : Symbol(x, Decl(thisTypeInObjectLiterals2.ts, 28, 14))
+>this.x : Symbol(Point.x, Decl(thisTypeInObjectLiterals2.ts, 28, 14))
+>this : Symbol(Point, Decl(thisTypeInObjectLiterals2.ts, 28, 12))
+>x : Symbol(Point.x, Decl(thisTypeInObjectLiterals2.ts, 28, 14))
 
     },
     set(value: number) {
@@ -570,9 +570,9 @@ let p11 = defineProp(p1, "bar", {
 >value : Symbol(value, Decl(thisTypeInObjectLiterals2.ts, 174, 8))
 
         this.x = value;
->this.x : Symbol(x, Decl(thisTypeInObjectLiterals2.ts, 28, 14))
->this : Symbol(__type, Decl(thisTypeInObjectLiterals2.ts, 28, 12))
->x : Symbol(x, Decl(thisTypeInObjectLiterals2.ts, 28, 14))
+>this.x : Symbol(Point.x, Decl(thisTypeInObjectLiterals2.ts, 28, 14))
+>this : Symbol(Point, Decl(thisTypeInObjectLiterals2.ts, 28, 12))
+>x : Symbol(Point.x, Decl(thisTypeInObjectLiterals2.ts, 28, 14))
 >value : Symbol(value, Decl(thisTypeInObjectLiterals2.ts, 174, 8))
     }
 });
@@ -603,9 +603,9 @@ let p12 = defineProps(p1, {
 >get : Symbol(get, Decl(thisTypeInObjectLiterals2.ts, 184, 10))
 
             return this.x;
->this.x : Symbol(x, Decl(thisTypeInObjectLiterals2.ts, 28, 14))
->this : Symbol(__type, Decl(thisTypeInObjectLiterals2.ts, 28, 12))
->x : Symbol(x, Decl(thisTypeInObjectLiterals2.ts, 28, 14))
+>this.x : Symbol(Point.x, Decl(thisTypeInObjectLiterals2.ts, 28, 14))
+>this : Symbol(Point, Decl(thisTypeInObjectLiterals2.ts, 28, 12))
+>x : Symbol(Point.x, Decl(thisTypeInObjectLiterals2.ts, 28, 14))
 
         },
         set(value: number) {
@@ -613,9 +613,9 @@ let p12 = defineProps(p1, {
 >value : Symbol(value, Decl(thisTypeInObjectLiterals2.ts, 188, 12))
 
             this.x = value;
->this.x : Symbol(x, Decl(thisTypeInObjectLiterals2.ts, 28, 14))
->this : Symbol(__type, Decl(thisTypeInObjectLiterals2.ts, 28, 12))
->x : Symbol(x, Decl(thisTypeInObjectLiterals2.ts, 28, 14))
+>this.x : Symbol(Point.x, Decl(thisTypeInObjectLiterals2.ts, 28, 14))
+>this : Symbol(Point, Decl(thisTypeInObjectLiterals2.ts, 28, 12))
+>x : Symbol(Point.x, Decl(thisTypeInObjectLiterals2.ts, 28, 14))
 >value : Symbol(value, Decl(thisTypeInObjectLiterals2.ts, 188, 12))
         }
     }
@@ -660,11 +660,11 @@ type Computed<T> = {
 >T : Symbol(T, Decl(thisTypeInObjectLiterals2.ts, 202, 14))
 
     get?(): T;
->get : Symbol(get, Decl(thisTypeInObjectLiterals2.ts, 202, 20))
+>get : Symbol(Computed.get, Decl(thisTypeInObjectLiterals2.ts, 202, 20))
 >T : Symbol(T, Decl(thisTypeInObjectLiterals2.ts, 202, 14))
 
     set?(value: T): void;
->set : Symbol(set, Decl(thisTypeInObjectLiterals2.ts, 203, 14))
+>set : Symbol(Computed.set, Decl(thisTypeInObjectLiterals2.ts, 203, 14))
 >value : Symbol(value, Decl(thisTypeInObjectLiterals2.ts, 204, 9))
 >T : Symbol(T, Decl(thisTypeInObjectLiterals2.ts, 202, 14))
 }
diff --git a/tests/baselines/reference/thisTypeInObjectLiterals2.types b/tests/baselines/reference/thisTypeInObjectLiterals2.types
index 227be40f79f39..a00869b72356e 100644
--- a/tests/baselines/reference/thisTypeInObjectLiterals2.types
+++ b/tests/baselines/reference/thisTypeInObjectLiterals2.types
@@ -84,7 +84,7 @@ type Point = {
 >z : number | undefined
 
     moveBy(dx: number, dy: number, dz?: number): void;
->moveBy : (dx: number, dy: number, dz?: number | undefined) => void
+>moveBy : (dx: number, dy: number, dz?: number) => void
 >dx : number
 >dy : number
 >dz : number | undefined
diff --git a/tests/baselines/reference/transformNestedGeneratorsWithTry.symbols b/tests/baselines/reference/transformNestedGeneratorsWithTry.symbols
index e13cce398aba3..1374c4e3441a3 100644
--- a/tests/baselines/reference/transformNestedGeneratorsWithTry.symbols
+++ b/tests/baselines/reference/transformNestedGeneratorsWithTry.symbols
@@ -38,12 +38,12 @@ declare module "bluebird" {
     type Bluebird<T> = Promise<T>;
 >Bluebird : Symbol(Bluebird, Decl(bluebird.d.ts, 0, 27), Decl(bluebird.d.ts, 2, 9))
 >T : Symbol(T, Decl(bluebird.d.ts, 1, 18))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Promise : Symbol(Bluebird, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
 >T : Symbol(T, Decl(bluebird.d.ts, 1, 18))
 
     const Bluebird: typeof Promise;
 >Bluebird : Symbol(Bluebird, Decl(bluebird.d.ts, 0, 27), Decl(bluebird.d.ts, 2, 9))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Promise : Symbol(Bluebird, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
 
     export = Bluebird;
 >Bluebird : Symbol(Bluebird, Decl(bluebird.d.ts, 0, 27), Decl(bluebird.d.ts, 2, 9))
diff --git a/tests/baselines/reference/truthinessCallExpressionCoercion.types b/tests/baselines/reference/truthinessCallExpressionCoercion.types
index 21c2328455c74..16c86086c20e8 100644
--- a/tests/baselines/reference/truthinessCallExpressionCoercion.types
+++ b/tests/baselines/reference/truthinessCallExpressionCoercion.types
@@ -1,6 +1,6 @@
 === tests/cases/compiler/truthinessCallExpressionCoercion.ts ===
 function onlyErrorsWhenTestingNonNullableFunctionType(required: () => boolean, optional?: () => boolean) {
->onlyErrorsWhenTestingNonNullableFunctionType : (required: () => boolean, optional?: (() => boolean) | undefined) => void
+>onlyErrorsWhenTestingNonNullableFunctionType : (required: () => boolean, optional?: () => boolean) => void
 >required : () => boolean
 >optional : (() => boolean) | undefined
 
diff --git a/tests/baselines/reference/truthinessCallExpressionCoercion1.types b/tests/baselines/reference/truthinessCallExpressionCoercion1.types
index cd9f357a5ed4c..7a0aced375dc9 100644
--- a/tests/baselines/reference/truthinessCallExpressionCoercion1.types
+++ b/tests/baselines/reference/truthinessCallExpressionCoercion1.types
@@ -1,6 +1,6 @@
 === tests/cases/compiler/truthinessCallExpressionCoercion1.ts ===
 function onlyErrorsWhenTestingNonNullableFunctionType(required: () => boolean, optional?: () => boolean) {
->onlyErrorsWhenTestingNonNullableFunctionType : (required: () => boolean, optional?: (() => boolean) | undefined) => void
+>onlyErrorsWhenTestingNonNullableFunctionType : (required: () => boolean, optional?: () => boolean) => void
 >required : () => boolean
 >optional : (() => boolean) | undefined
 
diff --git a/tests/baselines/reference/truthinessCallExpressionCoercion2.types b/tests/baselines/reference/truthinessCallExpressionCoercion2.types
index 85eeacc46f731..96f115a621d09 100644
--- a/tests/baselines/reference/truthinessCallExpressionCoercion2.types
+++ b/tests/baselines/reference/truthinessCallExpressionCoercion2.types
@@ -14,7 +14,7 @@ declare class B {
 }
 
 function test(required1: () => boolean, required2: () => boolean, b: boolean, optional?: () => boolean) {
->test : (required1: () => boolean, required2: () => boolean, b: boolean, optional?: (() => boolean) | undefined) => void
+>test : (required1: () => boolean, required2: () => boolean, b: boolean, optional?: () => boolean) => void
 >required1 : () => boolean
 >required2 : () => boolean
 >b : boolean
diff --git a/tests/baselines/reference/tsxDiscriminantPropertyInference.symbols b/tests/baselines/reference/tsxDiscriminantPropertyInference.symbols
index 4b74166e91b63..6b4a60a1ffdad 100644
--- a/tests/baselines/reference/tsxDiscriminantPropertyInference.symbols
+++ b/tests/baselines/reference/tsxDiscriminantPropertyInference.symbols
@@ -11,10 +11,10 @@ type DiscriminatorTrue = {
 >DiscriminatorTrue : Symbol(DiscriminatorTrue, Decl(tsxDiscriminantPropertyInference.tsx, 3, 1))
 
     disc: true;
->disc : Symbol(disc, Decl(tsxDiscriminantPropertyInference.tsx, 5, 26))
+>disc : Symbol(DiscriminatorTrue.disc, Decl(tsxDiscriminantPropertyInference.tsx, 5, 26))
 
     cb: (x: string) => void;
->cb : Symbol(cb, Decl(tsxDiscriminantPropertyInference.tsx, 6, 15))
+>cb : Symbol(DiscriminatorTrue.cb, Decl(tsxDiscriminantPropertyInference.tsx, 6, 15))
 >x : Symbol(x, Decl(tsxDiscriminantPropertyInference.tsx, 7, 9))
 }
 
@@ -22,10 +22,10 @@ type DiscriminatorFalse = {
 >DiscriminatorFalse : Symbol(DiscriminatorFalse, Decl(tsxDiscriminantPropertyInference.tsx, 8, 1))
 
     disc?: false;
->disc : Symbol(disc, Decl(tsxDiscriminantPropertyInference.tsx, 10, 27))
+>disc : Symbol(DiscriminatorFalse.disc, Decl(tsxDiscriminantPropertyInference.tsx, 10, 27))
 
     cb: (x: number) => void;
->cb : Symbol(cb, Decl(tsxDiscriminantPropertyInference.tsx, 11, 17))
+>cb : Symbol(DiscriminatorFalse.cb, Decl(tsxDiscriminantPropertyInference.tsx, 11, 17))
 >x : Symbol(x, Decl(tsxDiscriminantPropertyInference.tsx, 12, 9))
 }
 
diff --git a/tests/baselines/reference/tsxTypeArgumentsJsxPreserveOutput.symbols b/tests/baselines/reference/tsxTypeArgumentsJsxPreserveOutput.symbols
index 4a199f1a99696..9ae6af5552974 100644
--- a/tests/baselines/reference/tsxTypeArgumentsJsxPreserveOutput.symbols
+++ b/tests/baselines/reference/tsxTypeArgumentsJsxPreserveOutput.symbols
@@ -4,7 +4,7 @@ import React = require('react');
 
 type TypeProps = { foo?: boolean; };
 >TypeProps : Symbol(TypeProps, Decl(foo.tsx, 0, 32))
->foo : Symbol(foo, Decl(foo.tsx, 2, 18))
+>foo : Symbol(TypeProps.foo, Decl(foo.tsx, 2, 18))
 
 interface InterfaceProps { foo?: boolean; }
 >InterfaceProps : Symbol(InterfaceProps, Decl(foo.tsx, 2, 36))
diff --git a/tests/baselines/reference/tsxUnionSpread.symbols b/tests/baselines/reference/tsxUnionSpread.symbols
index fa838773a8a42..bd05b15bffa0b 100644
--- a/tests/baselines/reference/tsxUnionSpread.symbols
+++ b/tests/baselines/reference/tsxUnionSpread.symbols
@@ -8,12 +8,12 @@ namespace JSX {
 
 export type CatInfo = { type: 'Cat'; subType: string; };
 >CatInfo : Symbol(CatInfo, Decl(index.tsx, 2, 1))
->type : Symbol(type, Decl(index.tsx, 4, 23))
->subType : Symbol(subType, Decl(index.tsx, 4, 36))
+>type : Symbol(CatInfo.type, Decl(index.tsx, 4, 23))
+>subType : Symbol(CatInfo.subType, Decl(index.tsx, 4, 36))
 
 export type DogInfo = { type: 'Dog'; };
 >DogInfo : Symbol(DogInfo, Decl(index.tsx, 4, 56))
->type : Symbol(type, Decl(index.tsx, 5, 23))
+>type : Symbol(DogInfo.type, Decl(index.tsx, 5, 23))
 
 export type AnimalInfo = CatInfo | DogInfo;
 >AnimalInfo : Symbol(AnimalInfo, Decl(index.tsx, 5, 39))
diff --git a/tests/baselines/reference/typeAliasDeclarationEmit2.symbols b/tests/baselines/reference/typeAliasDeclarationEmit2.symbols
index 213d1c1ddae09..e9ecb6651efa4 100644
--- a/tests/baselines/reference/typeAliasDeclarationEmit2.symbols
+++ b/tests/baselines/reference/typeAliasDeclarationEmit2.symbols
@@ -2,6 +2,6 @@
 export type A<a> = { value: a };
 >A : Symbol(A, Decl(typeAliasDeclarationEmit2.ts, 0, 0))
 >a : Symbol(a, Decl(typeAliasDeclarationEmit2.ts, 0, 14))
->value : Symbol(value, Decl(typeAliasDeclarationEmit2.ts, 0, 20))
+>value : Symbol(A.value, Decl(typeAliasDeclarationEmit2.ts, 0, 20))
 >a : Symbol(a, Decl(typeAliasDeclarationEmit2.ts, 0, 14))
 
diff --git a/tests/baselines/reference/typeAliases.symbols b/tests/baselines/reference/typeAliases.symbols
index e34ff9e1a850a..87d924f68881b 100644
--- a/tests/baselines/reference/typeAliases.symbols
+++ b/tests/baselines/reference/typeAliases.symbols
@@ -105,7 +105,7 @@ var x9: T9;
 
 type T10 = { x: number };
 >T10 : Symbol(T10, Decl(typeAliases.ts, 38, 11))
->x : Symbol(x, Decl(typeAliases.ts, 40, 12))
+>x : Symbol(T10.x, Decl(typeAliases.ts, 40, 12))
 
 var x10: { x: number };
 >x10 : Symbol(x10, Decl(typeAliases.ts, 41, 3), Decl(typeAliases.ts, 42, 3))
diff --git a/tests/baselines/reference/typeAliasesForObjectTypes.symbols b/tests/baselines/reference/typeAliasesForObjectTypes.symbols
index e199dc8661723..bb93fd44f4c3a 100644
--- a/tests/baselines/reference/typeAliasesForObjectTypes.symbols
+++ b/tests/baselines/reference/typeAliasesForObjectTypes.symbols
@@ -1,7 +1,7 @@
 === tests/cases/conformance/types/typeAliases/typeAliasesForObjectTypes.ts ===
 type T1 = { x: string }
 >T1 : Symbol(T1, Decl(typeAliasesForObjectTypes.ts, 0, 0))
->x : Symbol(x, Decl(typeAliasesForObjectTypes.ts, 0, 11))
+>x : Symbol(T1.x, Decl(typeAliasesForObjectTypes.ts, 0, 11))
 
 // An interface can be named in an extends or implements clause, but a type alias for an object type literal cannot.
 interface I1 extends T1 { y: string }
@@ -20,7 +20,7 @@ class C1 implements T1 {
 // An interface can have multiple merged declarations, but a type alias for an object type literal cannot.
 type T2 = { x: string }
 >T2 : Symbol(T2, Decl(typeAliasesForObjectTypes.ts, 6, 1))
->x : Symbol(x, Decl(typeAliasesForObjectTypes.ts, 9, 11))
+>x : Symbol(T2.x, Decl(typeAliasesForObjectTypes.ts, 9, 11))
 
 type T2 = { y: number }
 >T2 : Symbol(T2, Decl(typeAliasesForObjectTypes.ts, 9, 23))
@@ -30,6 +30,6 @@ type T2 = { y: number }
 type T3<T> = { x: T }
 >T3 : Symbol(T3, Decl(typeAliasesForObjectTypes.ts, 10, 23))
 >T : Symbol(T, Decl(typeAliasesForObjectTypes.ts, 13, 8))
->x : Symbol(x, Decl(typeAliasesForObjectTypes.ts, 13, 14))
+>x : Symbol(T3.x, Decl(typeAliasesForObjectTypes.ts, 13, 14))
 >T : Symbol(T, Decl(typeAliasesForObjectTypes.ts, 13, 8))
 
diff --git a/tests/baselines/reference/typeArgumentDefaultUsesConstraintOnCircularDefault.symbols b/tests/baselines/reference/typeArgumentDefaultUsesConstraintOnCircularDefault.symbols
index 4c227899de9f1..57aa629145f38 100644
--- a/tests/baselines/reference/typeArgumentDefaultUsesConstraintOnCircularDefault.symbols
+++ b/tests/baselines/reference/typeArgumentDefaultUsesConstraintOnCircularDefault.symbols
@@ -3,7 +3,7 @@ type Test<T extends string = T> = { value: T };  // Error
 >Test : Symbol(Test, Decl(typeArgumentDefaultUsesConstraintOnCircularDefault.ts, 0, 0))
 >T : Symbol(T, Decl(typeArgumentDefaultUsesConstraintOnCircularDefault.ts, 0, 10))
 >T : Symbol(T, Decl(typeArgumentDefaultUsesConstraintOnCircularDefault.ts, 0, 10))
->value : Symbol(value, Decl(typeArgumentDefaultUsesConstraintOnCircularDefault.ts, 0, 35))
+>value : Symbol(Test.value, Decl(typeArgumentDefaultUsesConstraintOnCircularDefault.ts, 0, 35))
 >T : Symbol(T, Decl(typeArgumentDefaultUsesConstraintOnCircularDefault.ts, 0, 10))
 
 let zz: Test = { foo: "abc" };  // should error on comparison with Test<string>
diff --git a/tests/baselines/reference/typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral01.symbols b/tests/baselines/reference/typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral01.symbols
index 961ec823ad1f0..980a6b1bfa76a 100644
--- a/tests/baselines/reference/typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral01.symbols
+++ b/tests/baselines/reference/typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral01.symbols
@@ -3,10 +3,10 @@ type TreeNode = {
 >TreeNode : Symbol(TreeNode, Decl(typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral01.ts, 0, 0))
 
     name: string;
->name : Symbol(name, Decl(typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral01.ts, 0, 17))
+>name : Symbol(TreeNode.name, Decl(typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral01.ts, 0, 17))
 
     parent: TreeNode;
->parent : Symbol(parent, Decl(typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral01.ts, 1, 17))
+>parent : Symbol(TreeNode.parent, Decl(typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral01.ts, 1, 17))
 >TreeNode : Symbol(TreeNode, Decl(typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral01.ts, 0, 0))
 }
 
@@ -19,7 +19,7 @@ nodes.map(n => n.name);
 >nodes : Symbol(nodes, Decl(typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral01.ts, 5, 3))
 >map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --))
 >n : Symbol(n, Decl(typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral01.ts, 6, 10))
->n.name : Symbol(name, Decl(typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral01.ts, 0, 17))
+>n.name : Symbol(TreeNode.name, Decl(typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral01.ts, 0, 17))
 >n : Symbol(n, Decl(typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral01.ts, 6, 10))
->name : Symbol(name, Decl(typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral01.ts, 0, 17))
+>name : Symbol(TreeNode.name, Decl(typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral01.ts, 0, 17))
 
diff --git a/tests/baselines/reference/typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral02.symbols b/tests/baselines/reference/typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral02.symbols
index a41bb9ba952bd..59fa2408bbd46 100644
--- a/tests/baselines/reference/typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral02.symbols
+++ b/tests/baselines/reference/typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral02.symbols
@@ -3,10 +3,10 @@ type TreeNode = {
 >TreeNode : Symbol(TreeNode, Decl(typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral02.ts, 0, 0))
 
     name: string;
->name : Symbol(name, Decl(typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral02.ts, 0, 17))
+>name : Symbol(TreeNode.name, Decl(typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral02.ts, 0, 17))
 
     parent: TreeNode;
->parent : Symbol(parent, Decl(typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral02.ts, 1, 17))
+>parent : Symbol(TreeNode.parent, Decl(typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral02.ts, 1, 17))
 >TreeNode : Symbol(TreeNode, Decl(typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral02.ts, 0, 0))
 }
 
@@ -14,10 +14,10 @@ type TreeNodeMiddleman = {
 >TreeNodeMiddleman : Symbol(TreeNodeMiddleman, Decl(typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral02.ts, 3, 1))
 
     name: string;
->name : Symbol(name, Decl(typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral02.ts, 5, 26))
+>name : Symbol(TreeNodeMiddleman.name, Decl(typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral02.ts, 5, 26))
 
     parent: TreeNode;
->parent : Symbol(parent, Decl(typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral02.ts, 6, 17))
+>parent : Symbol(TreeNodeMiddleman.parent, Decl(typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral02.ts, 6, 17))
 >TreeNode : Symbol(TreeNode, Decl(typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral02.ts, 0, 0))
 }
 
@@ -30,7 +30,7 @@ nodes.map(n => n.name);
 >nodes : Symbol(nodes, Decl(typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral02.ts, 10, 3))
 >map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --))
 >n : Symbol(n, Decl(typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral02.ts, 11, 10))
->n.name : Symbol(name, Decl(typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral02.ts, 5, 26))
+>n.name : Symbol(TreeNodeMiddleman.name, Decl(typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral02.ts, 5, 26))
 >n : Symbol(n, Decl(typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral02.ts, 11, 10))
->name : Symbol(name, Decl(typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral02.ts, 5, 26))
+>name : Symbol(TreeNodeMiddleman.name, Decl(typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral02.ts, 5, 26))
 
diff --git a/tests/baselines/reference/typeGuardFunctionErrors.symbols b/tests/baselines/reference/typeGuardFunctionErrors.symbols
index 9c7e82bf9abcd..5451a26ea2e30 100644
--- a/tests/baselines/reference/typeGuardFunctionErrors.symbols
+++ b/tests/baselines/reference/typeGuardFunctionErrors.symbols
@@ -391,11 +391,11 @@ declare function hasKey<T extends Keys>(x: KeySet<T>): x is KeySet<T|'d'>;
 
 type Foo = { 'a': string; }
 >Foo : Symbol(Foo, Decl(typeGuardFunctionErrors.ts, 151, 74))
->'a' : Symbol('a', Decl(typeGuardFunctionErrors.ts, 153, 12))
+>'a' : Symbol(Foo['a'], Decl(typeGuardFunctionErrors.ts, 153, 12))
 
 type Bar = { 'a': number; }
 >Bar : Symbol(Bar, Decl(typeGuardFunctionErrors.ts, 153, 27))
->'a' : Symbol('a', Decl(typeGuardFunctionErrors.ts, 154, 12))
+>'a' : Symbol(Bar['a'], Decl(typeGuardFunctionErrors.ts, 154, 12))
 
 interface NeedsFoo<T extends Foo> {
 >NeedsFoo : Symbol(NeedsFoo, Decl(typeGuardFunctionErrors.ts, 154, 27))
diff --git a/tests/baselines/reference/typeGuardNarrowsPrimitiveIntersection.symbols b/tests/baselines/reference/typeGuardNarrowsPrimitiveIntersection.symbols
index da507fb94c5dc..5d0f164fd295c 100644
--- a/tests/baselines/reference/typeGuardNarrowsPrimitiveIntersection.symbols
+++ b/tests/baselines/reference/typeGuardNarrowsPrimitiveIntersection.symbols
@@ -1,7 +1,7 @@
 === tests/cases/conformance/expressions/typeGuards/typeGuardNarrowsPrimitiveIntersection.ts ===
 type Tag = {__tag: any};
 >Tag : Symbol(Tag, Decl(typeGuardNarrowsPrimitiveIntersection.ts, 0, 0))
->__tag : Symbol(__tag, Decl(typeGuardNarrowsPrimitiveIntersection.ts, 0, 12))
+>__tag : Symbol(Tag.__tag, Decl(typeGuardNarrowsPrimitiveIntersection.ts, 0, 12))
 
 declare function isNonBlank(value: string) : value is (string & Tag);
 >isNonBlank : Symbol(isNonBlank, Decl(typeGuardNarrowsPrimitiveIntersection.ts, 0, 24))
diff --git a/tests/baselines/reference/typePredicateStructuralMatch.symbols b/tests/baselines/reference/typePredicateStructuralMatch.symbols
index 5e4826ebbf2e8..4398262862349 100644
--- a/tests/baselines/reference/typePredicateStructuralMatch.symbols
+++ b/tests/baselines/reference/typePredicateStructuralMatch.symbols
@@ -17,7 +17,7 @@ getResults2({data: []});
 
 type Result = { value: string };
 >Result : Symbol(Result, Decl(typePredicateStructuralMatch.ts, 6, 24))
->value : Symbol(value, Decl(typePredicateStructuralMatch.ts, 8, 15))
+>value : Symbol(Result.value, Decl(typePredicateStructuralMatch.ts, 8, 15))
 
 type Results = Result[];
 >Results : Symbol(Results, Decl(typePredicateStructuralMatch.ts, 8, 32))
diff --git a/tests/baselines/reference/typeUsedAsTypeLiteralIndex.symbols b/tests/baselines/reference/typeUsedAsTypeLiteralIndex.symbols
index 840517048c513..4db4ef4afc083 100644
--- a/tests/baselines/reference/typeUsedAsTypeLiteralIndex.symbols
+++ b/tests/baselines/reference/typeUsedAsTypeLiteralIndex.symbols
@@ -6,7 +6,7 @@ type T = {
 >T : Symbol(T, Decl(typeUsedAsTypeLiteralIndex.ts, 0, 25))
 
     [K]: number;  // Did you mean to use 'P in K'?
->[K] : Symbol([K], Decl(typeUsedAsTypeLiteralIndex.ts, 1, 10))
+>[K] : Symbol(T[K], Decl(typeUsedAsTypeLiteralIndex.ts, 1, 10))
 }
 
 const K1 = Symbol();
@@ -17,7 +17,7 @@ type T1 = {
 >T1 : Symbol(T1, Decl(typeUsedAsTypeLiteralIndex.ts, 5, 20))
 
     [K1]: number;
->[K1] : Symbol([K1], Decl(typeUsedAsTypeLiteralIndex.ts, 6, 11))
+>[K1] : Symbol(T1[K1], Decl(typeUsedAsTypeLiteralIndex.ts, 6, 11))
 >K1 : Symbol(K1, Decl(typeUsedAsTypeLiteralIndex.ts, 5, 5))
 }
 
@@ -28,7 +28,7 @@ type T2 = {
 >T2 : Symbol(T2, Decl(typeUsedAsTypeLiteralIndex.ts, 10, 20))
 
     [K2]: number;  // Did you mean to use 'K in K2'?
->[K2] : Symbol([K2], Decl(typeUsedAsTypeLiteralIndex.ts, 11, 11))
+>[K2] : Symbol(T2[K2], Decl(typeUsedAsTypeLiteralIndex.ts, 11, 11))
 }
 
 type K3 = number | string;
@@ -38,7 +38,7 @@ type T3 = {
 >T3 : Symbol(T3, Decl(typeUsedAsTypeLiteralIndex.ts, 15, 26))
 
     [K3]: number; // Did you mean to use 'K in K3'?
->[K3] : Symbol([K3], Decl(typeUsedAsTypeLiteralIndex.ts, 16, 11))
+>[K3] : Symbol(T3[K3], Decl(typeUsedAsTypeLiteralIndex.ts, 16, 11))
 }
 
 type K4 = number | string;
@@ -48,9 +48,9 @@ type T4 = {
 >T4 : Symbol(T4, Decl(typeUsedAsTypeLiteralIndex.ts, 20, 26))
 
     [K4]: number;
->[K4] : Symbol([K4], Decl(typeUsedAsTypeLiteralIndex.ts, 21, 11))
+>[K4] : Symbol(T4[K4], Decl(typeUsedAsTypeLiteralIndex.ts, 21, 11))
 
     k4: string;
->k4 : Symbol(k4, Decl(typeUsedAsTypeLiteralIndex.ts, 22, 17))
+>k4 : Symbol(T4.k4, Decl(typeUsedAsTypeLiteralIndex.ts, 22, 17))
 }
 
diff --git a/tests/baselines/reference/typeUsedAsValueError.symbols b/tests/baselines/reference/typeUsedAsValueError.symbols
index f9efc8d2d3e60..e14c70259aa97 100644
--- a/tests/baselines/reference/typeUsedAsValueError.symbols
+++ b/tests/baselines/reference/typeUsedAsValueError.symbols
@@ -15,7 +15,7 @@ type TypeAliasForSomeClass = SomeClass;
 
 type someType = { x: number };
 >someType : Symbol(someType, Decl(typeUsedAsValueError.ts, 8, 39))
->x : Symbol(x, Decl(typeUsedAsValueError.ts, 9, 17))
+>x : Symbol(someType.x, Decl(typeUsedAsValueError.ts, 9, 17))
 
 function acceptsSomeType(a: someType) {
 >acceptsSomeType : Symbol(acceptsSomeType, Decl(typeUsedAsValueError.ts, 9, 30))
diff --git a/tests/baselines/reference/typeVariableTypeGuards.symbols b/tests/baselines/reference/typeVariableTypeGuards.symbols
index ded3e17d2d695..028de4b4a7b43 100644
--- a/tests/baselines/reference/typeVariableTypeGuards.symbols
+++ b/tests/baselines/reference/typeVariableTypeGuards.symbols
@@ -107,7 +107,7 @@ type Item = {
 
     (): string;
     x: string;
->x : Symbol(x, Decl(typeVariableTypeGuards.ts, 42, 15))
+>x : Symbol(Item.x, Decl(typeVariableTypeGuards.ts, 42, 15))
 }
 
 function f1<T extends Item | undefined>(obj: T) {
@@ -121,13 +121,13 @@ function f1<T extends Item | undefined>(obj: T) {
 >obj : Symbol(obj, Decl(typeVariableTypeGuards.ts, 46, 40))
 
         obj.x;
->obj.x : Symbol(x, Decl(typeVariableTypeGuards.ts, 42, 15))
+>obj.x : Symbol(Item.x, Decl(typeVariableTypeGuards.ts, 42, 15))
 >obj : Symbol(obj, Decl(typeVariableTypeGuards.ts, 46, 40))
->x : Symbol(x, Decl(typeVariableTypeGuards.ts, 42, 15))
+>x : Symbol(Item.x, Decl(typeVariableTypeGuards.ts, 42, 15))
 
         obj["x"];
 >obj : Symbol(obj, Decl(typeVariableTypeGuards.ts, 46, 40))
->"x" : Symbol(x, Decl(typeVariableTypeGuards.ts, 42, 15))
+>"x" : Symbol(Item.x, Decl(typeVariableTypeGuards.ts, 42, 15))
 
         obj();
 >obj : Symbol(obj, Decl(typeVariableTypeGuards.ts, 46, 40))
@@ -145,13 +145,13 @@ function f2<T extends Item | undefined>(obj: T | undefined) {
 >obj : Symbol(obj, Decl(typeVariableTypeGuards.ts, 54, 40))
 
         obj.x;
->obj.x : Symbol(x, Decl(typeVariableTypeGuards.ts, 42, 15))
+>obj.x : Symbol(Item.x, Decl(typeVariableTypeGuards.ts, 42, 15))
 >obj : Symbol(obj, Decl(typeVariableTypeGuards.ts, 54, 40))
->x : Symbol(x, Decl(typeVariableTypeGuards.ts, 42, 15))
+>x : Symbol(Item.x, Decl(typeVariableTypeGuards.ts, 42, 15))
 
         obj["x"];
 >obj : Symbol(obj, Decl(typeVariableTypeGuards.ts, 54, 40))
->"x" : Symbol(x, Decl(typeVariableTypeGuards.ts, 42, 15))
+>"x" : Symbol(Item.x, Decl(typeVariableTypeGuards.ts, 42, 15))
 
         obj();
 >obj : Symbol(obj, Decl(typeVariableTypeGuards.ts, 54, 40))
@@ -169,13 +169,13 @@ function f3<T extends Item | undefined>(obj: T | null) {
 >obj : Symbol(obj, Decl(typeVariableTypeGuards.ts, 62, 40))
 
         obj.x;
->obj.x : Symbol(x, Decl(typeVariableTypeGuards.ts, 42, 15))
+>obj.x : Symbol(Item.x, Decl(typeVariableTypeGuards.ts, 42, 15))
 >obj : Symbol(obj, Decl(typeVariableTypeGuards.ts, 62, 40))
->x : Symbol(x, Decl(typeVariableTypeGuards.ts, 42, 15))
+>x : Symbol(Item.x, Decl(typeVariableTypeGuards.ts, 42, 15))
 
         obj["x"];
 >obj : Symbol(obj, Decl(typeVariableTypeGuards.ts, 62, 40))
->"x" : Symbol(x, Decl(typeVariableTypeGuards.ts, 42, 15))
+>"x" : Symbol(Item.x, Decl(typeVariableTypeGuards.ts, 42, 15))
 
         obj();
 >obj : Symbol(obj, Decl(typeVariableTypeGuards.ts, 62, 40))
diff --git a/tests/baselines/reference/typedefOnStatements.symbols b/tests/baselines/reference/typedefOnStatements.symbols
index 8c9fb84750ab1..a383f5a342b1c 100644
--- a/tests/baselines/reference/typedefOnStatements.symbols
+++ b/tests/baselines/reference/typedefOnStatements.symbols
@@ -99,57 +99,57 @@ function proof (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q) {
 >console.log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --))
 >console : Symbol(console, Decl(lib.dom.d.ts, --, --))
 >log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --))
->a.a : Symbol(a, Decl(typedefOnStatements.js, 0, 15))
+>a.a : Symbol(A.a, Decl(typedefOnStatements.js, 0, 15))
 >a : Symbol(a, Decl(typedefOnStatements.js, 70, 16))
->a : Symbol(a, Decl(typedefOnStatements.js, 0, 15))
->b.b : Symbol(b, Decl(typedefOnStatements.js, 2, 15))
+>a : Symbol(A.a, Decl(typedefOnStatements.js, 0, 15))
+>b.b : Symbol(B.b, Decl(typedefOnStatements.js, 2, 15))
 >b : Symbol(b, Decl(typedefOnStatements.js, 70, 18))
->b : Symbol(b, Decl(typedefOnStatements.js, 2, 15))
->c.c : Symbol(c, Decl(typedefOnStatements.js, 4, 15))
+>b : Symbol(B.b, Decl(typedefOnStatements.js, 2, 15))
+>c.c : Symbol(C.c, Decl(typedefOnStatements.js, 4, 15))
 >c : Symbol(c, Decl(typedefOnStatements.js, 70, 20))
->c : Symbol(c, Decl(typedefOnStatements.js, 4, 15))
->d.d : Symbol(d, Decl(typedefOnStatements.js, 7, 15))
+>c : Symbol(C.c, Decl(typedefOnStatements.js, 4, 15))
+>d.d : Symbol(D.d, Decl(typedefOnStatements.js, 7, 15))
 >d : Symbol(d, Decl(typedefOnStatements.js, 70, 22))
->d : Symbol(d, Decl(typedefOnStatements.js, 7, 15))
->e.e : Symbol(e, Decl(typedefOnStatements.js, 9, 15))
+>d : Symbol(D.d, Decl(typedefOnStatements.js, 7, 15))
+>e.e : Symbol(E.e, Decl(typedefOnStatements.js, 9, 15))
 >e : Symbol(e, Decl(typedefOnStatements.js, 70, 24))
->e : Symbol(e, Decl(typedefOnStatements.js, 9, 15))
->f.f : Symbol(f, Decl(typedefOnStatements.js, 12, 15))
+>e : Symbol(E.e, Decl(typedefOnStatements.js, 9, 15))
+>f.f : Symbol(F.f, Decl(typedefOnStatements.js, 12, 15))
 >f : Symbol(f, Decl(typedefOnStatements.js, 70, 26))
->f : Symbol(f, Decl(typedefOnStatements.js, 12, 15))
->g.g : Symbol(g, Decl(typedefOnStatements.js, 15, 15))
+>f : Symbol(F.f, Decl(typedefOnStatements.js, 12, 15))
+>g.g : Symbol(G.g, Decl(typedefOnStatements.js, 15, 15))
 >g : Symbol(g, Decl(typedefOnStatements.js, 70, 28))
->g : Symbol(g, Decl(typedefOnStatements.js, 15, 15))
->h.h : Symbol(h, Decl(typedefOnStatements.js, 18, 15))
+>g : Symbol(G.g, Decl(typedefOnStatements.js, 15, 15))
+>h.h : Symbol(H.h, Decl(typedefOnStatements.js, 18, 15))
 >h : Symbol(h, Decl(typedefOnStatements.js, 70, 30))
->h : Symbol(h, Decl(typedefOnStatements.js, 18, 15))
->i.i : Symbol(i, Decl(typedefOnStatements.js, 21, 15))
+>h : Symbol(H.h, Decl(typedefOnStatements.js, 18, 15))
+>i.i : Symbol(I.i, Decl(typedefOnStatements.js, 21, 15))
 >i : Symbol(i, Decl(typedefOnStatements.js, 70, 32))
->i : Symbol(i, Decl(typedefOnStatements.js, 21, 15))
->j.j : Symbol(j, Decl(typedefOnStatements.js, 24, 15))
+>i : Symbol(I.i, Decl(typedefOnStatements.js, 21, 15))
+>j.j : Symbol(J.j, Decl(typedefOnStatements.js, 24, 15))
 >j : Symbol(j, Decl(typedefOnStatements.js, 70, 34))
->j : Symbol(j, Decl(typedefOnStatements.js, 24, 15))
->k.k : Symbol(k, Decl(typedefOnStatements.js, 26, 15))
+>j : Symbol(J.j, Decl(typedefOnStatements.js, 24, 15))
+>k.k : Symbol(K.k, Decl(typedefOnStatements.js, 26, 15))
 >k : Symbol(k, Decl(typedefOnStatements.js, 70, 36))
->k : Symbol(k, Decl(typedefOnStatements.js, 26, 15))
->l.l : Symbol(l, Decl(typedefOnStatements.js, 29, 15))
+>k : Symbol(K.k, Decl(typedefOnStatements.js, 26, 15))
+>l.l : Symbol(L.l, Decl(typedefOnStatements.js, 29, 15))
 >l : Symbol(l, Decl(typedefOnStatements.js, 70, 38))
->l : Symbol(l, Decl(typedefOnStatements.js, 29, 15))
->m.m : Symbol(m, Decl(typedefOnStatements.js, 31, 15))
+>l : Symbol(L.l, Decl(typedefOnStatements.js, 29, 15))
+>m.m : Symbol(M.m, Decl(typedefOnStatements.js, 31, 15))
 >m : Symbol(m, Decl(typedefOnStatements.js, 70, 40))
->m : Symbol(m, Decl(typedefOnStatements.js, 31, 15))
->n.n : Symbol(n, Decl(typedefOnStatements.js, 34, 15))
+>m : Symbol(M.m, Decl(typedefOnStatements.js, 31, 15))
+>n.n : Symbol(N.n, Decl(typedefOnStatements.js, 34, 15))
 >n : Symbol(n, Decl(typedefOnStatements.js, 70, 42))
->n : Symbol(n, Decl(typedefOnStatements.js, 34, 15))
->o.o : Symbol(o, Decl(typedefOnStatements.js, 38, 15))
+>n : Symbol(N.n, Decl(typedefOnStatements.js, 34, 15))
+>o.o : Symbol(O.o, Decl(typedefOnStatements.js, 38, 15))
 >o : Symbol(o, Decl(typedefOnStatements.js, 70, 44))
->o : Symbol(o, Decl(typedefOnStatements.js, 38, 15))
->p.p : Symbol(p, Decl(typedefOnStatements.js, 42, 15))
+>o : Symbol(O.o, Decl(typedefOnStatements.js, 38, 15))
+>p.p : Symbol(P.p, Decl(typedefOnStatements.js, 42, 15))
 >p : Symbol(p, Decl(typedefOnStatements.js, 70, 46))
->p : Symbol(p, Decl(typedefOnStatements.js, 42, 15))
->q.q : Symbol(q, Decl(typedefOnStatements.js, 45, 15))
+>p : Symbol(P.p, Decl(typedefOnStatements.js, 42, 15))
+>q.q : Symbol(Q.q, Decl(typedefOnStatements.js, 45, 15))
 >q : Symbol(q, Decl(typedefOnStatements.js, 70, 48))
->q : Symbol(q, Decl(typedefOnStatements.js, 45, 15))
+>q : Symbol(Q.q, Decl(typedefOnStatements.js, 45, 15))
 
     /** @type {Alpha} */
     var alpha = { alpha: "aleph" }
diff --git a/tests/baselines/reference/typedefTagNested.symbols b/tests/baselines/reference/typedefTagNested.symbols
index f6a346793065b..1a968b6fca64d 100644
--- a/tests/baselines/reference/typedefTagNested.symbols
+++ b/tests/baselines/reference/typedefTagNested.symbols
@@ -53,17 +53,17 @@ var sala = { name: 'uppsala', not: 0, nested: "ok" };
 >nested : Symbol(nested, Decl(a.js, 35, 37))
 
 sala.name
->sala.name : Symbol(name, Decl(a.js, 29, 3))
+>sala.name : Symbol(Upp.name, Decl(a.js, 29, 3))
 >sala : Symbol(sala, Decl(a.js, 35, 3))
->name : Symbol(name, Decl(a.js, 29, 3))
+>name : Symbol(Upp.name, Decl(a.js, 29, 3))
 
 sala.not
->sala.not : Symbol(not, Decl(a.js, 30, 3))
+>sala.not : Symbol(Upp.not, Decl(a.js, 30, 3))
 >sala : Symbol(sala, Decl(a.js, 35, 3))
->not : Symbol(not, Decl(a.js, 30, 3))
+>not : Symbol(Upp.not, Decl(a.js, 30, 3))
 
 sala.nested
->sala.nested : Symbol(nested, Decl(a.js, 31, 3))
+>sala.nested : Symbol(Upp.nested, Decl(a.js, 31, 3))
 >sala : Symbol(sala, Decl(a.js, 35, 3))
->nested : Symbol(nested, Decl(a.js, 31, 3))
+>nested : Symbol(Upp.nested, Decl(a.js, 31, 3))
 
diff --git a/tests/baselines/reference/typedefTagWrapping.symbols b/tests/baselines/reference/typedefTagWrapping.symbols
index ea0bb73a849ff..9b39f02277655 100644
--- a/tests/baselines/reference/typedefTagWrapping.symbols
+++ b/tests/baselines/reference/typedefTagWrapping.symbols
@@ -40,15 +40,15 @@ function check(obj) {
 >obj : Symbol(obj, Decl(mod2.js, 13, 15))
 
   return obj.boo ? obj.num : obj.str;
->obj.boo : Symbol(boo, Decl(mod2.js, 3, 17))
+>obj.boo : Symbol(Type2.boo, Decl(mod2.js, 3, 17))
 >obj : Symbol(obj, Decl(mod2.js, 13, 15))
->boo : Symbol(boo, Decl(mod2.js, 3, 17))
->obj.num : Symbol(num, Decl(mod2.js, 1, 14))
+>boo : Symbol(Type2.boo, Decl(mod2.js, 3, 17))
+>obj.num : Symbol(Type2.num, Decl(mod2.js, 1, 14))
 >obj : Symbol(obj, Decl(mod2.js, 13, 15))
->num : Symbol(num, Decl(mod2.js, 1, 14))
->obj.str : Symbol(str, Decl(mod2.js, 2, 17))
+>num : Symbol(Type2.num, Decl(mod2.js, 1, 14))
+>obj.str : Symbol(Type2.str, Decl(mod2.js, 2, 17))
 >obj : Symbol(obj, Decl(mod2.js, 13, 15))
->str : Symbol(str, Decl(mod2.js, 2, 17))
+>str : Symbol(Type2.str, Decl(mod2.js, 2, 17))
 }
 
 === tests/cases/conformance/jsdoc/mod3.js ===
@@ -134,15 +134,15 @@ function check5(obj) {
 >obj : Symbol(obj, Decl(mod5.js, 16, 16))
 
   return obj.boo ? obj.num : obj.str;
->obj.boo : Symbol(boo, Decl(mod5.js, 5, 12))
+>obj.boo : Symbol(Type5.boo, Decl(mod5.js, 5, 12))
 >obj : Symbol(obj, Decl(mod5.js, 16, 16))
->boo : Symbol(boo, Decl(mod5.js, 5, 12))
->obj.num : Symbol(num, Decl(mod5.js, 1, 14))
+>boo : Symbol(Type5.boo, Decl(mod5.js, 5, 12))
+>obj.num : Symbol(Type5.num, Decl(mod5.js, 1, 14))
 >obj : Symbol(obj, Decl(mod5.js, 16, 16))
->num : Symbol(num, Decl(mod5.js, 1, 14))
->obj.str : Symbol(str, Decl(mod5.js, 3, 12))
+>num : Symbol(Type5.num, Decl(mod5.js, 1, 14))
+>obj.str : Symbol(Type5.str, Decl(mod5.js, 3, 12))
 >obj : Symbol(obj, Decl(mod5.js, 16, 16))
->str : Symbol(str, Decl(mod5.js, 3, 12))
+>str : Symbol(Type5.str, Decl(mod5.js, 3, 12))
 }
 
 === tests/cases/conformance/jsdoc/mod6.js ===
@@ -165,9 +165,9 @@ function check6(obj) {
 >obj : Symbol(obj, Decl(mod6.js, 14, 16))
 
   return obj.foo;
->obj.foo : Symbol(foo, Decl(mod6.js, 1, 14))
+>obj.foo : Symbol(Type6.foo, Decl(mod6.js, 1, 14))
 >obj : Symbol(obj, Decl(mod6.js, 14, 16))
->foo : Symbol(foo, Decl(mod6.js, 1, 14))
+>foo : Symbol(Type6.foo, Decl(mod6.js, 1, 14))
 }
 
 
diff --git a/tests/baselines/reference/typeofThis.symbols b/tests/baselines/reference/typeofThis.symbols
index fade7c3c37511..f0682361d3036 100644
--- a/tests/baselines/reference/typeofThis.symbols
+++ b/tests/baselines/reference/typeofThis.symbols
@@ -332,41 +332,41 @@ class Tests12 {
 >Tests12 : Symbol(Tests12, Decl(typeofThis.ts, 121, 1))
 
     test1() { // OK
->test1 : Symbol(Tests12.test1, Decl(typeofThis.ts, 123, 15))
+>test1 : Symbol(Test.test1, Decl(typeofThis.ts, 123, 15))
 
         type Test = typeof this;
 >Test : Symbol(Test, Decl(typeofThis.ts, 124, 13))
->this : Symbol(Tests12, Decl(typeofThis.ts, 121, 1))
+>this : Symbol(Test, Decl(typeofThis.ts, 121, 1))
     }
 
     test2() { // OK
->test2 : Symbol(Tests12.test2, Decl(typeofThis.ts, 126, 5))
+>test2 : Symbol(Test.test2, Decl(typeofThis.ts, 126, 5))
 
         for (;;) {}
         type Test = typeof this;
 >Test : Symbol(Test, Decl(typeofThis.ts, 129, 19))
->this : Symbol(Tests12, Decl(typeofThis.ts, 121, 1))
+>this : Symbol(Test, Decl(typeofThis.ts, 121, 1))
     }
 
     test3() { // expected no compile errors
->test3 : Symbol(Tests12.test3, Decl(typeofThis.ts, 131, 5))
+>test3 : Symbol(Test.test3, Decl(typeofThis.ts, 131, 5))
 
         for (const dummy in []) {}
 >dummy : Symbol(dummy, Decl(typeofThis.ts, 134, 18))
 
         type Test = typeof this;
 >Test : Symbol(Test, Decl(typeofThis.ts, 134, 34))
->this : Symbol(Tests12, Decl(typeofThis.ts, 121, 1))
+>this : Symbol(Test, Decl(typeofThis.ts, 121, 1))
     }
 
     test4() { // expected no compile errors
->test4 : Symbol(Tests12.test4, Decl(typeofThis.ts, 136, 5))
+>test4 : Symbol(Test.test4, Decl(typeofThis.ts, 136, 5))
 
         for (const dummy of []) {}
 >dummy : Symbol(dummy, Decl(typeofThis.ts, 139, 18))
 
         type Test = typeof this;
 >Test : Symbol(Test, Decl(typeofThis.ts, 139, 34))
->this : Symbol(Tests12, Decl(typeofThis.ts, 121, 1))
+>this : Symbol(Test, Decl(typeofThis.ts, 121, 1))
     }
 }
diff --git a/tests/baselines/reference/unionAndIntersectionInference3.symbols b/tests/baselines/reference/unionAndIntersectionInference3.symbols
index 43079f9e8a958..1e04f5db271a7 100644
--- a/tests/baselines/reference/unionAndIntersectionInference3.symbols
+++ b/tests/baselines/reference/unionAndIntersectionInference3.symbols
@@ -114,7 +114,7 @@ type Foo2<T> = {
 >T : Symbol(T, Decl(unionAndIntersectionInference3.ts, 26, 10))
 
     test(value: T): void;
->test : Symbol(test, Decl(unionAndIntersectionInference3.ts, 26, 16))
+>test : Symbol(Foo2.test, Decl(unionAndIntersectionInference3.ts, 26, 16))
 >value : Symbol(value, Decl(unionAndIntersectionInference3.ts, 27, 9))
 >T : Symbol(T, Decl(unionAndIntersectionInference3.ts, 26, 10))
 }
@@ -124,7 +124,7 @@ type Bar2<T> = {
 >T : Symbol(T, Decl(unionAndIntersectionInference3.ts, 30, 10))
 
     test(value: T | PromiseLike<T>): void;
->test : Symbol(test, Decl(unionAndIntersectionInference3.ts, 30, 16))
+>test : Symbol(Bar2.test, Decl(unionAndIntersectionInference3.ts, 30, 16))
 >value : Symbol(value, Decl(unionAndIntersectionInference3.ts, 31, 9))
 >T : Symbol(T, Decl(unionAndIntersectionInference3.ts, 30, 10))
 >PromiseLike : Symbol(PromiseLike, Decl(lib.es5.d.ts, --, --))
diff --git a/tests/baselines/reference/unionErrorMessageOnMatchingDiscriminant.symbols b/tests/baselines/reference/unionErrorMessageOnMatchingDiscriminant.symbols
index 2ad830dd2dd79..4c4139dc9a493 100644
--- a/tests/baselines/reference/unionErrorMessageOnMatchingDiscriminant.symbols
+++ b/tests/baselines/reference/unionErrorMessageOnMatchingDiscriminant.symbols
@@ -3,10 +3,10 @@ type A = {
 >A : Symbol(A, Decl(unionErrorMessageOnMatchingDiscriminant.ts, 0, 0))
 
     type: 'a',
->type : Symbol(type, Decl(unionErrorMessageOnMatchingDiscriminant.ts, 0, 10))
+>type : Symbol(A.type, Decl(unionErrorMessageOnMatchingDiscriminant.ts, 0, 10))
 
     data: { a: string }
->data : Symbol(data, Decl(unionErrorMessageOnMatchingDiscriminant.ts, 1, 14))
+>data : Symbol(A.data, Decl(unionErrorMessageOnMatchingDiscriminant.ts, 1, 14))
 >a : Symbol(a, Decl(unionErrorMessageOnMatchingDiscriminant.ts, 2, 11))
 
 };
@@ -15,10 +15,10 @@ type B = {
 >B : Symbol(B, Decl(unionErrorMessageOnMatchingDiscriminant.ts, 3, 2))
 
     type: 'b',
->type : Symbol(type, Decl(unionErrorMessageOnMatchingDiscriminant.ts, 5, 10))
+>type : Symbol(B.type, Decl(unionErrorMessageOnMatchingDiscriminant.ts, 5, 10))
 
     data: null
->data : Symbol(data, Decl(unionErrorMessageOnMatchingDiscriminant.ts, 6, 14))
+>data : Symbol(B.data, Decl(unionErrorMessageOnMatchingDiscriminant.ts, 6, 14))
 
 };
 
@@ -26,10 +26,10 @@ type C = {
 >C : Symbol(C, Decl(unionErrorMessageOnMatchingDiscriminant.ts, 8, 2))
 
     type: 'c',
->type : Symbol(type, Decl(unionErrorMessageOnMatchingDiscriminant.ts, 10, 10))
+>type : Symbol(C.type, Decl(unionErrorMessageOnMatchingDiscriminant.ts, 10, 10))
 
     payload: string
->payload : Symbol(payload, Decl(unionErrorMessageOnMatchingDiscriminant.ts, 11, 14))
+>payload : Symbol(C.payload, Decl(unionErrorMessageOnMatchingDiscriminant.ts, 11, 14))
 
 };
 
diff --git a/tests/baselines/reference/unionReductionMutualSubtypes.types b/tests/baselines/reference/unionReductionMutualSubtypes.types
index 748826d08f6c9..0cd09be38a6db 100644
--- a/tests/baselines/reference/unionReductionMutualSubtypes.types
+++ b/tests/baselines/reference/unionReductionMutualSubtypes.types
@@ -15,9 +15,9 @@ declare const val: ReturnVal;
 >val : ReturnVal
 
 function run(options: { something?(b?: string): void }) {
->run : (options: { something?(b?: string | undefined): void; }) => void
->options : { something?(b?: string | undefined): void; }
->something : ((b?: string | undefined) => void) | undefined
+>run : (options: { something?(b?: string): void; }) => void
+>options : { something?(b?: string): void; }
+>something : ((b?: string) => void) | undefined
 >b : string | undefined
 
     const something = options.something ?? val.something;
diff --git a/tests/baselines/reference/unionTypeCallSignatures6.symbols b/tests/baselines/reference/unionTypeCallSignatures6.symbols
index 87d1928f0695b..68e681dcfa5bb 100644
--- a/tests/baselines/reference/unionTypeCallSignatures6.symbols
+++ b/tests/baselines/reference/unionTypeCallSignatures6.symbols
@@ -1,19 +1,19 @@
 === tests/cases/conformance/types/union/unionTypeCallSignatures6.ts ===
 type A = { a: string };
 >A : Symbol(A, Decl(unionTypeCallSignatures6.ts, 0, 0))
->a : Symbol(a, Decl(unionTypeCallSignatures6.ts, 0, 10))
+>a : Symbol(A.a, Decl(unionTypeCallSignatures6.ts, 0, 10))
 
 type B = { b: number };
 >B : Symbol(B, Decl(unionTypeCallSignatures6.ts, 0, 23))
->b : Symbol(b, Decl(unionTypeCallSignatures6.ts, 1, 10))
+>b : Symbol(B.b, Decl(unionTypeCallSignatures6.ts, 1, 10))
 
 type C = { c: string };
 >C : Symbol(C, Decl(unionTypeCallSignatures6.ts, 1, 23))
->c : Symbol(c, Decl(unionTypeCallSignatures6.ts, 2, 10))
+>c : Symbol(C.c, Decl(unionTypeCallSignatures6.ts, 2, 10))
 
 type D = { d: number };
 >D : Symbol(D, Decl(unionTypeCallSignatures6.ts, 2, 23))
->d : Symbol(d, Decl(unionTypeCallSignatures6.ts, 3, 10))
+>d : Symbol(D.d, Decl(unionTypeCallSignatures6.ts, 3, 10))
 
 type F0 = () => void;
 >F0 : Symbol(F0, Decl(unionTypeCallSignatures6.ts, 3, 23))
diff --git a/tests/baselines/reference/unionTypeErrorMessageTypeRefs01.symbols b/tests/baselines/reference/unionTypeErrorMessageTypeRefs01.symbols
index 1788d27a7dc96..ddf16a88d9e85 100644
--- a/tests/baselines/reference/unionTypeErrorMessageTypeRefs01.symbols
+++ b/tests/baselines/reference/unionTypeErrorMessageTypeRefs01.symbols
@@ -87,7 +87,7 @@ type X<T> = {
 >T : Symbol(T, Decl(unionTypeErrorMessageTypeRefs01.ts, 30, 7))
 
     xProp: T;
->xProp : Symbol(xProp, Decl(unionTypeErrorMessageTypeRefs01.ts, 30, 13))
+>xProp : Symbol(X.xProp, Decl(unionTypeErrorMessageTypeRefs01.ts, 30, 13))
 >T : Symbol(T, Decl(unionTypeErrorMessageTypeRefs01.ts, 30, 7))
 }
 
@@ -96,7 +96,7 @@ type Y<T> = {
 >T : Symbol(T, Decl(unionTypeErrorMessageTypeRefs01.ts, 34, 7))
 
     yProp: T;
->yProp : Symbol(yProp, Decl(unionTypeErrorMessageTypeRefs01.ts, 34, 13))
+>yProp : Symbol(Y.yProp, Decl(unionTypeErrorMessageTypeRefs01.ts, 34, 13))
 >T : Symbol(T, Decl(unionTypeErrorMessageTypeRefs01.ts, 34, 7))
 }
 
@@ -105,7 +105,7 @@ type Z<T> = {
 >T : Symbol(T, Decl(unionTypeErrorMessageTypeRefs01.ts, 38, 7))
 
     zProp: T;
->zProp : Symbol(zProp, Decl(unionTypeErrorMessageTypeRefs01.ts, 38, 13))
+>zProp : Symbol(Z.zProp, Decl(unionTypeErrorMessageTypeRefs01.ts, 38, 13))
 >T : Symbol(T, Decl(unionTypeErrorMessageTypeRefs01.ts, 38, 7))
 }
 
diff --git a/tests/baselines/reference/unionTypeReduction2.symbols b/tests/baselines/reference/unionTypeReduction2.symbols
index 0faf0055279f5..bf9e0f736584c 100644
--- a/tests/baselines/reference/unionTypeReduction2.symbols
+++ b/tests/baselines/reference/unionTypeReduction2.symbols
@@ -127,18 +127,18 @@ type A = {
 >A : Symbol(A, Decl(unionTypeReduction2.ts, 34, 1))
 
     f(): void;
->f : Symbol(f, Decl(unionTypeReduction2.ts, 36, 10))
+>f : Symbol(A.f, Decl(unionTypeReduction2.ts, 36, 10))
 }
 
 type B = {
 >B : Symbol(B, Decl(unionTypeReduction2.ts, 38, 1))
 
     f(x?: string): void;
->f : Symbol(f, Decl(unionTypeReduction2.ts, 40, 10))
+>f : Symbol(B.f, Decl(unionTypeReduction2.ts, 40, 10))
 >x : Symbol(x, Decl(unionTypeReduction2.ts, 41, 6))
 
     g(): void;
->g : Symbol(g, Decl(unionTypeReduction2.ts, 41, 24))
+>g : Symbol(B.g, Decl(unionTypeReduction2.ts, 41, 24))
 }
 
 function f11(a: A, b: B) {
diff --git a/tests/baselines/reference/unionTypeReduction2.types b/tests/baselines/reference/unionTypeReduction2.types
index 740ee28910069..c768871dd567d 100644
--- a/tests/baselines/reference/unionTypeReduction2.types
+++ b/tests/baselines/reference/unionTypeReduction2.types
@@ -1,10 +1,10 @@
 === tests/cases/conformance/types/union/unionTypeReduction2.ts ===
 function f1(x: { f(): void }, y: { f(x?: string): void }) {
->f1 : (x: {    f(): void;}, y: { f(x?: string | undefined): void; }) => void
+>f1 : (x: {    f(): void;}, y: { f(x?: string): void; }) => void
 >x : { f(): void; }
 >f : () => void
->y : { f(x?: string | undefined): void; }
->f : (x?: string | undefined) => void
+>y : { f(x?: string): void; }
+>f : (x?: string) => void
 >x : string | undefined
 
     let z = !!true ? x : y;  // { f(x?: string): void }
@@ -31,12 +31,12 @@ function f1(x: { f(): void }, y: { f(x?: string): void }) {
 }
 
 function f2(x: { f(x: string | undefined): void }, y: { f(x?: string): void }) {
->f2 : (x: { f(x: string | undefined): void; }, y: { f(x?: string | undefined): void; }) => void
+>f2 : (x: { f(x: string | undefined): void; }, y: { f(x?: string): void; }) => void
 >x : { f(x: string | undefined): void; }
 >f : (x: string | undefined) => void
 >x : string | undefined
->y : { f(x?: string | undefined): void; }
->f : (x?: string | undefined) => void
+>y : { f(x?: string): void; }
+>f : (x?: string) => void
 >x : string | undefined
 
     let z = !!true ? x : y;  // { f(x?: string): void }
@@ -63,9 +63,9 @@ function f2(x: { f(x: string | undefined): void }, y: { f(x?: string): void }) {
 }
 
 function f3(x: () => void, y: (x?: string) => void) {
->f3 : (x: () => void, y: (x?: string | undefined) => void) => void
+>f3 : (x: () => void, y: (x?: string) => void) => void
 >x : () => void
->y : (x?: string | undefined) => void
+>y : (x?: string) => void
 >x : string | undefined
 
     let f = !!true ? x : y;  // (x?: string) => void
@@ -88,10 +88,10 @@ function f3(x: () => void, y: (x?: string) => void) {
 }
 
 function f4(x: (x: string | undefined) => void, y: (x?: string) => void) {
->f4 : (x: (x: string | undefined) => void, y: (x?: string | undefined) => void) => void
+>f4 : (x: (x: string | undefined) => void, y: (x?: string) => void) => void
 >x : (x: string | undefined) => void
 >x : string | undefined
->y : (x?: string | undefined) => void
+>y : (x?: string) => void
 >x : string | undefined
 
     let f = !!true ? x : y;  // (x?: string) => void
@@ -114,10 +114,10 @@ function f4(x: (x: string | undefined) => void, y: (x?: string) => void) {
 }
 
 function f5(x: (x: string | undefined) => void, y: (x?: 'hello') => void) {
->f5 : (x: (x: string | undefined) => void, y: (x?: "hello" | undefined) => void) => void
+>f5 : (x: (x: string | undefined) => void, y: (x?: 'hello') => void) => void
 >x : (x: string | undefined) => void
 >x : string | undefined
->y : (x?: "hello" | undefined) => void
+>y : (x?: 'hello') => void
 >x : "hello" | undefined
 
     let f = !!true ? x : y;  // (x?: 'hello') => void
@@ -140,10 +140,10 @@ function f5(x: (x: string | undefined) => void, y: (x?: 'hello') => void) {
 }
 
 function f6(x: (x: 'hello' | undefined) => void, y: (x?: string) => void) {
->f6 : (x: (x: 'hello' | undefined) => void, y: (x?: string | undefined) => void) => void
+>f6 : (x: (x: 'hello' | undefined) => void, y: (x?: string) => void) => void
 >x : (x: 'hello' | undefined) => void
 >x : "hello" | undefined
->y : (x?: string | undefined) => void
+>y : (x?: string) => void
 >x : string | undefined
 
     let f = !!true ? x : y;  // (x: 'hello' | undefined) => void
@@ -176,7 +176,7 @@ type B = {
 >B : B
 
     f(x?: string): void;
->f : (x?: string | undefined) => void
+>f : (x?: string) => void
 >x : string | undefined
 
     g(): void;
@@ -227,9 +227,9 @@ declare const val: ReturnVal;
 >val : ReturnVal
 
 function run(options: { something?(b?: string): void }) {
->run : (options: { something?(b?: string | undefined): void; }) => void
->options : { something?(b?: string | undefined): void; }
->something : ((b?: string | undefined) => void) | undefined
+>run : (options: { something?(b?: string): void; }) => void
+>options : { something?(b?: string): void; }
+>something : ((b?: string) => void) | undefined
 >b : string | undefined
 
     const something = options.something ?? val.something;
diff --git a/tests/baselines/reference/uniqueSymbols.symbols b/tests/baselines/reference/uniqueSymbols.symbols
index 2df23f1fc95f4..516dec759700b 100644
--- a/tests/baselines/reference/uniqueSymbols.symbols
+++ b/tests/baselines/reference/uniqueSymbols.symbols
@@ -324,10 +324,10 @@ type L = {
 >L : Symbol(L, Decl(uniqueSymbols.ts, 96, 84))
 
     readonly readonlyType: unique symbol;
->readonlyType : Symbol(readonlyType, Decl(uniqueSymbols.ts, 99, 10))
+>readonlyType : Symbol(L.readonlyType, Decl(uniqueSymbols.ts, 99, 10))
 
     nested: {
->nested : Symbol(nested, Decl(uniqueSymbols.ts, 100, 41))
+>nested : Symbol(L.nested, Decl(uniqueSymbols.ts, 100, 41))
 
         readonly readonlyNestedType: unique symbol;
 >readonlyNestedType : Symbol(readonlyNestedType, Decl(uniqueSymbols.ts, 101, 13))
@@ -339,54 +339,54 @@ declare const l: L;
 
 const constInitToLReadonlyType = l.readonlyType;
 >constInitToLReadonlyType : Symbol(constInitToLReadonlyType, Decl(uniqueSymbols.ts, 107, 5))
->l.readonlyType : Symbol(readonlyType, Decl(uniqueSymbols.ts, 99, 10))
+>l.readonlyType : Symbol(L.readonlyType, Decl(uniqueSymbols.ts, 99, 10))
 >l : Symbol(l, Decl(uniqueSymbols.ts, 105, 13))
->readonlyType : Symbol(readonlyType, Decl(uniqueSymbols.ts, 99, 10))
+>readonlyType : Symbol(L.readonlyType, Decl(uniqueSymbols.ts, 99, 10))
 
 const constInitToLReadonlyNestedType = l.nested.readonlyNestedType;
 >constInitToLReadonlyNestedType : Symbol(constInitToLReadonlyNestedType, Decl(uniqueSymbols.ts, 108, 5))
 >l.nested.readonlyNestedType : Symbol(readonlyNestedType, Decl(uniqueSymbols.ts, 101, 13))
->l.nested : Symbol(nested, Decl(uniqueSymbols.ts, 100, 41))
+>l.nested : Symbol(L.nested, Decl(uniqueSymbols.ts, 100, 41))
 >l : Symbol(l, Decl(uniqueSymbols.ts, 105, 13))
->nested : Symbol(nested, Decl(uniqueSymbols.ts, 100, 41))
+>nested : Symbol(L.nested, Decl(uniqueSymbols.ts, 100, 41))
 >readonlyNestedType : Symbol(readonlyNestedType, Decl(uniqueSymbols.ts, 101, 13))
 
 const constInitToLReadonlyTypeWithTypeQuery: typeof l.readonlyType = l.readonlyType;
 >constInitToLReadonlyTypeWithTypeQuery : Symbol(constInitToLReadonlyTypeWithTypeQuery, Decl(uniqueSymbols.ts, 109, 5))
->l.readonlyType : Symbol(readonlyType, Decl(uniqueSymbols.ts, 99, 10))
+>l.readonlyType : Symbol(L.readonlyType, Decl(uniqueSymbols.ts, 99, 10))
 >l : Symbol(l, Decl(uniqueSymbols.ts, 105, 13))
->readonlyType : Symbol(readonlyType, Decl(uniqueSymbols.ts, 99, 10))
->l.readonlyType : Symbol(readonlyType, Decl(uniqueSymbols.ts, 99, 10))
+>readonlyType : Symbol(L.readonlyType, Decl(uniqueSymbols.ts, 99, 10))
+>l.readonlyType : Symbol(L.readonlyType, Decl(uniqueSymbols.ts, 99, 10))
 >l : Symbol(l, Decl(uniqueSymbols.ts, 105, 13))
->readonlyType : Symbol(readonlyType, Decl(uniqueSymbols.ts, 99, 10))
+>readonlyType : Symbol(L.readonlyType, Decl(uniqueSymbols.ts, 99, 10))
 
 const constInitToLReadonlyNestedTypeWithTypeQuery: typeof l.nested.readonlyNestedType = l.nested.readonlyNestedType;
 >constInitToLReadonlyNestedTypeWithTypeQuery : Symbol(constInitToLReadonlyNestedTypeWithTypeQuery, Decl(uniqueSymbols.ts, 110, 5))
 >l.nested.readonlyNestedType : Symbol(readonlyNestedType, Decl(uniqueSymbols.ts, 101, 13))
->l.nested : Symbol(nested, Decl(uniqueSymbols.ts, 100, 41))
+>l.nested : Symbol(L.nested, Decl(uniqueSymbols.ts, 100, 41))
 >l : Symbol(l, Decl(uniqueSymbols.ts, 105, 13))
->nested : Symbol(nested, Decl(uniqueSymbols.ts, 100, 41))
+>nested : Symbol(L.nested, Decl(uniqueSymbols.ts, 100, 41))
 >readonlyNestedType : Symbol(readonlyNestedType, Decl(uniqueSymbols.ts, 101, 13))
 >l.nested.readonlyNestedType : Symbol(readonlyNestedType, Decl(uniqueSymbols.ts, 101, 13))
->l.nested : Symbol(nested, Decl(uniqueSymbols.ts, 100, 41))
+>l.nested : Symbol(L.nested, Decl(uniqueSymbols.ts, 100, 41))
 >l : Symbol(l, Decl(uniqueSymbols.ts, 105, 13))
->nested : Symbol(nested, Decl(uniqueSymbols.ts, 100, 41))
+>nested : Symbol(L.nested, Decl(uniqueSymbols.ts, 100, 41))
 >readonlyNestedType : Symbol(readonlyNestedType, Decl(uniqueSymbols.ts, 101, 13))
 
 const constInitToLReadonlyTypeWithIndexedAccess: L["readonlyType"] = l.readonlyType;
 >constInitToLReadonlyTypeWithIndexedAccess : Symbol(constInitToLReadonlyTypeWithIndexedAccess, Decl(uniqueSymbols.ts, 111, 5))
 >L : Symbol(L, Decl(uniqueSymbols.ts, 96, 84))
->l.readonlyType : Symbol(readonlyType, Decl(uniqueSymbols.ts, 99, 10))
+>l.readonlyType : Symbol(L.readonlyType, Decl(uniqueSymbols.ts, 99, 10))
 >l : Symbol(l, Decl(uniqueSymbols.ts, 105, 13))
->readonlyType : Symbol(readonlyType, Decl(uniqueSymbols.ts, 99, 10))
+>readonlyType : Symbol(L.readonlyType, Decl(uniqueSymbols.ts, 99, 10))
 
 const constInitToLReadonlyNestedTypeWithIndexedAccess: L["nested"]["readonlyNestedType"] = l.nested.readonlyNestedType;
 >constInitToLReadonlyNestedTypeWithIndexedAccess : Symbol(constInitToLReadonlyNestedTypeWithIndexedAccess, Decl(uniqueSymbols.ts, 112, 5))
 >L : Symbol(L, Decl(uniqueSymbols.ts, 96, 84))
 >l.nested.readonlyNestedType : Symbol(readonlyNestedType, Decl(uniqueSymbols.ts, 101, 13))
->l.nested : Symbol(nested, Decl(uniqueSymbols.ts, 100, 41))
+>l.nested : Symbol(L.nested, Decl(uniqueSymbols.ts, 100, 41))
 >l : Symbol(l, Decl(uniqueSymbols.ts, 105, 13))
->nested : Symbol(nested, Decl(uniqueSymbols.ts, 100, 41))
+>nested : Symbol(L.nested, Decl(uniqueSymbols.ts, 100, 41))
 >readonlyNestedType : Symbol(readonlyNestedType, Decl(uniqueSymbols.ts, 101, 13))
 
 // type argument inference
diff --git a/tests/baselines/reference/uniqueSymbolsDeclarations.symbols b/tests/baselines/reference/uniqueSymbolsDeclarations.symbols
index 56024cf1cfb8b..2238757e6fab9 100644
--- a/tests/baselines/reference/uniqueSymbolsDeclarations.symbols
+++ b/tests/baselines/reference/uniqueSymbolsDeclarations.symbols
@@ -319,10 +319,10 @@ type L = {
 >L : Symbol(L, Decl(uniqueSymbolsDeclarations.ts, 92, 84))
 
     readonly readonlyType: unique symbol;
->readonlyType : Symbol(readonlyType, Decl(uniqueSymbolsDeclarations.ts, 95, 10))
+>readonlyType : Symbol(L.readonlyType, Decl(uniqueSymbolsDeclarations.ts, 95, 10))
 
     nested: {
->nested : Symbol(nested, Decl(uniqueSymbolsDeclarations.ts, 96, 41))
+>nested : Symbol(L.nested, Decl(uniqueSymbolsDeclarations.ts, 96, 41))
 
         readonly readonlyNestedType: unique symbol;
 >readonlyNestedType : Symbol(readonlyNestedType, Decl(uniqueSymbolsDeclarations.ts, 97, 13))
@@ -334,54 +334,54 @@ declare const l: L;
 
 const constInitToLReadonlyType = l.readonlyType;
 >constInitToLReadonlyType : Symbol(constInitToLReadonlyType, Decl(uniqueSymbolsDeclarations.ts, 103, 5))
->l.readonlyType : Symbol(readonlyType, Decl(uniqueSymbolsDeclarations.ts, 95, 10))
+>l.readonlyType : Symbol(L.readonlyType, Decl(uniqueSymbolsDeclarations.ts, 95, 10))
 >l : Symbol(l, Decl(uniqueSymbolsDeclarations.ts, 101, 13))
->readonlyType : Symbol(readonlyType, Decl(uniqueSymbolsDeclarations.ts, 95, 10))
+>readonlyType : Symbol(L.readonlyType, Decl(uniqueSymbolsDeclarations.ts, 95, 10))
 
 const constInitToLReadonlyNestedType = l.nested.readonlyNestedType;
 >constInitToLReadonlyNestedType : Symbol(constInitToLReadonlyNestedType, Decl(uniqueSymbolsDeclarations.ts, 104, 5))
 >l.nested.readonlyNestedType : Symbol(readonlyNestedType, Decl(uniqueSymbolsDeclarations.ts, 97, 13))
->l.nested : Symbol(nested, Decl(uniqueSymbolsDeclarations.ts, 96, 41))
+>l.nested : Symbol(L.nested, Decl(uniqueSymbolsDeclarations.ts, 96, 41))
 >l : Symbol(l, Decl(uniqueSymbolsDeclarations.ts, 101, 13))
->nested : Symbol(nested, Decl(uniqueSymbolsDeclarations.ts, 96, 41))
+>nested : Symbol(L.nested, Decl(uniqueSymbolsDeclarations.ts, 96, 41))
 >readonlyNestedType : Symbol(readonlyNestedType, Decl(uniqueSymbolsDeclarations.ts, 97, 13))
 
 const constInitToLReadonlyTypeWithTypeQuery: typeof l.readonlyType = l.readonlyType;
 >constInitToLReadonlyTypeWithTypeQuery : Symbol(constInitToLReadonlyTypeWithTypeQuery, Decl(uniqueSymbolsDeclarations.ts, 105, 5))
->l.readonlyType : Symbol(readonlyType, Decl(uniqueSymbolsDeclarations.ts, 95, 10))
+>l.readonlyType : Symbol(L.readonlyType, Decl(uniqueSymbolsDeclarations.ts, 95, 10))
 >l : Symbol(l, Decl(uniqueSymbolsDeclarations.ts, 101, 13))
->readonlyType : Symbol(readonlyType, Decl(uniqueSymbolsDeclarations.ts, 95, 10))
->l.readonlyType : Symbol(readonlyType, Decl(uniqueSymbolsDeclarations.ts, 95, 10))
+>readonlyType : Symbol(L.readonlyType, Decl(uniqueSymbolsDeclarations.ts, 95, 10))
+>l.readonlyType : Symbol(L.readonlyType, Decl(uniqueSymbolsDeclarations.ts, 95, 10))
 >l : Symbol(l, Decl(uniqueSymbolsDeclarations.ts, 101, 13))
->readonlyType : Symbol(readonlyType, Decl(uniqueSymbolsDeclarations.ts, 95, 10))
+>readonlyType : Symbol(L.readonlyType, Decl(uniqueSymbolsDeclarations.ts, 95, 10))
 
 const constInitToLReadonlyNestedTypeWithTypeQuery: typeof l.nested.readonlyNestedType = l.nested.readonlyNestedType;
 >constInitToLReadonlyNestedTypeWithTypeQuery : Symbol(constInitToLReadonlyNestedTypeWithTypeQuery, Decl(uniqueSymbolsDeclarations.ts, 106, 5))
 >l.nested.readonlyNestedType : Symbol(readonlyNestedType, Decl(uniqueSymbolsDeclarations.ts, 97, 13))
->l.nested : Symbol(nested, Decl(uniqueSymbolsDeclarations.ts, 96, 41))
+>l.nested : Symbol(L.nested, Decl(uniqueSymbolsDeclarations.ts, 96, 41))
 >l : Symbol(l, Decl(uniqueSymbolsDeclarations.ts, 101, 13))
->nested : Symbol(nested, Decl(uniqueSymbolsDeclarations.ts, 96, 41))
+>nested : Symbol(L.nested, Decl(uniqueSymbolsDeclarations.ts, 96, 41))
 >readonlyNestedType : Symbol(readonlyNestedType, Decl(uniqueSymbolsDeclarations.ts, 97, 13))
 >l.nested.readonlyNestedType : Symbol(readonlyNestedType, Decl(uniqueSymbolsDeclarations.ts, 97, 13))
->l.nested : Symbol(nested, Decl(uniqueSymbolsDeclarations.ts, 96, 41))
+>l.nested : Symbol(L.nested, Decl(uniqueSymbolsDeclarations.ts, 96, 41))
 >l : Symbol(l, Decl(uniqueSymbolsDeclarations.ts, 101, 13))
->nested : Symbol(nested, Decl(uniqueSymbolsDeclarations.ts, 96, 41))
+>nested : Symbol(L.nested, Decl(uniqueSymbolsDeclarations.ts, 96, 41))
 >readonlyNestedType : Symbol(readonlyNestedType, Decl(uniqueSymbolsDeclarations.ts, 97, 13))
 
 const constInitToLReadonlyTypeWithIndexedAccess: L["readonlyType"] = l.readonlyType;
 >constInitToLReadonlyTypeWithIndexedAccess : Symbol(constInitToLReadonlyTypeWithIndexedAccess, Decl(uniqueSymbolsDeclarations.ts, 107, 5))
 >L : Symbol(L, Decl(uniqueSymbolsDeclarations.ts, 92, 84))
->l.readonlyType : Symbol(readonlyType, Decl(uniqueSymbolsDeclarations.ts, 95, 10))
+>l.readonlyType : Symbol(L.readonlyType, Decl(uniqueSymbolsDeclarations.ts, 95, 10))
 >l : Symbol(l, Decl(uniqueSymbolsDeclarations.ts, 101, 13))
->readonlyType : Symbol(readonlyType, Decl(uniqueSymbolsDeclarations.ts, 95, 10))
+>readonlyType : Symbol(L.readonlyType, Decl(uniqueSymbolsDeclarations.ts, 95, 10))
 
 const constInitToLReadonlyNestedTypeWithIndexedAccess: L["nested"]["readonlyNestedType"] = l.nested.readonlyNestedType;
 >constInitToLReadonlyNestedTypeWithIndexedAccess : Symbol(constInitToLReadonlyNestedTypeWithIndexedAccess, Decl(uniqueSymbolsDeclarations.ts, 108, 5))
 >L : Symbol(L, Decl(uniqueSymbolsDeclarations.ts, 92, 84))
 >l.nested.readonlyNestedType : Symbol(readonlyNestedType, Decl(uniqueSymbolsDeclarations.ts, 97, 13))
->l.nested : Symbol(nested, Decl(uniqueSymbolsDeclarations.ts, 96, 41))
+>l.nested : Symbol(L.nested, Decl(uniqueSymbolsDeclarations.ts, 96, 41))
 >l : Symbol(l, Decl(uniqueSymbolsDeclarations.ts, 101, 13))
->nested : Symbol(nested, Decl(uniqueSymbolsDeclarations.ts, 96, 41))
+>nested : Symbol(L.nested, Decl(uniqueSymbolsDeclarations.ts, 96, 41))
 >readonlyNestedType : Symbol(readonlyNestedType, Decl(uniqueSymbolsDeclarations.ts, 97, 13))
 
 // type argument inference
diff --git a/tests/baselines/reference/uniqueSymbolsDeclarationsErrors.symbols b/tests/baselines/reference/uniqueSymbolsDeclarationsErrors.symbols
index 9e948fb3420d4..c498f1ad21502 100644
--- a/tests/baselines/reference/uniqueSymbolsDeclarationsErrors.symbols
+++ b/tests/baselines/reference/uniqueSymbolsDeclarationsErrors.symbols
@@ -86,7 +86,7 @@ export type TypeLiteralWithPrivateNamedProperties = {
 >TypeLiteralWithPrivateNamedProperties : Symbol(TypeLiteralWithPrivateNamedProperties, Decl(uniqueSymbolsDeclarationsErrors.ts, 33, 1))
 
     [s]: any;
->[s] : Symbol([s], Decl(uniqueSymbolsDeclarationsErrors.ts, 35, 53))
+>[s] : Symbol(TypeLiteralWithPrivateNamedProperties[s], Decl(uniqueSymbolsDeclarationsErrors.ts, 35, 53))
 >s : Symbol(s, Decl(uniqueSymbolsDeclarationsErrors.ts, 0, 13))
 }
 
@@ -94,7 +94,7 @@ export type TypeLiteralWithPrivateNamedMethods = {
 >TypeLiteralWithPrivateNamedMethods : Symbol(TypeLiteralWithPrivateNamedMethods, Decl(uniqueSymbolsDeclarationsErrors.ts, 37, 1))
 
     [s](): any;
->[s] : Symbol([s], Decl(uniqueSymbolsDeclarationsErrors.ts, 39, 50))
+>[s] : Symbol(TypeLiteralWithPrivateNamedMethods[s], Decl(uniqueSymbolsDeclarationsErrors.ts, 39, 50))
 >s : Symbol(s, Decl(uniqueSymbolsDeclarationsErrors.ts, 0, 13))
 }
 
diff --git a/tests/baselines/reference/uniqueSymbolsErrors.symbols b/tests/baselines/reference/uniqueSymbolsErrors.symbols
index 2e2b552225a6d..ea90b96be56f2 100644
--- a/tests/baselines/reference/uniqueSymbolsErrors.symbols
+++ b/tests/baselines/reference/uniqueSymbolsErrors.symbols
@@ -167,34 +167,34 @@ type InvalidTypeLiteral = {
 >InvalidTypeLiteral : Symbol(InvalidTypeLiteral, Decl(uniqueSymbolsErrors.ts, 53, 1))
 
     invalidPropertyType: unique symbol;
->invalidPropertyType : Symbol(invalidPropertyType, Decl(uniqueSymbolsErrors.ts, 56, 27))
+>invalidPropertyType : Symbol(InvalidTypeLiteral.invalidPropertyType, Decl(uniqueSymbolsErrors.ts, 56, 27))
 
     invalidArgType(arg: unique symbol): void;
->invalidArgType : Symbol(invalidArgType, Decl(uniqueSymbolsErrors.ts, 57, 39))
+>invalidArgType : Symbol(InvalidTypeLiteral.invalidArgType, Decl(uniqueSymbolsErrors.ts, 57, 39))
 >arg : Symbol(arg, Decl(uniqueSymbolsErrors.ts, 58, 19))
 
     invalidRestArgType(...args: (unique symbol)[]): void;
->invalidRestArgType : Symbol(invalidRestArgType, Decl(uniqueSymbolsErrors.ts, 58, 45))
+>invalidRestArgType : Symbol(InvalidTypeLiteral.invalidRestArgType, Decl(uniqueSymbolsErrors.ts, 58, 45))
 >args : Symbol(args, Decl(uniqueSymbolsErrors.ts, 59, 23))
 
     invalidReturnType(): unique symbol;
->invalidReturnType : Symbol(invalidReturnType, Decl(uniqueSymbolsErrors.ts, 59, 57))
+>invalidReturnType : Symbol(InvalidTypeLiteral.invalidReturnType, Decl(uniqueSymbolsErrors.ts, 59, 57))
 
     invalidThisType(this: unique symbol);
->invalidThisType : Symbol(invalidThisType, Decl(uniqueSymbolsErrors.ts, 60, 39))
+>invalidThisType : Symbol(InvalidTypeLiteral.invalidThisType, Decl(uniqueSymbolsErrors.ts, 60, 39))
 >this : Symbol(this, Decl(uniqueSymbolsErrors.ts, 61, 20))
 
     invalidTypePredicate(n: any): n is unique symbol
->invalidTypePredicate : Symbol(invalidTypePredicate, Decl(uniqueSymbolsErrors.ts, 61, 41))
+>invalidTypePredicate : Symbol(InvalidTypeLiteral.invalidTypePredicate, Decl(uniqueSymbolsErrors.ts, 61, 41))
 >n : Symbol(n, Decl(uniqueSymbolsErrors.ts, 62, 25))
 >n : Symbol(n, Decl(uniqueSymbolsErrors.ts, 62, 25))
 
     invalidTypeParameterConstraint<T extends unique symbol>(): void;
->invalidTypeParameterConstraint : Symbol(invalidTypeParameterConstraint, Decl(uniqueSymbolsErrors.ts, 62, 52))
+>invalidTypeParameterConstraint : Symbol(InvalidTypeLiteral.invalidTypeParameterConstraint, Decl(uniqueSymbolsErrors.ts, 62, 52))
 >T : Symbol(T, Decl(uniqueSymbolsErrors.ts, 63, 35))
 
     invalidTypeParameterDefault<T = unique symbol>(): void;
->invalidTypeParameterDefault : Symbol(invalidTypeParameterDefault, Decl(uniqueSymbolsErrors.ts, 63, 68))
+>invalidTypeParameterDefault : Symbol(InvalidTypeLiteral.invalidTypeParameterDefault, Decl(uniqueSymbolsErrors.ts, 63, 68))
 >T : Symbol(T, Decl(uniqueSymbolsErrors.ts, 64, 32))
 
 };
diff --git a/tests/baselines/reference/unknownType1.symbols b/tests/baselines/reference/unknownType1.symbols
index 01c61a925f7bd..346dcc0de0912 100644
--- a/tests/baselines/reference/unknownType1.symbols
+++ b/tests/baselines/reference/unknownType1.symbols
@@ -93,7 +93,7 @@ type T35<T> = T extends unknown ? { x: T } : false;
 >T35 : Symbol(T35, Decl(unknownType1.ts, 32, 45))
 >T : Symbol(T, Decl(unknownType1.ts, 34, 9))
 >T : Symbol(T, Decl(unknownType1.ts, 34, 9))
->x : Symbol(x, Decl(unknownType1.ts, 34, 35))
+>x : Symbol(T37.x, Decl(unknownType1.ts, 34, 35))
 >T : Symbol(T, Decl(unknownType1.ts, 34, 9))
 
 type T36 = T35<string | number>;  // { x: string } | { x: number }
diff --git a/tests/baselines/reference/unusedTypeParameters10.symbols b/tests/baselines/reference/unusedTypeParameters10.symbols
index a0ce39af7ce1e..a6ecca3b5b0e0 100644
--- a/tests/baselines/reference/unusedTypeParameters10.symbols
+++ b/tests/baselines/reference/unusedTypeParameters10.symbols
@@ -6,6 +6,6 @@ type Alias<T> = { };
 type Alias2<T> = { x: T };
 >Alias2 : Symbol(Alias2, Decl(unusedTypeParameters10.ts, 0, 20))
 >T : Symbol(T, Decl(unusedTypeParameters10.ts, 1, 12))
->x : Symbol(x, Decl(unusedTypeParameters10.ts, 1, 18))
+>x : Symbol(Alias2.x, Decl(unusedTypeParameters10.ts, 1, 18))
 >T : Symbol(T, Decl(unusedTypeParameters10.ts, 1, 12))
 
diff --git a/tests/baselines/reference/varRequireFromTypescript.symbols b/tests/baselines/reference/varRequireFromTypescript.symbols
index 9ed299b1d7b26..7ac002b5984d0 100644
--- a/tests/baselines/reference/varRequireFromTypescript.symbols
+++ b/tests/baselines/reference/varRequireFromTypescript.symbols
@@ -28,9 +28,9 @@ function f(greatest, wrap) {
 >wrap : Symbol(wrap, Decl(use.js, 12, 20))
 
     greatest.day
->greatest.day : Symbol(day, Decl(ex.d.ts, 0, 24))
+>greatest.day : Symbol(ex.Greatest.day, Decl(ex.d.ts, 0, 24))
 >greatest : Symbol(greatest, Decl(use.js, 12, 11))
->day : Symbol(day, Decl(ex.d.ts, 0, 24))
+>day : Symbol(ex.Greatest.day, Decl(ex.d.ts, 0, 24))
 
     wrap.n
 >wrap.n : Symbol(ex.Crunch.n, Decl(ex.d.ts, 1, 21))
@@ -41,7 +41,7 @@ function f(greatest, wrap) {
 === tests/cases/conformance/salsa/ex.d.ts ===
 export type Greatest = { day: 1 }
 >Greatest : Symbol(Greatest, Decl(ex.d.ts, 0, 0))
->day : Symbol(day, Decl(ex.d.ts, 0, 24))
+>day : Symbol(Greatest.day, Decl(ex.d.ts, 0, 24))
 
 export class Crunch {
 >Crunch : Symbol(Crunch, Decl(ex.d.ts, 0, 33))
diff --git a/tests/baselines/reference/variadicTuples1.types b/tests/baselines/reference/variadicTuples1.types
index 3bb6d7d6d65c2..7fe7a669d8429 100644
--- a/tests/baselines/reference/variadicTuples1.types
+++ b/tests/baselines/reference/variadicTuples1.types
@@ -1349,13 +1349,13 @@ const b = a.bind("", 1);  // Desc<[boolean], object>
 // Repro from #39607
 
 declare function getUser(id: string, options?: { x?: string }): string;
->getUser : (id: string, options?: { x?: string | undefined; } | undefined) => string
+>getUser : (id: string, options?: {    x?: string;}) => string
 >id : string
 >options : { x?: string | undefined; } | undefined
 >x : string | undefined
 
 declare function getOrgUser(id: string, orgId: number, options?: { y?: number, z?: boolean }): void;
->getOrgUser : (id: string, orgId: number, options?: { y?: number | undefined; z?: boolean | undefined; } | undefined) => void
+>getOrgUser : (id: string, orgId: number, options?: {    y?: number;    z?: boolean;}) => void
 >id : string
 >orgId : number
 >options : { y?: number | undefined; z?: boolean | undefined; } | undefined
diff --git a/tests/baselines/reference/varianceAnnotations.symbols b/tests/baselines/reference/varianceAnnotations.symbols
index 78a5b9be39322..b03e17bbd816e 100644
--- a/tests/baselines/reference/varianceAnnotations.symbols
+++ b/tests/baselines/reference/varianceAnnotations.symbols
@@ -4,7 +4,7 @@ type Covariant<out T> = {
 >T : Symbol(T, Decl(varianceAnnotations.ts, 0, 15))
 
     x: T;
->x : Symbol(x, Decl(varianceAnnotations.ts, 0, 25))
+>x : Symbol(Covariant.x, Decl(varianceAnnotations.ts, 0, 25))
 >T : Symbol(T, Decl(varianceAnnotations.ts, 0, 15))
 }
 
@@ -29,7 +29,7 @@ type Contravariant<in T> = {
 >T : Symbol(T, Decl(varianceAnnotations.ts, 10, 19))
 
     f: (x: T) => void;
->f : Symbol(f, Decl(varianceAnnotations.ts, 10, 28))
+>f : Symbol(Contravariant.f, Decl(varianceAnnotations.ts, 10, 28))
 >x : Symbol(x, Decl(varianceAnnotations.ts, 11, 8))
 >T : Symbol(T, Decl(varianceAnnotations.ts, 10, 19))
 }
@@ -55,7 +55,7 @@ type Invariant<in out T> = {
 >T : Symbol(T, Decl(varianceAnnotations.ts, 20, 15))
 
     f: (x: T) => T;
->f : Symbol(f, Decl(varianceAnnotations.ts, 20, 28))
+>f : Symbol(Invariant.f, Decl(varianceAnnotations.ts, 20, 28))
 >x : Symbol(x, Decl(varianceAnnotations.ts, 21, 8))
 >T : Symbol(T, Decl(varianceAnnotations.ts, 20, 15))
 >T : Symbol(T, Decl(varianceAnnotations.ts, 20, 15))
@@ -110,7 +110,7 @@ type Covariant1<in T> = {  // Error
 >T : Symbol(T, Decl(varianceAnnotations.ts, 39, 16))
 
     x: T;
->x : Symbol(x, Decl(varianceAnnotations.ts, 39, 25))
+>x : Symbol(Covariant1.x, Decl(varianceAnnotations.ts, 39, 25))
 >T : Symbol(T, Decl(varianceAnnotations.ts, 39, 16))
 }
 
@@ -124,7 +124,7 @@ type Contravariant2<out T> = {  // Error
 >T : Symbol(T, Decl(varianceAnnotations.ts, 45, 20))
 
     f: (x: T) => void;
->f : Symbol(f, Decl(varianceAnnotations.ts, 45, 30))
+>f : Symbol(Contravariant2.f, Decl(varianceAnnotations.ts, 45, 30))
 >x : Symbol(x, Decl(varianceAnnotations.ts, 46, 8))
 >T : Symbol(T, Decl(varianceAnnotations.ts, 45, 20))
 }
@@ -134,7 +134,7 @@ type Invariant1<in T> = {  // Error
 >T : Symbol(T, Decl(varianceAnnotations.ts, 49, 16))
 
     f: (x: T) => T;
->f : Symbol(f, Decl(varianceAnnotations.ts, 49, 25))
+>f : Symbol(Invariant1.f, Decl(varianceAnnotations.ts, 49, 25))
 >x : Symbol(x, Decl(varianceAnnotations.ts, 50, 8))
 >T : Symbol(T, Decl(varianceAnnotations.ts, 49, 16))
 >T : Symbol(T, Decl(varianceAnnotations.ts, 49, 16))
@@ -145,7 +145,7 @@ type Invariant2<out T> = {  // Error
 >T : Symbol(T, Decl(varianceAnnotations.ts, 53, 16))
 
     f: (x: T) => T;
->f : Symbol(f, Decl(varianceAnnotations.ts, 53, 26))
+>f : Symbol(Invariant2.f, Decl(varianceAnnotations.ts, 53, 26))
 >x : Symbol(x, Decl(varianceAnnotations.ts, 54, 8))
 >T : Symbol(T, Decl(varianceAnnotations.ts, 53, 16))
 >T : Symbol(T, Decl(varianceAnnotations.ts, 53, 16))
@@ -158,11 +158,11 @@ type Foo1<in T> = {  // Error
 >T : Symbol(T, Decl(varianceAnnotations.ts, 59, 10))
 
     x: T;
->x : Symbol(x, Decl(varianceAnnotations.ts, 59, 19))
+>x : Symbol(Foo1.x, Decl(varianceAnnotations.ts, 59, 19))
 >T : Symbol(T, Decl(varianceAnnotations.ts, 59, 10))
 
     f: FooFn1<T>;
->f : Symbol(f, Decl(varianceAnnotations.ts, 60, 9))
+>f : Symbol(Foo1.f, Decl(varianceAnnotations.ts, 60, 9))
 >FooFn1 : Symbol(FooFn1, Decl(varianceAnnotations.ts, 62, 1))
 >T : Symbol(T, Decl(varianceAnnotations.ts, 59, 10))
 }
@@ -179,7 +179,7 @@ type Bar1<T> = {
 >T : Symbol(T, Decl(varianceAnnotations.ts, 66, 10))
 
     value: Foo1<T[]>;
->value : Symbol(value, Decl(varianceAnnotations.ts, 66, 16))
+>value : Symbol(Bar1.value, Decl(varianceAnnotations.ts, 66, 16))
 >Foo1 : Symbol(Foo1, Decl(varianceAnnotations.ts, 55, 1))
 >T : Symbol(T, Decl(varianceAnnotations.ts, 66, 10))
 }
@@ -189,11 +189,11 @@ type Foo2<out T> = {  // Error
 >T : Symbol(T, Decl(varianceAnnotations.ts, 70, 10))
 
     x: T;
->x : Symbol(x, Decl(varianceAnnotations.ts, 70, 20))
+>x : Symbol(Foo2.x, Decl(varianceAnnotations.ts, 70, 20))
 >T : Symbol(T, Decl(varianceAnnotations.ts, 70, 10))
 
     f: FooFn2<T>;
->f : Symbol(f, Decl(varianceAnnotations.ts, 71, 9))
+>f : Symbol(Foo2.f, Decl(varianceAnnotations.ts, 71, 9))
 >FooFn2 : Symbol(FooFn2, Decl(varianceAnnotations.ts, 73, 1))
 >T : Symbol(T, Decl(varianceAnnotations.ts, 70, 10))
 }
@@ -210,7 +210,7 @@ type Bar2<T> = {
 >T : Symbol(T, Decl(varianceAnnotations.ts, 77, 10))
 
     value: Foo2<T[]>;
->value : Symbol(value, Decl(varianceAnnotations.ts, 77, 16))
+>value : Symbol(Bar2.value, Decl(varianceAnnotations.ts, 77, 16))
 >Foo2 : Symbol(Foo2, Decl(varianceAnnotations.ts, 68, 1))
 >T : Symbol(T, Decl(varianceAnnotations.ts, 77, 10))
 }
@@ -220,11 +220,11 @@ type Foo3<in out T> = {
 >T : Symbol(T, Decl(varianceAnnotations.ts, 81, 10))
 
     x: T;
->x : Symbol(x, Decl(varianceAnnotations.ts, 81, 23))
+>x : Symbol(Foo3.x, Decl(varianceAnnotations.ts, 81, 23))
 >T : Symbol(T, Decl(varianceAnnotations.ts, 81, 10))
 
     f: FooFn3<T>;
->f : Symbol(f, Decl(varianceAnnotations.ts, 82, 9))
+>f : Symbol(Foo3.f, Decl(varianceAnnotations.ts, 82, 9))
 >FooFn3 : Symbol(FooFn3, Decl(varianceAnnotations.ts, 84, 1))
 >T : Symbol(T, Decl(varianceAnnotations.ts, 81, 10))
 }
@@ -241,7 +241,7 @@ type Bar3<T> = {
 >T : Symbol(T, Decl(varianceAnnotations.ts, 88, 10))
 
     value: Foo3<T[]>;
->value : Symbol(value, Decl(varianceAnnotations.ts, 88, 16))
+>value : Symbol(Bar3.value, Decl(varianceAnnotations.ts, 88, 16))
 >Foo3 : Symbol(Foo3, Decl(varianceAnnotations.ts, 79, 1))
 >T : Symbol(T, Decl(varianceAnnotations.ts, 88, 10))
 }
diff --git a/tests/baselines/reference/varianceMeasurement.symbols b/tests/baselines/reference/varianceMeasurement.symbols
index 4cbdc76f7d60e..31aa122fd3552 100644
--- a/tests/baselines/reference/varianceMeasurement.symbols
+++ b/tests/baselines/reference/varianceMeasurement.symbols
@@ -74,11 +74,11 @@ type Foo3<T> = {
 >T : Symbol(T, Decl(varianceMeasurement.ts, 26, 10))
 
   x: T;
->x : Symbol(x, Decl(varianceMeasurement.ts, 26, 16))
+>x : Symbol(Foo3.x, Decl(varianceMeasurement.ts, 26, 16))
 >T : Symbol(T, Decl(varianceMeasurement.ts, 26, 10))
 
   y: Foo3<(arg: T) => void>;
->y : Symbol(y, Decl(varianceMeasurement.ts, 27, 7))
+>y : Symbol(Foo3.y, Decl(varianceMeasurement.ts, 27, 7))
 >Foo3 : Symbol(Foo3, Decl(varianceMeasurement.ts, 21, 31))
 >arg : Symbol(arg, Decl(varianceMeasurement.ts, 28, 11))
 >T : Symbol(T, Decl(varianceMeasurement.ts, 26, 10))
@@ -105,11 +105,11 @@ type Foo4<T> = {
 >T : Symbol(T, Decl(varianceMeasurement.ts, 37, 10))
 
   x: T;
->x : Symbol(x, Decl(varianceMeasurement.ts, 37, 16))
+>x : Symbol(Foo4.x, Decl(varianceMeasurement.ts, 37, 16))
 >T : Symbol(T, Decl(varianceMeasurement.ts, 37, 10))
 
   y: { x: (arg: T) => void, y: Foo4<(arg: T) => void>; }
->y : Symbol(y, Decl(varianceMeasurement.ts, 38, 7))
+>y : Symbol(Foo4.y, Decl(varianceMeasurement.ts, 38, 7))
 >x : Symbol(x, Decl(varianceMeasurement.ts, 39, 6))
 >arg : Symbol(arg, Decl(varianceMeasurement.ts, 39, 11))
 >T : Symbol(T, Decl(varianceMeasurement.ts, 37, 10))
diff --git a/tests/baselines/reference/varianceProblingAndZeroOrderIndexSignatureRelationsAlign.symbols b/tests/baselines/reference/varianceProblingAndZeroOrderIndexSignatureRelationsAlign.symbols
index ce297b87bbe41..e81c629ad7df7 100644
--- a/tests/baselines/reference/varianceProblingAndZeroOrderIndexSignatureRelationsAlign.symbols
+++ b/tests/baselines/reference/varianceProblingAndZeroOrderIndexSignatureRelationsAlign.symbols
@@ -209,7 +209,7 @@ type NeededInfo<MyNamespaceSchema = {}> = {
 >MyNamespaceSchema : Symbol(MyNamespaceSchema, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 54, 16))
 
   ASchema: ToA<MyNamespaceSchema>;
->ASchema : Symbol(ASchema, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 54, 43))
+>ASchema : Symbol(NeededInfo.ASchema, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 54, 43))
 >ToA : Symbol(ToA, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 51, 94))
 >MyNamespaceSchema : Symbol(MyNamespaceSchema, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 54, 16))
 
diff --git a/tests/baselines/reference/varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.symbols b/tests/baselines/reference/varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.symbols
index 8680b44cc166e..4d31e6cd1ff93 100644
--- a/tests/baselines/reference/varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.symbols
+++ b/tests/baselines/reference/varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.symbols
@@ -209,7 +209,7 @@ type NeededInfo<MyNamespaceSchema = {}> = {
 >MyNamespaceSchema : Symbol(MyNamespaceSchema, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 54, 16))
 
   ASchema: ToA<MyNamespaceSchema>;
->ASchema : Symbol(ASchema, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 54, 43))
+>ASchema : Symbol(NeededInfo.ASchema, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 54, 43))
 >ToA : Symbol(ToA, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 51, 94))
 >MyNamespaceSchema : Symbol(MyNamespaceSchema, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 54, 16))
 
diff --git a/tests/baselines/reference/varianceRepeatedlyPropegatesWithUnreliableFlag.symbols b/tests/baselines/reference/varianceRepeatedlyPropegatesWithUnreliableFlag.symbols
index b2e1f46f1e87b..c2560ae8a1fdb 100644
--- a/tests/baselines/reference/varianceRepeatedlyPropegatesWithUnreliableFlag.symbols
+++ b/tests/baselines/reference/varianceRepeatedlyPropegatesWithUnreliableFlag.symbols
@@ -1,11 +1,11 @@
 === tests/cases/compiler/varianceRepeatedlyPropegatesWithUnreliableFlag.ts ===
 type A = { a: number };
 >A : Symbol(A, Decl(varianceRepeatedlyPropegatesWithUnreliableFlag.ts, 0, 0))
->a : Symbol(a, Decl(varianceRepeatedlyPropegatesWithUnreliableFlag.ts, 0, 10))
+>a : Symbol(A.a, Decl(varianceRepeatedlyPropegatesWithUnreliableFlag.ts, 0, 10))
 
 type B = { b: number };
 >B : Symbol(B, Decl(varianceRepeatedlyPropegatesWithUnreliableFlag.ts, 0, 23))
->b : Symbol(b, Decl(varianceRepeatedlyPropegatesWithUnreliableFlag.ts, 1, 10))
+>b : Symbol(B.b, Decl(varianceRepeatedlyPropegatesWithUnreliableFlag.ts, 1, 10))
 
 type X<T> = ({ [K in keyof T]: T[K] } & Record<string, void>)[keyof T];
 >X : Symbol(X, Decl(varianceRepeatedlyPropegatesWithUnreliableFlag.ts, 1, 23))
@@ -20,14 +20,14 @@ type X<T> = ({ [K in keyof T]: T[K] } & Record<string, void>)[keyof T];
 type P1<T> = { data: X<T> };
 >P1 : Symbol(P1, Decl(varianceRepeatedlyPropegatesWithUnreliableFlag.ts, 2, 71))
 >T : Symbol(T, Decl(varianceRepeatedlyPropegatesWithUnreliableFlag.ts, 3, 8))
->data : Symbol(data, Decl(varianceRepeatedlyPropegatesWithUnreliableFlag.ts, 3, 14))
+>data : Symbol(P1.data, Decl(varianceRepeatedlyPropegatesWithUnreliableFlag.ts, 3, 14))
 >X : Symbol(X, Decl(varianceRepeatedlyPropegatesWithUnreliableFlag.ts, 1, 23))
 >T : Symbol(T, Decl(varianceRepeatedlyPropegatesWithUnreliableFlag.ts, 3, 8))
 
 type P2<T> = { data: X<T> };
 >P2 : Symbol(P2, Decl(varianceRepeatedlyPropegatesWithUnreliableFlag.ts, 3, 28))
 >T : Symbol(T, Decl(varianceRepeatedlyPropegatesWithUnreliableFlag.ts, 4, 8))
->data : Symbol(data, Decl(varianceRepeatedlyPropegatesWithUnreliableFlag.ts, 4, 14))
+>data : Symbol(P2.data, Decl(varianceRepeatedlyPropegatesWithUnreliableFlag.ts, 4, 14))
 >X : Symbol(X, Decl(varianceRepeatedlyPropegatesWithUnreliableFlag.ts, 1, 23))
 >T : Symbol(T, Decl(varianceRepeatedlyPropegatesWithUnreliableFlag.ts, 4, 8))
 
diff --git a/tests/baselines/reference/weakType.symbols b/tests/baselines/reference/weakType.symbols
index 0b51b726517b0..f33b2d43dd56a 100644
--- a/tests/baselines/reference/weakType.symbols
+++ b/tests/baselines/reference/weakType.symbols
@@ -54,11 +54,11 @@ doSomething(false);
 // this example is from services/textChanges.ts
 type ConfigurableStart = { useStart?: boolean }
 >ConfigurableStart : Symbol(ConfigurableStart, Decl(weakType.ts, 19, 19))
->useStart : Symbol(useStart, Decl(weakType.ts, 23, 26))
+>useStart : Symbol(ConfigurableStart.useStart, Decl(weakType.ts, 23, 26))
 
 type ConfigurableEnd = { useEnd?: boolean }
 >ConfigurableEnd : Symbol(ConfigurableEnd, Decl(weakType.ts, 23, 47))
->useEnd : Symbol(useEnd, Decl(weakType.ts, 24, 24))
+>useEnd : Symbol(ConfigurableEnd.useEnd, Decl(weakType.ts, 24, 24))
 
 type ConfigurableStartEnd = ConfigurableStart & ConfigurableEnd
 >ConfigurableStartEnd : Symbol(ConfigurableStartEnd, Decl(weakType.ts, 24, 43))
@@ -129,16 +129,16 @@ let ctor: Ctor = K
 
 type Spoiler = { nope?: string }
 >Spoiler : Symbol(Spoiler, Decl(weakType.ts, 47, 18))
->nope : Symbol(nope, Decl(weakType.ts, 49, 16))
+>nope : Symbol(Spoiler.nope, Decl(weakType.ts, 49, 16))
 
 type Weak = {
 >Weak : Symbol(Weak, Decl(weakType.ts, 49, 32))
 
     a?: number
->a : Symbol(a, Decl(weakType.ts, 50, 13))
+>a : Symbol(Weak.a, Decl(weakType.ts, 50, 13))
 
     properties?: {
->properties : Symbol(properties, Decl(weakType.ts, 51, 14))
+>properties : Symbol(Weak.properties, Decl(weakType.ts, 51, 14))
 
         b?: number
 >b : Symbol(b, Decl(weakType.ts, 52, 18))
diff --git a/tests/cases/conformance/declarationEmit/leaveOptionalParameterAsWritten.ts b/tests/cases/conformance/declarationEmit/leaveOptionalParameterAsWritten.ts
new file mode 100644
index 0000000000000..8943ebc47573b
--- /dev/null
+++ b/tests/cases/conformance/declarationEmit/leaveOptionalParameterAsWritten.ts
@@ -0,0 +1,25 @@
+// @module: esnext
+// @outDir: dist
+// @declaration: true
+// @emitDeclarationOnly: true
+// @strictNullChecks: true
+
+// @Filename: a.ts
+export interface Foo {}
+
+// @Filename: b.ts
+import * as a from "./a";
+declare global {
+  namespace teams {
+    export namespace calling {
+      export import Foo = a.Foo;
+    }
+  }
+}
+
+// @Filename: c.ts
+type Foo = teams.calling.Foo;
+export const f = (p?: Foo) => {}
+export const o = {
+  p: undefined! as Foo
+};
diff --git a/tests/cases/fourslash/completionReturnConstAssertion.ts b/tests/cases/fourslash/completionReturnConstAssertion.ts
index addb207bf65e3..735da22595a04 100644
--- a/tests/cases/fourslash/completionReturnConstAssertion.ts
+++ b/tests/cases/fourslash/completionReturnConstAssertion.ts
@@ -11,7 +11,7 @@
 verify.completions({
     marker: "1",
     exact: [
-        { name: "foo1", text: "(property) foo1: 1" },
-        { name: "foo2", text: "(property) foo2: 2" },
+        { name: "foo1", text: "(property) T.foo1: 1" },
+        { name: "foo2", text: "(property) T.foo2: 2" },
     ],
 });
diff --git a/tests/cases/fourslash/findAllRefsTypedef.ts b/tests/cases/fourslash/findAllRefsTypedef.ts
index c17f568946db3..8929883be0996 100644
--- a/tests/cases/fourslash/findAllRefsTypedef.ts
+++ b/tests/cases/fourslash/findAllRefsTypedef.ts
@@ -12,4 +12,4 @@
 ////let x;
 ////x.[|p|];
 
-verify.singleReferenceGroup("(property) p: number", "p");
+verify.singleReferenceGroup("(property) I.p: number", "p");
diff --git a/tests/cases/fourslash/jsDocTagsWithHyphen.ts b/tests/cases/fourslash/jsDocTagsWithHyphen.ts
index 6726122a1fd35..8f74b08474d43 100644
--- a/tests/cases/fourslash/jsDocTagsWithHyphen.ts
+++ b/tests/cases/fourslash/jsDocTagsWithHyphen.ts
@@ -14,7 +14,7 @@
 //// const product = {
 ////     /*3*/
 //// }
-verify.quickInfoAt('1', '(property) high-top: boolean', 'some-comments');
+verify.quickInfoAt('1', '(property) Product.high-top: boolean', 'some-comments');
 
 verify.quickInfoAt('2', 'type Product = {\n    title: string;\n    "high-top": boolean;\n}');
 
diff --git a/tests/cases/fourslash/memberListInFunctionCall2.ts b/tests/cases/fourslash/memberListInFunctionCall2.ts
index 5eb117b58f9cd..5838cfab7cf2d 100644
--- a/tests/cases/fourslash/memberListInFunctionCall2.ts
+++ b/tests/cases/fourslash/memberListInFunctionCall2.ts
@@ -11,7 +11,7 @@
 verify.completions({
     marker: "1",
     exact: [
-        { name: "a", text: "(property) a: 1" },
-        { name: "b", text: "(property) b: 2" },
+        { name: "a", text: "(property) T.a: 1" },
+        { name: "b", text: "(property) T.b: 2" },
     ],
 });
diff --git a/tests/cases/fourslash/quickInfoForTypeParameterInTypeAlias2.ts b/tests/cases/fourslash/quickInfoForTypeParameterInTypeAlias2.ts
index 9bfc760b8f7dd..b9dae8b791f44 100644
--- a/tests/cases/fourslash/quickInfoForTypeParameterInTypeAlias2.ts
+++ b/tests/cases/fourslash/quickInfoForTypeParameterInTypeAlias2.ts
@@ -9,8 +9,8 @@ verify.quickInfos({
     1: "(type parameter) AA in type Call<AA>",
     2: "(type parameter) AA in type Index<AA>",
     3: "(type parameter) AA in type GenericMethod<AA>",
-    4: "(type parameter) BB in method<BB>(): AA & BB",
+    4: "(type parameter) BB in GenericMethod<AA>.method<BB>(): AA & BB",
     5: "(type parameter) TT in type Nesting<TT>",
-    6: "(type parameter) UU in method<UU>(): new <WW>() => TT & UU & WW",
+    6: "(type parameter) UU in Nesting<TT>.method<UU>(): new <WW>() => TT & UU & WW",
     7: "(type parameter) WW in <WW>(): TT & UU & WW"
 });
diff --git a/tests/cases/fourslash/quickInfoPropertyTag.ts b/tests/cases/fourslash/quickInfoPropertyTag.ts
index e702436ed423d..2344c6bfc449f 100644
--- a/tests/cases/fourslash/quickInfoPropertyTag.ts
+++ b/tests/cases/fourslash/quickInfoPropertyTag.ts
@@ -12,4 +12,4 @@
 /////** @type {I} */
 ////const obj = { /**/x: 10 };
 
-verify.quickInfoAt("", "(property) x: number", "Doc\nMore doc");
+verify.quickInfoAt("", "(property) I.x: number", "Doc\nMore doc");