From 06f73dde70e1fe368e68d86315fcbfdc31990c9b Mon Sep 17 00:00:00 2001
From: Nathan Shively-Sanders <293473+sandersn@users.noreply.github.com>
Date: Mon, 3 Oct 2022 09:08:07 -0700
Subject: [PATCH] getTypeAtLocation supports parenthesised class exprs

And accept baselines for later inspection.

One fourslash test changes, indicating that quick info relied on
getTypeAtLocation not returning anything for class expressions to
distinguish named from anonymous class expressions. This predicate will
have to be improved.
---
 src/compiler/checker.ts                       |  4 +
 .../reference/YieldExpression19_es6.symbols   |  1 +
 .../reference/YieldExpression8_es6.symbols    |  1 +
 .../accessorsOverrideProperty8.symbols        |  1 +
 .../reference/ambientEnumDeclaration1.symbols |  1 +
 .../amdDeclarationEmitNoExtraDeclare.symbols  |  1 +
 .../anonClassDeclarationEmitIsAnon.symbols    |  2 +
 ...DeclarationDoesntPrintWithReadonly.symbols |  1 +
 .../anonymousClassExpression1.symbols         |  1 +
 ...ializerOrStaticInitializationBlock.symbols |  5 ++
 .../assertionTypePredicates2.symbols          |  1 +
 ...ropertyToPropertyDeclarationESNext.symbols |  2 +
 .../assignmentLHSIsReference.symbols          |  3 +
 .../reference/assignmentLHSIsValue.symbols    |  5 ++
 ...signmentToParenthesizedIdentifiers.symbols | 22 ++++++
 .../asyncAwaitNestedClasses_es5.symbols       |  2 +
 .../awaitInClassInAsyncFunction.symbols       |  2 +
 .../baseConstraintOfDecorator.symbols         |  2 +
 .../blockScopedVariablesUseBeforeDef.symbols  |  5 ++
 .../reference/callWithSpread.symbols          |  9 +++
 .../reference/callWithSpreadES6.symbols       |  3 +
 .../capturedParametersInInitializers1.symbols |  1 +
 .../capturedParametersInInitializers2.symbols |  2 +
 .../castExpressionParentheses.symbols         |  1 +
 .../checkSpecialPropertyAssignments.symbols   |  1 +
 .../reference/classBlockScoping.symbols       |  1 +
 .../classDeclaredBeforeClassFactory.symbols   |  1 +
 .../reference/classExpression.symbols         |  3 +
 .../reference/classExpression1.symbols        |  1 +
 .../reference/classExpression2.symbols        |  1 +
 .../reference/classExpression3.symbols        |  3 +
 .../reference/classExpression4.symbols        |  1 +
 .../reference/classExpression5.symbols        |  1 +
 .../classExpressionAssignment.symbols         |  1 +
 .../reference/classExpressionES61.symbols     |  1 +
 .../reference/classExpressionES62.symbols     |  1 +
 .../reference/classExpressionES63.symbols     |  3 +
 ...ssExpressionExtendingAbstractClass.symbols |  1 +
 ...xpressionInClassStaticDeclarations.symbols |  1 +
 .../reference/classExpressionLoop.symbols     |  1 +
 .../reference/classExpressionNames.symbols    |  4 +
 .../reference/classExpressionTest2.symbols    |  1 +
 ...hResolutionOfNamespaceOfSameName01.symbols |  1 +
 ...assExpressionWithStaticProperties1.symbols |  1 +
 ...assExpressionWithStaticProperties2.symbols |  1 +
 ...assExpressionWithStaticProperties3.symbols |  1 +
 ...ExpressionWithStaticPropertiesES61.symbols |  1 +
 ...ExpressionWithStaticPropertiesES62.symbols |  1 +
 ...ExpressionWithStaticPropertiesES63.symbols |  1 +
 ...ExpressionWithStaticPropertiesES64.symbols |  2 +
 .../reference/classExpressions.symbols        |  1 +
 .../classStaticBlock18(target=es2015).symbols |  3 +
 .../classStaticBlock18(target=es2022).symbols |  3 +
 .../classStaticBlock18(target=es5).symbols    |  3 +
 .../classStaticBlock18(target=esnext).symbols |  3 +
 .../classStaticBlock22(target=es2022).symbols |  2 +
 .../classStaticBlock22(target=esnext).symbols |  2 +
 .../reference/classStaticBlock27.symbols      |  1 +
 ...lassUsedBeforeInitializedVariables.symbols |  2 +
 ...monJSImportExportedClassExpression.symbols |  1 +
 ...onJSImportNestedClassTypeReference.symbols |  1 +
 .../commonJsImportClassExpression.symbols     |  2 +
 .../compoundAssignmentLHSIsReference.symbols  |  6 ++
 .../compoundAssignmentLHSIsValue.symbols      | 10 +++
 ...nentiationAssignmentLHSIsReference.symbols |  3 +
 ...ExponentiationAssignmentLHSIsValue.symbols |  5 ++
 ...utedPropertyNames52(target=es2015).symbols |  1 +
 ...omputedPropertyNames52(target=es5).symbols |  1 +
 .../reference/constAssertionOnEnum.symbols    |  1 +
 .../constDeclarations-access2.symbols         |  3 +
 .../constDeclarations-access3.symbols         |  3 +
 .../constDeclarations-access4.symbols         |  3 +
 .../constDeclarations-access5.symbols         |  3 +
 .../reference/constInClassExpression.symbols  |  1 +
 .../reference/constructorFunctions.symbols    |  1 +
 ...ClassExpressionMethodDeclaration01.symbols |  6 ++
 ...ClassExpressionMethodDeclaration02.symbols |  6 ++
 .../reference/controlFlowArrays.symbols       |  2 +
 ...ssionToFunctionFromObjectProperty1.symbols | 78 +++++++++++++++++++
 ...ssionToFunctionFromObjectProperty2.symbols | 78 +++++++++++++++++++
 ...eclarationEmitExpressionInExtends4.symbols |  1 +
 ...clarationEmitMixinPrivateProtected.symbols |  2 +
 ...larationEmitPrivateNameCausesError.symbols |  1 +
 .../declarationNoDanglingGenerics.symbols     |  2 +
 ...tionsForFileShadowingGlobalNoError.symbols |  1 +
 .../decoratorsOnComputedProperties.symbols    |  5 ++
 .../decrementAndIncrementOperators.symbols    |  6 ++
 .../defaultValueInFunctionTypes.symbols       |  1 +
 tests/baselines/reference/deleteChain.symbols |  6 ++
 .../derivedClassSuperProperties.symbols       | 15 ++++
 ...MixinConditionalTypeBaseClassWorks.symbols |  2 +
 ...itClassExpressionInDeclarationFile.symbols |  3 +
 ...tClassExpressionInDeclarationFile2.symbols |  2 +
 ...nmentDefineProperrtyPotentialMerge.symbols |  1 +
 .../errorsWithInvokablesInUnions01.symbols    |  1 +
 .../exportAssignNonIdentifier.symbols         |  1 +
 .../exportClassExtendingIntersection.symbols  |  1 +
 .../exportDefaultParenthesizeES6.symbols      |  1 +
 .../reference/exportNestedNamespaces.symbols  |  1 +
 ...rtPropertyAssignmentNameResolution.symbols |  1 +
 .../expressionTypeNodeShouldError.symbols     |  3 +
 .../externalModuleImmutableBindings.symbols   |  4 +
 .../reference/for-inStatementsArray.symbols   |  2 +
 ...functionLikeInParameterInitializer.symbols |  1 +
 ...DefaultParameterWithNoStatements12.symbols |  2 +
 .../functionsInClassExpressions.symbols       |  1 +
 .../reference/generatorTypeCheck55.symbols    |  1 +
 .../reference/generatorTypeCheck56.symbols    |  1 +
 .../genericClassExpressionInFunction.symbols  |  4 +
 .../genericClassWithStaticFactory.symbols     |  2 +
 ...essMethodIntersectionCanBeAccessed.symbols |  1 +
 .../implementsInClassExpression.symbols       |  1 +
 .../reference/importTypeInJSDoc.symbols       |  2 +
 ...WithFunctionTypeSyntacticScenarios.symbols |  1 +
 ...gClassStaticMembersFromAssignments.symbols |  2 +
 .../reference/jsDeclarationsClasses.symbols   |  1 +
 ...tionsExportAssignedClassExpression.symbols |  1 +
 ...rtAssignedClassExpressionAnonymous.symbols |  1 +
 ...nedClassExpressionAnonymousWithSub.symbols |  2 +
 ...rtAssignedClassExpressionShadowing.symbols |  1 +
 ...clarationsExportAssignedVisibility.symbols |  1 +
 .../reference/jsDeclarationsFunctions.symbols |  1 +
 .../jsDeclarationsFunctionsCjs.symbols        |  1 +
 .../reference/jsEnumCrossFileExport.symbols   |  1 +
 ...peParameterSyntaxOfClassExpression.symbols |  1 +
 .../reference/jsdocImplements_class.symbols   |  5 ++
 .../reference/jsdocImportType2.symbols        |  1 +
 .../baselines/reference/jsdocTypeCast.symbols |  5 ++
 ...ReferenceToImportOfClassExpression.symbols |  1 +
 .../reference/jsdocTypeTagCast.symbols        | 10 +++
 .../jsdocTypecastNoTypeNoCrash.symbols        |  1 +
 .../reference/jsxComponentTypeErrors.symbols  |  1 +
 .../reference/jsxInExtendsClause.symbols      |  1 +
 ...NestedWithinTernaryParsesCorrectly.symbols |  2 +
 .../reference/letDeclarations-access.symbols  |  1 +
 .../reference/literals-negative.symbols       |  1 +
 .../logicalAssignment3(target=es2015).symbols |  3 +
 .../logicalAssignment3(target=es2020).symbols |  3 +
 .../logicalAssignment3(target=es2021).symbols |  3 +
 .../logicalAssignment3(target=esnext).symbols |  3 +
 .../reference/mappedTypeProperties.symbols    |  2 +
 ...missingPropertiesOfClassExpression.symbols |  1 +
 .../reference/mixinClassesAnnotated.symbols   |  1 +
 .../reference/mixinClassesAnonymous.symbols   |  2 +
 .../mixinIntersectionIsValidbaseType.symbols  |  3 +
 .../mixinPrivateAndProtected.symbols          |  4 +
 .../mixingApparentTypeOverrides.symbols       |  1 +
 ...rOnClassExpressionMemberInFunction.symbols |  1 +
 .../reference/moduleExportAlias4.symbols      |  2 +
 .../moduleExportNestedNamespaces.symbols      |  1 +
 tests/baselines/reference/nanEquality.symbols |  8 ++
 .../reference/narrowedConstInMethod.symbols   |  2 +
 .../neverReturningFunctions1.symbols          |  2 +
 .../baselines/reference/newWithSpread.symbols |  3 +
 .../reference/newWithSpreadES5.symbols        |  3 +
 .../reference/newWithSpreadES6.symbols        |  3 +
 .../reference/noCrashOnMixin.symbols          |  1 +
 .../nonNullReferenceMatching.symbols          | 12 +++
 tests/baselines/reference/override1.symbols   |  5 ++
 tests/baselines/reference/override20.symbols  |  2 +
 .../overrideBaseIntersectionMethod.symbols    |  1 +
 .../reference/parserForOfStatement24.symbols  |  1 +
 ...esizedVariableAndFunctionInTernary.symbols |  1 +
 ...eAndParenthesizedFunctionInTernary.symbols |  2 +
 .../reference/parserRealSource11.symbols      |  2 +
 .../reference/parserRealSource12.symbols      | 16 ++++
 .../reference/parserRealSource4.symbols       |  1 +
 .../reference/parserS7.2_A1.5_T2.symbols      |  2 +
 .../reference/parserS7.3_A1.1_T2.symbols      |  1 +
 .../reference/parserUnicode1.symbols          |  2 +
 .../baselines/reference/parserharness.symbols |  1 +
 .../privateNameClassExpressionLoop.symbols    |  1 +
 .../privateNameFieldClassExpression.symbols   |  2 +
 .../privateNameFieldUnaryMutation.symbols     | 20 +++++
 ...privateNameInLhsReceiverExpression.symbols |  2 +
 .../reference/privateNameMethodAsync.symbols  |  1 +
 .../privateNameMethodCallExpression.symbols   |  1 +
 .../privateNameMethodClassExpression.symbols  |  1 +
 .../privateNameNestedMethodAccess.symbols     |  1 +
 .../reference/privateNameReadonly.symbols     |  1 +
 .../privateNameSetterNoGetter.symbols         |  1 +
 ...vateNameStaticFieldClassExpression.symbols |  2 +
 ...cFieldNoInitializer(target=es2015).symbols |  1 +
 ...cFieldNoInitializer(target=es2022).symbols |  1 +
 ...cFieldNoInitializer(target=esnext).symbols |  1 +
 .../privateNameStaticMethodAsync.symbols      |  1 +
 ...vateNameStaticMethodCallExpression.symbols |  1 +
 ...ateNameStaticMethodClassExpression.symbols |  1 +
 ...ClassFieldsInEsNext(target=es2020).symbols |  8 ++
 ...ClassFieldsInEsNext(target=esnext).symbols |  8 ++
 .../privateNamesAndStaticFields.symbols       |  1 +
 .../reference/quotedConstructors.symbols      |  2 +
 .../reactReadonlyHOCAssignabilityReal.symbols |  1 +
 ...ignmentInSubclassOfClassExpression.symbols |  1 +
 ...nlyPropertySubtypeRelationDirected.symbols |  4 +
 .../reference/recursiveClassBaseType.symbols  |  1 +
 .../reference/scannerS7.2_A1.5_T2.symbols     |  2 +
 .../reference/scannerS7.3_A1.1_T2.symbols     |  1 +
 .../staticFieldWithInterfaceContext.symbols   | 15 ++++
 .../reference/staticIndexSignature6.symbols   |  1 +
 .../staticPropertyNameConflicts.symbols       | 10 +++
 tests/baselines/reference/statics.symbols     |  2 +
 .../reference/strictModeReservedWord.symbols  |  1 +
 .../superCallInsideClassExpression.symbols    |  1 +
 ...ComputedPropertiesOfNestedType_ES5.symbols |  2 +
 ...ComputedPropertiesOfNestedType_ES6.symbols |  2 +
 ...xOnExistingReadonlyFieldIsNotNever.symbols |  1 +
 .../thisTypeInTaggedTemplateCall.symbols      |  1 +
 .../thisTypeSyntacticContext.symbols          |  1 +
 ...ait.1(module=es2022,target=es2015).symbols |  2 +
 ...ait.1(module=es2022,target=es2017).symbols |  2 +
 ...ait.1(module=esnext,target=es2015).symbols |  2 +
 ...ait.1(module=esnext,target=es2017).symbols |  2 +
 ...ait.1(module=system,target=es2015).symbols |  2 +
 ...ait.1(module=system,target=es2017).symbols |  2 +
 .../transformsElideNullUndefinedType.symbols  |  2 +
 .../truthinessPromiseCoercion.symbols         |  7 ++
 .../tsxGenericAttributesType9.symbols         |  1 +
 .../typeAliasFunctionTypeSharedSymbol.symbols |  1 +
 ...umentInferenceWithClassExpression1.symbols |  2 +
 ...umentInferenceWithClassExpression2.symbols |  2 +
 ...umentInferenceWithClassExpression3.symbols |  2 +
 .../typeFromParamTagForFunction.symbols       |  1 +
 .../typeFromPropertyAssignment.symbols        |  2 +
 .../typeFromPropertyAssignment10.symbols      |  1 +
 .../typeFromPropertyAssignment10_1.symbols    |  1 +
 .../typeFromPropertyAssignment15.symbols      |  1 +
 .../typeFromPropertyAssignment2.symbols       |  1 +
 .../typeFromPropertyAssignment24.symbols      |  1 +
 .../typeFromPropertyAssignment25.symbols      |  2 +
 .../typeFromPropertyAssignment26.symbols      |  1 +
 .../typeFromPropertyAssignment29.symbols      |  1 +
 .../typeFromPropertyAssignment3.symbols       |  1 +
 .../typeFromPropertyAssignment35.symbols      |  1 +
 .../typeFromPropertyAssignment4.symbols       |  1 +
 .../typeFromPropertyAssignment5.symbols       |  1 +
 .../typeFromPropertyAssignment6.symbols       |  1 +
 .../typeFromPropertyAssignment9.symbols       |  2 +
 .../typeFromPropertyAssignment9_1.symbols     |  2 +
 ...peFromPropertyAssignmentOutOfOrder.symbols |  3 +
 .../reference/typeGuardInClass.symbols        |  2 +
 ...typeGuardOfFromPropNameInUnionType.symbols |  1 +
 .../typeGuardOnContainerTypeNoHang.symbols    |  1 +
 ...isInStaticMembers12(target=es2022).symbols |  1 +
 ...fThisInStaticMembers12(target=es5).symbols |  1 +
 ...fThisInStaticMembers12(target=es6).symbols |  1 +
 ...isInStaticMembers12(target=esnext).symbols |  1 +
 ...isInStaticMembers13(target=es2022).symbols |  1 +
 ...fThisInStaticMembers13(target=es5).symbols |  1 +
 ...fThisInStaticMembers13(target=es6).symbols |  1 +
 ...isInStaticMembers13(target=esnext).symbols |  1 +
 ...hisInStaticMembers7(target=es2022).symbols |  1 +
 ...OfThisInStaticMembers7(target=es5).symbols |  1 +
 ...OfThisInStaticMembers7(target=es6).symbols |  1 +
 ...hisInStaticMembers7(target=esnext).symbols |  1 +
 ...hisInStaticMembers8(target=es2022).symbols |  1 +
 ...OfThisInStaticMembers8(target=es5).symbols |  1 +
 ...OfThisInStaticMembers8(target=es6).symbols |  1 +
 ...hisInStaticMembers8(target=esnext).symbols |  1 +
 ...hisInStaticMembers9(target=es2022).symbols |  1 +
 ...OfThisInStaticMembers9(target=es5).symbols |  1 +
 ...OfThisInStaticMembers9(target=es6).symbols |  1 +
 ...hisInStaticMembers9(target=esnext).symbols |  1 +
 .../reference/typedefCrossModule2.symbols     |  2 +
 .../reference/typedefCrossModule3.symbols     |  1 +
 ...ledFunctionChecksInConditionalPerf.symbols |  1 +
 .../baselines/reference/uniqueSymbols.symbols |  1 +
 .../uniqueSymbolsDeclarationsErrors.symbols   |  1 +
 .../unusedLocalsAndParameters.symbols         |  2 +
 .../unusedLocalsAndParametersDeferred.symbols |  1 +
 ...foreDeclaration_propertyAssignment.symbols |  2 +
 .../reference/varianceAnnotations.symbols     |  2 +
 272 files changed, 767 insertions(+)

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 0e4f940238c..7c9531a30c6 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -43099,6 +43099,8 @@ namespace ts {
                 case SyntaxKind.EqualsGreaterThanToken:
                 case SyntaxKind.ClassKeyword:
                     return getSymbolOfNode(node.parent);
+                case SyntaxKind.ClassExpression:
+                    return node.symbol;
                 case SyntaxKind.ImportType:
                     return isLiteralImportTypeNode(node) ? getSymbolAtLocation(node.argument.literal, ignoreErrors) : undefined;
 
@@ -43110,6 +43112,8 @@ namespace ts {
                     return isMetaProperty(node.parent) ? checkMetaPropertyKeyword(node.parent).symbol : undefined;
                 case SyntaxKind.MetaProperty:
                     return checkExpression(node as Expression).symbol;
+                case SyntaxKind.ParenthesizedExpression:
+                    return getSymbolAtLocation((node as ParenthesizedExpression).expression, ignoreErrors);
 
                 default:
                     return undefined;
diff --git a/tests/baselines/reference/YieldExpression19_es6.symbols b/tests/baselines/reference/YieldExpression19_es6.symbols
index 609102001c4..2fb64f7cb40 100644
--- a/tests/baselines/reference/YieldExpression19_es6.symbols
+++ b/tests/baselines/reference/YieldExpression19_es6.symbols
@@ -9,6 +9,7 @@ function*foo() {
 >quux : Symbol(quux, Decl(YieldExpression19_es6.ts, 1, 18))
 
       yield(foo);
+>(foo) : Symbol(foo, Decl(YieldExpression19_es6.ts, 0, 0))
 >foo : Symbol(foo, Decl(YieldExpression19_es6.ts, 0, 0))
     }
   }
diff --git a/tests/baselines/reference/YieldExpression8_es6.symbols b/tests/baselines/reference/YieldExpression8_es6.symbols
index 028ef8dcaa1..d31aaedee8d 100644
--- a/tests/baselines/reference/YieldExpression8_es6.symbols
+++ b/tests/baselines/reference/YieldExpression8_es6.symbols
@@ -6,5 +6,6 @@ function* foo() {
 >foo : Symbol(foo, Decl(YieldExpression8_es6.ts, 0, 11))
 
   yield(foo);
+>(foo) : Symbol(foo, Decl(YieldExpression8_es6.ts, 0, 11))
 >foo : Symbol(foo, Decl(YieldExpression8_es6.ts, 0, 11))
 }
diff --git a/tests/baselines/reference/accessorsOverrideProperty8.symbols b/tests/baselines/reference/accessorsOverrideProperty8.symbols
index 7e60b8c582d..a2ce6a10108 100644
--- a/tests/baselines/reference/accessorsOverrideProperty8.symbols
+++ b/tests/baselines/reference/accessorsOverrideProperty8.symbols
@@ -60,6 +60,7 @@ const Base = classWithProperties({
 >y : Symbol(y, Decl(accessorsOverrideProperty8.ts, 14, 42))
 
 }, class Base {
+>class Base {} : Symbol(Base, Decl(accessorsOverrideProperty8.ts, 16, 2))
 >Base : Symbol(Base, Decl(accessorsOverrideProperty8.ts, 16, 2))
 
 });
diff --git a/tests/baselines/reference/ambientEnumDeclaration1.symbols b/tests/baselines/reference/ambientEnumDeclaration1.symbols
index 62e6250cf95..ac365e0f008 100644
--- a/tests/baselines/reference/ambientEnumDeclaration1.symbols
+++ b/tests/baselines/reference/ambientEnumDeclaration1.symbols
@@ -16,6 +16,7 @@ declare enum E {
 
     d = (c) + 1,
 >d : Symbol(E.d, Decl(ambientEnumDeclaration1.ts, 5, 10))
+>(c) : Symbol(E.c, Decl(ambientEnumDeclaration1.ts, 4, 15))
 >c : Symbol(E.c, Decl(ambientEnumDeclaration1.ts, 4, 15))
 
     e = 10 << 2 * 8,
diff --git a/tests/baselines/reference/amdDeclarationEmitNoExtraDeclare.symbols b/tests/baselines/reference/amdDeclarationEmitNoExtraDeclare.symbols
index e3754a46eed..7f5a2084632 100644
--- a/tests/baselines/reference/amdDeclarationEmitNoExtraDeclare.symbols
+++ b/tests/baselines/reference/amdDeclarationEmitNoExtraDeclare.symbols
@@ -28,6 +28,7 @@ export function Configurable<T extends Constructor<{}>>(base: T): T {
 >T : Symbol(T, Decl(Configurable.ts, 3, 29))
 
     return class extends base {
+>class extends base {        constructor(...args: any[]) {            super(...args);        }    } : Symbol((Anonymous class), Decl(Configurable.ts, 4, 10))
 >base : Symbol(base, Decl(Configurable.ts, 3, 56))
 
         constructor(...args: any[]) {
diff --git a/tests/baselines/reference/anonClassDeclarationEmitIsAnon.symbols b/tests/baselines/reference/anonClassDeclarationEmitIsAnon.symbols
index f2988d8cb2e..9de359997f3 100644
--- a/tests/baselines/reference/anonClassDeclarationEmitIsAnon.symbols
+++ b/tests/baselines/reference/anonClassDeclarationEmitIsAnon.symbols
@@ -4,6 +4,7 @@ export function wrapClass(param: any) {
 >param : Symbol(param, Decl(wrapClass.ts, 0, 26))
 
     return class Wrapped {
+>class Wrapped {        foo() {            return param;        }    } : Symbol(Wrapped, Decl(wrapClass.ts, 1, 10))
 >Wrapped : Symbol(Wrapped, Decl(wrapClass.ts, 1, 10))
 
         foo() {
@@ -29,6 +30,7 @@ export function Timestamped<TBase extends Constructor>(Base: TBase) {
 >TBase : Symbol(TBase, Decl(wrapClass.ts, 10, 28))
 
     return class extends Base {
+>class extends Base {        timestamp = Date.now();    } : Symbol((Anonymous class), Decl(wrapClass.ts, 11, 10))
 >Base : Symbol(Base, Decl(wrapClass.ts, 10, 55))
 
         timestamp = Date.now();
diff --git a/tests/baselines/reference/anonymousClassDeclarationDoesntPrintWithReadonly.symbols b/tests/baselines/reference/anonymousClassDeclarationDoesntPrintWithReadonly.symbols
index b450e1b3b83..2785c486fd3 100644
--- a/tests/baselines/reference/anonymousClassDeclarationDoesntPrintWithReadonly.symbols
+++ b/tests/baselines/reference/anonymousClassDeclarationDoesntPrintWithReadonly.symbols
@@ -10,5 +10,6 @@ export function y() {
 >y : Symbol(y, Decl(anonymousClassDeclarationDoesntPrintWithReadonly.ts, 2, 1))
 
     return class extends X { }
+>class extends X { } : Symbol((Anonymous class), Decl(anonymousClassDeclarationDoesntPrintWithReadonly.ts, 5, 10))
 >X : Symbol(X, Decl(anonymousClassDeclarationDoesntPrintWithReadonly.ts, 0, 0))
 }
diff --git a/tests/baselines/reference/anonymousClassExpression1.symbols b/tests/baselines/reference/anonymousClassExpression1.symbols
index 114bfc96097..25d7b9a1e0a 100644
--- a/tests/baselines/reference/anonymousClassExpression1.symbols
+++ b/tests/baselines/reference/anonymousClassExpression1.symbols
@@ -3,4 +3,5 @@ function f() {
 >f : Symbol(f, Decl(anonymousClassExpression1.ts, 0, 0))
 
     return typeof class {} === "function";
+>class {} : Symbol((Anonymous class), Decl(anonymousClassExpression1.ts, 1, 17))
 }
diff --git a/tests/baselines/reference/argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.symbols b/tests/baselines/reference/argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.symbols
index b087127c457..07ecda9b945 100644
--- a/tests/baselines/reference/argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.symbols
+++ b/tests/baselines/reference/argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.symbols
@@ -3,6 +3,7 @@ function A() {
 >A : Symbol(A, Decl(argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts, 0, 0))
 
   return class T {
+>class T {     a = arguments  } : Symbol(T, Decl(argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts, 1, 8))
 >T : Symbol(T, Decl(argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts, 1, 8))
 
      a = arguments
@@ -15,6 +16,7 @@ function A1() {
 >A1 : Symbol(A1, Decl(argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts, 4, 1))
 
   return new class T {
+>class T {     a = arguments  } : Symbol(T, Decl(argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts, 7, 12))
 >T : Symbol(T, Decl(argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts, 7, 12))
 
      a = arguments
@@ -27,6 +29,7 @@ function B() {
 >B : Symbol(B, Decl(argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts, 10, 1))
 
   return class T {
+>class T {     a = { b: arguments }  } : Symbol(T, Decl(argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts, 13, 8))
 >T : Symbol(T, Decl(argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts, 13, 8))
 
      a = { b: arguments }
@@ -40,6 +43,7 @@ function B1() {
 >B1 : Symbol(B1, Decl(argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts, 16, 1))
 
   return new class T {
+>class T {     a = { b: arguments }  } : Symbol(T, Decl(argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts, 19, 12))
 >T : Symbol(T, Decl(argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts, 19, 12))
 
      a = { b: arguments }
@@ -53,6 +57,7 @@ function C() {
 >C : Symbol(C, Decl(argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts, 22, 1))
 
   return class T {
+>class T {     a = function () { arguments }  } : Symbol(T, Decl(argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts, 25, 8))
 >T : Symbol(T, Decl(argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts, 25, 8))
 
      a = function () { arguments }
diff --git a/tests/baselines/reference/assertionTypePredicates2.symbols b/tests/baselines/reference/assertionTypePredicates2.symbols
index 24086f27a21..22b7208b4e1 100644
--- a/tests/baselines/reference/assertionTypePredicates2.symbols
+++ b/tests/baselines/reference/assertionTypePredicates2.symbols
@@ -17,6 +17,7 @@ const foo = (a) => {
 
     if (/** @type { B } */ (a).y !== 0) throw TypeError();
 >(a).y : Symbol(y, Decl(assertionTypePredicates2.js, 5, 19))
+>(a) : Symbol(a, Decl(assertionTypePredicates2.js, 12, 13))
 >a : Symbol(a, Decl(assertionTypePredicates2.js, 12, 13))
 >y : Symbol(y, Decl(assertionTypePredicates2.js, 5, 19))
 >TypeError : Symbol(TypeError, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
diff --git a/tests/baselines/reference/assignParameterPropertyToPropertyDeclarationESNext.symbols b/tests/baselines/reference/assignParameterPropertyToPropertyDeclarationESNext.symbols
index b94171e52b6..6c13dd50bb4 100644
--- a/tests/baselines/reference/assignParameterPropertyToPropertyDeclarationESNext.symbols
+++ b/tests/baselines/reference/assignParameterPropertyToPropertyDeclarationESNext.symbols
@@ -109,6 +109,7 @@ class F {
 
     Inner = class extends F {
 >Inner : Symbol(F.Inner, Decl(assignParameterPropertyToPropertyDeclarationESNext.ts, 29, 9))
+>class extends F {        p2 = this.p1    } : Symbol((Anonymous class), Decl(assignParameterPropertyToPropertyDeclarationESNext.ts, 30, 11))
 >F : Symbol(F, Decl(assignParameterPropertyToPropertyDeclarationESNext.ts, 27, 1))
 
         p2 = this.p1
@@ -125,6 +126,7 @@ class G {
 
     Inner = class extends G {
 >Inner : Symbol(G.Inner, Decl(assignParameterPropertyToPropertyDeclarationESNext.ts, 35, 9))
+>class extends G {        p2 = this.p1    } : Symbol((Anonymous class), Decl(assignParameterPropertyToPropertyDeclarationESNext.ts, 36, 11))
 >G : Symbol(G, Decl(assignParameterPropertyToPropertyDeclarationESNext.ts, 34, 1))
 
         p2 = this.p1
diff --git a/tests/baselines/reference/assignmentLHSIsReference.symbols b/tests/baselines/reference/assignmentLHSIsReference.symbols
index 417ba3c07ea..2b16704120d 100644
--- a/tests/baselines/reference/assignmentLHSIsReference.symbols
+++ b/tests/baselines/reference/assignmentLHSIsReference.symbols
@@ -37,6 +37,7 @@ x3['a'] = value;
 
 // parentheses, the contained expression is reference
 (x1) = value;
+>(x1) : Symbol(x1, Decl(assignmentLHSIsReference.ts, 3, 3))
 >x1 : Symbol(x1, Decl(assignmentLHSIsReference.ts, 3, 3))
 >value : Symbol(value, Decl(assignmentLHSIsReference.ts, 0, 3))
 
@@ -45,11 +46,13 @@ function fn2(x4: number) {
 >x4 : Symbol(x4, Decl(assignmentLHSIsReference.ts, 18, 13))
 
     (x4) = value;
+>(x4) : Symbol(x4, Decl(assignmentLHSIsReference.ts, 18, 13))
 >x4 : Symbol(x4, Decl(assignmentLHSIsReference.ts, 18, 13))
 >value : Symbol(value, Decl(assignmentLHSIsReference.ts, 0, 3))
 }
 
 (x3.a) = value;
+>(x3.a) : Symbol(a, Decl(assignmentLHSIsReference.ts, 11, 9))
 >x3.a : Symbol(a, Decl(assignmentLHSIsReference.ts, 11, 9))
 >x3 : Symbol(x3, Decl(assignmentLHSIsReference.ts, 11, 3))
 >a : Symbol(a, Decl(assignmentLHSIsReference.ts, 11, 9))
diff --git a/tests/baselines/reference/assignmentLHSIsValue.symbols b/tests/baselines/reference/assignmentLHSIsValue.symbols
index aad2ec2ed95..1a898944903 100644
--- a/tests/baselines/reference/assignmentLHSIsValue.symbols
+++ b/tests/baselines/reference/assignmentLHSIsValue.symbols
@@ -117,22 +117,27 @@ foo() = value;
 
 // parentheses, the containted expression is value
 (this) = value;
+>(this) : Symbol(globalThis)
 >this : Symbol(globalThis)
 >value : Symbol(value, Decl(assignmentLHSIsValue.ts, 1, 3))
 
 (M) = value;
+>(M) : Symbol(M, Decl(assignmentLHSIsValue.ts, 12, 13))
 >M : Symbol(M, Decl(assignmentLHSIsValue.ts, 12, 13))
 >value : Symbol(value, Decl(assignmentLHSIsValue.ts, 1, 3))
 
 (C) = value;
+>(C) : Symbol(C, Decl(assignmentLHSIsValue.ts, 1, 15))
 >C : Symbol(C, Decl(assignmentLHSIsValue.ts, 1, 15))
 >value : Symbol(value, Decl(assignmentLHSIsValue.ts, 1, 3))
 
 (E) = value;
+>(E) : Symbol(E, Decl(assignmentLHSIsValue.ts, 18, 10))
 >E : Symbol(E, Decl(assignmentLHSIsValue.ts, 18, 10))
 >value : Symbol(value, Decl(assignmentLHSIsValue.ts, 1, 3))
 
 (foo) = value;
+>(foo) : Symbol(foo, Decl(assignmentLHSIsValue.ts, 8, 1))
 >foo : Symbol(foo, Decl(assignmentLHSIsValue.ts, 8, 1))
 >value : Symbol(value, Decl(assignmentLHSIsValue.ts, 1, 3))
 
diff --git a/tests/baselines/reference/assignmentToParenthesizedIdentifiers.symbols b/tests/baselines/reference/assignmentToParenthesizedIdentifiers.symbols
index 6330ac20b5f..fe847bc2106 100644
--- a/tests/baselines/reference/assignmentToParenthesizedIdentifiers.symbols
+++ b/tests/baselines/reference/assignmentToParenthesizedIdentifiers.symbols
@@ -6,12 +6,14 @@ x = 3; // OK
 >x : Symbol(x, Decl(assignmentToParenthesizedIdentifiers.ts, 0, 3))
 
 (x) = 3; // OK
+>(x) : Symbol(x, Decl(assignmentToParenthesizedIdentifiers.ts, 0, 3))
 >x : Symbol(x, Decl(assignmentToParenthesizedIdentifiers.ts, 0, 3))
 
 x = ''; // Error
 >x : Symbol(x, Decl(assignmentToParenthesizedIdentifiers.ts, 0, 3))
 
 (x) = ''; // Error
+>(x) : Symbol(x, Decl(assignmentToParenthesizedIdentifiers.ts, 0, 3))
 >x : Symbol(x, Decl(assignmentToParenthesizedIdentifiers.ts, 0, 3))
 
 module M {
@@ -27,10 +29,12 @@ M.y = 3; // OK
 
 (M).y = 3; // OK
 >(M).y : Symbol(M.y, Decl(assignmentToParenthesizedIdentifiers.ts, 7, 14))
+>(M) : Symbol(M, Decl(assignmentToParenthesizedIdentifiers.ts, 4, 9))
 >M : Symbol(M, Decl(assignmentToParenthesizedIdentifiers.ts, 4, 9))
 >y : Symbol(M.y, Decl(assignmentToParenthesizedIdentifiers.ts, 7, 14))
 
 (M.y) = 3; // OK
+>(M.y) : Symbol(M.y, Decl(assignmentToParenthesizedIdentifiers.ts, 7, 14))
 >M.y : Symbol(M.y, Decl(assignmentToParenthesizedIdentifiers.ts, 7, 14))
 >M : Symbol(M, Decl(assignmentToParenthesizedIdentifiers.ts, 4, 9))
 >y : Symbol(M.y, Decl(assignmentToParenthesizedIdentifiers.ts, 7, 14))
@@ -42,10 +46,12 @@ M.y = ''; // Error
 
 (M).y = ''; // Error
 >(M).y : Symbol(M.y, Decl(assignmentToParenthesizedIdentifiers.ts, 7, 14))
+>(M) : Symbol(M, Decl(assignmentToParenthesizedIdentifiers.ts, 4, 9))
 >M : Symbol(M, Decl(assignmentToParenthesizedIdentifiers.ts, 4, 9))
 >y : Symbol(M.y, Decl(assignmentToParenthesizedIdentifiers.ts, 7, 14))
 
 (M.y) = ''; // Error
+>(M.y) : Symbol(M.y, Decl(assignmentToParenthesizedIdentifiers.ts, 7, 14))
 >M.y : Symbol(M.y, Decl(assignmentToParenthesizedIdentifiers.ts, 7, 14))
 >M : Symbol(M, Decl(assignmentToParenthesizedIdentifiers.ts, 4, 9))
 >y : Symbol(M.y, Decl(assignmentToParenthesizedIdentifiers.ts, 7, 14))
@@ -55,6 +61,7 @@ M = { y: 3 }; // Error
 >y : Symbol(y, Decl(assignmentToParenthesizedIdentifiers.ts, 16, 5))
 
 (M) = { y: 3 }; // Error
+>(M) : Symbol(M, Decl(assignmentToParenthesizedIdentifiers.ts, 4, 9))
 >M : Symbol(M, Decl(assignmentToParenthesizedIdentifiers.ts, 4, 9))
 >y : Symbol(y, Decl(assignmentToParenthesizedIdentifiers.ts, 17, 7))
 
@@ -80,11 +87,13 @@ M2.M3 = { x: 3 }; // OK
 
 (M2).M3 = { x: 3 }; // OK
 >(M2).M3 : Symbol(M2.M3, Decl(assignmentToParenthesizedIdentifiers.ts, 19, 11))
+>(M2) : Symbol(M2, Decl(assignmentToParenthesizedIdentifiers.ts, 17, 15))
 >M2 : Symbol(M2, Decl(assignmentToParenthesizedIdentifiers.ts, 17, 15))
 >M3 : Symbol(M2.M3, Decl(assignmentToParenthesizedIdentifiers.ts, 19, 11))
 >x : Symbol(x, Decl(assignmentToParenthesizedIdentifiers.ts, 27, 11))
 
 (M2.M3) = { x: 3 }; // OK
+>(M2.M3) : Symbol(M2.M3, Decl(assignmentToParenthesizedIdentifiers.ts, 19, 11))
 >M2.M3 : Symbol(M2.M3, Decl(assignmentToParenthesizedIdentifiers.ts, 19, 11))
 >M2 : Symbol(M2, Decl(assignmentToParenthesizedIdentifiers.ts, 17, 15))
 >M3 : Symbol(M2.M3, Decl(assignmentToParenthesizedIdentifiers.ts, 19, 11))
@@ -98,11 +107,13 @@ M2.M3 = { x: '' }; // Error
 
 (M2).M3 = { x: '' }; // Error
 >(M2).M3 : Symbol(M2.M3, Decl(assignmentToParenthesizedIdentifiers.ts, 19, 11))
+>(M2) : Symbol(M2, Decl(assignmentToParenthesizedIdentifiers.ts, 17, 15))
 >M2 : Symbol(M2, Decl(assignmentToParenthesizedIdentifiers.ts, 17, 15))
 >M3 : Symbol(M2.M3, Decl(assignmentToParenthesizedIdentifiers.ts, 19, 11))
 >x : Symbol(x, Decl(assignmentToParenthesizedIdentifiers.ts, 31, 11))
 
 (M2.M3) = { x: '' }; // Error
+>(M2.M3) : Symbol(M2.M3, Decl(assignmentToParenthesizedIdentifiers.ts, 19, 11))
 >M2.M3 : Symbol(M2.M3, Decl(assignmentToParenthesizedIdentifiers.ts, 19, 11))
 >M2 : Symbol(M2, Decl(assignmentToParenthesizedIdentifiers.ts, 17, 15))
 >M3 : Symbol(M2.M3, Decl(assignmentToParenthesizedIdentifiers.ts, 19, 11))
@@ -116,6 +127,7 @@ fn = () => 3; // Bug 823548: Should be error (fn is not a reference)
 >fn : Symbol(fn, Decl(assignmentToParenthesizedIdentifiers.ts, 32, 20))
 
 (fn) = () => 3; // Should be error
+>(fn) : Symbol(fn, Decl(assignmentToParenthesizedIdentifiers.ts, 32, 20))
 >fn : Symbol(fn, Decl(assignmentToParenthesizedIdentifiers.ts, 32, 20))
 
 function fn2(x: number, y: { t: number }) {
@@ -128,30 +140,36 @@ function fn2(x: number, y: { t: number }) {
 >x : Symbol(x, Decl(assignmentToParenthesizedIdentifiers.ts, 39, 13))
 
     (x) = 3; // OK
+>(x) : Symbol(x, Decl(assignmentToParenthesizedIdentifiers.ts, 39, 13))
 >x : Symbol(x, Decl(assignmentToParenthesizedIdentifiers.ts, 39, 13))
 
     x = ''; // Error
 >x : Symbol(x, Decl(assignmentToParenthesizedIdentifiers.ts, 39, 13))
 
     (x) = ''; // Error
+>(x) : Symbol(x, Decl(assignmentToParenthesizedIdentifiers.ts, 39, 13))
 >x : Symbol(x, Decl(assignmentToParenthesizedIdentifiers.ts, 39, 13))
 
     (y).t = 3; // OK
 >(y).t : Symbol(t, Decl(assignmentToParenthesizedIdentifiers.ts, 39, 28))
+>(y) : Symbol(y, Decl(assignmentToParenthesizedIdentifiers.ts, 39, 23))
 >y : Symbol(y, Decl(assignmentToParenthesizedIdentifiers.ts, 39, 23))
 >t : Symbol(t, Decl(assignmentToParenthesizedIdentifiers.ts, 39, 28))
 
     (y.t) = 3; // OK
+>(y.t) : Symbol(t, Decl(assignmentToParenthesizedIdentifiers.ts, 39, 28))
 >y.t : Symbol(t, Decl(assignmentToParenthesizedIdentifiers.ts, 39, 28))
 >y : Symbol(y, Decl(assignmentToParenthesizedIdentifiers.ts, 39, 23))
 >t : Symbol(t, Decl(assignmentToParenthesizedIdentifiers.ts, 39, 28))
 
     (y).t = ''; // Error
 >(y).t : Symbol(t, Decl(assignmentToParenthesizedIdentifiers.ts, 39, 28))
+>(y) : Symbol(y, Decl(assignmentToParenthesizedIdentifiers.ts, 39, 23))
 >y : Symbol(y, Decl(assignmentToParenthesizedIdentifiers.ts, 39, 23))
 >t : Symbol(t, Decl(assignmentToParenthesizedIdentifiers.ts, 39, 28))
 
     (y.t) = ''; // Error
+>(y.t) : Symbol(t, Decl(assignmentToParenthesizedIdentifiers.ts, 39, 28))
 >y.t : Symbol(t, Decl(assignmentToParenthesizedIdentifiers.ts, 39, 28))
 >y : Symbol(y, Decl(assignmentToParenthesizedIdentifiers.ts, 39, 23))
 >t : Symbol(t, Decl(assignmentToParenthesizedIdentifiers.ts, 39, 28))
@@ -161,6 +179,7 @@ function fn2(x: number, y: { t: number }) {
 >'t' : Symbol(t, Decl(assignmentToParenthesizedIdentifiers.ts, 39, 28))
 
     (y)['t'] = 3; // OK
+>(y) : Symbol(y, Decl(assignmentToParenthesizedIdentifiers.ts, 39, 23))
 >y : Symbol(y, Decl(assignmentToParenthesizedIdentifiers.ts, 39, 23))
 >'t' : Symbol(t, Decl(assignmentToParenthesizedIdentifiers.ts, 39, 28))
 
@@ -173,6 +192,7 @@ function fn2(x: number, y: { t: number }) {
 >'t' : Symbol(t, Decl(assignmentToParenthesizedIdentifiers.ts, 39, 28))
 
     (y)['t'] = ''; // Error
+>(y) : Symbol(y, Decl(assignmentToParenthesizedIdentifiers.ts, 39, 23))
 >y : Symbol(y, Decl(assignmentToParenthesizedIdentifiers.ts, 39, 23))
 >'t' : Symbol(t, Decl(assignmentToParenthesizedIdentifiers.ts, 39, 28))
 
@@ -192,6 +212,7 @@ E = undefined; // Error
 >undefined : Symbol(undefined)
 
 (E) = undefined; // Error
+>(E) : Symbol(E, Decl(assignmentToParenthesizedIdentifiers.ts, 56, 1))
 >E : Symbol(E, Decl(assignmentToParenthesizedIdentifiers.ts, 56, 1))
 >undefined : Symbol(undefined)
 
@@ -205,6 +226,7 @@ C = undefined; // Error
 >undefined : Symbol(undefined)
 
 (C) = undefined; // Error
+>(C) : Symbol(C, Decl(assignmentToParenthesizedIdentifiers.ts, 62, 16))
 >C : Symbol(C, Decl(assignmentToParenthesizedIdentifiers.ts, 62, 16))
 >undefined : Symbol(undefined)
 
diff --git a/tests/baselines/reference/asyncAwaitNestedClasses_es5.symbols b/tests/baselines/reference/asyncAwaitNestedClasses_es5.symbols
index 59259fb5713..198520aaf84 100644
--- a/tests/baselines/reference/asyncAwaitNestedClasses_es5.symbols
+++ b/tests/baselines/reference/asyncAwaitNestedClasses_es5.symbols
@@ -5,6 +5,7 @@ class A {
 
     static B = class B {
 >B : Symbol(A.B, Decl(asyncAwaitNestedClasses_es5.ts, 1, 9))
+>class B {        static func2(): Promise<void> {            return new Promise((resolve) => { resolve(null); });        }        static C = class C {            static async func() {                await B.func2();            }        }    } : Symbol(B, Decl(asyncAwaitNestedClasses_es5.ts, 2, 14))
 >B : Symbol(B, Decl(asyncAwaitNestedClasses_es5.ts, 2, 14))
 
         static func2(): Promise<void> {
@@ -18,6 +19,7 @@ class A {
         }
         static C = class C {
 >C : Symbol(B.C, Decl(asyncAwaitNestedClasses_es5.ts, 5, 9))
+>class C {            static async func() {                await B.func2();            }        } : Symbol(C, Decl(asyncAwaitNestedClasses_es5.ts, 6, 18))
 >C : Symbol(C, Decl(asyncAwaitNestedClasses_es5.ts, 6, 18))
 
             static async func() {
diff --git a/tests/baselines/reference/awaitInClassInAsyncFunction.symbols b/tests/baselines/reference/awaitInClassInAsyncFunction.symbols
index 31fc7b10916..b2aee784df1 100644
--- a/tests/baselines/reference/awaitInClassInAsyncFunction.symbols
+++ b/tests/baselines/reference/awaitInClassInAsyncFunction.symbols
@@ -11,6 +11,8 @@ async function foo() {
 >foo : Symbol(foo, Decl(awaitInClassInAsyncFunction.ts, 4, 1))
 
     return new class {
+>class {        baz = await bar();    } : Symbol((Anonymous class), Decl(awaitInClassInAsyncFunction.ts, 7, 14))
+
         baz = await bar();
 >baz : Symbol((Anonymous class).baz, Decl(awaitInClassInAsyncFunction.ts, 7, 22))
 >bar : Symbol(bar, Decl(awaitInClassInAsyncFunction.ts, 0, 0))
diff --git a/tests/baselines/reference/baseConstraintOfDecorator.symbols b/tests/baselines/reference/baseConstraintOfDecorator.symbols
index 0a1dad239af..f0d1daaa6a4 100644
--- a/tests/baselines/reference/baseConstraintOfDecorator.symbols
+++ b/tests/baselines/reference/baseConstraintOfDecorator.symbols
@@ -10,6 +10,7 @@ export function classExtender<TFunction>(superClass: TFunction, _instanceModifie
 >TFunction : Symbol(TFunction, Decl(baseConstraintOfDecorator.ts, 0, 30))
 
     return class decoratorFunc extends superClass {
+>class decoratorFunc extends superClass {        constructor(...args: any[]) {            super(...args);            _instanceModifier(this, args);        }    } : Symbol(decoratorFunc, Decl(baseConstraintOfDecorator.ts, 1, 10))
 >decoratorFunc : Symbol(decoratorFunc, Decl(baseConstraintOfDecorator.ts, 1, 10))
 >superClass : Symbol(superClass, Decl(baseConstraintOfDecorator.ts, 0, 41))
 
@@ -44,6 +45,7 @@ export function classExtender2<TFunction extends new (...args: string[]) => MyCl
 >TFunction : Symbol(TFunction, Decl(baseConstraintOfDecorator.ts, 10, 31))
 
     return class decoratorFunc extends superClass {
+>class decoratorFunc extends superClass {        constructor(...args: any[]) {            super(...args);            _instanceModifier(this, args);        }    } : Symbol(decoratorFunc, Decl(baseConstraintOfDecorator.ts, 11, 10))
 >decoratorFunc : Symbol(decoratorFunc, Decl(baseConstraintOfDecorator.ts, 11, 10))
 >superClass : Symbol(superClass, Decl(baseConstraintOfDecorator.ts, 10, 85))
 
diff --git a/tests/baselines/reference/blockScopedVariablesUseBeforeDef.symbols b/tests/baselines/reference/blockScopedVariablesUseBeforeDef.symbols
index ea588cd22fa..3f7f2f0a5b9 100644
--- a/tests/baselines/reference/blockScopedVariablesUseBeforeDef.symbols
+++ b/tests/baselines/reference/blockScopedVariablesUseBeforeDef.symbols
@@ -51,6 +51,7 @@ function foo4() {
 
     let y = class {
 >y : Symbol(y, Decl(blockScopedVariablesUseBeforeDef.ts, 23, 7))
+>class {        m() { return x; }    } : Symbol(y, Decl(blockScopedVariablesUseBeforeDef.ts, 23, 11))
 
         m() { return x; }
 >m : Symbol(y.m, Decl(blockScopedVariablesUseBeforeDef.ts, 23, 19))
@@ -105,6 +106,7 @@ function foo8() {
 
     let y = class {
 >y : Symbol(y, Decl(blockScopedVariablesUseBeforeDef.ts, 49, 7))
+>class {        a = x;    } : Symbol(y, Decl(blockScopedVariablesUseBeforeDef.ts, 49, 11))
 
         a = x;
 >a : Symbol(y.a, Decl(blockScopedVariablesUseBeforeDef.ts, 49, 19))
@@ -119,6 +121,7 @@ function foo9() {
 
     let y = class {
 >y : Symbol(y, Decl(blockScopedVariablesUseBeforeDef.ts, 56, 7))
+>class {        static a = x;    } : Symbol(y, Decl(blockScopedVariablesUseBeforeDef.ts, 56, 11))
 
         static a = x;
 >a : Symbol(y.a, Decl(blockScopedVariablesUseBeforeDef.ts, 56, 19))
@@ -150,6 +153,7 @@ function foo11() {
 
         let y = class {
 >y : Symbol(y, Decl(blockScopedVariablesUseBeforeDef.ts, 71, 11))
+>class {            static a = x;        } : Symbol(y, Decl(blockScopedVariablesUseBeforeDef.ts, 71, 15))
 
             static a = x;
 >a : Symbol(y.a, Decl(blockScopedVariablesUseBeforeDef.ts, 71, 23))
@@ -168,6 +172,7 @@ function foo12() {
 
         let y = class {
 >y : Symbol(y, Decl(blockScopedVariablesUseBeforeDef.ts, 80, 11))
+>class {            a;            constructor() {                this.a = x;            }        } : Symbol(y, Decl(blockScopedVariablesUseBeforeDef.ts, 80, 15))
 
             a;
 >a : Symbol(y.a, Decl(blockScopedVariablesUseBeforeDef.ts, 80, 23))
diff --git a/tests/baselines/reference/callWithSpread.symbols b/tests/baselines/reference/callWithSpread.symbols
index 7b711cce14a..5768ed20b6f 100644
--- a/tests/baselines/reference/callWithSpread.symbols
+++ b/tests/baselines/reference/callWithSpread.symbols
@@ -86,24 +86,29 @@ obj.foo(1, 2, ...a).foo(1, 2, ...a, "abc");
 >a : Symbol(a, Decl(callWithSpread.ts, 7, 3))
 
 (obj.foo)(1, 2, "abc");
+>(obj.foo) : Symbol(X.foo, Decl(callWithSpread.ts, 0, 13))
 >obj.foo : Symbol(X.foo, Decl(callWithSpread.ts, 0, 13))
 >obj : Symbol(obj, Decl(callWithSpread.ts, 9, 3))
 >foo : Symbol(X.foo, Decl(callWithSpread.ts, 0, 13))
 
 (obj.foo)(1, 2, ...a);
+>(obj.foo) : Symbol(X.foo, Decl(callWithSpread.ts, 0, 13))
 >obj.foo : Symbol(X.foo, Decl(callWithSpread.ts, 0, 13))
 >obj : Symbol(obj, Decl(callWithSpread.ts, 9, 3))
 >foo : Symbol(X.foo, Decl(callWithSpread.ts, 0, 13))
 >a : Symbol(a, Decl(callWithSpread.ts, 7, 3))
 
 (obj.foo)(1, 2, ...a, "abc");
+>(obj.foo) : Symbol(X.foo, Decl(callWithSpread.ts, 0, 13))
 >obj.foo : Symbol(X.foo, Decl(callWithSpread.ts, 0, 13))
 >obj : Symbol(obj, Decl(callWithSpread.ts, 9, 3))
 >foo : Symbol(X.foo, Decl(callWithSpread.ts, 0, 13))
 >a : Symbol(a, Decl(callWithSpread.ts, 7, 3))
 
 ((obj.foo)(1, 2, ...a).foo)(1, 2, "abc");
+>((obj.foo)(1, 2, ...a).foo) : Symbol(X.foo, Decl(callWithSpread.ts, 0, 13))
 >(obj.foo)(1, 2, ...a).foo : Symbol(X.foo, Decl(callWithSpread.ts, 0, 13))
+>(obj.foo) : Symbol(X.foo, Decl(callWithSpread.ts, 0, 13))
 >obj.foo : Symbol(X.foo, Decl(callWithSpread.ts, 0, 13))
 >obj : Symbol(obj, Decl(callWithSpread.ts, 9, 3))
 >foo : Symbol(X.foo, Decl(callWithSpread.ts, 0, 13))
@@ -111,7 +116,9 @@ obj.foo(1, 2, ...a).foo(1, 2, ...a, "abc");
 >foo : Symbol(X.foo, Decl(callWithSpread.ts, 0, 13))
 
 ((obj.foo)(1, 2, ...a).foo)(1, 2, ...a);
+>((obj.foo)(1, 2, ...a).foo) : Symbol(X.foo, Decl(callWithSpread.ts, 0, 13))
 >(obj.foo)(1, 2, ...a).foo : Symbol(X.foo, Decl(callWithSpread.ts, 0, 13))
+>(obj.foo) : Symbol(X.foo, Decl(callWithSpread.ts, 0, 13))
 >obj.foo : Symbol(X.foo, Decl(callWithSpread.ts, 0, 13))
 >obj : Symbol(obj, Decl(callWithSpread.ts, 9, 3))
 >foo : Symbol(X.foo, Decl(callWithSpread.ts, 0, 13))
@@ -120,7 +127,9 @@ obj.foo(1, 2, ...a).foo(1, 2, ...a, "abc");
 >a : Symbol(a, Decl(callWithSpread.ts, 7, 3))
 
 ((obj.foo)(1, 2, ...a).foo)(1, 2, ...a, "abc");
+>((obj.foo)(1, 2, ...a).foo) : Symbol(X.foo, Decl(callWithSpread.ts, 0, 13))
 >(obj.foo)(1, 2, ...a).foo : Symbol(X.foo, Decl(callWithSpread.ts, 0, 13))
+>(obj.foo) : Symbol(X.foo, Decl(callWithSpread.ts, 0, 13))
 >obj.foo : Symbol(X.foo, Decl(callWithSpread.ts, 0, 13))
 >obj : Symbol(obj, Decl(callWithSpread.ts, 9, 3))
 >foo : Symbol(X.foo, Decl(callWithSpread.ts, 0, 13))
diff --git a/tests/baselines/reference/callWithSpreadES6.symbols b/tests/baselines/reference/callWithSpreadES6.symbols
index 9da935b0e51..80b097a7835 100644
--- a/tests/baselines/reference/callWithSpreadES6.symbols
+++ b/tests/baselines/reference/callWithSpreadES6.symbols
@@ -59,17 +59,20 @@ obj.foo(1, 2, ...a, "abc");
 >a : Symbol(a, Decl(callWithSpreadES6.ts, 7, 3))
 
 (obj.foo)(1, 2, "abc");
+>(obj.foo) : Symbol(X.foo, Decl(callWithSpreadES6.ts, 0, 13))
 >obj.foo : Symbol(X.foo, Decl(callWithSpreadES6.ts, 0, 13))
 >obj : Symbol(obj, Decl(callWithSpreadES6.ts, 9, 3))
 >foo : Symbol(X.foo, Decl(callWithSpreadES6.ts, 0, 13))
 
 (obj.foo)(1, 2, ...a);
+>(obj.foo) : Symbol(X.foo, Decl(callWithSpreadES6.ts, 0, 13))
 >obj.foo : Symbol(X.foo, Decl(callWithSpreadES6.ts, 0, 13))
 >obj : Symbol(obj, Decl(callWithSpreadES6.ts, 9, 3))
 >foo : Symbol(X.foo, Decl(callWithSpreadES6.ts, 0, 13))
 >a : Symbol(a, Decl(callWithSpreadES6.ts, 7, 3))
 
 (obj.foo)(1, 2, ...a, "abc");
+>(obj.foo) : Symbol(X.foo, Decl(callWithSpreadES6.ts, 0, 13))
 >obj.foo : Symbol(X.foo, Decl(callWithSpreadES6.ts, 0, 13))
 >obj : Symbol(obj, Decl(callWithSpreadES6.ts, 9, 3))
 >foo : Symbol(X.foo, Decl(callWithSpreadES6.ts, 0, 13))
diff --git a/tests/baselines/reference/capturedParametersInInitializers1.symbols b/tests/baselines/reference/capturedParametersInInitializers1.symbols
index d9ab1ef6cc2..390863663c1 100644
--- a/tests/baselines/reference/capturedParametersInInitializers1.symbols
+++ b/tests/baselines/reference/capturedParametersInInitializers1.symbols
@@ -3,6 +3,7 @@
 function foo1(y = class {c = x}, x = 1) {
 >foo1 : Symbol(foo1, Decl(capturedParametersInInitializers1.ts, 0, 0))
 >y : Symbol(y, Decl(capturedParametersInInitializers1.ts, 1, 14))
+>class {c = x} : Symbol((Anonymous class), Decl(capturedParametersInInitializers1.ts, 1, 17))
 >c : Symbol((Anonymous class).c, Decl(capturedParametersInInitializers1.ts, 1, 25))
 >x : Symbol(x, Decl(capturedParametersInInitializers1.ts, 1, 32))
 >x : Symbol(x, Decl(capturedParametersInInitializers1.ts, 1, 32))
diff --git a/tests/baselines/reference/capturedParametersInInitializers2.symbols b/tests/baselines/reference/capturedParametersInInitializers2.symbols
index e3cf3a07dff..61535fdf05d 100644
--- a/tests/baselines/reference/capturedParametersInInitializers2.symbols
+++ b/tests/baselines/reference/capturedParametersInInitializers2.symbols
@@ -4,6 +4,7 @@ function foo(
 
     y = class {
 >y : Symbol(y, Decl(capturedParametersInInitializers2.ts, 0, 13))
+>class {        static c = x;        get [x]() {return x;}        constructor() { x; }        [z]() { return z; }    } : Symbol((Anonymous class), Decl(capturedParametersInInitializers2.ts, 1, 7))
 
         static c = x;
 >c : Symbol((Anonymous class).c, Decl(capturedParametersInInitializers2.ts, 1, 15))
@@ -38,6 +39,7 @@ function foo(
 function foo2(y = class {[x] = x}, x = 1) {
 >foo2 : Symbol(foo2, Decl(capturedParametersInInitializers2.ts, 11, 1))
 >y : Symbol(y, Decl(capturedParametersInInitializers2.ts, 12, 14))
+>class {[x] = x} : Symbol((Anonymous class), Decl(capturedParametersInInitializers2.ts, 12, 17))
 >[x] : Symbol((Anonymous class)[x], Decl(capturedParametersInInitializers2.ts, 12, 25))
 >x : Symbol(x, Decl(capturedParametersInInitializers2.ts, 12, 34))
 >x : Symbol(x, Decl(capturedParametersInInitializers2.ts, 12, 34))
diff --git a/tests/baselines/reference/castExpressionParentheses.symbols b/tests/baselines/reference/castExpressionParentheses.symbols
index ebc326e0a85..f372e70bd6e 100644
--- a/tests/baselines/reference/castExpressionParentheses.symbols
+++ b/tests/baselines/reference/castExpressionParentheses.symbols
@@ -79,6 +79,7 @@ new (<any>A());
 
 // nested parenthesized expression, should keep one pair of parenthese
 (<any>(A)) 
+>(A) : Symbol(A, Decl(castExpressionParentheses.ts, 31, 11))
 >A : Symbol(A, Decl(castExpressionParentheses.ts, 31, 11))
 
 
diff --git a/tests/baselines/reference/checkSpecialPropertyAssignments.symbols b/tests/baselines/reference/checkSpecialPropertyAssignments.symbols
index 8de3cd208c3..f4e785033db 100644
--- a/tests/baselines/reference/checkSpecialPropertyAssignments.symbols
+++ b/tests/baselines/reference/checkSpecialPropertyAssignments.symbols
@@ -6,6 +6,7 @@ A.B = class {
 >A.B : Symbol(A.B, Decl(bug24252.js, 0, 11))
 >A : Symbol(A, Decl(bug24252.js, 0, 3), Decl(bug24252.js, 0, 11))
 >B : Symbol(A.B, Decl(bug24252.js, 0, 11))
+>class {    m() {        /** @type {string[]} */        var x = [];        /** @type {number[]} */        var y;        y = x;    }} : Symbol(B, Decl(bug24252.js, 1, 5))
 
     m() {
 >m : Symbol(B.m, Decl(bug24252.js, 1, 13))
diff --git a/tests/baselines/reference/classBlockScoping.symbols b/tests/baselines/reference/classBlockScoping.symbols
index 571d54f2d8e..4d2cf798435 100644
--- a/tests/baselines/reference/classBlockScoping.symbols
+++ b/tests/baselines/reference/classBlockScoping.symbols
@@ -11,6 +11,7 @@ function f(b: boolean) {
 
     Foo = class Foo {
 >Foo : Symbol(Foo, Decl(classBlockScoping.ts, 1, 5))
+>class Foo {      static y = new Foo();      static x() {        new Foo();      }      m() {        new Foo();      }    } : Symbol(Foo, Decl(classBlockScoping.ts, 3, 9))
 >Foo : Symbol(Foo, Decl(classBlockScoping.ts, 3, 9))
 
       static y = new Foo();
diff --git a/tests/baselines/reference/classDeclaredBeforeClassFactory.symbols b/tests/baselines/reference/classDeclaredBeforeClassFactory.symbols
index cf23402c3b4..7f39b9d7d52 100644
--- a/tests/baselines/reference/classDeclaredBeforeClassFactory.symbols
+++ b/tests/baselines/reference/classDeclaredBeforeClassFactory.symbols
@@ -8,6 +8,7 @@ function makeBaseClass() {
 >makeBaseClass : Symbol(makeBaseClass, Decl(classDeclaredBeforeClassFactory.ts, 1, 40))
 
     return class Base {};
+>class Base {} : Symbol(Base, Decl(classDeclaredBeforeClassFactory.ts, 4, 10))
 >Base : Symbol(Base, Decl(classDeclaredBeforeClassFactory.ts, 4, 10))
 }
 
diff --git a/tests/baselines/reference/classExpression.symbols b/tests/baselines/reference/classExpression.symbols
index f4d44236499..833b46aeaad 100644
--- a/tests/baselines/reference/classExpression.symbols
+++ b/tests/baselines/reference/classExpression.symbols
@@ -1,6 +1,7 @@
 === tests/cases/conformance/classes/classExpression.ts ===
 var x = class C {
 >x : Symbol(x, Decl(classExpression.ts, 0, 3))
+>class C {} : Symbol(C, Decl(classExpression.ts, 0, 7))
 >C : Symbol(C, Decl(classExpression.ts, 0, 7))
 }
 
@@ -9,6 +10,7 @@ var y = {
 
     foo: class C2 {
 >foo : Symbol(foo, Decl(classExpression.ts, 3, 9))
+>class C2 {    } : Symbol(C2, Decl(classExpression.ts, 4, 8))
 >C2 : Symbol(C2, Decl(classExpression.ts, 4, 8))
     }
 }
@@ -18,6 +20,7 @@ module M {
 
     var z = class C4 {
 >z : Symbol(z, Decl(classExpression.ts, 9, 7))
+>class C4 {    } : Symbol(C4, Decl(classExpression.ts, 9, 11))
 >C4 : Symbol(C4, Decl(classExpression.ts, 9, 11))
     }
 }
diff --git a/tests/baselines/reference/classExpression1.symbols b/tests/baselines/reference/classExpression1.symbols
index 8d3bad269b4..719ee3971f4 100644
--- a/tests/baselines/reference/classExpression1.symbols
+++ b/tests/baselines/reference/classExpression1.symbols
@@ -1,5 +1,6 @@
 === tests/cases/conformance/classes/classExpressions/classExpression1.ts ===
 var v = class C {};
 >v : Symbol(v, Decl(classExpression1.ts, 0, 3))
+>class C {} : Symbol(C, Decl(classExpression1.ts, 0, 7))
 >C : Symbol(C, Decl(classExpression1.ts, 0, 7))
 
diff --git a/tests/baselines/reference/classExpression2.symbols b/tests/baselines/reference/classExpression2.symbols
index 11c78a2cad2..a82fb2eef3a 100644
--- a/tests/baselines/reference/classExpression2.symbols
+++ b/tests/baselines/reference/classExpression2.symbols
@@ -4,6 +4,7 @@ class D { }
 
 var v = class C extends D {};
 >v : Symbol(v, Decl(classExpression2.ts, 1, 3))
+>class C extends D {} : Symbol(C, Decl(classExpression2.ts, 1, 7))
 >C : Symbol(C, Decl(classExpression2.ts, 1, 7))
 >D : Symbol(D, Decl(classExpression2.ts, 0, 0))
 
diff --git a/tests/baselines/reference/classExpression3.symbols b/tests/baselines/reference/classExpression3.symbols
index fbd5f7b5331..75f3e30b9f3 100644
--- a/tests/baselines/reference/classExpression3.symbols
+++ b/tests/baselines/reference/classExpression3.symbols
@@ -1,6 +1,9 @@
 === tests/cases/conformance/classes/classExpressions/classExpression3.ts ===
 let C = class extends class extends class { a = 1 } { b = 2 } { c = 3 };
 >C : Symbol(C, Decl(classExpression3.ts, 0, 3))
+>class extends class extends class { a = 1 } { b = 2 } { c = 3 } : Symbol(C, Decl(classExpression3.ts, 0, 7))
+>class extends class { a = 1 } { b = 2 } : Symbol((Anonymous class), Decl(classExpression3.ts, 0, 21))
+>class { a = 1 } : Symbol((Anonymous class), Decl(classExpression3.ts, 0, 35))
 >a : Symbol((Anonymous class).a, Decl(classExpression3.ts, 0, 43))
 >b : Symbol((Anonymous class).b, Decl(classExpression3.ts, 0, 53))
 >c : Symbol(C.c, Decl(classExpression3.ts, 0, 63))
diff --git a/tests/baselines/reference/classExpression4.symbols b/tests/baselines/reference/classExpression4.symbols
index 47a03bc4c96..4e00d995bb0 100644
--- a/tests/baselines/reference/classExpression4.symbols
+++ b/tests/baselines/reference/classExpression4.symbols
@@ -1,6 +1,7 @@
 === tests/cases/conformance/classes/classExpressions/classExpression4.ts ===
 let C = class {
 >C : Symbol(C, Decl(classExpression4.ts, 0, 3))
+>class {    foo() {        return new C();    }} : Symbol(C, Decl(classExpression4.ts, 0, 7))
 
     foo() {
 >foo : Symbol(C.foo, Decl(classExpression4.ts, 0, 15))
diff --git a/tests/baselines/reference/classExpression5.symbols b/tests/baselines/reference/classExpression5.symbols
index 17899f51ea4..dc1ded78e68 100644
--- a/tests/baselines/reference/classExpression5.symbols
+++ b/tests/baselines/reference/classExpression5.symbols
@@ -1,6 +1,7 @@
 === tests/cases/conformance/classes/classExpressions/classExpression5.ts ===
 new class {
 >new class {    hi() {        return "Hi!";    }}().hi : Symbol((Anonymous class).hi, Decl(classExpression5.ts, 0, 11))
+>class {    hi() {        return "Hi!";    }} : Symbol((Anonymous class), Decl(classExpression5.ts, 0, 3))
 
     hi() {
 >hi : Symbol((Anonymous class).hi, Decl(classExpression5.ts, 0, 11))
diff --git a/tests/baselines/reference/classExpressionAssignment.symbols b/tests/baselines/reference/classExpressionAssignment.symbols
index a1d8abd41cf..c53e6eea6f5 100644
--- a/tests/baselines/reference/classExpressionAssignment.symbols
+++ b/tests/baselines/reference/classExpressionAssignment.symbols
@@ -10,4 +10,5 @@ interface A {
 const A: {new(): A} = class {}
 >A : Symbol(A, Decl(classExpressionAssignment.ts, 0, 0), Decl(classExpressionAssignment.ts, 5, 5))
 >A : Symbol(A, Decl(classExpressionAssignment.ts, 0, 0), Decl(classExpressionAssignment.ts, 5, 5))
+>class {} : Symbol(A, Decl(classExpressionAssignment.ts, 5, 21))
 
diff --git a/tests/baselines/reference/classExpressionES61.symbols b/tests/baselines/reference/classExpressionES61.symbols
index 1f49229fbc7..7a8cf95402b 100644
--- a/tests/baselines/reference/classExpressionES61.symbols
+++ b/tests/baselines/reference/classExpressionES61.symbols
@@ -1,5 +1,6 @@
 === tests/cases/conformance/es6/classExpressions/classExpressionES61.ts ===
 var v = class C {};
 >v : Symbol(v, Decl(classExpressionES61.ts, 0, 3))
+>class C {} : Symbol(C, Decl(classExpressionES61.ts, 0, 7))
 >C : Symbol(C, Decl(classExpressionES61.ts, 0, 7))
 
diff --git a/tests/baselines/reference/classExpressionES62.symbols b/tests/baselines/reference/classExpressionES62.symbols
index 18e1a48ca30..aa612d33e0b 100644
--- a/tests/baselines/reference/classExpressionES62.symbols
+++ b/tests/baselines/reference/classExpressionES62.symbols
@@ -4,6 +4,7 @@ class D { }
 
 var v = class C extends D {};
 >v : Symbol(v, Decl(classExpressionES62.ts, 1, 3))
+>class C extends D {} : Symbol(C, Decl(classExpressionES62.ts, 1, 7))
 >C : Symbol(C, Decl(classExpressionES62.ts, 1, 7))
 >D : Symbol(D, Decl(classExpressionES62.ts, 0, 0))
 
diff --git a/tests/baselines/reference/classExpressionES63.symbols b/tests/baselines/reference/classExpressionES63.symbols
index f74b2893f73..ef2aac589b5 100644
--- a/tests/baselines/reference/classExpressionES63.symbols
+++ b/tests/baselines/reference/classExpressionES63.symbols
@@ -1,6 +1,9 @@
 === tests/cases/conformance/es6/classExpressions/classExpressionES63.ts ===
 let C = class extends class extends class { a = 1 } { b = 2 } { c = 3 };
 >C : Symbol(C, Decl(classExpressionES63.ts, 0, 3))
+>class extends class extends class { a = 1 } { b = 2 } { c = 3 } : Symbol(C, Decl(classExpressionES63.ts, 0, 7))
+>class extends class { a = 1 } { b = 2 } : Symbol((Anonymous class), Decl(classExpressionES63.ts, 0, 21))
+>class { a = 1 } : Symbol((Anonymous class), Decl(classExpressionES63.ts, 0, 35))
 >a : Symbol((Anonymous class).a, Decl(classExpressionES63.ts, 0, 43))
 >b : Symbol((Anonymous class).b, Decl(classExpressionES63.ts, 0, 53))
 >c : Symbol(C.c, Decl(classExpressionES63.ts, 0, 63))
diff --git a/tests/baselines/reference/classExpressionExtendingAbstractClass.symbols b/tests/baselines/reference/classExpressionExtendingAbstractClass.symbols
index 9250e755ee0..37b2e57a7a2 100644
--- a/tests/baselines/reference/classExpressionExtendingAbstractClass.symbols
+++ b/tests/baselines/reference/classExpressionExtendingAbstractClass.symbols
@@ -8,6 +8,7 @@ abstract class A {
 
 var C = class extends A {     // no error reported!
 >C : Symbol(C, Decl(classExpressionExtendingAbstractClass.ts, 4, 3))
+>class extends A {     // no error reported!} : Symbol(C, Decl(classExpressionExtendingAbstractClass.ts, 4, 7))
 >A : Symbol(A, Decl(classExpressionExtendingAbstractClass.ts, 0, 0))
 
 };
diff --git a/tests/baselines/reference/classExpressionInClassStaticDeclarations.symbols b/tests/baselines/reference/classExpressionInClassStaticDeclarations.symbols
index 99ca22158d6..9da004862a0 100644
--- a/tests/baselines/reference/classExpressionInClassStaticDeclarations.symbols
+++ b/tests/baselines/reference/classExpressionInClassStaticDeclarations.symbols
@@ -4,5 +4,6 @@ class C {
 
     static D = class extends C {};
 >D : Symbol(C.D, Decl(classExpressionInClassStaticDeclarations.ts, 0, 9))
+>class extends C {} : Symbol((Anonymous class), Decl(classExpressionInClassStaticDeclarations.ts, 1, 14))
 >C : Symbol(C, Decl(classExpressionInClassStaticDeclarations.ts, 0, 0))
 }
diff --git a/tests/baselines/reference/classExpressionLoop.symbols b/tests/baselines/reference/classExpressionLoop.symbols
index bd438712eb6..a925205ebb1 100644
--- a/tests/baselines/reference/classExpressionLoop.symbols
+++ b/tests/baselines/reference/classExpressionLoop.symbols
@@ -11,6 +11,7 @@ for (let i = 0; i < 10; ++i) {
 >arr.push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --))
 >arr : Symbol(arr, Decl(classExpressionLoop.ts, 0, 3))
 >push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --))
+>class C {        prop = i;    } : Symbol(C, Decl(classExpressionLoop.ts, 2, 13))
 >C : Symbol(C, Decl(classExpressionLoop.ts, 2, 13))
 
         prop = i;
diff --git a/tests/baselines/reference/classExpressionNames.symbols b/tests/baselines/reference/classExpressionNames.symbols
index 79674257be5..aefc36cab89 100644
--- a/tests/baselines/reference/classExpressionNames.symbols
+++ b/tests/baselines/reference/classExpressionNames.symbols
@@ -4,6 +4,7 @@ var o = {
 
     C: class {
 >C : Symbol(C, Decl(ts.ts, 0, 9))
+>class {    } : Symbol(C, Decl(ts.ts, 1, 6))
     }
 }
 var oc = new o.C()
@@ -14,6 +15,7 @@ var oc = new o.C()
 
 var V = class {
 >V : Symbol(V, Decl(ts.ts, 6, 3))
+>class {} : Symbol(V, Decl(ts.ts, 6, 7))
 }
 var v = new V()
 >v : Symbol(v, Decl(ts.ts, 8, 3))
@@ -24,6 +26,7 @@ var A;
 
 A = class {
 >A : Symbol(A, Decl(ts.ts, 10, 3))
+>class {} : Symbol(A, Decl(ts.ts, 11, 3))
 }
 var a = new A()
 >a : Symbol(a, Decl(ts.ts, 13, 3))
@@ -32,6 +35,7 @@ var a = new A()
 const {
     B = class { }
 >B : Symbol(B, Decl(ts.ts, 15, 7))
+>class { } : Symbol(B, Decl(ts.ts, 16, 7))
 
 } = ({ B: undefined });
 >B : Symbol(B, Decl(ts.ts, 17, 6))
diff --git a/tests/baselines/reference/classExpressionTest2.symbols b/tests/baselines/reference/classExpressionTest2.symbols
index 62143cf0b9f..7dfd81b167a 100644
--- a/tests/baselines/reference/classExpressionTest2.symbols
+++ b/tests/baselines/reference/classExpressionTest2.symbols
@@ -4,6 +4,7 @@ function M() {
 
     var m = class C<X> {
 >m : Symbol(m, Decl(classExpressionTest2.ts, 1, 7))
+>class C<X> {        f<T>() {            var t: T;            var x: X;            return { t, x };        }    } : Symbol(C, Decl(classExpressionTest2.ts, 1, 11))
 >C : Symbol(C, Decl(classExpressionTest2.ts, 1, 11))
 >X : Symbol(X, Decl(classExpressionTest2.ts, 1, 20))
 
diff --git a/tests/baselines/reference/classExpressionWithResolutionOfNamespaceOfSameName01.symbols b/tests/baselines/reference/classExpressionWithResolutionOfNamespaceOfSameName01.symbols
index fcd4f0388db..0db0c1df64d 100644
--- a/tests/baselines/reference/classExpressionWithResolutionOfNamespaceOfSameName01.symbols
+++ b/tests/baselines/reference/classExpressionWithResolutionOfNamespaceOfSameName01.symbols
@@ -9,6 +9,7 @@ namespace C {
 
 var x = class C {
 >x : Symbol(x, Decl(classExpressionWithResolutionOfNamespaceOfSameName01.ts, 5, 3))
+>class C {    prop: C.type;} : Symbol(C, Decl(classExpressionWithResolutionOfNamespaceOfSameName01.ts, 5, 7))
 >C : Symbol(C, Decl(classExpressionWithResolutionOfNamespaceOfSameName01.ts, 5, 7))
 
     prop: C.type;
diff --git a/tests/baselines/reference/classExpressionWithStaticProperties1.symbols b/tests/baselines/reference/classExpressionWithStaticProperties1.symbols
index f8b3c270ea9..b6fd92366bd 100644
--- a/tests/baselines/reference/classExpressionWithStaticProperties1.symbols
+++ b/tests/baselines/reference/classExpressionWithStaticProperties1.symbols
@@ -1,6 +1,7 @@
 === tests/cases/compiler/classExpressionWithStaticProperties1.ts ===
 var v = class C {
 >v : Symbol(v, Decl(classExpressionWithStaticProperties1.ts, 0, 3))
+>class C {    static a = 1;    static b = 2;    static c = C.a + C.b;} : Symbol(C, Decl(classExpressionWithStaticProperties1.ts, 0, 7))
 >C : Symbol(C, Decl(classExpressionWithStaticProperties1.ts, 0, 7))
 
     static a = 1;
diff --git a/tests/baselines/reference/classExpressionWithStaticProperties2.symbols b/tests/baselines/reference/classExpressionWithStaticProperties2.symbols
index 981e1e258c7..b18dea3448b 100644
--- a/tests/baselines/reference/classExpressionWithStaticProperties2.symbols
+++ b/tests/baselines/reference/classExpressionWithStaticProperties2.symbols
@@ -1,6 +1,7 @@
 === tests/cases/compiler/classExpressionWithStaticProperties2.ts ===
 var v = class C {
 >v : Symbol(v, Decl(classExpressionWithStaticProperties2.ts, 0, 3))
+>class C {    static a = 1;    static b    static c = {        x: "hi"    }    static d = C.c.x + " world"; } : Symbol(C, Decl(classExpressionWithStaticProperties2.ts, 0, 7))
 >C : Symbol(C, Decl(classExpressionWithStaticProperties2.ts, 0, 7))
 
     static a = 1;
diff --git a/tests/baselines/reference/classExpressionWithStaticProperties3.symbols b/tests/baselines/reference/classExpressionWithStaticProperties3.symbols
index 1ce28c7aab8..de495eb366f 100644
--- a/tests/baselines/reference/classExpressionWithStaticProperties3.symbols
+++ b/tests/baselines/reference/classExpressionWithStaticProperties3.symbols
@@ -15,6 +15,7 @@ for (let i = 0; i < 3; i++) {
 >arr.push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --))
 >arr : Symbol(arr, Decl(classExpressionWithStaticProperties3.ts, 1, 5))
 >push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --))
+>class C {        static x = i;        static y = () => C.x * 2;    } : Symbol(C, Decl(classExpressionWithStaticProperties3.ts, 3, 13))
 >C : Symbol(C, Decl(classExpressionWithStaticProperties3.ts, 3, 13))
 
         static x = i;
diff --git a/tests/baselines/reference/classExpressionWithStaticPropertiesES61.symbols b/tests/baselines/reference/classExpressionWithStaticPropertiesES61.symbols
index 1101c0bab2f..3e09aa7a45d 100644
--- a/tests/baselines/reference/classExpressionWithStaticPropertiesES61.symbols
+++ b/tests/baselines/reference/classExpressionWithStaticPropertiesES61.symbols
@@ -1,6 +1,7 @@
 === tests/cases/compiler/classExpressionWithStaticPropertiesES61.ts ===
 var v = class C { 
 >v : Symbol(v, Decl(classExpressionWithStaticPropertiesES61.ts, 0, 3))
+>class C {     static a = 1;    static b = 2;    static c = C.a + 3;} : Symbol(C, Decl(classExpressionWithStaticPropertiesES61.ts, 0, 7))
 >C : Symbol(C, Decl(classExpressionWithStaticPropertiesES61.ts, 0, 7))
 
     static a = 1;
diff --git a/tests/baselines/reference/classExpressionWithStaticPropertiesES62.symbols b/tests/baselines/reference/classExpressionWithStaticPropertiesES62.symbols
index 697be499595..65786b093ac 100644
--- a/tests/baselines/reference/classExpressionWithStaticPropertiesES62.symbols
+++ b/tests/baselines/reference/classExpressionWithStaticPropertiesES62.symbols
@@ -1,6 +1,7 @@
 === tests/cases/compiler/classExpressionWithStaticPropertiesES62.ts ===
 var v = class C {
 >v : Symbol(v, Decl(classExpressionWithStaticPropertiesES62.ts, 0, 3))
+>class C {    static a = 1;    static b    static c = {        x: "hi"    }    static d = C.c.x + " world"; } : Symbol(C, Decl(classExpressionWithStaticPropertiesES62.ts, 0, 7))
 >C : Symbol(C, Decl(classExpressionWithStaticPropertiesES62.ts, 0, 7))
 
     static a = 1;
diff --git a/tests/baselines/reference/classExpressionWithStaticPropertiesES63.symbols b/tests/baselines/reference/classExpressionWithStaticPropertiesES63.symbols
index d39463b228c..b036698e691 100644
--- a/tests/baselines/reference/classExpressionWithStaticPropertiesES63.symbols
+++ b/tests/baselines/reference/classExpressionWithStaticPropertiesES63.symbols
@@ -15,6 +15,7 @@ for (let i = 0; i < 3; i++) {
 >arr.push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --))
 >arr : Symbol(arr, Decl(classExpressionWithStaticPropertiesES63.ts, 1, 5))
 >push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --))
+>class C {        static x = i;        static y = () => C.x * 2;    } : Symbol(C, Decl(classExpressionWithStaticPropertiesES63.ts, 3, 13))
 >C : Symbol(C, Decl(classExpressionWithStaticPropertiesES63.ts, 3, 13))
 
         static x = i;
diff --git a/tests/baselines/reference/classExpressionWithStaticPropertiesES64.symbols b/tests/baselines/reference/classExpressionWithStaticPropertiesES64.symbols
index 1289a526e4a..21702d54afe 100644
--- a/tests/baselines/reference/classExpressionWithStaticPropertiesES64.symbols
+++ b/tests/baselines/reference/classExpressionWithStaticPropertiesES64.symbols
@@ -1,4 +1,6 @@
 === tests/cases/compiler/classExpressionWithStaticPropertiesES64.ts ===
 (class { static x = 0; });
+>(class { static x = 0; }) : Symbol((Anonymous class), Decl(classExpressionWithStaticPropertiesES64.ts, 0, 1))
+>class { static x = 0; } : Symbol((Anonymous class), Decl(classExpressionWithStaticPropertiesES64.ts, 0, 1))
 >x : Symbol((Anonymous class).x, Decl(classExpressionWithStaticPropertiesES64.ts, 0, 8))
 
diff --git a/tests/baselines/reference/classExpressions.symbols b/tests/baselines/reference/classExpressions.symbols
index 038b1b81116..f53a3f25853 100644
--- a/tests/baselines/reference/classExpressions.symbols
+++ b/tests/baselines/reference/classExpressions.symbols
@@ -4,6 +4,7 @@ interface A {}
 
 let x = class B implements A {
 >x : Symbol(x, Decl(classExpressions.ts, 1, 3))
+>class B implements A {    prop: number;    onStart(): void {    }    func = () => {    }} : Symbol(B, Decl(classExpressions.ts, 1, 7))
 >B : Symbol(B, Decl(classExpressions.ts, 1, 7))
 >A : Symbol(A, Decl(classExpressions.ts, 0, 0))
 
diff --git a/tests/baselines/reference/classStaticBlock18(target=es2015).symbols b/tests/baselines/reference/classStaticBlock18(target=es2015).symbols
index 22e9413ef67..0fd7b2beb87 100644
--- a/tests/baselines/reference/classStaticBlock18(target=es2015).symbols
+++ b/tests/baselines/reference/classStaticBlock18(target=es2015).symbols
@@ -3,12 +3,15 @@ function foo () {
 >foo : Symbol(foo, Decl(classStaticBlock18.ts, 0, 0))
 
   return class {
+>class {    static foo = 1;    static {      const c = class {        static bar = 2;        static {          // do        }      }    }  } : Symbol((Anonymous class), Decl(classStaticBlock18.ts, 1, 8))
+
     static foo = 1;
 >foo : Symbol((Anonymous class).foo, Decl(classStaticBlock18.ts, 1, 16))
 
     static {
       const c = class {
 >c : Symbol(c, Decl(classStaticBlock18.ts, 4, 11))
+>class {        static bar = 2;        static {          // do        }      } : Symbol(c, Decl(classStaticBlock18.ts, 4, 15))
 
         static bar = 2;
 >bar : Symbol(c.bar, Decl(classStaticBlock18.ts, 4, 23))
diff --git a/tests/baselines/reference/classStaticBlock18(target=es2022).symbols b/tests/baselines/reference/classStaticBlock18(target=es2022).symbols
index 22e9413ef67..0fd7b2beb87 100644
--- a/tests/baselines/reference/classStaticBlock18(target=es2022).symbols
+++ b/tests/baselines/reference/classStaticBlock18(target=es2022).symbols
@@ -3,12 +3,15 @@ function foo () {
 >foo : Symbol(foo, Decl(classStaticBlock18.ts, 0, 0))
 
   return class {
+>class {    static foo = 1;    static {      const c = class {        static bar = 2;        static {          // do        }      }    }  } : Symbol((Anonymous class), Decl(classStaticBlock18.ts, 1, 8))
+
     static foo = 1;
 >foo : Symbol((Anonymous class).foo, Decl(classStaticBlock18.ts, 1, 16))
 
     static {
       const c = class {
 >c : Symbol(c, Decl(classStaticBlock18.ts, 4, 11))
+>class {        static bar = 2;        static {          // do        }      } : Symbol(c, Decl(classStaticBlock18.ts, 4, 15))
 
         static bar = 2;
 >bar : Symbol(c.bar, Decl(classStaticBlock18.ts, 4, 23))
diff --git a/tests/baselines/reference/classStaticBlock18(target=es5).symbols b/tests/baselines/reference/classStaticBlock18(target=es5).symbols
index 22e9413ef67..0fd7b2beb87 100644
--- a/tests/baselines/reference/classStaticBlock18(target=es5).symbols
+++ b/tests/baselines/reference/classStaticBlock18(target=es5).symbols
@@ -3,12 +3,15 @@ function foo () {
 >foo : Symbol(foo, Decl(classStaticBlock18.ts, 0, 0))
 
   return class {
+>class {    static foo = 1;    static {      const c = class {        static bar = 2;        static {          // do        }      }    }  } : Symbol((Anonymous class), Decl(classStaticBlock18.ts, 1, 8))
+
     static foo = 1;
 >foo : Symbol((Anonymous class).foo, Decl(classStaticBlock18.ts, 1, 16))
 
     static {
       const c = class {
 >c : Symbol(c, Decl(classStaticBlock18.ts, 4, 11))
+>class {        static bar = 2;        static {          // do        }      } : Symbol(c, Decl(classStaticBlock18.ts, 4, 15))
 
         static bar = 2;
 >bar : Symbol(c.bar, Decl(classStaticBlock18.ts, 4, 23))
diff --git a/tests/baselines/reference/classStaticBlock18(target=esnext).symbols b/tests/baselines/reference/classStaticBlock18(target=esnext).symbols
index 22e9413ef67..0fd7b2beb87 100644
--- a/tests/baselines/reference/classStaticBlock18(target=esnext).symbols
+++ b/tests/baselines/reference/classStaticBlock18(target=esnext).symbols
@@ -3,12 +3,15 @@ function foo () {
 >foo : Symbol(foo, Decl(classStaticBlock18.ts, 0, 0))
 
   return class {
+>class {    static foo = 1;    static {      const c = class {        static bar = 2;        static {          // do        }      }    }  } : Symbol((Anonymous class), Decl(classStaticBlock18.ts, 1, 8))
+
     static foo = 1;
 >foo : Symbol((Anonymous class).foo, Decl(classStaticBlock18.ts, 1, 16))
 
     static {
       const c = class {
 >c : Symbol(c, Decl(classStaticBlock18.ts, 4, 11))
+>class {        static bar = 2;        static {          // do        }      } : Symbol(c, Decl(classStaticBlock18.ts, 4, 15))
 
         static bar = 2;
 >bar : Symbol(c.bar, Decl(classStaticBlock18.ts, 4, 23))
diff --git a/tests/baselines/reference/classStaticBlock22(target=es2022).symbols b/tests/baselines/reference/classStaticBlock22(target=es2022).symbols
index 6d927f0fe62..19d26548782 100644
--- a/tests/baselines/reference/classStaticBlock22(target=es2022).symbols
+++ b/tests/baselines/reference/classStaticBlock22(target=es2022).symbols
@@ -49,6 +49,8 @@ class C {
   }
   static {
     (class await { }); // legal, 'await' in class expression name not bound inside of static block
+>(class await { }) : Symbol(await, Decl(classStaticBlock22.ts, 31, 5))
+>class await { } : Symbol(await, Decl(classStaticBlock22.ts, 31, 5))
 >await : Symbol(await, Decl(classStaticBlock22.ts, 31, 5))
   }
   static {
diff --git a/tests/baselines/reference/classStaticBlock22(target=esnext).symbols b/tests/baselines/reference/classStaticBlock22(target=esnext).symbols
index 6d927f0fe62..19d26548782 100644
--- a/tests/baselines/reference/classStaticBlock22(target=esnext).symbols
+++ b/tests/baselines/reference/classStaticBlock22(target=esnext).symbols
@@ -49,6 +49,8 @@ class C {
   }
   static {
     (class await { }); // legal, 'await' in class expression name not bound inside of static block
+>(class await { }) : Symbol(await, Decl(classStaticBlock22.ts, 31, 5))
+>class await { } : Symbol(await, Decl(classStaticBlock22.ts, 31, 5))
 >await : Symbol(await, Decl(classStaticBlock22.ts, 31, 5))
   }
   static {
diff --git a/tests/baselines/reference/classStaticBlock27.symbols b/tests/baselines/reference/classStaticBlock27.symbols
index a5c6ef843bf..ebfa5dd77e2 100644
--- a/tests/baselines/reference/classStaticBlock27.symbols
+++ b/tests/baselines/reference/classStaticBlock27.symbols
@@ -2,6 +2,7 @@
 // https://github.com/microsoft/TypeScript/issues/44872
 
 void class Foo {
+>class Foo {    static prop = 1    static {        console.log(Foo.prop);        Foo.prop++;    }    static {        console.log(Foo.prop);        Foo.prop++;    }    static {        console.log(Foo.prop);        Foo.prop++;    }} : Symbol(Foo, Decl(classStaticBlock27.ts, 2, 4))
 >Foo : Symbol(Foo, Decl(classStaticBlock27.ts, 2, 4))
 
     static prop = 1
diff --git a/tests/baselines/reference/classUsedBeforeInitializedVariables.symbols b/tests/baselines/reference/classUsedBeforeInitializedVariables.symbols
index f51022958e6..04b48897278 100644
--- a/tests/baselines/reference/classUsedBeforeInitializedVariables.symbols
+++ b/tests/baselines/reference/classUsedBeforeInitializedVariables.symbols
@@ -93,6 +93,8 @@ class Test {
 
     withinClassDeclarationExtension: any = (class extends this.withinClassDeclarationExtension { });
 >withinClassDeclarationExtension : Symbol(Test.withinClassDeclarationExtension, Decl(classUsedBeforeInitializedVariables.ts, 32, 6))
+>(class extends this.withinClassDeclarationExtension { }) : Symbol((Anonymous class), Decl(classUsedBeforeInitializedVariables.ts, 34, 44))
+>class extends this.withinClassDeclarationExtension { } : Symbol((Anonymous class), Decl(classUsedBeforeInitializedVariables.ts, 34, 44))
 >this.withinClassDeclarationExtension : Symbol(Test.withinClassDeclarationExtension, Decl(classUsedBeforeInitializedVariables.ts, 32, 6))
 >this : Symbol(Test, Decl(classUsedBeforeInitializedVariables.ts, 0, 0))
 >withinClassDeclarationExtension : Symbol(Test.withinClassDeclarationExtension, Decl(classUsedBeforeInitializedVariables.ts, 32, 6))
diff --git a/tests/baselines/reference/commonJSImportExportedClassExpression.symbols b/tests/baselines/reference/commonJSImportExportedClassExpression.symbols
index 25f9f440bfb..2c0cc3d646c 100644
--- a/tests/baselines/reference/commonJSImportExportedClassExpression.symbols
+++ b/tests/baselines/reference/commonJSImportExportedClassExpression.symbols
@@ -20,6 +20,7 @@ exports.K = class K {
 >exports.K : Symbol(K, Decl(mod1.js, 0, 0))
 >exports : Symbol(K, Decl(mod1.js, 0, 0))
 >K : Symbol(K, Decl(mod1.js, 0, 0))
+>class K {    values() {    }} : Symbol(K, Decl(mod1.js, 0, 11))
 >K : Symbol(K, Decl(mod1.js, 0, 11))
 
     values() {
diff --git a/tests/baselines/reference/commonJSImportNestedClassTypeReference.symbols b/tests/baselines/reference/commonJSImportNestedClassTypeReference.symbols
index fe96f34558a..f8f3edfc918 100644
--- a/tests/baselines/reference/commonJSImportNestedClassTypeReference.symbols
+++ b/tests/baselines/reference/commonJSImportNestedClassTypeReference.symbols
@@ -23,6 +23,7 @@ NS.K =class {
 >NS.K : Symbol(K, Decl(mod1.js, 0, 11))
 >NS : Symbol(NS, Decl(mod1.js, 0, 3), Decl(mod1.js, 0, 11))
 >K : Symbol(K, Decl(mod1.js, 0, 11))
+>class {    values() {        return new NS.K()    }} : Symbol(K, Decl(mod1.js, 1, 6))
 
     values() {
 >values : Symbol(K.values, Decl(mod1.js, 1, 13))
diff --git a/tests/baselines/reference/commonJsImportClassExpression.symbols b/tests/baselines/reference/commonJsImportClassExpression.symbols
index 5f6bc93188f..310edefbb2c 100644
--- a/tests/baselines/reference/commonJsImportClassExpression.symbols
+++ b/tests/baselines/reference/commonJsImportClassExpression.symbols
@@ -13,6 +13,8 @@ c.chunk;
 
 === tests/cases/compiler/mod1.ts ===
 export = class {
+>class {    chunk = 1} : Symbol((Anonymous class), Decl(mod1.ts, 0, 8))
+
     chunk = 1
 >chunk : Symbol((Anonymous class).chunk, Decl(mod1.ts, 0, 16))
 }
diff --git a/tests/baselines/reference/compoundAssignmentLHSIsReference.symbols b/tests/baselines/reference/compoundAssignmentLHSIsReference.symbols
index e7c19e4d781..b1eaa4fcee5 100644
--- a/tests/baselines/reference/compoundAssignmentLHSIsReference.symbols
+++ b/tests/baselines/reference/compoundAssignmentLHSIsReference.symbols
@@ -56,10 +56,12 @@ x3['a'] += value;
 
 // parentheses, the contained expression is reference
 (x1) *= value;
+>(x1) : Symbol(x1, Decl(compoundAssignmentLHSIsReference.ts, 3, 3))
 >x1 : Symbol(x1, Decl(compoundAssignmentLHSIsReference.ts, 3, 3))
 >value : Symbol(value, Decl(compoundAssignmentLHSIsReference.ts, 0, 3))
 
 (x1) += value;
+>(x1) : Symbol(x1, Decl(compoundAssignmentLHSIsReference.ts, 3, 3))
 >x1 : Symbol(x1, Decl(compoundAssignmentLHSIsReference.ts, 3, 3))
 >value : Symbol(value, Decl(compoundAssignmentLHSIsReference.ts, 0, 3))
 
@@ -68,21 +70,25 @@ function fn2(x4: number) {
 >x4 : Symbol(x4, Decl(compoundAssignmentLHSIsReference.ts, 24, 13))
 
     (x4) *= value;
+>(x4) : Symbol(x4, Decl(compoundAssignmentLHSIsReference.ts, 24, 13))
 >x4 : Symbol(x4, Decl(compoundAssignmentLHSIsReference.ts, 24, 13))
 >value : Symbol(value, Decl(compoundAssignmentLHSIsReference.ts, 0, 3))
 
     (x4) += value;
+>(x4) : Symbol(x4, Decl(compoundAssignmentLHSIsReference.ts, 24, 13))
 >x4 : Symbol(x4, Decl(compoundAssignmentLHSIsReference.ts, 24, 13))
 >value : Symbol(value, Decl(compoundAssignmentLHSIsReference.ts, 0, 3))
 }
 
 (x3.a) *= value;
+>(x3.a) : Symbol(a, Decl(compoundAssignmentLHSIsReference.ts, 13, 9))
 >x3.a : Symbol(a, Decl(compoundAssignmentLHSIsReference.ts, 13, 9))
 >x3 : Symbol(x3, Decl(compoundAssignmentLHSIsReference.ts, 13, 3))
 >a : Symbol(a, Decl(compoundAssignmentLHSIsReference.ts, 13, 9))
 >value : Symbol(value, Decl(compoundAssignmentLHSIsReference.ts, 0, 3))
 
 (x3.a) += value;
+>(x3.a) : Symbol(a, Decl(compoundAssignmentLHSIsReference.ts, 13, 9))
 >x3.a : Symbol(a, Decl(compoundAssignmentLHSIsReference.ts, 13, 9))
 >x3 : Symbol(x3, Decl(compoundAssignmentLHSIsReference.ts, 13, 3))
 >a : Symbol(a, Decl(compoundAssignmentLHSIsReference.ts, 13, 9))
diff --git a/tests/baselines/reference/compoundAssignmentLHSIsValue.symbols b/tests/baselines/reference/compoundAssignmentLHSIsValue.symbols
index 891127c32cc..4fdb0b682fd 100644
--- a/tests/baselines/reference/compoundAssignmentLHSIsValue.symbols
+++ b/tests/baselines/reference/compoundAssignmentLHSIsValue.symbols
@@ -218,42 +218,52 @@ foo() += value;
 
 // parentheses, the containted expression is value
 (this) *= value;
+>(this) : Symbol(globalThis)
 >this : Symbol(globalThis)
 >value : Symbol(value, Decl(compoundAssignmentLHSIsValue.ts, 1, 3))
 
 (this) += value;
+>(this) : Symbol(globalThis)
 >this : Symbol(globalThis)
 >value : Symbol(value, Decl(compoundAssignmentLHSIsValue.ts, 1, 3))
 
 (M) *= value;
+>(M) : Symbol(M, Decl(compoundAssignmentLHSIsValue.ts, 25, 14))
 >M : Symbol(M, Decl(compoundAssignmentLHSIsValue.ts, 25, 14))
 >value : Symbol(value, Decl(compoundAssignmentLHSIsValue.ts, 1, 3))
 
 (M) += value;
+>(M) : Symbol(M, Decl(compoundAssignmentLHSIsValue.ts, 25, 14))
 >M : Symbol(M, Decl(compoundAssignmentLHSIsValue.ts, 25, 14))
 >value : Symbol(value, Decl(compoundAssignmentLHSIsValue.ts, 1, 3))
 
 (C) *= value;
+>(C) : Symbol(C, Decl(compoundAssignmentLHSIsValue.ts, 1, 15))
 >C : Symbol(C, Decl(compoundAssignmentLHSIsValue.ts, 1, 15))
 >value : Symbol(value, Decl(compoundAssignmentLHSIsValue.ts, 1, 3))
 
 (C) += value;
+>(C) : Symbol(C, Decl(compoundAssignmentLHSIsValue.ts, 1, 15))
 >C : Symbol(C, Decl(compoundAssignmentLHSIsValue.ts, 1, 15))
 >value : Symbol(value, Decl(compoundAssignmentLHSIsValue.ts, 1, 3))
 
 (E) *= value;
+>(E) : Symbol(E, Decl(compoundAssignmentLHSIsValue.ts, 33, 11))
 >E : Symbol(E, Decl(compoundAssignmentLHSIsValue.ts, 33, 11))
 >value : Symbol(value, Decl(compoundAssignmentLHSIsValue.ts, 1, 3))
 
 (E) += value;
+>(E) : Symbol(E, Decl(compoundAssignmentLHSIsValue.ts, 33, 11))
 >E : Symbol(E, Decl(compoundAssignmentLHSIsValue.ts, 33, 11))
 >value : Symbol(value, Decl(compoundAssignmentLHSIsValue.ts, 1, 3))
 
 (foo) *= value;
+>(foo) : Symbol(foo, Decl(compoundAssignmentLHSIsValue.ts, 17, 1))
 >foo : Symbol(foo, Decl(compoundAssignmentLHSIsValue.ts, 17, 1))
 >value : Symbol(value, Decl(compoundAssignmentLHSIsValue.ts, 1, 3))
 
 (foo) += value;
+>(foo) : Symbol(foo, Decl(compoundAssignmentLHSIsValue.ts, 17, 1))
 >foo : Symbol(foo, Decl(compoundAssignmentLHSIsValue.ts, 17, 1))
 >value : Symbol(value, Decl(compoundAssignmentLHSIsValue.ts, 1, 3))
 
diff --git a/tests/baselines/reference/compoundExponentiationAssignmentLHSIsReference.symbols b/tests/baselines/reference/compoundExponentiationAssignmentLHSIsReference.symbols
index b69c1afdb9b..ebdf86772a3 100644
--- a/tests/baselines/reference/compoundExponentiationAssignmentLHSIsReference.symbols
+++ b/tests/baselines/reference/compoundExponentiationAssignmentLHSIsReference.symbols
@@ -37,6 +37,7 @@ x3['a'] **= value;
 
 // parentheses, the contained expression is reference
 (x1) **= value;
+>(x1) : Symbol(x1, Decl(compoundExponentiationAssignmentLHSIsReference.ts, 3, 3))
 >x1 : Symbol(x1, Decl(compoundExponentiationAssignmentLHSIsReference.ts, 3, 3))
 >value : Symbol(value, Decl(compoundExponentiationAssignmentLHSIsReference.ts, 0, 3))
 
@@ -45,11 +46,13 @@ function fn2(x4: number) {
 >x4 : Symbol(x4, Decl(compoundExponentiationAssignmentLHSIsReference.ts, 19, 13))
 
     (x4) **= value;
+>(x4) : Symbol(x4, Decl(compoundExponentiationAssignmentLHSIsReference.ts, 19, 13))
 >x4 : Symbol(x4, Decl(compoundExponentiationAssignmentLHSIsReference.ts, 19, 13))
 >value : Symbol(value, Decl(compoundExponentiationAssignmentLHSIsReference.ts, 0, 3))
 }
 
 (x3.a) **= value;
+>(x3.a) : Symbol(a, Decl(compoundExponentiationAssignmentLHSIsReference.ts, 11, 9))
 >x3.a : Symbol(a, Decl(compoundExponentiationAssignmentLHSIsReference.ts, 11, 9))
 >x3 : Symbol(x3, Decl(compoundExponentiationAssignmentLHSIsReference.ts, 11, 3))
 >a : Symbol(a, Decl(compoundExponentiationAssignmentLHSIsReference.ts, 11, 9))
diff --git a/tests/baselines/reference/compoundExponentiationAssignmentLHSIsValue.symbols b/tests/baselines/reference/compoundExponentiationAssignmentLHSIsValue.symbols
index 5596f648979..a835521b917 100644
--- a/tests/baselines/reference/compoundExponentiationAssignmentLHSIsValue.symbols
+++ b/tests/baselines/reference/compoundExponentiationAssignmentLHSIsValue.symbols
@@ -136,22 +136,27 @@ foo() **= value;
 
 // parentheses, the containted expression is value
 (this) **= value;
+>(this) : Symbol(globalThis)
 >this : Symbol(globalThis)
 >value : Symbol(value, Decl(compoundExponentiationAssignmentLHSIsValue.ts, 1, 3))
 
 (M) **= value;
+>(M) : Symbol(M, Decl(compoundExponentiationAssignmentLHSIsValue.ts, 20, 15))
 >M : Symbol(M, Decl(compoundExponentiationAssignmentLHSIsValue.ts, 20, 15))
 >value : Symbol(value, Decl(compoundExponentiationAssignmentLHSIsValue.ts, 1, 3))
 
 (C) **= value;
+>(C) : Symbol(C, Decl(compoundExponentiationAssignmentLHSIsValue.ts, 1, 15))
 >C : Symbol(C, Decl(compoundExponentiationAssignmentLHSIsValue.ts, 1, 15))
 >value : Symbol(value, Decl(compoundExponentiationAssignmentLHSIsValue.ts, 1, 3))
 
 (E) **= value;
+>(E) : Symbol(E, Decl(compoundExponentiationAssignmentLHSIsValue.ts, 26, 12))
 >E : Symbol(E, Decl(compoundExponentiationAssignmentLHSIsValue.ts, 26, 12))
 >value : Symbol(value, Decl(compoundExponentiationAssignmentLHSIsValue.ts, 1, 3))
 
 (foo) **= value;
+>(foo) : Symbol(foo, Decl(compoundExponentiationAssignmentLHSIsValue.ts, 14, 1))
 >foo : Symbol(foo, Decl(compoundExponentiationAssignmentLHSIsValue.ts, 14, 1))
 >value : Symbol(value, Decl(compoundExponentiationAssignmentLHSIsValue.ts, 1, 3))
 
diff --git a/tests/baselines/reference/computedPropertyNames52(target=es2015).symbols b/tests/baselines/reference/computedPropertyNames52(target=es2015).symbols
index c36c9f73f92..b921770ffbf 100644
--- a/tests/baselines/reference/computedPropertyNames52(target=es2015).symbols
+++ b/tests/baselines/reference/computedPropertyNames52(target=es2015).symbols
@@ -11,6 +11,7 @@ for (let i = 0; i < 10; ++i) {
 >array.push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --))
 >array : Symbol(array, Decl(computedPropertyNames52.js, 0, 5))
 >push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --))
+>class C {        [i] = () => C;        static [i] = 100;    } : Symbol(C, Decl(computedPropertyNames52.js, 2, 15))
 >C : Symbol(C, Decl(computedPropertyNames52.js, 2, 15))
 
         [i] = () => C;
diff --git a/tests/baselines/reference/computedPropertyNames52(target=es5).symbols b/tests/baselines/reference/computedPropertyNames52(target=es5).symbols
index c36c9f73f92..b921770ffbf 100644
--- a/tests/baselines/reference/computedPropertyNames52(target=es5).symbols
+++ b/tests/baselines/reference/computedPropertyNames52(target=es5).symbols
@@ -11,6 +11,7 @@ for (let i = 0; i < 10; ++i) {
 >array.push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --))
 >array : Symbol(array, Decl(computedPropertyNames52.js, 0, 5))
 >push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --))
+>class C {        [i] = () => C;        static [i] = 100;    } : Symbol(C, Decl(computedPropertyNames52.js, 2, 15))
 >C : Symbol(C, Decl(computedPropertyNames52.js, 2, 15))
 
         [i] = () => C;
diff --git a/tests/baselines/reference/constAssertionOnEnum.symbols b/tests/baselines/reference/constAssertionOnEnum.symbols
index 0323eafb03a..65964331822 100644
--- a/tests/baselines/reference/constAssertionOnEnum.symbols
+++ b/tests/baselines/reference/constAssertionOnEnum.symbols
@@ -60,6 +60,7 @@ export enum Foo { X }
 
 (Foo).X as const;
 >(Foo).X : Symbol(Foo.X, Decl(more.ts, 0, 17))
+>(Foo) : Symbol(Foo, Decl(more.ts, 0, 0))
 >Foo : Symbol(Foo, Decl(more.ts, 0, 0))
 >X : Symbol(Foo.X, Decl(more.ts, 0, 17))
 >const : Symbol(const)
diff --git a/tests/baselines/reference/constDeclarations-access2.symbols b/tests/baselines/reference/constDeclarations-access2.symbols
index 0f67618b1ad..2560bc8b260 100644
--- a/tests/baselines/reference/constDeclarations-access2.symbols
+++ b/tests/baselines/reference/constDeclarations-access2.symbols
@@ -52,6 +52,8 @@ x--;
 >x : Symbol(x, Decl(constDeclarations-access2.ts, 0, 5))
 
 ++((x));
+>((x)) : Symbol(x, Decl(constDeclarations-access2.ts, 0, 5))
+>(x) : Symbol(x, Decl(constDeclarations-access2.ts, 0, 5))
 >x : Symbol(x, Decl(constDeclarations-access2.ts, 0, 5))
 
 // OK
@@ -74,6 +76,7 @@ x;
 >x : Symbol(x, Decl(constDeclarations-access2.ts, 0, 5))
 
 (x);
+>(x) : Symbol(x, Decl(constDeclarations-access2.ts, 0, 5))
 >x : Symbol(x, Decl(constDeclarations-access2.ts, 0, 5))
 
 -x;
diff --git a/tests/baselines/reference/constDeclarations-access3.symbols b/tests/baselines/reference/constDeclarations-access3.symbols
index 43049ff355a..c83fd837dcf 100644
--- a/tests/baselines/reference/constDeclarations-access3.symbols
+++ b/tests/baselines/reference/constDeclarations-access3.symbols
@@ -88,6 +88,8 @@ M.x--;
 >x : Symbol(M.x, Decl(constDeclarations-access3.ts, 1, 16))
 
 ++((M.x));
+>((M.x)) : Symbol(M.x, Decl(constDeclarations-access3.ts, 1, 16))
+>(M.x) : Symbol(M.x, Decl(constDeclarations-access3.ts, 1, 16))
 >M.x : Symbol(M.x, Decl(constDeclarations-access3.ts, 1, 16))
 >M : Symbol(M, Decl(constDeclarations-access3.ts, 0, 0))
 >x : Symbol(M.x, Decl(constDeclarations-access3.ts, 1, 16))
@@ -124,6 +126,7 @@ M.x;
 >x : Symbol(M.x, Decl(constDeclarations-access3.ts, 1, 16))
 
 (M.x);
+>(M.x) : Symbol(M.x, Decl(constDeclarations-access3.ts, 1, 16))
 >M.x : Symbol(M.x, Decl(constDeclarations-access3.ts, 1, 16))
 >M : Symbol(M, Decl(constDeclarations-access3.ts, 0, 0))
 >x : Symbol(M.x, Decl(constDeclarations-access3.ts, 1, 16))
diff --git a/tests/baselines/reference/constDeclarations-access4.symbols b/tests/baselines/reference/constDeclarations-access4.symbols
index 4e5179f1e81..622d320aab9 100644
--- a/tests/baselines/reference/constDeclarations-access4.symbols
+++ b/tests/baselines/reference/constDeclarations-access4.symbols
@@ -88,6 +88,8 @@ M.x--;
 >x : Symbol(M.x, Decl(constDeclarations-access4.ts, 1, 9))
 
 ++((M.x));
+>((M.x)) : Symbol(M.x, Decl(constDeclarations-access4.ts, 1, 9))
+>(M.x) : Symbol(M.x, Decl(constDeclarations-access4.ts, 1, 9))
 >M.x : Symbol(M.x, Decl(constDeclarations-access4.ts, 1, 9))
 >M : Symbol(M, Decl(constDeclarations-access4.ts, 0, 0))
 >x : Symbol(M.x, Decl(constDeclarations-access4.ts, 1, 9))
@@ -124,6 +126,7 @@ M.x;
 >x : Symbol(M.x, Decl(constDeclarations-access4.ts, 1, 9))
 
 (M.x);
+>(M.x) : Symbol(M.x, Decl(constDeclarations-access4.ts, 1, 9))
 >M.x : Symbol(M.x, Decl(constDeclarations-access4.ts, 1, 9))
 >M : Symbol(M, Decl(constDeclarations-access4.ts, 0, 0))
 >x : Symbol(M.x, Decl(constDeclarations-access4.ts, 1, 9))
diff --git a/tests/baselines/reference/constDeclarations-access5.symbols b/tests/baselines/reference/constDeclarations-access5.symbols
index 776f78b8015..b038843987b 100644
--- a/tests/baselines/reference/constDeclarations-access5.symbols
+++ b/tests/baselines/reference/constDeclarations-access5.symbols
@@ -88,6 +88,8 @@ m.x--;
 >x : Symbol(m.x, Decl(constDeclarations_access_1.ts, 0, 12))
 
 ++((m.x));
+>((m.x)) : Symbol(m.x, Decl(constDeclarations_access_1.ts, 0, 12))
+>(m.x) : Symbol(m.x, Decl(constDeclarations_access_1.ts, 0, 12))
 >m.x : Symbol(m.x, Decl(constDeclarations_access_1.ts, 0, 12))
 >m : Symbol(m, Decl(constDeclarations_access_2.ts, 0, 0))
 >x : Symbol(m.x, Decl(constDeclarations_access_1.ts, 0, 12))
@@ -124,6 +126,7 @@ m.x;
 >x : Symbol(m.x, Decl(constDeclarations_access_1.ts, 0, 12))
 
 (m.x);
+>(m.x) : Symbol(m.x, Decl(constDeclarations_access_1.ts, 0, 12))
 >m.x : Symbol(m.x, Decl(constDeclarations_access_1.ts, 0, 12))
 >m : Symbol(m, Decl(constDeclarations_access_2.ts, 0, 0))
 >x : Symbol(m.x, Decl(constDeclarations_access_1.ts, 0, 12))
diff --git a/tests/baselines/reference/constInClassExpression.symbols b/tests/baselines/reference/constInClassExpression.symbols
index 7468772edfb..9c6682f172a 100644
--- a/tests/baselines/reference/constInClassExpression.symbols
+++ b/tests/baselines/reference/constInClassExpression.symbols
@@ -1,6 +1,7 @@
 === tests/cases/compiler/constInClassExpression.ts ===
 let C = class {
 >C : Symbol(C, Decl(constInClassExpression.ts, 0, 3))
+>class {    const a = 4;} : Symbol(C, Decl(constInClassExpression.ts, 0, 7))
 
     const a = 4;
 >a : Symbol(C.a, Decl(constInClassExpression.ts, 0, 15))
diff --git a/tests/baselines/reference/constructorFunctions.symbols b/tests/baselines/reference/constructorFunctions.symbols
index f31c5936801..9dd013c1346 100644
--- a/tests/baselines/reference/constructorFunctions.symbols
+++ b/tests/baselines/reference/constructorFunctions.symbols
@@ -97,6 +97,7 @@ var c5_v2;
 
 c5_v2 = class { };
 >c5_v2 : Symbol(c5_v2, Decl(index.js, 36, 3))
+>class { } : Symbol(c5_v2, Decl(index.js, 37, 7))
 
 new c5_v2();
 >c5_v2 : Symbol(c5_v2, Decl(index.js, 36, 3))
diff --git a/tests/baselines/reference/contextuallyTypedClassExpressionMethodDeclaration01.symbols b/tests/baselines/reference/contextuallyTypedClassExpressionMethodDeclaration01.symbols
index e305c38300c..789b03d10d7 100644
--- a/tests/baselines/reference/contextuallyTypedClassExpressionMethodDeclaration01.symbols
+++ b/tests/baselines/reference/contextuallyTypedClassExpressionMethodDeclaration01.symbols
@@ -32,6 +32,8 @@ function getFoo1(): Foo {
 >Foo : Symbol(Foo, Decl(contextuallyTypedClassExpressionMethodDeclaration01.ts, 6, 1))
 
     return class {
+>class {        static method1(arg) {            arg.numProp = 10;        }        static method2(arg) {            arg.strProp = "hello";        }    } : Symbol((Anonymous class), Decl(contextuallyTypedClassExpressionMethodDeclaration01.ts, 14, 10))
+
         static method1(arg) {
 >method1 : Symbol((Anonymous class).method1, Decl(contextuallyTypedClassExpressionMethodDeclaration01.ts, 14, 18))
 >arg : Symbol(arg, Decl(contextuallyTypedClassExpressionMethodDeclaration01.ts, 15, 23))
@@ -54,6 +56,8 @@ function getFoo2(): Foo {
 >Foo : Symbol(Foo, Decl(contextuallyTypedClassExpressionMethodDeclaration01.ts, 6, 1))
 
     return class {
+>class {        static method1 = (arg) => {            arg.numProp = 10;        }        static method2 = (arg) => {            arg.strProp = "hello";        }    } : Symbol((Anonymous class), Decl(contextuallyTypedClassExpressionMethodDeclaration01.ts, 25, 10))
+
         static method1 = (arg) => {
 >method1 : Symbol((Anonymous class).method1, Decl(contextuallyTypedClassExpressionMethodDeclaration01.ts, 25, 18))
 >arg : Symbol(arg, Decl(contextuallyTypedClassExpressionMethodDeclaration01.ts, 26, 26))
@@ -80,6 +84,8 @@ function getFoo3(): Foo {
 >Foo : Symbol(Foo, Decl(contextuallyTypedClassExpressionMethodDeclaration01.ts, 6, 1))
 
     return class {
+>class {        static method1 = function (arg) {            arg.numProp = 10;        }        static method2 = function (arg) {            arg.strProp = "hello";        }    } : Symbol((Anonymous class), Decl(contextuallyTypedClassExpressionMethodDeclaration01.ts, 36, 10))
+
         static method1 = function (arg) {
 >method1 : Symbol((Anonymous class).method1, Decl(contextuallyTypedClassExpressionMethodDeclaration01.ts, 36, 18))
 >arg : Symbol(arg, Decl(contextuallyTypedClassExpressionMethodDeclaration01.ts, 37, 35))
diff --git a/tests/baselines/reference/contextuallyTypedClassExpressionMethodDeclaration02.symbols b/tests/baselines/reference/contextuallyTypedClassExpressionMethodDeclaration02.symbols
index 22d04abfe65..15754690889 100644
--- a/tests/baselines/reference/contextuallyTypedClassExpressionMethodDeclaration02.symbols
+++ b/tests/baselines/reference/contextuallyTypedClassExpressionMethodDeclaration02.symbols
@@ -39,6 +39,8 @@ function getFoo1(): Foo {
 >Foo : Symbol(Foo, Decl(contextuallyTypedClassExpressionMethodDeclaration02.ts, 6, 1))
 
     return class {
+>class {        method1(arg) {            arg.numProp = 10;        }        method2(arg) {            arg.strProp = "hello";        }    } : Symbol((Anonymous class), Decl(contextuallyTypedClassExpressionMethodDeclaration02.ts, 18, 10))
+
         method1(arg) {
 >method1 : Symbol((Anonymous class).method1, Decl(contextuallyTypedClassExpressionMethodDeclaration02.ts, 18, 18))
 >arg : Symbol(arg, Decl(contextuallyTypedClassExpressionMethodDeclaration02.ts, 19, 16))
@@ -61,6 +63,8 @@ function getFoo2(): Foo {
 >Foo : Symbol(Foo, Decl(contextuallyTypedClassExpressionMethodDeclaration02.ts, 6, 1))
 
     return class {
+>class {        method1 = (arg) => {            arg.numProp = 10;        }        method2 = (arg) => {            arg.strProp = "hello";        }    } : Symbol((Anonymous class), Decl(contextuallyTypedClassExpressionMethodDeclaration02.ts, 29, 10))
+
         method1 = (arg) => {
 >method1 : Symbol((Anonymous class).method1, Decl(contextuallyTypedClassExpressionMethodDeclaration02.ts, 29, 18))
 >arg : Symbol(arg, Decl(contextuallyTypedClassExpressionMethodDeclaration02.ts, 30, 19))
@@ -83,6 +87,8 @@ function getFoo3(): Foo {
 >Foo : Symbol(Foo, Decl(contextuallyTypedClassExpressionMethodDeclaration02.ts, 6, 1))
 
     return class {
+>class {        method1 = function (arg) {            arg.numProp = 10;        }        method2 = function (arg) {            arg.strProp = "hello";        }    } : Symbol((Anonymous class), Decl(contextuallyTypedClassExpressionMethodDeclaration02.ts, 40, 10))
+
         method1 = function (arg) {
 >method1 : Symbol((Anonymous class).method1, Decl(contextuallyTypedClassExpressionMethodDeclaration02.ts, 40, 18))
 >arg : Symbol(arg, Decl(contextuallyTypedClassExpressionMethodDeclaration02.ts, 41, 28))
diff --git a/tests/baselines/reference/controlFlowArrays.symbols b/tests/baselines/reference/controlFlowArrays.symbols
index b36020031dd..3f1fb80dd9e 100644
--- a/tests/baselines/reference/controlFlowArrays.symbols
+++ b/tests/baselines/reference/controlFlowArrays.symbols
@@ -413,6 +413,8 @@ function f16() {
 >push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --))
 
     ((x))[3] = { a: 1 };
+>((x)) : Symbol(x, Decl(controlFlowArrays.ts, 155, 7))
+>(x) : Symbol(x, Decl(controlFlowArrays.ts, 155, 7))
 >x : Symbol(x, Decl(controlFlowArrays.ts, 155, 7))
 >a : Symbol(a, Decl(controlFlowArrays.ts, 159, 16))
 
diff --git a/tests/baselines/reference/convertClassExpressionToFunctionFromObjectProperty1.symbols b/tests/baselines/reference/convertClassExpressionToFunctionFromObjectProperty1.symbols
index 923b52e7e14..4b879db7dcf 100644
--- a/tests/baselines/reference/convertClassExpressionToFunctionFromObjectProperty1.symbols
+++ b/tests/baselines/reference/convertClassExpressionToFunctionFromObjectProperty1.symbols
@@ -5,11 +5,13 @@ const foo: any = {};
 // properties
 foo.x = class {
 >foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
+>class {    constructor () {}} : Symbol(x, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 3, 7))
 
     constructor () {}
 }
 foo.y = class {
 >foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
+>class {    constructor () {}} : Symbol(y, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 6, 7))
 
     constructor () {}
 }
@@ -17,381 +19,457 @@ foo.y = class {
 // keywords
 foo.break = class {
 >foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
+>class {    constructor () {}} : Symbol(break, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 11, 11))
 
     constructor () {}
 }
 foo.case = class {
 >foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
+>class {    constructor () {}} : Symbol(case, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 14, 10))
 
     constructor () {}
 }
 foo.catch = class {
 >foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
+>class {    constructor () {}} : Symbol(catch, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 17, 11))
 
     constructor () {}
 }
 foo.class = class {
 >foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
+>class {    constructor () {}} : Symbol(class, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 20, 11))
 
     constructor () {}
 }
 foo.const = class {
 >foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
+>class {    constructor () {}} : Symbol(const, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 23, 11))
 
     constructor () {}
 }
 foo.continue = class {
 >foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
+>class {    constructor () {}} : Symbol(continue, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 26, 14))
 
     constructor () {}
 }
 foo.debugger = class {
 >foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
+>class {    constructor () {}} : Symbol(debugger, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 29, 14))
 
     constructor () {}
 }
 foo.default = class {
 >foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
+>class {    constructor () {}} : Symbol(default, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 32, 13))
 
     constructor () {}
 }
 foo.delete = class {
 >foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
+>class {    constructor () {}} : Symbol(delete, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 35, 12))
 
     constructor () {}
 }
 foo.do = class {
 >foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
+>class {    constructor () {}} : Symbol(do, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 38, 8))
 
     constructor () {}
 }
 foo.else = class {
 >foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
+>class {    constructor () {}} : Symbol(else, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 41, 10))
 
     constructor () {}
 }
 foo.enum = class {
 >foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
+>class {    constructor () {}} : Symbol(enum, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 44, 10))
 
     constructor () {}
 }
 foo.export = class {
 >foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
+>class {    constructor () {}} : Symbol(export, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 47, 12))
 
     constructor () {}
 }
 foo.extends = class {
 >foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
+>class {    constructor () {}} : Symbol(extends, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 50, 13))
 
     constructor () {}
 }
 foo.false = class {
 >foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
+>class {    constructor () {}} : Symbol(false, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 53, 11))
 
     constructor () {}
 }
 foo.finally = class {
 >foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
+>class {    constructor () {}} : Symbol(finally, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 56, 13))
 
     constructor () {}
 }
 foo.for = class {
 >foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
+>class {    constructor () {}} : Symbol(for, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 59, 9))
 
     constructor () {}
 }
 foo.function = class {
 >foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
+>class {    constructor () {}} : Symbol(function, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 62, 14))
 
     constructor () {}
 }
 foo.if = class {
 >foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
+>class {    constructor () {}} : Symbol(if, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 65, 8))
 
     constructor () {}
 }
 foo.import = class {
 >foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
+>class {    constructor () {}} : Symbol(import, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 68, 12))
 
     constructor () {}
 }
 foo.in = class {
 >foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
+>class {    constructor () {}} : Symbol(in, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 71, 8))
 
     constructor () {}
 }
 foo.instanceof = class {
 >foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
+>class {    constructor () {}} : Symbol(instanceof, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 74, 16))
 
     constructor () {}
 }
 foo.new = class {
 >foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
+>class {    constructor () {}} : Symbol(new, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 77, 9))
 
     constructor () {}
 }
 foo.null = class {
 >foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
+>class {    constructor () {}} : Symbol(null, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 80, 10))
 
     constructor () {}
 }
 foo.return = class {
 >foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
+>class {    constructor () {}} : Symbol(return, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 83, 12))
 
     constructor () {}
 }
 foo.super = class {
 >foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
+>class {    constructor () {}} : Symbol(super, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 86, 11))
 
     constructor () {}
 }
 foo.switch = class {
 >foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
+>class {    constructor () {}} : Symbol(switch, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 89, 12))
 
     constructor () {}
 }
 foo.this = class {
 >foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
+>class {    constructor () {}} : Symbol(this, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 92, 10))
 
     constructor () {}
 }
 foo.throw = class {
 >foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
+>class {    constructor () {}} : Symbol(throw, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 95, 11))
 
     constructor () {}
 }
 foo.true = class {
 >foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
+>class {    constructor () {}} : Symbol(true, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 98, 10))
 
     constructor () {}
 }
 foo.try = class {
 >foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
+>class {    constructor () {}} : Symbol(try, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 101, 9))
 
     constructor () {}
 }
 foo.typeof = class {
 >foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
+>class {    constructor () {}} : Symbol(typeof, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 104, 12))
 
     constructor () {}
 }
 foo.var = class {
 >foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
+>class {    constructor () {}} : Symbol(var, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 107, 9))
 
     constructor () {}
 }
 foo.void = class {
 >foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
+>class {    constructor () {}} : Symbol(void, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 110, 10))
 
     constructor () {}
 }
 foo.while = class {
 >foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
+>class {    constructor () {}} : Symbol(while, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 113, 11))
 
     constructor () {}
 }
 foo.with = class {
 >foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
+>class {    constructor () {}} : Symbol(with, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 116, 10))
 
     constructor () {}
 }
 foo.implements = class {
 >foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
+>class {    constructor () {}} : Symbol(implements, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 119, 16))
 
     constructor () {}
 }
 foo.interface = class {
 >foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
+>class {    constructor () {}} : Symbol(interface, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 122, 15))
 
     constructor () {}
 }
 foo.let = class {
 >foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
+>class {    constructor () {}} : Symbol(let, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 125, 9))
 
     constructor () {}
 }
 foo.package = class {
 >foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
+>class {    constructor () {}} : Symbol(package, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 128, 13))
 
     constructor () {}
 }
 foo.private = class {
 >foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
+>class {    constructor () {}} : Symbol(private, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 131, 13))
 
     constructor () {}
 }
 foo.protected = class {
 >foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
+>class {    constructor () {}} : Symbol(protected, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 134, 15))
 
     constructor () {}
 }
 foo.public = class {
 >foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
+>class {    constructor () {}} : Symbol(public, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 137, 12))
 
     constructor () {}
 }
 foo.static = class {
 >foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
+>class {    constructor () {}} : Symbol(static, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 140, 12))
 
     constructor () {}
 }
 foo.yield = class {
 >foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
+>class {    constructor () {}} : Symbol(yield, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 143, 11))
 
     constructor () {}
 }
 foo.abstract = class {
 >foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
+>class {    constructor () {}} : Symbol(abstract, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 146, 14))
 
     constructor () {}
 }
 foo.as = class {
 >foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
+>class {    constructor () {}} : Symbol(as, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 149, 8))
 
     constructor () {}
 }
 foo.asserts = class {
 >foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
+>class {    constructor () {}} : Symbol(asserts, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 152, 13))
 
     constructor () {}
 }
 foo.any = class {
 >foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
+>class {    constructor () {}} : Symbol(any, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 155, 9))
 
     constructor () {}
 }
 foo.async = class {
 >foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
+>class {    constructor () {}} : Symbol(async, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 158, 11))
 
     constructor () {}
 }
 foo.await = class {
 >foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
+>class {    constructor () {}} : Symbol(await, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 161, 11))
 
     constructor () {}
 }
 foo.boolean = class {
 >foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
+>class {    constructor () {}} : Symbol(boolean, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 164, 13))
 
     constructor () {}
 }
 foo.constructor = class {
 >foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
+>class {    constructor () {}} : Symbol(constructor, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 167, 17))
 
     constructor () {}
 }
 foo.declare = class {
 >foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
+>class {    constructor () {}} : Symbol(declare, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 170, 13))
 
     constructor () {}
 }
 foo.get = class {
 >foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
+>class {    constructor () {}} : Symbol(get, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 173, 9))
 
     constructor () {}
 }
 foo.infer = class {
 >foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
+>class {    constructor () {}} : Symbol(infer, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 176, 11))
 
     constructor () {}
 }
 foo.is = class {
 >foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
+>class {    constructor () {}} : Symbol(is, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 179, 8))
 
     constructor () {}
 }
 foo.keyof = class {
 >foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
+>class {    constructor () {}} : Symbol(keyof, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 182, 11))
 
     constructor () {}
 }
 foo.module = class {
 >foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
+>class {    constructor () {}} : Symbol(module, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 185, 12))
 
     constructor () {}
 }
 foo.namespace = class {
 >foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
+>class {    constructor () {}} : Symbol(namespace, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 188, 15))
 
     constructor () {}
 }
 foo.never = class {
 >foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
+>class {    constructor () {}} : Symbol(never, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 191, 11))
 
     constructor () {}
 }
 foo.readonly = class {
 >foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
+>class {    constructor () {}} : Symbol(readonly, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 194, 14))
 
     constructor () {}
 }
 foo.require = class {
 >foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
+>class {    constructor () {}} : Symbol(require, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 197, 13))
 
     constructor () {}
 }
 foo.number = class {
 >foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
+>class {    constructor () {}} : Symbol(number, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 200, 12))
 
     constructor () {}
 }
 foo.object = class {
 >foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
+>class {    constructor () {}} : Symbol(object, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 203, 12))
 
     constructor () {}
 }
 foo.set = class {
 >foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
+>class {    constructor () {}} : Symbol(set, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 206, 9))
 
     constructor () {}
 }
 foo.string = class {
 >foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
+>class {    constructor () {}} : Symbol(string, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 209, 12))
 
     constructor () {}
 }
 foo.symbol = class {
 >foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
+>class {    constructor () {}} : Symbol(symbol, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 212, 12))
 
     constructor () {}
 }
 foo.type = class {
 >foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
+>class {    constructor () {}} : Symbol(type, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 215, 10))
 
     constructor () {}
 }
 foo.undefined = class {
 >foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
+>class {    constructor () {}} : Symbol(undefined, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 218, 15))
 
     constructor () {}
 }
 foo.unique = class {
 >foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
+>class {    constructor () {}} : Symbol(unique, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 221, 12))
 
     constructor () {}
 }
 foo.unknown = class {
 >foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
+>class {    constructor () {}} : Symbol(unknown, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 224, 13))
 
     constructor () {}
 }
 foo.from = class {
 >foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
+>class {    constructor () {}} : Symbol(from, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 227, 10))
 
     constructor () {}
 }
 foo.global = class {
 >foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
+>class {    constructor () {}} : Symbol(global, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 230, 12))
 
     constructor () {}
 }
 foo.bigint = class {
 >foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
+>class {    constructor () {}} : Symbol(bigint, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 233, 12))
 
     constructor () {}
 }
 foo.of = class {
 >foo : Symbol(foo, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 0, 5))
+>class {    constructor () {}} : Symbol(of, Decl(convertClassExpressionToFunctionFromObjectProperty1.ts, 236, 8))
 
     constructor () {}
 }
diff --git a/tests/baselines/reference/convertClassExpressionToFunctionFromObjectProperty2.symbols b/tests/baselines/reference/convertClassExpressionToFunctionFromObjectProperty2.symbols
index aeb1957cdcf..a72c1e9b337 100644
--- a/tests/baselines/reference/convertClassExpressionToFunctionFromObjectProperty2.symbols
+++ b/tests/baselines/reference/convertClassExpressionToFunctionFromObjectProperty2.symbols
@@ -2,11 +2,13 @@
 ({
     x: class {
 >x : Symbol(x, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 0, 2))
+>class {        constructor() { }    } : Symbol(x, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 1, 6))
 
         constructor() { }
     },
     y: class {
 >y : Symbol(y, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 3, 6))
+>class {        constructor() { }    } : Symbol(y, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 4, 6))
 
         constructor() { }
     },
@@ -14,381 +16,457 @@
     // keywords
     break: class {
 >break : Symbol(break, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 6, 6))
+>class {        constructor() { }    } : Symbol(break, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 9, 10))
 
         constructor() { }
     },
     case: class {
 >case : Symbol(case, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 11, 6))
+>class {        constructor() { }    } : Symbol(case, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 12, 9))
 
         constructor() { }
     },
     catch: class {
 >catch : Symbol(catch, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 14, 6))
+>class {        constructor() { }    } : Symbol(catch, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 15, 10))
 
         constructor() { }
     },
     class: class {
 >class : Symbol(class, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 17, 6))
+>class {        constructor() { }    } : Symbol(class, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 18, 10))
 
         constructor() { }
     },
     const: class {
 >const : Symbol(const, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 20, 6))
+>class {        constructor() { }    } : Symbol(const, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 21, 10))
 
         constructor() { }
     },
     continue: class {
 >continue : Symbol(continue, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 23, 6))
+>class {        constructor() { }    } : Symbol(continue, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 24, 13))
 
         constructor() { }
     },
     debugger: class {
 >debugger : Symbol(debugger, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 26, 6))
+>class {        constructor() { }    } : Symbol(debugger, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 27, 13))
 
         constructor() { }
     },
     default: class {
 >default : Symbol(default, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 29, 6))
+>class {        constructor() { }    } : Symbol(default, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 30, 12))
 
         constructor() { }
     },
     delete: class {
 >delete : Symbol(delete, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 32, 6))
+>class {        constructor() { }    } : Symbol(delete, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 33, 11))
 
         constructor() { }
     },
     do: class {
 >do : Symbol(do, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 35, 6))
+>class {        constructor() { }    } : Symbol(do, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 36, 7))
 
         constructor() { }
     },
     else: class {
 >else : Symbol(else, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 38, 6))
+>class {        constructor() { }    } : Symbol(else, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 39, 9))
 
         constructor() { }
     },
     enum: class {
 >enum : Symbol(enum, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 41, 6))
+>class {        constructor() { }    } : Symbol(enum, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 42, 9))
 
         constructor() { }
     },
     export: class {
 >export : Symbol(export, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 44, 6))
+>class {        constructor() { }    } : Symbol(export, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 45, 11))
 
         constructor() { }
     },
     extends: class {
 >extends : Symbol(extends, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 47, 6))
+>class {        constructor() { }    } : Symbol(extends, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 48, 12))
 
         constructor() { }
     },
     false: class {
 >false : Symbol(false, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 50, 6))
+>class {        constructor() { }    } : Symbol(false, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 51, 10))
 
         constructor() { }
     },
     finally: class {
 >finally : Symbol(finally, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 53, 6))
+>class {        constructor() { }    } : Symbol(finally, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 54, 12))
 
         constructor() { }
     },
     for: class {
 >for : Symbol(for, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 56, 6))
+>class {        constructor() { }    } : Symbol(for, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 57, 8))
 
         constructor() { }
     },
     function: class {
 >function : Symbol(function, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 59, 6))
+>class {        constructor() { }    } : Symbol(function, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 60, 13))
 
         constructor() { }
     },
     if: class {
 >if : Symbol(if, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 62, 6))
+>class {        constructor() { }    } : Symbol(if, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 63, 7))
 
         constructor() { }
     },
     import: class {
 >import : Symbol(import, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 65, 6))
+>class {        constructor() { }    } : Symbol(import, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 66, 11))
 
         constructor() { }
     },
     in: class {
 >in : Symbol(in, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 68, 6))
+>class {        constructor() { }    } : Symbol(in, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 69, 7))
 
         constructor() { }
     },
     instanceof: class {
 >instanceof : Symbol(instanceof, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 71, 6))
+>class {        constructor() { }    } : Symbol(instanceof, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 72, 15))
 
         constructor() { }
     },
     new: class {
 >new : Symbol(new, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 74, 6))
+>class {        constructor() { }    } : Symbol(new, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 75, 8))
 
         constructor() { }
     },
     null: class {
 >null : Symbol(null, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 77, 6))
+>class {        constructor() { }    } : Symbol(null, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 78, 9))
 
         constructor() { }
     },
     return: class {
 >return : Symbol(return, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 80, 6))
+>class {        constructor() { }    } : Symbol(return, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 81, 11))
 
         constructor() { }
     },
     super: class {
 >super : Symbol(super, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 83, 6))
+>class {        constructor() { }    } : Symbol(super, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 84, 10))
 
         constructor() { }
     },
     switch: class {
 >switch : Symbol(switch, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 86, 6))
+>class {        constructor() { }    } : Symbol(switch, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 87, 11))
 
         constructor() { }
     },
     this: class {
 >this : Symbol(this, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 89, 6))
+>class {        constructor() { }    } : Symbol(this, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 90, 9))
 
         constructor() { }
     },
     throw: class {
 >throw : Symbol(throw, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 92, 6))
+>class {        constructor() { }    } : Symbol(throw, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 93, 10))
 
         constructor() { }
     },
     true: class {
 >true : Symbol(true, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 95, 6))
+>class {        constructor() { }    } : Symbol(true, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 96, 9))
 
         constructor() { }
     },
     try: class {
 >try : Symbol(try, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 98, 6))
+>class {        constructor() { }    } : Symbol(try, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 99, 8))
 
         constructor() { }
     },
     typeof: class {
 >typeof : Symbol(typeof, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 101, 6))
+>class {        constructor() { }    } : Symbol(typeof, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 102, 11))
 
         constructor() { }
     },
     var: class {
 >var : Symbol(var, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 104, 6))
+>class {        constructor() { }    } : Symbol(var, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 105, 8))
 
         constructor() { }
     },
     void: class {
 >void : Symbol(void, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 107, 6))
+>class {        constructor() { }    } : Symbol(void, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 108, 9))
 
         constructor() { }
     },
     while: class {
 >while : Symbol(while, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 110, 6))
+>class {        constructor() { }    } : Symbol(while, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 111, 10))
 
         constructor() { }
     },
     with: class {
 >with : Symbol(with, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 113, 6))
+>class {        constructor() { }    } : Symbol(with, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 114, 9))
 
         constructor() { }
     },
     implements: class {
 >implements : Symbol(implements, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 116, 6))
+>class {        constructor() { }    } : Symbol(implements, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 117, 15))
 
         constructor() { }
     },
     interface: class {
 >interface : Symbol(interface, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 119, 6))
+>class {        constructor() { }    } : Symbol(interface, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 120, 14))
 
         constructor() { }
     },
     let: class {
 >let : Symbol(let, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 122, 6))
+>class {        constructor() { }    } : Symbol(let, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 123, 8))
 
         constructor() { }
     },
     package: class {
 >package : Symbol(package, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 125, 6))
+>class {        constructor() { }    } : Symbol(package, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 126, 12))
 
         constructor() { }
     },
     private: class {
 >private : Symbol(private, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 128, 6))
+>class {        constructor() { }    } : Symbol(private, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 129, 12))
 
         constructor() { }
     },
     protected: class {
 >protected : Symbol(protected, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 131, 6))
+>class {        constructor() { }    } : Symbol(protected, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 132, 14))
 
         constructor() { }
     },
     public: class {
 >public : Symbol(public, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 134, 6))
+>class {        constructor() { }    } : Symbol(public, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 135, 11))
 
         constructor() { }
     },
     static: class {
 >static : Symbol(static, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 137, 6))
+>class {        constructor() { }    } : Symbol(static, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 138, 11))
 
         constructor() { }
     },
     yield: class {
 >yield : Symbol(yield, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 140, 6))
+>class {        constructor() { }    } : Symbol(yield, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 141, 10))
 
         constructor() { }
     },
     abstract: class {
 >abstract : Symbol(abstract, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 143, 6))
+>class {        constructor() { }    } : Symbol(abstract, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 144, 13))
 
         constructor() { }
     },
     as: class {
 >as : Symbol(as, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 146, 6))
+>class {        constructor() { }    } : Symbol(as, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 147, 7))
 
         constructor() { }
     },
     asserts: class {
 >asserts : Symbol(asserts, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 149, 6))
+>class {        constructor() { }    } : Symbol(asserts, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 150, 12))
 
         constructor() { }
     },
     any: class {
 >any : Symbol(any, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 152, 6))
+>class {        constructor() { }    } : Symbol(any, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 153, 8))
 
         constructor() { }
     },
     async: class {
 >async : Symbol(async, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 155, 6))
+>class {        constructor() { }    } : Symbol(async, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 156, 10))
 
         constructor() { }
     },
     await: class {
 >await : Symbol(await, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 158, 6))
+>class {        constructor() { }    } : Symbol(await, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 159, 10))
 
         constructor() { }
     },
     boolean: class {
 >boolean : Symbol(boolean, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 161, 6))
+>class {        constructor() { }    } : Symbol(boolean, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 162, 12))
 
         constructor() { }
     },
     constructor: class {
 >constructor : Symbol(constructor, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 164, 6))
+>class {        constructor() { }    } : Symbol(constructor, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 165, 16))
 
         constructor() { }
     },
     declare: class {
 >declare : Symbol(declare, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 167, 6))
+>class {        constructor() { }    } : Symbol(declare, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 168, 12))
 
         constructor() { }
     },
     get: class {
 >get : Symbol(get, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 170, 6))
+>class {        constructor() { }    } : Symbol(get, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 171, 8))
 
         constructor() { }
     },
     infer: class {
 >infer : Symbol(infer, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 173, 6))
+>class {        constructor() { }    } : Symbol(infer, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 174, 10))
 
         constructor() { }
     },
     is: class {
 >is : Symbol(is, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 176, 6))
+>class {        constructor() { }    } : Symbol(is, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 177, 7))
 
         constructor() { }
     },
     keyof: class {
 >keyof : Symbol(keyof, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 179, 6))
+>class {        constructor() { }    } : Symbol(keyof, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 180, 10))
 
         constructor() { }
     },
     module: class {
 >module : Symbol(module, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 182, 6))
+>class {        constructor() { }    } : Symbol(module, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 183, 11))
 
         constructor() { }
     },
     namespace: class {
 >namespace : Symbol(namespace, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 185, 6))
+>class {        constructor() { }    } : Symbol(namespace, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 186, 14))
 
         constructor() { }
     },
     never: class {
 >never : Symbol(never, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 188, 6))
+>class {        constructor() { }    } : Symbol(never, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 189, 10))
 
         constructor() { }
     },
     readonly: class {
 >readonly : Symbol(readonly, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 191, 6))
+>class {        constructor() { }    } : Symbol(readonly, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 192, 13))
 
         constructor() { }
     },
     require: class {
 >require : Symbol(require, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 194, 6))
+>class {        constructor() { }    } : Symbol(require, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 195, 12))
 
         constructor() { }
     },
     number: class {
 >number : Symbol(number, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 197, 6))
+>class {        constructor() { }    } : Symbol(number, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 198, 11))
 
         constructor() { }
     },
     object: class {
 >object : Symbol(object, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 200, 6))
+>class {        constructor() { }    } : Symbol(object, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 201, 11))
 
         constructor() { }
     },
     set: class {
 >set : Symbol(set, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 203, 6))
+>class {        constructor() { }    } : Symbol(set, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 204, 8))
 
         constructor() { }
     },
     string: class {
 >string : Symbol(string, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 206, 6))
+>class {        constructor() { }    } : Symbol(string, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 207, 11))
 
         constructor() { }
     },
     symbol: class {
 >symbol : Symbol(symbol, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 209, 6))
+>class {        constructor() { }    } : Symbol(symbol, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 210, 11))
 
         constructor() { }
     },
     type: class {
 >type : Symbol(type, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 212, 6))
+>class {        constructor() { }    } : Symbol(type, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 213, 9))
 
         constructor() { }
     },
     undefined: class {
 >undefined : Symbol(undefined, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 215, 6))
+>class {        constructor() { }    } : Symbol(undefined, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 216, 14))
 
         constructor() { }
     },
     unique: class {
 >unique : Symbol(unique, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 218, 6))
+>class {        constructor() { }    } : Symbol(unique, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 219, 11))
 
         constructor() { }
     },
     unknown: class {
 >unknown : Symbol(unknown, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 221, 6))
+>class {        constructor() { }    } : Symbol(unknown, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 222, 12))
 
         constructor() { }
     },
     from: class {
 >from : Symbol(from, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 224, 6))
+>class {        constructor() { }    } : Symbol(from, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 225, 9))
 
         constructor() { }
     },
     global: class {
 >global : Symbol(global, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 227, 6))
+>class {        constructor() { }    } : Symbol(global, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 228, 11))
 
         constructor() { }
     },
     bigint: class {
 >bigint : Symbol(bigint, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 230, 6))
+>class {        constructor() { }    } : Symbol(bigint, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 231, 11))
 
         constructor() { }
     },
     of: class {
 >of : Symbol(of, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 233, 6))
+>class {        constructor() { }    } : Symbol(of, Decl(convertClassExpressionToFunctionFromObjectProperty2.ts, 234, 7))
 
         constructor() { }
     }
diff --git a/tests/baselines/reference/declarationEmitExpressionInExtends4.symbols b/tests/baselines/reference/declarationEmitExpressionInExtends4.symbols
index a0feadf3b9b..00777e8b755 100644
--- a/tests/baselines/reference/declarationEmitExpressionInExtends4.symbols
+++ b/tests/baselines/reference/declarationEmitExpressionInExtends4.symbols
@@ -3,6 +3,7 @@ function getSomething() {
 >getSomething : Symbol(getSomething, Decl(declarationEmitExpressionInExtends4.ts, 0, 0))
 
     return class D { }
+>class D { } : Symbol(D, Decl(declarationEmitExpressionInExtends4.ts, 1, 10))
 >D : Symbol(D, Decl(declarationEmitExpressionInExtends4.ts, 1, 10))
 }
 
diff --git a/tests/baselines/reference/declarationEmitMixinPrivateProtected.symbols b/tests/baselines/reference/declarationEmitMixinPrivateProtected.symbols
index 8f543a285d7..6d39c5ef8a2 100644
--- a/tests/baselines/reference/declarationEmitMixinPrivateProtected.symbols
+++ b/tests/baselines/reference/declarationEmitMixinPrivateProtected.symbols
@@ -8,6 +8,7 @@ declare function mix<TMix>(mixin: TMix): TMix;
 
 const DisposableMixin = class {
 >DisposableMixin : Symbol(DisposableMixin, Decl(first.ts, 2, 5))
+>class {    protected _onDispose() {        this._assertIsStripped()    }    private _assertIsStripped() {    }} : Symbol(DisposableMixin, Decl(first.ts, 2, 23))
 
     protected _onDispose() {
 >_onDispose : Symbol(DisposableMixin._onDispose, Decl(first.ts, 2, 31))
@@ -47,6 +48,7 @@ declare function mix<TMix>(mixin: TMix): TMix;
 
 const DisposableMixin = class {
 >DisposableMixin : Symbol(DisposableMixin, Decl(another.ts, 2, 5))
+>class {    protected _onDispose() {        this._assertIsStripped()    }    private _assertIsStripped() {    }} : Symbol(DisposableMixin, Decl(another.ts, 2, 23))
 
     protected _onDispose() {
 >_onDispose : Symbol(DisposableMixin._onDispose, Decl(another.ts, 2, 31))
diff --git a/tests/baselines/reference/declarationEmitPrivateNameCausesError.symbols b/tests/baselines/reference/declarationEmitPrivateNameCausesError.symbols
index 8a0c4c24408..d6f9df45d50 100644
--- a/tests/baselines/reference/declarationEmitPrivateNameCausesError.symbols
+++ b/tests/baselines/reference/declarationEmitPrivateNameCausesError.symbols
@@ -12,6 +12,7 @@ export function ignoreExtraVariables<CtorT extends {new(...args:any[]):{}}> (cto
 >CtorT : Symbol(CtorT, Decl(file.ts, 3, 37))
 
     return class extends ctor {
+>class extends ctor {        [IGNORE_EXTRA_VARIABLES] = true; //An unexported constant is used    } : Symbol((Anonymous class), Decl(file.ts, 4, 10))
 >ctor : Symbol(ctor, Decl(file.ts, 3, 77))
 
         [IGNORE_EXTRA_VARIABLES] = true; //An unexported constant is used
diff --git a/tests/baselines/reference/declarationNoDanglingGenerics.symbols b/tests/baselines/reference/declarationNoDanglingGenerics.symbols
index 4cc6949542d..555a1abc30f 100644
--- a/tests/baselines/reference/declarationNoDanglingGenerics.symbols
+++ b/tests/baselines/reference/declarationNoDanglingGenerics.symbols
@@ -31,6 +31,8 @@ function ClassFactory<TKind extends string>(kind: TKind) {
 >kind : Symbol(kind, Decl(declarationNoDanglingGenerics.ts, 9, 44))
 
   return class {
+>class {    static readonly THE_KIND: TKind = kind;    readonly kind: TKind = kind;  } : Symbol((Anonymous class), Decl(declarationNoDanglingGenerics.ts, 12, 8))
+
     static readonly THE_KIND: TKind = kind;
 >THE_KIND : Symbol((Anonymous class).THE_KIND, Decl(declarationNoDanglingGenerics.ts, 12, 16))
 >TKind : Symbol(TKind, Decl(declarationNoDanglingGenerics.ts, 9, 22))
diff --git a/tests/baselines/reference/declarationsForFileShadowingGlobalNoError.symbols b/tests/baselines/reference/declarationsForFileShadowingGlobalNoError.symbols
index 70b06cd5209..c2aa8d480d8 100644
--- a/tests/baselines/reference/declarationsForFileShadowingGlobalNoError.symbols
+++ b/tests/baselines/reference/declarationsForFileShadowingGlobalNoError.symbols
@@ -24,6 +24,7 @@ export const mixin = (Base: Constructor) => {
 >Constructor : Symbol(Constructor, Decl(index.ts, 1, 31))
 
   return class extends Base {
+>class extends Base {    get(domNode: DOMNode) {}  } : Symbol((Anonymous class), Decl(index.ts, 6, 8))
 >Base : Symbol(Base, Decl(index.ts, 5, 22))
 
     get(domNode: DOMNode) {}
diff --git a/tests/baselines/reference/decoratorsOnComputedProperties.symbols b/tests/baselines/reference/decoratorsOnComputedProperties.symbols
index def5c2c50d6..aaab779c529 100644
--- a/tests/baselines/reference/decoratorsOnComputedProperties.symbols
+++ b/tests/baselines/reference/decoratorsOnComputedProperties.symbols
@@ -98,6 +98,7 @@ class A {
 }
 
 void class B {
+>class B {    @x ["property"]: any;    @x [Symbol.toStringTag]: any;    @x ["property2"]: any = 2;    @x [Symbol.iterator]: any = null;    ["property3"]: any;    [Symbol.isConcatSpreadable]: any;    ["property4"]: any = 2;    [Symbol.match]: any = null;    [foo()]: any;    @x [foo()]: any;    @x [foo()]: any = null;    [fieldNameA]: any;    @x [fieldNameB]: any;    @x [fieldNameC]: any = null;} : Symbol(B, Decl(decoratorsOnComputedProperties.ts, 25, 4))
 >B : Symbol(B, Decl(decoratorsOnComputedProperties.ts, 25, 4))
 
     @x ["property"]: any;
@@ -254,6 +255,7 @@ class C {
 }
 
 void class D {
+>class D {    @x ["property"]: any;    @x [Symbol.toStringTag]: any;    @x ["property2"]: any = 2;    @x [Symbol.iterator]: any = null;    ["property3"]: any;    [Symbol.isConcatSpreadable]: any;    ["property4"]: any = 2;    [Symbol.match]: any = null;    [foo()]: any;    @x [foo()]: any;    @x [foo()]: any = null;    [fieldNameA]: any;    @x [fieldNameB]: any;    @x [fieldNameC]: any = null;    ["some" + "method"]() {}} : Symbol(D, Decl(decoratorsOnComputedProperties.ts, 60, 4))
 >D : Symbol(D, Decl(decoratorsOnComputedProperties.ts, 60, 4))
 
     @x ["property"]: any;
@@ -413,6 +415,7 @@ class E {
 }
 
 void class F {
+>class F {    @x ["property"]: any;    @x [Symbol.toStringTag]: any;    @x ["property2"]: any = 2;    @x [Symbol.iterator]: any = null;    ["property3"]: any;    [Symbol.isConcatSpreadable]: any;    ["property4"]: any = 2;    [Symbol.match]: any = null;    [foo()]: any;    @x [foo()]: any;    @x [foo()]: any = null;    ["some" + "method"]() {}    [fieldNameA]: any;    @x [fieldNameB]: any;    @x [fieldNameC]: any = null;} : Symbol(F, Decl(decoratorsOnComputedProperties.ts, 96, 4))
 >F : Symbol(F, Decl(decoratorsOnComputedProperties.ts, 96, 4))
 
     @x ["property"]: any;
@@ -575,6 +578,7 @@ class G {
 }
 
 void class H {
+>class H {    @x ["property"]: any;    @x [Symbol.toStringTag]: any;    @x ["property2"]: any = 2;    @x [Symbol.iterator]: any = null;    ["property3"]: any;    [Symbol.isConcatSpreadable]: any;    ["property4"]: any = 2;    [Symbol.match]: any = null;    [foo()]: any;    @x [foo()]: any;    @x [foo()]: any = null;    ["some" + "method"]() {}    [fieldNameA]: any;    @x [fieldNameB]: any;    ["some" + "method2"]() {}    @x [fieldNameC]: any = null;} : Symbol(H, Decl(decoratorsOnComputedProperties.ts, 133, 4))
 >H : Symbol(H, Decl(decoratorsOnComputedProperties.ts, 133, 4))
 
     @x ["property"]: any;
@@ -741,6 +745,7 @@ class I {
 }
 
 void class J {
+>class J {    @x ["property"]: any;    @x [Symbol.toStringTag]: any;    @x ["property2"]: any = 2;    @x [Symbol.iterator]: any = null;    ["property3"]: any;    [Symbol.isConcatSpreadable]: any;    ["property4"]: any = 2;    [Symbol.match]: any = null;    [foo()]: any;    @x [foo()]: any;    @x [foo()]: any = null;    @x ["some" + "method"]() {}    [fieldNameA]: any;    @x [fieldNameB]: any;    ["some" + "method2"]() {}    @x [fieldNameC]: any = null;} : Symbol(J, Decl(decoratorsOnComputedProperties.ts, 171, 4))
 >J : Symbol(J, Decl(decoratorsOnComputedProperties.ts, 171, 4))
 
     @x ["property"]: any;
diff --git a/tests/baselines/reference/decrementAndIncrementOperators.symbols b/tests/baselines/reference/decrementAndIncrementOperators.symbols
index 9a16cf15cc0..8d4ccf6b711 100644
--- a/tests/baselines/reference/decrementAndIncrementOperators.symbols
+++ b/tests/baselines/reference/decrementAndIncrementOperators.symbols
@@ -47,15 +47,21 @@ x--;
 >x : Symbol(x, Decl(decrementAndIncrementOperators.ts, 0, 3))
 
 (x)++;
+>(x) : Symbol(x, Decl(decrementAndIncrementOperators.ts, 0, 3))
 >x : Symbol(x, Decl(decrementAndIncrementOperators.ts, 0, 3))
 
 --(x);
+>(x) : Symbol(x, Decl(decrementAndIncrementOperators.ts, 0, 3))
 >x : Symbol(x, Decl(decrementAndIncrementOperators.ts, 0, 3))
 
 ((x))++;
+>((x)) : Symbol(x, Decl(decrementAndIncrementOperators.ts, 0, 3))
+>(x) : Symbol(x, Decl(decrementAndIncrementOperators.ts, 0, 3))
 >x : Symbol(x, Decl(decrementAndIncrementOperators.ts, 0, 3))
 
 ((x))--;
+>((x)) : Symbol(x, Decl(decrementAndIncrementOperators.ts, 0, 3))
+>(x) : Symbol(x, Decl(decrementAndIncrementOperators.ts, 0, 3))
 >x : Symbol(x, Decl(decrementAndIncrementOperators.ts, 0, 3))
 
 x[x++]++;
diff --git a/tests/baselines/reference/defaultValueInFunctionTypes.symbols b/tests/baselines/reference/defaultValueInFunctionTypes.symbols
index ce4f8c3d4d0..8c7a6057854 100644
--- a/tests/baselines/reference/defaultValueInFunctionTypes.symbols
+++ b/tests/baselines/reference/defaultValueInFunctionTypes.symbols
@@ -6,5 +6,6 @@ var x: (a: number = 1) => number;
 var y = <(a : string = "") => any>(undefined)
 >y : Symbol(y, Decl(defaultValueInFunctionTypes.ts, 1, 3))
 >a : Symbol(a, Decl(defaultValueInFunctionTypes.ts, 1, 10))
+>(undefined) : Symbol(undefined)
 >undefined : Symbol(undefined)
 
diff --git a/tests/baselines/reference/deleteChain.symbols b/tests/baselines/reference/deleteChain.symbols
index 7efc0abae47..61d9d61182d 100644
--- a/tests/baselines/reference/deleteChain.symbols
+++ b/tests/baselines/reference/deleteChain.symbols
@@ -9,6 +9,7 @@ delete o1?.b;
 >b : Symbol(b, Decl(deleteChain.ts, 0, 31))
 
 delete (o1?.b);
+>(o1?.b) : Symbol(b, Decl(deleteChain.ts, 0, 31))
 >o1?.b : Symbol(b, Decl(deleteChain.ts, 0, 31))
 >o1 : Symbol(o1, Decl(deleteChain.ts, 0, 13))
 >b : Symbol(b, Decl(deleteChain.ts, 0, 31))
@@ -26,6 +27,7 @@ delete o2?.b.c;
 >c : Symbol(c, Decl(deleteChain.ts, 4, 36))
 
 delete (o2?.b.c);
+>(o2?.b.c) : Symbol(c, Decl(deleteChain.ts, 4, 36))
 >o2?.b.c : Symbol(c, Decl(deleteChain.ts, 4, 36))
 >o2?.b : Symbol(b, Decl(deleteChain.ts, 4, 31))
 >o2 : Symbol(o2, Decl(deleteChain.ts, 4, 13))
@@ -45,6 +47,7 @@ delete o3.b?.c;
 >c : Symbol(c, Decl(deleteChain.ts, 8, 36))
 
 delete (o3.b?.c);
+>(o3.b?.c) : Symbol(c, Decl(deleteChain.ts, 8, 36))
 >o3.b?.c : Symbol(c, Decl(deleteChain.ts, 8, 36))
 >o3.b : Symbol(b, Decl(deleteChain.ts, 8, 19))
 >o3 : Symbol(o3, Decl(deleteChain.ts, 8, 13))
@@ -71,6 +74,7 @@ delete o4.b?.c.d?.e;
 
 delete (o4.b?.c.d)?.e;
 >(o4.b?.c.d)?.e : Symbol(e, Decl(deleteChain.ts, 12, 36))
+>(o4.b?.c.d) : Symbol(d, Decl(deleteChain.ts, 12, 30))
 >o4.b?.c.d : Symbol(d, Decl(deleteChain.ts, 12, 30))
 >o4.b?.c : Symbol(c, Decl(deleteChain.ts, 12, 25))
 >o4.b : Symbol(b, Decl(deleteChain.ts, 12, 19))
@@ -81,6 +85,7 @@ delete (o4.b?.c.d)?.e;
 >e : Symbol(e, Decl(deleteChain.ts, 12, 36))
 
 delete (o4.b?.c.d?.e);
+>(o4.b?.c.d?.e) : Symbol(e, Decl(deleteChain.ts, 12, 36))
 >o4.b?.c.d?.e : Symbol(e, Decl(deleteChain.ts, 12, 36))
 >o4.b?.c.d : Symbol(d, Decl(deleteChain.ts, 12, 30))
 >o4.b?.c : Symbol(c, Decl(deleteChain.ts, 12, 25))
@@ -110,6 +115,7 @@ delete o5.b?.().c.d?.e;
 >e : Symbol(e, Decl(deleteChain.ts, 17, 38))
 
 delete (o5.b?.().c.d?.e);
+>(o5.b?.().c.d?.e) : Symbol(e, Decl(deleteChain.ts, 17, 38))
 >o5.b?.().c.d?.e : Symbol(e, Decl(deleteChain.ts, 17, 38))
 >o5.b?.().c.d : Symbol(d, Decl(deleteChain.ts, 17, 32))
 >o5.b?.().c : Symbol(c, Decl(deleteChain.ts, 17, 27))
diff --git a/tests/baselines/reference/derivedClassSuperProperties.symbols b/tests/baselines/reference/derivedClassSuperProperties.symbols
index 67d18567ad9..1e27c1c67f7 100644
--- a/tests/baselines/reference/derivedClassSuperProperties.symbols
+++ b/tests/baselines/reference/derivedClassSuperProperties.symbols
@@ -413,6 +413,7 @@ class DerivedWithClassDeclarationExtendingMember extends Base {
 
     memberClass = class { };
 >memberClass : Symbol(DerivedWithClassDeclarationExtendingMember.memberClass, Decl(derivedClassSuperProperties.ts, 192, 63))
+>class { } : Symbol((Anonymous class), Decl(derivedClassSuperProperties.ts, 193, 17))
 
     constructor() {
         class InnerClass extends this.memberClass {
@@ -462,6 +463,7 @@ class DerivedWithClassExpression extends Base {
 >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, --, --))
+>class {            private method() {                return this;            }            private property = 7;            constructor() {                this.property;                this.method();            }        } : Symbol((Anonymous class), Decl(derivedClassSuperProperties.ts, 213, 20))
 
             private method() {
 >method : Symbol((Anonymous class).method, Decl(derivedClassSuperProperties.ts, 213, 27))
@@ -495,12 +497,14 @@ class DerivedWithClassExpressionExtendingMember extends Base {
 
     memberClass = class { };
 >memberClass : Symbol(DerivedWithClassExpressionExtendingMember.memberClass, Decl(derivedClassSuperProperties.ts, 227, 62))
+>class { } : Symbol((Anonymous class), Decl(derivedClassSuperProperties.ts, 228, 17))
 
     constructor() {
         console.log(class extends this.memberClass { });
 >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, --, --))
+>class extends this.memberClass { } : Symbol((Anonymous class), Decl(derivedClassSuperProperties.ts, 230, 20))
 >this.memberClass : Symbol(DerivedWithClassExpressionExtendingMember.memberClass, Decl(derivedClassSuperProperties.ts, 227, 62))
 >this : Symbol(DerivedWithClassExpressionExtendingMember, Decl(derivedClassSuperProperties.ts, 225, 1))
 >memberClass : Symbol(DerivedWithClassExpressionExtendingMember.memberClass, Decl(derivedClassSuperProperties.ts, 227, 62))
@@ -522,6 +526,7 @@ class DerivedWithDerivedClassExpression extends Base {
 >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, --, --))
+>class extends Base {            constructor() {                super();            }            public foo() {                return this;            }            public bar = () => this;        } : Symbol((Anonymous class), Decl(derivedClassSuperProperties.ts, 238, 20))
 >Base : Symbol(Base, Decl(derivedClassSuperProperties.ts, 0, 28))
 
             constructor() {
@@ -556,6 +561,7 @@ class DerivedWithNewDerivedClassExpression extends Base {
 >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, --, --))
+>class extends Base {            constructor() {                super();            }        } : Symbol((Anonymous class), Decl(derivedClassSuperProperties.ts, 254, 23))
 >Base : Symbol(Base, Decl(derivedClassSuperProperties.ts, 0, 28))
 
             constructor() {
@@ -743,6 +749,7 @@ const DerivedWithLoops = [
 >DerivedWithLoops : Symbol(DerivedWithLoops, Decl(derivedClassSuperProperties.ts, 344, 5))
 
     class extends Base {
+>class extends Base {        prop = true;        constructor() {            for(super();;) {}        }    } : Symbol((Anonymous class), Decl(derivedClassSuperProperties.ts, 344, 26))
 >Base : Symbol(Base, Decl(derivedClassSuperProperties.ts, 0, 28))
 
         prop = true;
@@ -754,6 +761,7 @@ const DerivedWithLoops = [
         }
     },
     class extends Base {
+>class extends Base {        prop = true;        constructor() {            for(a; super();) {}        }    } : Symbol((Anonymous class), Decl(derivedClassSuperProperties.ts, 350, 6))
 >Base : Symbol(Base, Decl(derivedClassSuperProperties.ts, 0, 28))
 
         prop = true;
@@ -766,6 +774,7 @@ const DerivedWithLoops = [
         }
     },
     class extends Base {
+>class extends Base {        prop = true;        constructor() {            for(a; b; super()) {}        }    } : Symbol((Anonymous class), Decl(derivedClassSuperProperties.ts, 356, 6))
 >Base : Symbol(Base, Decl(derivedClassSuperProperties.ts, 0, 28))
 
         prop = true;
@@ -779,6 +788,7 @@ const DerivedWithLoops = [
         }
     },
     class extends Base {
+>class extends Base {        prop = true;        constructor() {            for(; ; super()) { break; }        }    } : Symbol((Anonymous class), Decl(derivedClassSuperProperties.ts, 362, 6))
 >Base : Symbol(Base, Decl(derivedClassSuperProperties.ts, 0, 28))
 
         prop = true;
@@ -790,6 +800,7 @@ const DerivedWithLoops = [
         }
     },
     class extends Base {
+>class extends Base {        prop = true;        constructor() {            for (const x of super()) {}        }    } : Symbol((Anonymous class), Decl(derivedClassSuperProperties.ts, 368, 6))
 >Base : Symbol(Base, Decl(derivedClassSuperProperties.ts, 0, 28))
 
         prop = true;
@@ -802,6 +813,7 @@ const DerivedWithLoops = [
         }
     },
     class extends Base {
+>class extends Base {        prop = true;        constructor() {            while (super()) {}        }    } : Symbol((Anonymous class), Decl(derivedClassSuperProperties.ts, 374, 6))
 >Base : Symbol(Base, Decl(derivedClassSuperProperties.ts, 0, 28))
 
         prop = true;
@@ -813,6 +825,7 @@ const DerivedWithLoops = [
         }
     },
     class extends Base {
+>class extends Base {        prop = true;        constructor() {            do {} while (super());        }    } : Symbol((Anonymous class), Decl(derivedClassSuperProperties.ts, 380, 6))
 >Base : Symbol(Base, Decl(derivedClassSuperProperties.ts, 0, 28))
 
         prop = true;
@@ -824,6 +837,7 @@ const DerivedWithLoops = [
         }
     },
     class extends Base {
+>class extends Base {        prop = true;        constructor() {            if (super()) {}        }    } : Symbol((Anonymous class), Decl(derivedClassSuperProperties.ts, 386, 6))
 >Base : Symbol(Base, Decl(derivedClassSuperProperties.ts, 0, 28))
 
         prop = true;
@@ -835,6 +849,7 @@ const DerivedWithLoops = [
         }
     },
     class extends Base {
+>class extends Base {        prop = true;        constructor() {            switch (super()) {}        }    } : Symbol((Anonymous class), Decl(derivedClassSuperProperties.ts, 392, 6))
 >Base : Symbol(Base, Decl(derivedClassSuperProperties.ts, 0, 28))
 
         prop = true;
diff --git a/tests/baselines/reference/doubleMixinConditionalTypeBaseClassWorks.symbols b/tests/baselines/reference/doubleMixinConditionalTypeBaseClassWorks.symbols
index 52bf6d41484..fe48a0823ec 100644
--- a/tests/baselines/reference/doubleMixinConditionalTypeBaseClassWorks.symbols
+++ b/tests/baselines/reference/doubleMixinConditionalTypeBaseClassWorks.symbols
@@ -9,6 +9,7 @@ const Mixin1 = <C extends Constructor>(Base: C) => class extends Base { private
 >Constructor : Symbol(Constructor, Decl(doubleMixinConditionalTypeBaseClassWorks.ts, 0, 0))
 >Base : Symbol(Base, Decl(doubleMixinConditionalTypeBaseClassWorks.ts, 2, 39))
 >C : Symbol(C, Decl(doubleMixinConditionalTypeBaseClassWorks.ts, 2, 16))
+>class extends Base { private _fooPrivate: {}; } : Symbol((Anonymous class), Decl(doubleMixinConditionalTypeBaseClassWorks.ts, 2, 50))
 >Base : Symbol(Base, Decl(doubleMixinConditionalTypeBaseClassWorks.ts, 2, 39))
 >_fooPrivate : Symbol((Anonymous class)._fooPrivate, Decl(doubleMixinConditionalTypeBaseClassWorks.ts, 2, 71))
 
@@ -26,6 +27,7 @@ const Mixin2 = <C extends FooConstructor>(Base: C) => class extends Base {};
 >FooConstructor : Symbol(FooConstructor, Decl(doubleMixinConditionalTypeBaseClassWorks.ts, 2, 98))
 >Base : Symbol(Base, Decl(doubleMixinConditionalTypeBaseClassWorks.ts, 5, 42))
 >C : Symbol(C, Decl(doubleMixinConditionalTypeBaseClassWorks.ts, 5, 16))
+>class extends Base {} : Symbol((Anonymous class), Decl(doubleMixinConditionalTypeBaseClassWorks.ts, 5, 53))
 >Base : Symbol(Base, Decl(doubleMixinConditionalTypeBaseClassWorks.ts, 5, 42))
 
 class C extends Mixin2(Mixin1(Object)) {}
diff --git a/tests/baselines/reference/emitClassExpressionInDeclarationFile.symbols b/tests/baselines/reference/emitClassExpressionInDeclarationFile.symbols
index 537838937c5..f0e600a982e 100644
--- a/tests/baselines/reference/emitClassExpressionInDeclarationFile.symbols
+++ b/tests/baselines/reference/emitClassExpressionInDeclarationFile.symbols
@@ -1,6 +1,7 @@
 === tests/cases/compiler/emitClassExpressionInDeclarationFile.ts ===
 export var simpleExample = class {
 >simpleExample : Symbol(simpleExample, Decl(emitClassExpressionInDeclarationFile.ts, 0, 10))
+>class {    static getTags() { }    tags() { }} : Symbol(simpleExample, Decl(emitClassExpressionInDeclarationFile.ts, 0, 26))
 
     static getTags() { }
 >getTags : Symbol(simpleExample.getTags, Decl(emitClassExpressionInDeclarationFile.ts, 0, 34))
@@ -10,6 +11,7 @@ export var simpleExample = class {
 }
 export var circularReference = class C {
 >circularReference : Symbol(circularReference, Decl(emitClassExpressionInDeclarationFile.ts, 4, 10))
+>class C {    static getTags(c: C): C { return c }    tags(c: C): C { return c }} : Symbol(C, Decl(emitClassExpressionInDeclarationFile.ts, 4, 30))
 >C : Symbol(C, Decl(emitClassExpressionInDeclarationFile.ts, 4, 30))
 
     static getTags(c: C): C { return c }
@@ -53,6 +55,7 @@ export function WithTags<T extends Constructor<FooItem>>(Base: T) {
 >T : Symbol(T, Decl(emitClassExpressionInDeclarationFile.ts, 16, 25))
 
     return class extends Base {
+>class extends Base {        static getTags(): void { }        tags(): void { }    } : Symbol((Anonymous class), Decl(emitClassExpressionInDeclarationFile.ts, 17, 10))
 >Base : Symbol(Base, Decl(emitClassExpressionInDeclarationFile.ts, 16, 57))
 
         static getTags(): void { }
diff --git a/tests/baselines/reference/emitClassExpressionInDeclarationFile2.symbols b/tests/baselines/reference/emitClassExpressionInDeclarationFile2.symbols
index e2fcd479019..8dd08318868 100644
--- a/tests/baselines/reference/emitClassExpressionInDeclarationFile2.symbols
+++ b/tests/baselines/reference/emitClassExpressionInDeclarationFile2.symbols
@@ -1,6 +1,7 @@
 === tests/cases/compiler/emitClassExpressionInDeclarationFile2.ts ===
 export var noPrivates = class {
 >noPrivates : Symbol(noPrivates, Decl(emitClassExpressionInDeclarationFile2.ts, 0, 10))
+>class {    static getTags() { }    tags() { }    private static ps = -1    private p = 12} : Symbol(noPrivates, Decl(emitClassExpressionInDeclarationFile2.ts, 0, 23))
 
     static getTags() { }
 >getTags : Symbol(noPrivates.getTags, Decl(emitClassExpressionInDeclarationFile2.ts, 0, 31))
@@ -44,6 +45,7 @@ export function WithTags<T extends Constructor<FooItem>>(Base: T) {
 >T : Symbol(T, Decl(emitClassExpressionInDeclarationFile2.ts, 15, 25))
 
     return class extends Base {
+>class extends Base {        static getTags(): void { }        tags(): void { }    } : Symbol((Anonymous class), Decl(emitClassExpressionInDeclarationFile2.ts, 16, 10))
 >Base : Symbol(Base, Decl(emitClassExpressionInDeclarationFile2.ts, 15, 57))
 
         static getTags(): void { }
diff --git a/tests/baselines/reference/ensureNoCrashExportAssignmentDefineProperrtyPotentialMerge.symbols b/tests/baselines/reference/ensureNoCrashExportAssignmentDefineProperrtyPotentialMerge.symbols
index 4b0737b3fc0..3067bada010 100644
--- a/tests/baselines/reference/ensureNoCrashExportAssignmentDefineProperrtyPotentialMerge.symbols
+++ b/tests/baselines/reference/ensureNoCrashExportAssignmentDefineProperrtyPotentialMerge.symbols
@@ -25,6 +25,7 @@ A.bar = class Q {}
 >A.bar : Symbol(A.bar, Decl(namespacey.js, 0, 12))
 >A : Symbol(A, Decl(namespacey.js, 0, 5), Decl(namespacey.js, 0, 12))
 >bar : Symbol(A.bar, Decl(namespacey.js, 0, 12))
+>class Q {} : Symbol(Q, Decl(namespacey.js, 1, 7))
 >Q : Symbol(Q, Decl(namespacey.js, 1, 7))
 
 module.exports = A;
diff --git a/tests/baselines/reference/errorsWithInvokablesInUnions01.symbols b/tests/baselines/reference/errorsWithInvokablesInUnions01.symbols
index a82cecb7665..3f6dd2f6be1 100644
--- a/tests/baselines/reference/errorsWithInvokablesInUnions01.symbols
+++ b/tests/baselines/reference/errorsWithInvokablesInUnions01.symbols
@@ -42,6 +42,7 @@ export let ctor: IDirectiveLinkFn<number> | ConstructableA | IDirectivePrePost<n
 >IDirectiveLinkFn : Symbol(IDirectiveLinkFn, Decl(errorsWithInvokablesInUnions01.ts, 2, 1))
 >ConstructableA : Symbol(ConstructableA, Decl(errorsWithInvokablesInUnions01.ts, 0, 0))
 >IDirectivePrePost : Symbol(IDirectivePrePost, Decl(errorsWithInvokablesInUnions01.ts, 6, 1))
+>class {    someUnaccountedProp: any;} : Symbol(ctor, Decl(errorsWithInvokablesInUnions01.ts, 15, 88))
 
     someUnaccountedProp: any;
 >someUnaccountedProp : Symbol(ctor.someUnaccountedProp, Decl(errorsWithInvokablesInUnions01.ts, 15, 96))
diff --git a/tests/baselines/reference/exportAssignNonIdentifier.symbols b/tests/baselines/reference/exportAssignNonIdentifier.symbols
index 0c1e7c3611d..a74334782ca 100644
--- a/tests/baselines/reference/exportAssignNonIdentifier.symbols
+++ b/tests/baselines/reference/exportAssignNonIdentifier.symbols
@@ -10,6 +10,7 @@ export = "sausages"; // Ok
 No type information for this code.
 No type information for this code.=== tests/cases/conformance/externalModules/foo3.ts ===
 export = class Foo3 {}; // Error, not an expression
+>class Foo3 {} : Symbol(Foo3, Decl(foo3.ts, 0, 8))
 >Foo3 : Symbol(Foo3, Decl(foo3.ts, 0, 8))
 
 === tests/cases/conformance/externalModules/foo4.ts ===
diff --git a/tests/baselines/reference/exportClassExtendingIntersection.symbols b/tests/baselines/reference/exportClassExtendingIntersection.symbols
index 01b502e28be..adb1dd7e509 100644
--- a/tests/baselines/reference/exportClassExtendingIntersection.symbols
+++ b/tests/baselines/reference/exportClassExtendingIntersection.symbols
@@ -40,6 +40,7 @@ export function MyMixin<T extends Constructor<MyBaseClass<any>>>(base: T): T & C
 >MyMixin : Symbol(MyMixin, Decl(MixinClass.ts, 4, 1), Decl(MixinClass.ts, 0, 55))
 
     return class extends base {
+>class extends base {        mixinProperty: string;    } : Symbol((Anonymous class), Decl(MixinClass.ts, 7, 10))
 >base : Symbol(base, Decl(MixinClass.ts, 6, 65))
 
         mixinProperty: string;
diff --git a/tests/baselines/reference/exportDefaultParenthesizeES6.symbols b/tests/baselines/reference/exportDefaultParenthesizeES6.symbols
index bddaccade51..de761b3075d 100644
--- a/tests/baselines/reference/exportDefaultParenthesizeES6.symbols
+++ b/tests/baselines/reference/exportDefaultParenthesizeES6.symbols
@@ -1,4 +1,5 @@
 === tests/cases/compiler/classexpr.ts ===
 export default (class Foo {} as any);
+>class Foo {} : Symbol(Foo, Decl(classexpr.ts, 0, 16))
 >Foo : Symbol(Foo, Decl(classexpr.ts, 0, 16))
 
diff --git a/tests/baselines/reference/exportNestedNamespaces.symbols b/tests/baselines/reference/exportNestedNamespaces.symbols
index a63a81c7545..a236c9b0276 100644
--- a/tests/baselines/reference/exportNestedNamespaces.symbols
+++ b/tests/baselines/reference/exportNestedNamespaces.symbols
@@ -20,6 +20,7 @@ exports.Classic = class {
 >exports.Classic : Symbol(Classic, Decl(mod.js, 3, 1))
 >exports : Symbol(Classic, Decl(mod.js, 3, 1))
 >Classic : Symbol(Classic, Decl(mod.js, 3, 1))
+>class {    constructor() {        this.p = 1    }} : Symbol(Classic, Decl(mod.js, 4, 17))
 
     constructor() {
         this.p = 1
diff --git a/tests/baselines/reference/exportPropertyAssignmentNameResolution.symbols b/tests/baselines/reference/exportPropertyAssignmentNameResolution.symbols
index eaa7581dec0..2ca35cd6bf8 100644
--- a/tests/baselines/reference/exportPropertyAssignmentNameResolution.symbols
+++ b/tests/baselines/reference/exportPropertyAssignmentNameResolution.symbols
@@ -5,6 +5,7 @@ module.exports.D = class { }
 >module : Symbol(module, Decl(bug24492.js, 0, 0))
 >exports : Symbol(module.exports, Decl(bug24492.js, 0, 0))
 >D : Symbol(D, Decl(bug24492.js, 0, 0))
+>class { } : Symbol(D, Decl(bug24492.js, 0, 18))
 
 new D()
 
diff --git a/tests/baselines/reference/expressionTypeNodeShouldError.symbols b/tests/baselines/reference/expressionTypeNodeShouldError.symbols
index 48ea26a444d..0fd69370c0a 100644
--- a/tests/baselines/reference/expressionTypeNodeShouldError.symbols
+++ b/tests/baselines/reference/expressionTypeNodeShouldError.symbols
@@ -23,6 +23,7 @@ class C {
 
         const x: "".typeof(this.foo);
 >x : Symbol(x, Decl(string.ts, 6, 13))
+>(this.foo) : Symbol(C.foo, Decl(string.ts, 4, 9))
 >this.foo : Symbol(C.foo, Decl(string.ts, 4, 9))
 >this : Symbol(C, Decl(string.ts, 2, 1))
 >foo : Symbol(C.foo, Decl(string.ts, 4, 9))
@@ -61,6 +62,7 @@ class C2 {
 
         const x: 3.141592.typeof(this.foo);
 >x : Symbol(x, Decl(number.ts, 6, 13))
+>(this.foo) : Symbol(C2.foo, Decl(number.ts, 4, 10))
 >this.foo : Symbol(C2.foo, Decl(number.ts, 4, 10))
 >this : Symbol(C2, Decl(number.ts, 2, 1))
 >foo : Symbol(C2.foo, Decl(number.ts, 4, 10))
@@ -99,6 +101,7 @@ class C3 {
 
         const x: false.typeof(this.foo);
 >x : Symbol(x, Decl(boolean.ts, 6, 13))
+>(this.foo) : Symbol(C3.foo, Decl(boolean.ts, 4, 10))
 >this.foo : Symbol(C3.foo, Decl(boolean.ts, 4, 10))
 >this : Symbol(C3, Decl(boolean.ts, 2, 1))
 >foo : Symbol(C3.foo, Decl(boolean.ts, 4, 10))
diff --git a/tests/baselines/reference/externalModuleImmutableBindings.symbols b/tests/baselines/reference/externalModuleImmutableBindings.symbols
index ddad0a8e052..6b48af9d740 100644
--- a/tests/baselines/reference/externalModuleImmutableBindings.symbols
+++ b/tests/baselines/reference/externalModuleImmutableBindings.symbols
@@ -43,6 +43,7 @@ stuff[n]++;
 >n : Symbol(n, Decl(f2.ts, 3, 3))
 
 (stuff.x) = 0;
+>(stuff.x) : Symbol(stuff.x, Decl(f1.ts, 0, 10))
 >stuff.x : Symbol(stuff.x, Decl(f1.ts, 0, 10))
 >stuff : Symbol(stuff, Decl(f2.ts, 1, 6))
 >x : Symbol(stuff.x, Decl(f1.ts, 0, 10))
@@ -59,6 +60,7 @@ stuff[n]++;
 >n : Symbol(n, Decl(f2.ts, 3, 3))
 
 (stuff.x)++;
+>(stuff.x) : Symbol(stuff.x, Decl(f1.ts, 0, 10))
 >stuff.x : Symbol(stuff.x, Decl(f1.ts, 0, 10))
 >stuff : Symbol(stuff, Decl(f2.ts, 1, 6))
 >x : Symbol(stuff.x, Decl(f1.ts, 0, 10))
@@ -107,11 +109,13 @@ for (stuff[n] of []) {}
 >n : Symbol(n, Decl(f2.ts, 3, 3))
 
 for ((stuff.x) in []) {}
+>(stuff.x) : Symbol(stuff.x, Decl(f1.ts, 0, 10))
 >stuff.x : Symbol(stuff.x, Decl(f1.ts, 0, 10))
 >stuff : Symbol(stuff, Decl(f2.ts, 1, 6))
 >x : Symbol(stuff.x, Decl(f1.ts, 0, 10))
 
 for ((stuff.x) of []) {}
+>(stuff.x) : Symbol(stuff.x, Decl(f1.ts, 0, 10))
 >stuff.x : Symbol(stuff.x, Decl(f1.ts, 0, 10))
 >stuff : Symbol(stuff, Decl(f2.ts, 1, 6))
 >x : Symbol(stuff.x, Decl(f1.ts, 0, 10))
diff --git a/tests/baselines/reference/for-inStatementsArray.symbols b/tests/baselines/reference/for-inStatementsArray.symbols
index 9290ae4a92f..0c71ef34d1d 100644
--- a/tests/baselines/reference/for-inStatementsArray.symbols
+++ b/tests/baselines/reference/for-inStatementsArray.symbols
@@ -18,6 +18,7 @@ for (let x in a) {
     let a2 = a[(x)];
 >a2 : Symbol(a2, Decl(for-inStatementsArray.ts, 5, 7))
 >a : Symbol(a, Decl(for-inStatementsArray.ts, 0, 3))
+>(x) : Symbol(x, Decl(for-inStatementsArray.ts, 3, 8))
 >x : Symbol(x, Decl(for-inStatementsArray.ts, 3, 8))
 
     let a3 = a[+x];
@@ -33,6 +34,7 @@ for (let x in a) {
     let b2 = b[(x)];
 >b2 : Symbol(b2, Decl(for-inStatementsArray.ts, 8, 7))
 >b : Symbol(b, Decl(for-inStatementsArray.ts, 1, 3))
+>(x) : Symbol(x, Decl(for-inStatementsArray.ts, 3, 8))
 >x : Symbol(x, Decl(for-inStatementsArray.ts, 3, 8))
 
     let b3 = b[+x];
diff --git a/tests/baselines/reference/functionLikeInParameterInitializer.symbols b/tests/baselines/reference/functionLikeInParameterInitializer.symbols
index 0b7eae489de..1ca2d6d7e14 100644
--- a/tests/baselines/reference/functionLikeInParameterInitializer.symbols
+++ b/tests/baselines/reference/functionLikeInParameterInitializer.symbols
@@ -33,6 +33,7 @@ export function baz2(func = function () { return foo }) {
 export function baz3(func = class { x = foo }) {
 >baz3 : Symbol(baz3, Decl(functionLikeInParameterInitializer.ts, 12, 1))
 >func : Symbol(func, Decl(functionLikeInParameterInitializer.ts, 15, 21))
+>class { x = foo } : Symbol((Anonymous class), Decl(functionLikeInParameterInitializer.ts, 15, 27))
 >x : Symbol((Anonymous class).x, Decl(functionLikeInParameterInitializer.ts, 15, 35))
 >foo : Symbol(foo, Decl(functionLikeInParameterInitializer.ts, 16, 7))
 
diff --git a/tests/baselines/reference/functionWithDefaultParameterWithNoStatements12.symbols b/tests/baselines/reference/functionWithDefaultParameterWithNoStatements12.symbols
index 49d428ce430..1431540ac9c 100644
--- a/tests/baselines/reference/functionWithDefaultParameterWithNoStatements12.symbols
+++ b/tests/baselines/reference/functionWithDefaultParameterWithNoStatements12.symbols
@@ -5,10 +5,12 @@ var v: any[];
 function foo(a = (v)) { }
 >foo : Symbol(foo, Decl(functionWithDefaultParameterWithNoStatements12.ts, 0, 13))
 >a : Symbol(a, Decl(functionWithDefaultParameterWithNoStatements12.ts, 2, 13))
+>(v) : Symbol(v, Decl(functionWithDefaultParameterWithNoStatements12.ts, 0, 3))
 >v : Symbol(v, Decl(functionWithDefaultParameterWithNoStatements12.ts, 0, 3))
 
 function bar(a = (v)) {
 >bar : Symbol(bar, Decl(functionWithDefaultParameterWithNoStatements12.ts, 2, 25))
 >a : Symbol(a, Decl(functionWithDefaultParameterWithNoStatements12.ts, 4, 13))
+>(v) : Symbol(v, Decl(functionWithDefaultParameterWithNoStatements12.ts, 0, 3))
 >v : Symbol(v, Decl(functionWithDefaultParameterWithNoStatements12.ts, 0, 3))
 }
diff --git a/tests/baselines/reference/functionsInClassExpressions.symbols b/tests/baselines/reference/functionsInClassExpressions.symbols
index 4aa62da8e33..3465cca2751 100644
--- a/tests/baselines/reference/functionsInClassExpressions.symbols
+++ b/tests/baselines/reference/functionsInClassExpressions.symbols
@@ -1,6 +1,7 @@
 === tests/cases/compiler/functionsInClassExpressions.ts ===
 let Foo = class {
 >Foo : Symbol(Foo, Decl(functionsInClassExpressions.ts, 0, 3))
+>class {    constructor() {        this.bar++;    }    bar = 0;    inc = () => {        this.bar++;    }    m() { return this.bar; }} : Symbol(Foo, Decl(functionsInClassExpressions.ts, 0, 9))
 
     constructor() {
         this.bar++;
diff --git a/tests/baselines/reference/generatorTypeCheck55.symbols b/tests/baselines/reference/generatorTypeCheck55.symbols
index 1444b2af144..9e1ef5f3eb6 100644
--- a/tests/baselines/reference/generatorTypeCheck55.symbols
+++ b/tests/baselines/reference/generatorTypeCheck55.symbols
@@ -4,5 +4,6 @@ function* g() {
 
     var x = class C extends (yield) {};
 >x : Symbol(x, Decl(generatorTypeCheck55.ts, 1, 7))
+>class C extends (yield) {} : Symbol(C, Decl(generatorTypeCheck55.ts, 1, 11))
 >C : Symbol(C, Decl(generatorTypeCheck55.ts, 1, 11))
 }
diff --git a/tests/baselines/reference/generatorTypeCheck56.symbols b/tests/baselines/reference/generatorTypeCheck56.symbols
index 8a56bdf24cf..74246638879 100644
--- a/tests/baselines/reference/generatorTypeCheck56.symbols
+++ b/tests/baselines/reference/generatorTypeCheck56.symbols
@@ -4,6 +4,7 @@ function* g() {
 
     var x = class C {
 >x : Symbol(x, Decl(generatorTypeCheck56.ts, 1, 7))
+>class C {        *[yield 0]() {            yield 0;        }    } : Symbol(C, Decl(generatorTypeCheck56.ts, 1, 11))
 >C : Symbol(C, Decl(generatorTypeCheck56.ts, 1, 11))
 
         *[yield 0]() {
diff --git a/tests/baselines/reference/genericClassExpressionInFunction.symbols b/tests/baselines/reference/genericClassExpressionInFunction.symbols
index 2384cd2ed47..1a1b78699ff 100644
--- a/tests/baselines/reference/genericClassExpressionInFunction.symbols
+++ b/tests/baselines/reference/genericClassExpressionInFunction.symbols
@@ -13,6 +13,7 @@ function B1<U>() {
 
     // class expression can use T
     return class extends A<U> { }
+>class extends A<U> { } : Symbol((Anonymous class), Decl(genericClassExpressionInFunction.ts, 5, 10))
 >A : Symbol(A, Decl(genericClassExpressionInFunction.ts, 0, 0))
 >U : Symbol(U, Decl(genericClassExpressionInFunction.ts, 3, 12))
 }
@@ -22,6 +23,7 @@ class B2<V> {
 
     anon = class extends A<V> { }
 >anon : Symbol(B2.anon, Decl(genericClassExpressionInFunction.ts, 7, 13))
+>class extends A<V> { } : Symbol((Anonymous class), Decl(genericClassExpressionInFunction.ts, 8, 10))
 >A : Symbol(A, Decl(genericClassExpressionInFunction.ts, 0, 0))
 >V : Symbol(V, Decl(genericClassExpressionInFunction.ts, 7, 9))
 }
@@ -30,6 +32,7 @@ function B3<W>() {
 >W : Symbol(W, Decl(genericClassExpressionInFunction.ts, 10, 12))
 
     return class Inner<TInner> extends A<W> { }
+>class Inner<TInner> extends A<W> { } : Symbol(Inner, Decl(genericClassExpressionInFunction.ts, 11, 10))
 >Inner : Symbol(Inner, Decl(genericClassExpressionInFunction.ts, 11, 10))
 >TInner : Symbol(TInner, Decl(genericClassExpressionInFunction.ts, 11, 23))
 >A : Symbol(A, Decl(genericClassExpressionInFunction.ts, 0, 0))
@@ -45,6 +48,7 @@ class K extends B1<number>() {
 }
 class C extends (new B2<number>().anon) {
 >C : Symbol(C, Decl(genericClassExpressionInFunction.ts, 16, 1))
+>(new B2<number>().anon) : Symbol(B2.anon, Decl(genericClassExpressionInFunction.ts, 7, 13))
 >new B2<number>().anon : Symbol(B2.anon, Decl(genericClassExpressionInFunction.ts, 7, 13))
 >B2 : Symbol(B2, Decl(genericClassExpressionInFunction.ts, 6, 1))
 >anon : Symbol(B2.anon, Decl(genericClassExpressionInFunction.ts, 7, 13))
diff --git a/tests/baselines/reference/genericClassWithStaticFactory.symbols b/tests/baselines/reference/genericClassWithStaticFactory.symbols
index eb4c58ab3cc..f225677bf8d 100644
--- a/tests/baselines/reference/genericClassWithStaticFactory.symbols
+++ b/tests/baselines/reference/genericClassWithStaticFactory.symbols
@@ -102,6 +102,7 @@ module Editor {
 
             for (i = 0; !(entry.isHead); i++) {
 >i : Symbol(i, Decl(genericClassWithStaticFactory.ts, 24, 15))
+>(entry.isHead) : Symbol(List.isHead, Decl(genericClassWithStaticFactory.ts, 7, 20))
 >entry.isHead : Symbol(List.isHead, Decl(genericClassWithStaticFactory.ts, 7, 20))
 >entry : Symbol(entry, Decl(genericClassWithStaticFactory.ts, 23, 15))
 >isHead : Symbol(List.isHead, Decl(genericClassWithStaticFactory.ts, 7, 20))
@@ -115,6 +116,7 @@ module Editor {
             }
 
             return (i);
+>(i) : Symbol(i, Decl(genericClassWithStaticFactory.ts, 24, 15))
 >i : Symbol(i, Decl(genericClassWithStaticFactory.ts, 24, 15))
         }
 
diff --git a/tests/baselines/reference/genericIndexedAccessMethodIntersectionCanBeAccessed.symbols b/tests/baselines/reference/genericIndexedAccessMethodIntersectionCanBeAccessed.symbols
index 2b619c997dc..cb819830537 100644
--- a/tests/baselines/reference/genericIndexedAccessMethodIntersectionCanBeAccessed.symbols
+++ b/tests/baselines/reference/genericIndexedAccessMethodIntersectionCanBeAccessed.symbols
@@ -54,6 +54,7 @@ export const createService = <T>(
 
         const method = (ServiceCtr)[key as keyof T];
 >method : Symbol(method, Decl(genericIndexedAccessMethodIntersectionCanBeAccessed.ts, 15, 13))
+>(ServiceCtr) : Symbol(ServiceCtr, Decl(genericIndexedAccessMethodIntersectionCanBeAccessed.ts, 11, 33))
 >ServiceCtr : Symbol(ServiceCtr, Decl(genericIndexedAccessMethodIntersectionCanBeAccessed.ts, 11, 33))
 >key : Symbol(key, Decl(genericIndexedAccessMethodIntersectionCanBeAccessed.ts, 14, 36))
 >T : Symbol(T, Decl(genericIndexedAccessMethodIntersectionCanBeAccessed.ts, 11, 30))
diff --git a/tests/baselines/reference/implementsInClassExpression.symbols b/tests/baselines/reference/implementsInClassExpression.symbols
index bf3b3ef9337..3a7e653cddf 100644
--- a/tests/baselines/reference/implementsInClassExpression.symbols
+++ b/tests/baselines/reference/implementsInClassExpression.symbols
@@ -8,6 +8,7 @@ interface Foo {
 
 let cls = class implements Foo {
 >cls : Symbol(cls, Decl(implementsInClassExpression.ts, 4, 3))
+>class implements Foo {    doThing() { }} : Symbol(cls, Decl(implementsInClassExpression.ts, 4, 9))
 >Foo : Symbol(Foo, Decl(implementsInClassExpression.ts, 0, 0))
 
     doThing() { }
diff --git a/tests/baselines/reference/importTypeInJSDoc.symbols b/tests/baselines/reference/importTypeInJSDoc.symbols
index d00eab51a18..07dcb179943 100644
--- a/tests/baselines/reference/importTypeInJSDoc.symbols
+++ b/tests/baselines/reference/importTypeInJSDoc.symbols
@@ -43,6 +43,8 @@ export = MyClass;
 
 let a = /** @type {Foo} */(/** @type {*} */(undefined)); 
 >a : Symbol(a, Decl(index.js, 4, 3))
+>(/** @type {*} */(undefined)) : Symbol(undefined)
+>(undefined) : Symbol(undefined)
 >undefined : Symbol(undefined)
 
 a = new Foo({doer: Foo.Bar});
diff --git a/tests/baselines/reference/inferentialTypingWithFunctionTypeSyntacticScenarios.symbols b/tests/baselines/reference/inferentialTypingWithFunctionTypeSyntacticScenarios.symbols
index a9571bc8a38..d496ec8d0a1 100644
--- a/tests/baselines/reference/inferentialTypingWithFunctionTypeSyntacticScenarios.symbols
+++ b/tests/baselines/reference/inferentialTypingWithFunctionTypeSyntacticScenarios.symbols
@@ -84,6 +84,7 @@ s = map("", <typeof identity>identity);
 s = map("", (identity));
 >s : Symbol(s, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 2, 3))
 >map : Symbol(map, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 0, 0))
+>(identity) : Symbol(identity, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 0, 59))
 >identity : Symbol(identity, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 0, 59))
 
 // comma
diff --git a/tests/baselines/reference/inferringClassStaticMembersFromAssignments.symbols b/tests/baselines/reference/inferringClassStaticMembersFromAssignments.symbols
index a643fbfba9e..91afb72a9d8 100644
--- a/tests/baselines/reference/inferringClassStaticMembersFromAssignments.symbols
+++ b/tests/baselines/reference/inferringClassStaticMembersFromAssignments.symbols
@@ -17,6 +17,7 @@ F1.staticProp = 0;
 
 export var C2 = class { };
 >C2 : Symbol(C2, Decl(a.js, 6, 10), Decl(a.js, 6, 26))
+>class { } : Symbol(C2, Decl(a.js, 6, 15))
 
 C2.staticProp = 0;
 >C2.staticProp : Symbol(C2.staticProp, Decl(a.js, 6, 26))
@@ -50,6 +51,7 @@ F3.staticProp = 0;
 
 var C4 = class { };
 >C4 : Symbol(C4, Decl(global.js, 6, 3), Decl(global.js, 6, 19))
+>class { } : Symbol(C4, Decl(global.js, 6, 8))
 
 C4.staticProp = 0;
 >C4.staticProp : Symbol(C4.staticProp, Decl(global.js, 6, 19))
diff --git a/tests/baselines/reference/jsDeclarationsClasses.symbols b/tests/baselines/reference/jsDeclarationsClasses.symbols
index dd92edbd4e6..efa71efa8cc 100644
--- a/tests/baselines/reference/jsDeclarationsClasses.symbols
+++ b/tests/baselines/reference/jsDeclarationsClasses.symbols
@@ -14,6 +14,7 @@ export class C {
 
     static Cls = class {}
 >Cls : Symbol(C.Cls, Decl(index.js, 6, 16))
+>class {} : Symbol((Anonymous class), Decl(index.js, 7, 16))
 }
 
 export class D {
diff --git a/tests/baselines/reference/jsDeclarationsExportAssignedClassExpression.symbols b/tests/baselines/reference/jsDeclarationsExportAssignedClassExpression.symbols
index dad52ee5af6..3109fb7b675 100644
--- a/tests/baselines/reference/jsDeclarationsExportAssignedClassExpression.symbols
+++ b/tests/baselines/reference/jsDeclarationsExportAssignedClassExpression.symbols
@@ -3,6 +3,7 @@ module.exports = class Thing {
 >module.exports : Symbol(module.exports, Decl(index.js, 0, 0))
 >module : Symbol(export=, Decl(index.js, 0, 0))
 >exports : Symbol(export=, Decl(index.js, 0, 0))
+>class Thing {    /**     * @param {number} p     */    constructor(p) {        this.t = 12 + p;    }} : Symbol(Thing, Decl(index.js, 0, 16))
 >Thing : Symbol(Thing, Decl(index.js, 0, 16))
 
     /**
diff --git a/tests/baselines/reference/jsDeclarationsExportAssignedClassExpressionAnonymous.symbols b/tests/baselines/reference/jsDeclarationsExportAssignedClassExpressionAnonymous.symbols
index 35d8ed6240f..0837511ca6f 100644
--- a/tests/baselines/reference/jsDeclarationsExportAssignedClassExpressionAnonymous.symbols
+++ b/tests/baselines/reference/jsDeclarationsExportAssignedClassExpressionAnonymous.symbols
@@ -3,6 +3,7 @@ module.exports = class {
 >module.exports : Symbol(module.exports, Decl(index.js, 0, 0))
 >module : Symbol(export=, Decl(index.js, 0, 0))
 >exports : Symbol(export=, Decl(index.js, 0, 0))
+>class {    /**     * @param {number} p     */    constructor(p) {        this.t = 12 + p;    }} : Symbol(exports, Decl(index.js, 0, 16))
 
     /**
      * @param {number} p
diff --git a/tests/baselines/reference/jsDeclarationsExportAssignedClassExpressionAnonymousWithSub.symbols b/tests/baselines/reference/jsDeclarationsExportAssignedClassExpressionAnonymousWithSub.symbols
index 2af24b70c59..ffbe68c267a 100644
--- a/tests/baselines/reference/jsDeclarationsExportAssignedClassExpressionAnonymousWithSub.symbols
+++ b/tests/baselines/reference/jsDeclarationsExportAssignedClassExpressionAnonymousWithSub.symbols
@@ -3,6 +3,7 @@ module.exports = class {
 >module.exports : Symbol(module.exports, Decl(index.js, 0, 0))
 >module : Symbol(export=, Decl(index.js, 0, 0))
 >exports : Symbol(export=, Decl(index.js, 0, 0))
+>class {    /**     * @param {number} p     */    constructor(p) {        this.t = 12 + p;    }} : Symbol(exports, Decl(index.js, 0, 16))
 
     /**
      * @param {number} p
@@ -23,6 +24,7 @@ module.exports.Sub = class {
 >module : Symbol(module, Decl(index.js, 0, 0), Decl(index.js, 10, 27))
 >exports : Symbol(module.exports, Decl(index.js, 0, 0))
 >Sub : Symbol(Sub, Decl(index.js, 7, 1))
+>class {    constructor() {        this.instance = new module.exports(10);    }} : Symbol(Sub, Decl(index.js, 8, 20))
 
     constructor() {
         this.instance = new module.exports(10);
diff --git a/tests/baselines/reference/jsDeclarationsExportAssignedClassExpressionShadowing.symbols b/tests/baselines/reference/jsDeclarationsExportAssignedClassExpressionShadowing.symbols
index 9ca39685537..1c55bc9e891 100644
--- a/tests/baselines/reference/jsDeclarationsExportAssignedClassExpressionShadowing.symbols
+++ b/tests/baselines/reference/jsDeclarationsExportAssignedClassExpressionShadowing.symbols
@@ -16,6 +16,7 @@ module.exports = class Q {
 >module.exports : Symbol(module.exports, Decl(index.js, 0, 0))
 >module : Symbol(export=, Decl(index.js, 5, 1))
 >exports : Symbol(export=, Decl(index.js, 5, 1))
+>class Q {    constructor() {        this.x = new A();    }} : Symbol(Q, Decl(index.js, 6, 16))
 >Q : Symbol(Q, Decl(index.js, 6, 16))
 
     constructor() {
diff --git a/tests/baselines/reference/jsDeclarationsExportAssignedVisibility.symbols b/tests/baselines/reference/jsDeclarationsExportAssignedVisibility.symbols
index 6fb12e0a9eb..66d28ff0146 100644
--- a/tests/baselines/reference/jsDeclarationsExportAssignedVisibility.symbols
+++ b/tests/baselines/reference/jsDeclarationsExportAssignedVisibility.symbols
@@ -27,6 +27,7 @@ module.exports = class Obj {
 >module.exports : Symbol(module.exports, Decl(obj.js, 0, 0))
 >module : Symbol(export=, Decl(obj.js, 0, 0))
 >exports : Symbol(export=, Decl(obj.js, 0, 0))
+>class Obj {    constructor() {        this.x = 12;    }} : Symbol(Obj, Decl(obj.js, 0, 16))
 >Obj : Symbol(Obj, Decl(obj.js, 0, 16))
 
     constructor() {
diff --git a/tests/baselines/reference/jsDeclarationsFunctions.symbols b/tests/baselines/reference/jsDeclarationsFunctions.symbols
index 0f2a41a6222..25050feb167 100644
--- a/tests/baselines/reference/jsDeclarationsFunctions.symbols
+++ b/tests/baselines/reference/jsDeclarationsFunctions.symbols
@@ -17,6 +17,7 @@ c.Cls = class {}
 >c.Cls : Symbol(c.Cls, Decl(index.js, 5, 22))
 >c : Symbol(c, Decl(index.js, 3, 14), Decl(index.js, 5, 22))
 >Cls : Symbol(c.Cls, Decl(index.js, 5, 22))
+>class {} : Symbol(Cls, Decl(index.js, 6, 7))
 
 /**
  * @param {number} a
diff --git a/tests/baselines/reference/jsDeclarationsFunctionsCjs.symbols b/tests/baselines/reference/jsDeclarationsFunctionsCjs.symbols
index 237e2f981ca..8c0ca0afc2b 100644
--- a/tests/baselines/reference/jsDeclarationsFunctionsCjs.symbols
+++ b/tests/baselines/reference/jsDeclarationsFunctionsCjs.symbols
@@ -40,6 +40,7 @@ module.exports.c.Cls = class {}
 >exports : Symbol(module.exports, Decl(index.js, 0, 0))
 >c : Symbol(c, Decl(index.js, 3, 29), Decl(index.js, 6, 15))
 >Cls : Symbol(c.Cls, Decl(index.js, 5, 34))
+>class {} : Symbol(Cls, Decl(index.js, 6, 22))
 
 /**
  * @param {number} a
diff --git a/tests/baselines/reference/jsEnumCrossFileExport.symbols b/tests/baselines/reference/jsEnumCrossFileExport.symbols
index 10bf9c60045..1041a148590 100644
--- a/tests/baselines/reference/jsEnumCrossFileExport.symbols
+++ b/tests/baselines/reference/jsEnumCrossFileExport.symbols
@@ -52,6 +52,7 @@ Other.Cls = class {
 >Other.Cls : Symbol(Other.Cls, Decl(index.js, 0, 15))
 >Other : Symbol(Other, Decl(index.js, 0, 3), Decl(index.js, 0, 15))
 >Cls : Symbol(Other.Cls, Decl(index.js, 0, 15))
+>class {    /**     * @param {!Host.UserMetrics.Action} p     */    method(p) {}    usage() {        this.method(Host.UserMetrics.Action.WindowDocked);    }} : Symbol(Cls, Decl(index.js, 1, 11))
 
     /**
      * @param {!Host.UserMetrics.Action} p
diff --git a/tests/baselines/reference/jsFileCompilationTypeParameterSyntaxOfClassExpression.symbols b/tests/baselines/reference/jsFileCompilationTypeParameterSyntaxOfClassExpression.symbols
index f3aa9cd5926..9d0df515fb3 100644
--- a/tests/baselines/reference/jsFileCompilationTypeParameterSyntaxOfClassExpression.symbols
+++ b/tests/baselines/reference/jsFileCompilationTypeParameterSyntaxOfClassExpression.symbols
@@ -1,5 +1,6 @@
 === tests/cases/compiler/a.js ===
 const Bar = class<T> {};
 >Bar : Symbol(Bar, Decl(a.js, 0, 5))
+>class<T> {} : Symbol(Bar, Decl(a.js, 0, 11))
 >T : Symbol(T, Decl(a.js, 0, 18))
 
diff --git a/tests/baselines/reference/jsdocImplements_class.symbols b/tests/baselines/reference/jsdocImplements_class.symbols
index ab8a02a7679..8267cf68404 100644
--- a/tests/baselines/reference/jsdocImplements_class.symbols
+++ b/tests/baselines/reference/jsdocImplements_class.symbols
@@ -38,6 +38,7 @@ Ns.C1 = class {
 >Ns.C1 : Symbol(Ns.C1, Decl(a.js, 20, 12))
 >Ns : Symbol(Ns, Decl(a.js, 20, 3), Decl(a.js, 20, 12), Decl(a.js, 44, 7))
 >C1 : Symbol(Ns.C1, Decl(a.js, 20, 12))
+>class {    method() { return 11; }} : Symbol(C1, Decl(a.js, 22, 7))
 
     method() { return 11; }
 >method : Symbol(C1.method, Decl(a.js, 22, 15))
@@ -45,6 +46,7 @@ Ns.C1 = class {
 /** @implements {A} */
 var C2 = class {
 >C2 : Symbol(C2, Decl(a.js, 26, 3))
+>class {    method() { return 12; }} : Symbol(C2, Decl(a.js, 26, 8))
 
     method() { return 12; }
 >method : Symbol(C2.method, Decl(a.js, 26, 16))
@@ -55,6 +57,7 @@ var o = {
     /** @implements {A} */
     C3: class {
 >C3 : Symbol(C3, Decl(a.js, 29, 9))
+>class {        method() { return 13; }    } : Symbol(C3, Decl(a.js, 31, 7))
 
         method() { return 13; }
 >method : Symbol(C3.method, Decl(a.js, 31, 15))
@@ -66,6 +69,7 @@ class CC {
     /** @implements {A} */
     C4 = class {
 >C4 : Symbol(CC.C4, Decl(a.js, 35, 10))
+>class {        method() {            return 14;        }    } : Symbol((Anonymous class), Decl(a.js, 37, 8))
 
         method() {
 >method : Symbol((Anonymous class).method, Decl(a.js, 37, 16))
@@ -84,6 +88,7 @@ Ns.C5 = C5 || class {
 >Ns : Symbol(Ns, Decl(a.js, 20, 3), Decl(a.js, 20, 12), Decl(a.js, 44, 7))
 >C5 : Symbol(Ns.C5, Decl(a.js, 44, 7))
 >C5 : Symbol(C5, Decl(a.js, 44, 3))
+>class {    method() {        return 15;    }} : Symbol(C5, Decl(a.js, 46, 13))
 
     method() {
 >method : Symbol(C5.method, Decl(a.js, 46, 21))
diff --git a/tests/baselines/reference/jsdocImportType2.symbols b/tests/baselines/reference/jsdocImportType2.symbols
index 1db0262b4d9..eb80d997041 100644
--- a/tests/baselines/reference/jsdocImportType2.symbols
+++ b/tests/baselines/reference/jsdocImportType2.symbols
@@ -42,6 +42,7 @@ module.exports = class Chunk {
 >module.exports : Symbol(module.exports, Decl(mod1.js, 0, 0))
 >module : Symbol(export=, Decl(mod1.js, 0, 0))
 >exports : Symbol(export=, Decl(mod1.js, 0, 0))
+>class Chunk {    constructor() {        this.chunk = 1;    }} : Symbol(Chunk, Decl(mod1.js, 1, 16))
 >Chunk : Symbol(Chunk, Decl(mod1.js, 1, 16))
 
     constructor() {
diff --git a/tests/baselines/reference/jsdocTypeCast.symbols b/tests/baselines/reference/jsdocTypeCast.symbols
index 9e376f384b2..ba5124848ee 100644
--- a/tests/baselines/reference/jsdocTypeCast.symbols
+++ b/tests/baselines/reference/jsdocTypeCast.symbols
@@ -9,6 +9,7 @@
     /** @type {'a' | 'b'} */
     let a = (x); // Error
 >a : Symbol(a, Decl(jsdocTypeCast.js, 5, 7))
+>(x) : Symbol(x, Decl(jsdocTypeCast.js, 3, 12))
 >x : Symbol(x, Decl(jsdocTypeCast.js, 3, 12))
 
     a;
@@ -17,6 +18,9 @@
     /** @type {'a' | 'b'} */
     let b = (((x))); // Error
 >b : Symbol(b, Decl(jsdocTypeCast.js, 9, 7))
+>(((x))) : Symbol(x, Decl(jsdocTypeCast.js, 3, 12))
+>((x)) : Symbol(x, Decl(jsdocTypeCast.js, 3, 12))
+>(x) : Symbol(x, Decl(jsdocTypeCast.js, 3, 12))
 >x : Symbol(x, Decl(jsdocTypeCast.js, 3, 12))
 
     b;
@@ -25,6 +29,7 @@
     /** @type {'a' | 'b'} */
     let c = /** @type {'a' | 'b'} */ (x); // Ok
 >c : Symbol(c, Decl(jsdocTypeCast.js, 13, 7))
+>(x) : Symbol(x, Decl(jsdocTypeCast.js, 3, 12))
 >x : Symbol(x, Decl(jsdocTypeCast.js, 3, 12))
 
     c;
diff --git a/tests/baselines/reference/jsdocTypeReferenceToImportOfClassExpression.symbols b/tests/baselines/reference/jsdocTypeReferenceToImportOfClassExpression.symbols
index 26d216ce83a..2a83613b3b1 100644
--- a/tests/baselines/reference/jsdocTypeReferenceToImportOfClassExpression.symbols
+++ b/tests/baselines/reference/jsdocTypeReferenceToImportOfClassExpression.symbols
@@ -10,6 +10,7 @@ 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))
+>class MC {  watch() {    return new MW(this);  }} : Symbol(MC, Decl(MC.js, 4, 16))
 >MC : Symbol(MC, Decl(MC.js, 4, 16))
 
   watch() {
diff --git a/tests/baselines/reference/jsdocTypeTagCast.symbols b/tests/baselines/reference/jsdocTypeTagCast.symbols
index f719cfd9739..89d4e496dcc 100644
--- a/tests/baselines/reference/jsdocTypeTagCast.symbols
+++ b/tests/baselines/reference/jsdocTypeTagCast.symbols
@@ -88,38 +88,47 @@ var someFakeClass = new SomeFakeClass();
 
 someBase = /** @type {SomeBase} */(someDerived);
 >someBase : Symbol(someBase, Decl(b.js, 37, 3))
+>(someDerived) : Symbol(someDerived, Decl(b.js, 38, 3))
 >someDerived : Symbol(someDerived, Decl(b.js, 38, 3))
 
 someBase = /** @type {SomeBase} */(someBase);
 >someBase : Symbol(someBase, Decl(b.js, 37, 3))
+>(someBase) : Symbol(someBase, Decl(b.js, 37, 3))
 >someBase : Symbol(someBase, Decl(b.js, 37, 3))
 
 someBase = /** @type {SomeBase} */(someOther); // Error
 >someBase : Symbol(someBase, Decl(b.js, 37, 3))
+>(someOther) : Symbol(someOther, Decl(b.js, 39, 3))
 >someOther : Symbol(someOther, Decl(b.js, 39, 3))
 
 someDerived = /** @type {SomeDerived} */(someDerived);
 >someDerived : Symbol(someDerived, Decl(b.js, 38, 3))
+>(someDerived) : Symbol(someDerived, Decl(b.js, 38, 3))
 >someDerived : Symbol(someDerived, Decl(b.js, 38, 3))
 
 someDerived = /** @type {SomeDerived} */(someBase);
 >someDerived : Symbol(someDerived, Decl(b.js, 38, 3))
+>(someBase) : Symbol(someBase, Decl(b.js, 37, 3))
 >someBase : Symbol(someBase, Decl(b.js, 37, 3))
 
 someDerived = /** @type {SomeDerived} */(someOther); // Error
 >someDerived : Symbol(someDerived, Decl(b.js, 38, 3))
+>(someOther) : Symbol(someOther, Decl(b.js, 39, 3))
 >someOther : Symbol(someOther, Decl(b.js, 39, 3))
 
 someOther = /** @type {SomeOther} */(someDerived); // Error
 >someOther : Symbol(someOther, Decl(b.js, 39, 3))
+>(someDerived) : Symbol(someDerived, Decl(b.js, 38, 3))
 >someDerived : Symbol(someDerived, Decl(b.js, 38, 3))
 
 someOther = /** @type {SomeOther} */(someBase); // Error
 >someOther : Symbol(someOther, Decl(b.js, 39, 3))
+>(someBase) : Symbol(someBase, Decl(b.js, 37, 3))
 >someBase : Symbol(someBase, Decl(b.js, 37, 3))
 
 someOther = /** @type {SomeOther} */(someOther);
 >someOther : Symbol(someOther, Decl(b.js, 39, 3))
+>(someOther) : Symbol(someOther, Decl(b.js, 39, 3))
 >someOther : Symbol(someOther, Decl(b.js, 39, 3))
 
 someFakeClass = someBase;
@@ -136,6 +145,7 @@ someBase = someFakeClass; // Error
 
 someBase = /** @type {SomeBase} */(someFakeClass);
 >someBase : Symbol(someBase, Decl(b.js, 37, 3))
+>(someFakeClass) : Symbol(someFakeClass, Decl(b.js, 40, 3))
 >someFakeClass : Symbol(someFakeClass, Decl(b.js, 40, 3))
 
 // Type assertion cannot be a type-predicate type
diff --git a/tests/baselines/reference/jsdocTypecastNoTypeNoCrash.symbols b/tests/baselines/reference/jsdocTypecastNoTypeNoCrash.symbols
index 7a9d98e39ec..261d44fd9f3 100644
--- a/tests/baselines/reference/jsdocTypecastNoTypeNoCrash.symbols
+++ b/tests/baselines/reference/jsdocTypecastNoTypeNoCrash.symbols
@@ -4,5 +4,6 @@ function Foo() {}
 
 const a = /* @type string */(Foo);
 >a : Symbol(a, Decl(index.js, 1, 5))
+>(Foo) : Symbol(Foo, Decl(index.js, 0, 0))
 >Foo : Symbol(Foo, Decl(index.js, 0, 0))
 
diff --git a/tests/baselines/reference/jsxComponentTypeErrors.symbols b/tests/baselines/reference/jsxComponentTypeErrors.symbols
index f728d5a5f04..23e64014cf5 100644
--- a/tests/baselines/reference/jsxComponentTypeErrors.symbols
+++ b/tests/baselines/reference/jsxComponentTypeErrors.symbols
@@ -80,6 +80,7 @@ const obj = {
   },
   MemberClassComponent: class {},
 >MemberClassComponent : Symbol(MemberClassComponent, Decl(jsxComponentTypeErrors.tsx, 32, 4))
+>class {} : Symbol(MemberClassComponent, Decl(jsxComponentTypeErrors.tsx, 33, 23))
 
 };
 
diff --git a/tests/baselines/reference/jsxInExtendsClause.symbols b/tests/baselines/reference/jsxInExtendsClause.symbols
index 4853d339d88..b27779707ef 100644
--- a/tests/baselines/reference/jsxInExtendsClause.symbols
+++ b/tests/baselines/reference/jsxInExtendsClause.symbols
@@ -28,6 +28,7 @@ declare function createComponentClass<P>(factory: () => React.ComponentClass<P>)
 class Foo extends createComponentClass(() => class extends React.Component<{}, {}> {
 >Foo : Symbol(Foo, Decl(jsxInExtendsClause.tsx, 5, 106))
 >createComponentClass : Symbol(createComponentClass, Decl(jsxInExtendsClause.tsx, 4, 1))
+>class extends React.Component<{}, {}> {  render() {    return <span>Hello, world!</span>;  }} : Symbol((Anonymous class), Decl(jsxInExtendsClause.tsx, 6, 44))
 >React.Component : Symbol(React.Component, Decl(jsxInExtendsClause.tsx, 2, 59))
 >React : Symbol(React, Decl(jsxInExtendsClause.tsx, 0, 0))
 >Component : Symbol(React.Component, Decl(jsxInExtendsClause.tsx, 2, 59))
diff --git a/tests/baselines/reference/jsxNestedWithinTernaryParsesCorrectly.symbols b/tests/baselines/reference/jsxNestedWithinTernaryParsesCorrectly.symbols
index 73ee27251ae..9b89cab8a11 100644
--- a/tests/baselines/reference/jsxNestedWithinTernaryParsesCorrectly.symbols
+++ b/tests/baselines/reference/jsxNestedWithinTernaryParsesCorrectly.symbols
@@ -7,6 +7,8 @@ const a = (
 
     <div>
       {0 ? (
+>(        emptyMessage // must be identifier?      ) : Symbol(emptyMessage, Decl(jsxNestedWithinTernaryParsesCorrectly.tsx, 0, 5))
+
         emptyMessage // must be identifier?
 >emptyMessage : Symbol(emptyMessage, Decl(jsxNestedWithinTernaryParsesCorrectly.tsx, 0, 5))
 
diff --git a/tests/baselines/reference/letDeclarations-access.symbols b/tests/baselines/reference/letDeclarations-access.symbols
index 31a64fab3f8..8f23fd83968 100644
--- a/tests/baselines/reference/letDeclarations-access.symbols
+++ b/tests/baselines/reference/letDeclarations-access.symbols
@@ -71,6 +71,7 @@ x;
 >x : Symbol(x, Decl(letDeclarations-access.ts, 0, 3))
 
 (x);
+>(x) : Symbol(x, Decl(letDeclarations-access.ts, 0, 3))
 >x : Symbol(x, Decl(letDeclarations-access.ts, 0, 3))
 
 -x;
diff --git a/tests/baselines/reference/literals-negative.symbols b/tests/baselines/reference/literals-negative.symbols
index a8957f0c5db..3ff730f5dbc 100644
--- a/tests/baselines/reference/literals-negative.symbols
+++ b/tests/baselines/reference/literals-negative.symbols
@@ -9,6 +9,7 @@ var s = <string>(null);
 
 var b = <boolean>(n);
 >b : Symbol(b, Decl(literals-negative.ts, 4, 3))
+>(n) : Symbol(n, Decl(literals-negative.ts, 2, 3))
 >n : Symbol(n, Decl(literals-negative.ts, 2, 3))
 
 function isVoid() : void { }
diff --git a/tests/baselines/reference/logicalAssignment3(target=es2015).symbols b/tests/baselines/reference/logicalAssignment3(target=es2015).symbols
index d2270b90b94..fd9ee52e997 100644
--- a/tests/baselines/reference/logicalAssignment3(target=es2015).symbols
+++ b/tests/baselines/reference/logicalAssignment3(target=es2015).symbols
@@ -23,6 +23,7 @@ declare const c: A;
 >A : Symbol(A, Decl(logicalAssignment3.ts, 0, 0))
 
 (a.baz) &&= result.baz;
+>(a.baz) : Symbol(A.baz, Decl(logicalAssignment3.ts, 0, 13))
 >a.baz : Symbol(A.baz, Decl(logicalAssignment3.ts, 0, 13))
 >a : Symbol(a, Decl(logicalAssignment3.ts, 5, 13))
 >baz : Symbol(A.baz, Decl(logicalAssignment3.ts, 0, 13))
@@ -31,6 +32,7 @@ declare const c: A;
 >baz : Symbol(A.baz, Decl(logicalAssignment3.ts, 0, 13))
 
 (b.baz) ||= result.baz;
+>(b.baz) : Symbol(A.baz, Decl(logicalAssignment3.ts, 0, 13))
 >b.baz : Symbol(A.baz, Decl(logicalAssignment3.ts, 0, 13))
 >b : Symbol(b, Decl(logicalAssignment3.ts, 6, 13))
 >baz : Symbol(A.baz, Decl(logicalAssignment3.ts, 0, 13))
@@ -39,6 +41,7 @@ declare const c: A;
 >baz : Symbol(A.baz, Decl(logicalAssignment3.ts, 0, 13))
 
 (c.baz) ??= result.baz;
+>(c.baz) : Symbol(A.baz, Decl(logicalAssignment3.ts, 0, 13))
 >c.baz : Symbol(A.baz, Decl(logicalAssignment3.ts, 0, 13))
 >c : Symbol(c, Decl(logicalAssignment3.ts, 7, 13))
 >baz : Symbol(A.baz, Decl(logicalAssignment3.ts, 0, 13))
diff --git a/tests/baselines/reference/logicalAssignment3(target=es2020).symbols b/tests/baselines/reference/logicalAssignment3(target=es2020).symbols
index d2270b90b94..fd9ee52e997 100644
--- a/tests/baselines/reference/logicalAssignment3(target=es2020).symbols
+++ b/tests/baselines/reference/logicalAssignment3(target=es2020).symbols
@@ -23,6 +23,7 @@ declare const c: A;
 >A : Symbol(A, Decl(logicalAssignment3.ts, 0, 0))
 
 (a.baz) &&= result.baz;
+>(a.baz) : Symbol(A.baz, Decl(logicalAssignment3.ts, 0, 13))
 >a.baz : Symbol(A.baz, Decl(logicalAssignment3.ts, 0, 13))
 >a : Symbol(a, Decl(logicalAssignment3.ts, 5, 13))
 >baz : Symbol(A.baz, Decl(logicalAssignment3.ts, 0, 13))
@@ -31,6 +32,7 @@ declare const c: A;
 >baz : Symbol(A.baz, Decl(logicalAssignment3.ts, 0, 13))
 
 (b.baz) ||= result.baz;
+>(b.baz) : Symbol(A.baz, Decl(logicalAssignment3.ts, 0, 13))
 >b.baz : Symbol(A.baz, Decl(logicalAssignment3.ts, 0, 13))
 >b : Symbol(b, Decl(logicalAssignment3.ts, 6, 13))
 >baz : Symbol(A.baz, Decl(logicalAssignment3.ts, 0, 13))
@@ -39,6 +41,7 @@ declare const c: A;
 >baz : Symbol(A.baz, Decl(logicalAssignment3.ts, 0, 13))
 
 (c.baz) ??= result.baz;
+>(c.baz) : Symbol(A.baz, Decl(logicalAssignment3.ts, 0, 13))
 >c.baz : Symbol(A.baz, Decl(logicalAssignment3.ts, 0, 13))
 >c : Symbol(c, Decl(logicalAssignment3.ts, 7, 13))
 >baz : Symbol(A.baz, Decl(logicalAssignment3.ts, 0, 13))
diff --git a/tests/baselines/reference/logicalAssignment3(target=es2021).symbols b/tests/baselines/reference/logicalAssignment3(target=es2021).symbols
index d2270b90b94..fd9ee52e997 100644
--- a/tests/baselines/reference/logicalAssignment3(target=es2021).symbols
+++ b/tests/baselines/reference/logicalAssignment3(target=es2021).symbols
@@ -23,6 +23,7 @@ declare const c: A;
 >A : Symbol(A, Decl(logicalAssignment3.ts, 0, 0))
 
 (a.baz) &&= result.baz;
+>(a.baz) : Symbol(A.baz, Decl(logicalAssignment3.ts, 0, 13))
 >a.baz : Symbol(A.baz, Decl(logicalAssignment3.ts, 0, 13))
 >a : Symbol(a, Decl(logicalAssignment3.ts, 5, 13))
 >baz : Symbol(A.baz, Decl(logicalAssignment3.ts, 0, 13))
@@ -31,6 +32,7 @@ declare const c: A;
 >baz : Symbol(A.baz, Decl(logicalAssignment3.ts, 0, 13))
 
 (b.baz) ||= result.baz;
+>(b.baz) : Symbol(A.baz, Decl(logicalAssignment3.ts, 0, 13))
 >b.baz : Symbol(A.baz, Decl(logicalAssignment3.ts, 0, 13))
 >b : Symbol(b, Decl(logicalAssignment3.ts, 6, 13))
 >baz : Symbol(A.baz, Decl(logicalAssignment3.ts, 0, 13))
@@ -39,6 +41,7 @@ declare const c: A;
 >baz : Symbol(A.baz, Decl(logicalAssignment3.ts, 0, 13))
 
 (c.baz) ??= result.baz;
+>(c.baz) : Symbol(A.baz, Decl(logicalAssignment3.ts, 0, 13))
 >c.baz : Symbol(A.baz, Decl(logicalAssignment3.ts, 0, 13))
 >c : Symbol(c, Decl(logicalAssignment3.ts, 7, 13))
 >baz : Symbol(A.baz, Decl(logicalAssignment3.ts, 0, 13))
diff --git a/tests/baselines/reference/logicalAssignment3(target=esnext).symbols b/tests/baselines/reference/logicalAssignment3(target=esnext).symbols
index d2270b90b94..fd9ee52e997 100644
--- a/tests/baselines/reference/logicalAssignment3(target=esnext).symbols
+++ b/tests/baselines/reference/logicalAssignment3(target=esnext).symbols
@@ -23,6 +23,7 @@ declare const c: A;
 >A : Symbol(A, Decl(logicalAssignment3.ts, 0, 0))
 
 (a.baz) &&= result.baz;
+>(a.baz) : Symbol(A.baz, Decl(logicalAssignment3.ts, 0, 13))
 >a.baz : Symbol(A.baz, Decl(logicalAssignment3.ts, 0, 13))
 >a : Symbol(a, Decl(logicalAssignment3.ts, 5, 13))
 >baz : Symbol(A.baz, Decl(logicalAssignment3.ts, 0, 13))
@@ -31,6 +32,7 @@ declare const c: A;
 >baz : Symbol(A.baz, Decl(logicalAssignment3.ts, 0, 13))
 
 (b.baz) ||= result.baz;
+>(b.baz) : Symbol(A.baz, Decl(logicalAssignment3.ts, 0, 13))
 >b.baz : Symbol(A.baz, Decl(logicalAssignment3.ts, 0, 13))
 >b : Symbol(b, Decl(logicalAssignment3.ts, 6, 13))
 >baz : Symbol(A.baz, Decl(logicalAssignment3.ts, 0, 13))
@@ -39,6 +41,7 @@ declare const c: A;
 >baz : Symbol(A.baz, Decl(logicalAssignment3.ts, 0, 13))
 
 (c.baz) ??= result.baz;
+>(c.baz) : Symbol(A.baz, Decl(logicalAssignment3.ts, 0, 13))
 >c.baz : Symbol(A.baz, Decl(logicalAssignment3.ts, 0, 13))
 >c : Symbol(c, Decl(logicalAssignment3.ts, 7, 13))
 >baz : Symbol(A.baz, Decl(logicalAssignment3.ts, 0, 13))
diff --git a/tests/baselines/reference/mappedTypeProperties.symbols b/tests/baselines/reference/mappedTypeProperties.symbols
index a38d36c2406..bac76e9a102 100644
--- a/tests/baselines/reference/mappedTypeProperties.symbols
+++ b/tests/baselines/reference/mappedTypeProperties.symbols
@@ -80,12 +80,14 @@ class C {
 }
 const D = class {
 >D : Symbol(D, Decl(mappedTypeProperties.ts, 35, 5))
+>class {    [P in PlaceType]: any} : Symbol(D, Decl(mappedTypeProperties.ts, 35, 9))
 
     [P in PlaceType]: any
 >[P in PlaceType] : Symbol(D[P in PlaceType], Decl(mappedTypeProperties.ts, 35, 17))
 }
 const E = class {
 >E : Symbol(E, Decl(mappedTypeProperties.ts, 38, 5))
+>class {    [P in 'a' | 'b']: any} : Symbol(E, Decl(mappedTypeProperties.ts, 38, 9))
 
     [P in 'a' | 'b']: any
 >[P in 'a' | 'b'] : Symbol(E[P in 'a' | 'b'], Decl(mappedTypeProperties.ts, 38, 17))
diff --git a/tests/baselines/reference/missingPropertiesOfClassExpression.symbols b/tests/baselines/reference/missingPropertiesOfClassExpression.symbols
index 5db7c47a4c2..8c8e9f44183 100644
--- a/tests/baselines/reference/missingPropertiesOfClassExpression.symbols
+++ b/tests/baselines/reference/missingPropertiesOfClassExpression.symbols
@@ -1,6 +1,7 @@
 === tests/cases/compiler/missingPropertiesOfClassExpression.ts ===
 class George extends class { reset() { return this.y; } } {
 >George : Symbol(George, Decl(missingPropertiesOfClassExpression.ts, 0, 0))
+>class { reset() { return this.y; } } : Symbol((Anonymous class), Decl(missingPropertiesOfClassExpression.ts, 0, 20))
 >reset : Symbol((Anonymous class).reset, Decl(missingPropertiesOfClassExpression.ts, 0, 28))
 >this : Symbol((Anonymous class), Decl(missingPropertiesOfClassExpression.ts, 0, 20))
 
diff --git a/tests/baselines/reference/mixinClassesAnnotated.symbols b/tests/baselines/reference/mixinClassesAnnotated.symbols
index 826842b66c3..0d12c684786 100644
--- a/tests/baselines/reference/mixinClassesAnnotated.symbols
+++ b/tests/baselines/reference/mixinClassesAnnotated.symbols
@@ -49,6 +49,7 @@ const Printable = <T extends Constructor<Base>>(superClass: T): Constructor<Prin
 >T : Symbol(T, Decl(mixinClassesAnnotated.ts, 16, 19))
 
     class extends superClass {
+>class extends superClass {        static message = "hello";        print() {            const output = this.x + "," + this.y;        }    } : Symbol((Anonymous class), Decl(mixinClassesAnnotated.ts, 16, 115))
 >superClass : Symbol(superClass, Decl(mixinClassesAnnotated.ts, 16, 48))
 
         static message = "hello";
diff --git a/tests/baselines/reference/mixinClassesAnonymous.symbols b/tests/baselines/reference/mixinClassesAnonymous.symbols
index b7adea1d713..a93fec67662 100644
--- a/tests/baselines/reference/mixinClassesAnonymous.symbols
+++ b/tests/baselines/reference/mixinClassesAnonymous.symbols
@@ -36,6 +36,7 @@ const Printable = <T extends Constructor<Base>>(superClass: T) => class extends
 >Base : Symbol(Base, Decl(mixinClassesAnonymous.ts, 0, 47))
 >superClass : Symbol(superClass, Decl(mixinClassesAnonymous.ts, 12, 48))
 >T : Symbol(T, Decl(mixinClassesAnonymous.ts, 12, 19))
+>class extends superClass {    static message = "hello";    print() {        const output = this.x + "," + this.y;    }} : Symbol((Anonymous class), Decl(mixinClassesAnonymous.ts, 12, 65))
 >superClass : Symbol(superClass, Decl(mixinClassesAnonymous.ts, 12, 48))
 
     static message = "hello";
@@ -177,6 +178,7 @@ const Timestamped = <CT extends Constructor<object>>(Base: CT) => {
 >CT : Symbol(CT, Decl(mixinClassesAnonymous.ts, 59, 21))
 
     return class extends Base {
+>class extends Base {        timestamp = new Date();    } : Symbol((Anonymous class), Decl(mixinClassesAnonymous.ts, 60, 10))
 >Base : Symbol(Base, Decl(mixinClassesAnonymous.ts, 59, 53))
 
         timestamp = new Date();
diff --git a/tests/baselines/reference/mixinIntersectionIsValidbaseType.symbols b/tests/baselines/reference/mixinIntersectionIsValidbaseType.symbols
index 69fe63bab23..b89e3a130f0 100644
--- a/tests/baselines/reference/mixinIntersectionIsValidbaseType.symbols
+++ b/tests/baselines/reference/mixinIntersectionIsValidbaseType.symbols
@@ -34,6 +34,7 @@ export const Serializable = <K extends Constructor<Initable> & Initable>(
 >K : Symbol(K, Decl(mixinIntersectionIsValidbaseType.ts, 9, 29))
 
         return class SerializableLocal extends InnerSuperClass {
+>class SerializableLocal extends InnerSuperClass {        } : Symbol(SerializableLocal, Decl(mixinIntersectionIsValidbaseType.ts, 13, 14))
 >SerializableLocal : Symbol(SerializableLocal, Decl(mixinIntersectionIsValidbaseType.ts, 13, 14))
 >InnerSuperClass : Symbol(InnerSuperClass, Decl(mixinIntersectionIsValidbaseType.ts, 12, 24))
         }
@@ -59,6 +60,7 @@ const AMixin = <K extends Constructor<Initable> & Initable>(SuperClass: K) => {
 
     let SomeHowOkay = class A extends SuperClass {
 >SomeHowOkay : Symbol(SomeHowOkay, Decl(mixinIntersectionIsValidbaseType.ts, 21, 7))
+>class A extends SuperClass {    } : Symbol(A, Decl(mixinIntersectionIsValidbaseType.ts, 21, 21))
 >A : Symbol(A, Decl(mixinIntersectionIsValidbaseType.ts, 21, 21))
 >SuperClass : Symbol(SuperClass, Decl(mixinIntersectionIsValidbaseType.ts, 20, 60))
 
@@ -66,6 +68,7 @@ const AMixin = <K extends Constructor<Initable> & Initable>(SuperClass: K) => {
 
     let SomeHowNotOkay = class A extends Serializable(SuperClass) {
 >SomeHowNotOkay : Symbol(SomeHowNotOkay, Decl(mixinIntersectionIsValidbaseType.ts, 24, 7))
+>class A extends Serializable(SuperClass) {    } : Symbol(A, Decl(mixinIntersectionIsValidbaseType.ts, 24, 24))
 >A : Symbol(A, Decl(mixinIntersectionIsValidbaseType.ts, 24, 24))
 >Serializable : Symbol(Serializable, Decl(mixinIntersectionIsValidbaseType.ts, 9, 12))
 >SuperClass : Symbol(SuperClass, Decl(mixinIntersectionIsValidbaseType.ts, 20, 60))
diff --git a/tests/baselines/reference/mixinPrivateAndProtected.symbols b/tests/baselines/reference/mixinPrivateAndProtected.symbols
index fd8d676d863..ca660543af4 100644
--- a/tests/baselines/reference/mixinPrivateAndProtected.symbols
+++ b/tests/baselines/reference/mixinPrivateAndProtected.symbols
@@ -28,6 +28,7 @@ function mixB<T extends Constructor<{}>>(Cls: T) {
 >T : Symbol(T, Decl(mixinPrivateAndProtected.ts, 10, 14))
 
     return class extends Cls {
+>class extends Cls {        protected ptd: number = 10;        private pvt: number = 0;    } : Symbol((Anonymous class), Decl(mixinPrivateAndProtected.ts, 11, 10))
 >Cls : Symbol(Cls, Decl(mixinPrivateAndProtected.ts, 10, 41))
 
         protected ptd: number = 10;
@@ -48,6 +49,7 @@ function mixB2<T extends Constructor<A>>(Cls: T) {
 >T : Symbol(T, Decl(mixinPrivateAndProtected.ts, 17, 15))
 
     return class extends Cls {
+>class extends Cls {        protected ptd: number = 10;    } : Symbol((Anonymous class), Decl(mixinPrivateAndProtected.ts, 18, 10))
 >Cls : Symbol(Cls, Decl(mixinPrivateAndProtected.ts, 17, 41))
 
         protected ptd: number = 10;
@@ -75,6 +77,7 @@ function mixC<T extends Constructor<{}>>(Cls: T) {
 >T : Symbol(T, Decl(mixinPrivateAndProtected.ts, 27, 14))
 
     return class extends Cls {
+>class extends Cls {        protected ptd: number = 100;        private pvt: number = 0;    } : Symbol((Anonymous class), Decl(mixinPrivateAndProtected.ts, 28, 10))
 >Cls : Symbol(Cls, Decl(mixinPrivateAndProtected.ts, 27, 41))
 
         protected ptd: number = 100;
@@ -186,6 +189,7 @@ function PersonMixin<T extends Constructor<Person>>(Base: T) {
 >T : Symbol(T, Decl(mixinPrivateAndProtected.ts, 70, 21))
 
 	return class extends Base {
+>class extends Base {		constructor(...args: any[]) {			super(...args);		}		myProtectedFunction() {			super.myProtectedFunction();			// do more things		}	} : Symbol((Anonymous class), Decl(mixinPrivateAndProtected.ts, 71, 7))
 >Base : Symbol(Base, Decl(mixinPrivateAndProtected.ts, 70, 52))
 
 		constructor(...args: any[]) {
diff --git a/tests/baselines/reference/mixingApparentTypeOverrides.symbols b/tests/baselines/reference/mixingApparentTypeOverrides.symbols
index ea0adbb8acd..4521d202b6e 100644
--- a/tests/baselines/reference/mixingApparentTypeOverrides.symbols
+++ b/tests/baselines/reference/mixingApparentTypeOverrides.symbols
@@ -13,6 +13,7 @@ function Tagged<T extends Constructor<{}>>(Base: T) {
 >T : Symbol(T, Decl(mixingApparentTypeOverrides.ts, 1, 16))
 
   return class extends Base {
+>class extends Base {    _tag: string;    constructor(...args: any[]) {      super(...args);      this._tag = "";    }  } : Symbol((Anonymous class), Decl(mixingApparentTypeOverrides.ts, 2, 8))
 >Base : Symbol(Base, Decl(mixingApparentTypeOverrides.ts, 1, 43))
 
     _tag: string;
diff --git a/tests/baselines/reference/modifierOnClassExpressionMemberInFunction.symbols b/tests/baselines/reference/modifierOnClassExpressionMemberInFunction.symbols
index 680d9c4d78b..0126c91d7eb 100644
--- a/tests/baselines/reference/modifierOnClassExpressionMemberInFunction.symbols
+++ b/tests/baselines/reference/modifierOnClassExpressionMemberInFunction.symbols
@@ -4,6 +4,7 @@ function g() {
 
     var x = class C {
 >x : Symbol(x, Decl(modifierOnClassExpressionMemberInFunction.ts, 1, 7))
+>class C {        public prop1 = 1;        private foo() { }        static prop2 = 43;    } : Symbol(C, Decl(modifierOnClassExpressionMemberInFunction.ts, 1, 11))
 >C : Symbol(C, Decl(modifierOnClassExpressionMemberInFunction.ts, 1, 11))
 
         public prop1 = 1;
diff --git a/tests/baselines/reference/moduleExportAlias4.symbols b/tests/baselines/reference/moduleExportAlias4.symbols
index 561d668343b..9e9a1ad53ec 100644
--- a/tests/baselines/reference/moduleExportAlias4.symbols
+++ b/tests/baselines/reference/moduleExportAlias4.symbols
@@ -9,6 +9,7 @@ module.exports = class C {}
 >module.exports : Symbol(module.exports, Decl(bug24024.js, 0, 0))
 >module : Symbol(export=, Decl(bug24024.js, 1, 31))
 >exports : Symbol(export=, Decl(bug24024.js, 1, 31))
+>class C {} : Symbol(wat, Decl(bug24024.js, 2, 16))
 >C : Symbol(wat, Decl(bug24024.js, 2, 16))
 
 module.exports.D = class D { }
@@ -17,5 +18,6 @@ module.exports.D = class D { }
 >module : Symbol(module, Decl(bug24024.js, 1, 31))
 >exports : Symbol(module.exports, Decl(bug24024.js, 0, 0))
 >D : Symbol(wat.D, Decl(bug24024.js, 2, 27))
+>class D { } : Symbol(wat.D, Decl(bug24024.js, 3, 18))
 >D : Symbol(wat.D, Decl(bug24024.js, 3, 18))
 
diff --git a/tests/baselines/reference/moduleExportNestedNamespaces.symbols b/tests/baselines/reference/moduleExportNestedNamespaces.symbols
index af7c29bde1a..0bee6017484 100644
--- a/tests/baselines/reference/moduleExportNestedNamespaces.symbols
+++ b/tests/baselines/reference/moduleExportNestedNamespaces.symbols
@@ -27,6 +27,7 @@ module.exports.Classic = class {
 >module : Symbol(module, Decl(mod.js, 0, 0))
 >exports : Symbol(module.exports, Decl(mod.js, 0, 0))
 >Classic : Symbol(Classic, Decl(mod.js, 3, 1))
+>class {    constructor() {        this.p = 1    }} : Symbol(Classic, Decl(mod.js, 4, 24))
 
     constructor() {
         this.p = 1
diff --git a/tests/baselines/reference/nanEquality.symbols b/tests/baselines/reference/nanEquality.symbols
index 4398b9c32f6..14ab85a23fb 100644
--- a/tests/baselines/reference/nanEquality.symbols
+++ b/tests/baselines/reference/nanEquality.symbols
@@ -36,17 +36,25 @@ if (NaN != x) {}
 
 if (x === ((NaN))) {}
 >x : Symbol(x, Decl(nanEquality.ts, 0, 13))
+>((NaN)) : Symbol(NaN, Decl(lib.es5.d.ts, --, --))
+>(NaN) : Symbol(NaN, Decl(lib.es5.d.ts, --, --))
 >NaN : Symbol(NaN, Decl(lib.es5.d.ts, --, --))
 
 if (((NaN)) === x) {}
+>((NaN)) : Symbol(NaN, Decl(lib.es5.d.ts, --, --))
+>(NaN) : Symbol(NaN, Decl(lib.es5.d.ts, --, --))
 >NaN : Symbol(NaN, Decl(lib.es5.d.ts, --, --))
 >x : Symbol(x, Decl(nanEquality.ts, 0, 13))
 
 if (x !== ((NaN))) {}
 >x : Symbol(x, Decl(nanEquality.ts, 0, 13))
+>((NaN)) : Symbol(NaN, Decl(lib.es5.d.ts, --, --))
+>(NaN) : Symbol(NaN, Decl(lib.es5.d.ts, --, --))
 >NaN : Symbol(NaN, Decl(lib.es5.d.ts, --, --))
 
 if (((NaN)) !== x) {}
+>((NaN)) : Symbol(NaN, Decl(lib.es5.d.ts, --, --))
+>(NaN) : Symbol(NaN, Decl(lib.es5.d.ts, --, --))
 >NaN : Symbol(NaN, Decl(lib.es5.d.ts, --, --))
 >x : Symbol(x, Decl(nanEquality.ts, 0, 13))
 
diff --git a/tests/baselines/reference/narrowedConstInMethod.symbols b/tests/baselines/reference/narrowedConstInMethod.symbols
index 9d8279378c3..30ea4286846 100644
--- a/tests/baselines/reference/narrowedConstInMethod.symbols
+++ b/tests/baselines/reference/narrowedConstInMethod.symbols
@@ -30,6 +30,8 @@ function f2() {
 >x : Symbol(x, Decl(narrowedConstInMethod.ts, 11, 9))
 
         return class {
+>class {            bar() { return x.length; }  // ok        } : Symbol((Anonymous class), Decl(narrowedConstInMethod.ts, 13, 14))
+
             bar() { return x.length; }  // ok
 >bar : Symbol((Anonymous class).bar, Decl(narrowedConstInMethod.ts, 13, 22))
 >x.length : Symbol(String.length, Decl(lib.es5.d.ts, --, --))
diff --git a/tests/baselines/reference/neverReturningFunctions1.symbols b/tests/baselines/reference/neverReturningFunctions1.symbols
index b91c8fdb4b0..f2329c2d67e 100644
--- a/tests/baselines/reference/neverReturningFunctions1.symbols
+++ b/tests/baselines/reference/neverReturningFunctions1.symbols
@@ -168,7 +168,9 @@ function f24(x: string) {
 >x : Symbol(x, Decl(neverReturningFunctions1.ts, 59, 13))
 
     ((Debug).fail)();
+>((Debug).fail) : Symbol(Debug.fail, Decl(neverReturningFunctions1.ts, 38, 17))
 >(Debug).fail : Symbol(Debug.fail, Decl(neverReturningFunctions1.ts, 38, 17))
+>(Debug) : Symbol(Debug, Decl(neverReturningFunctions1.ts, 36, 1))
 >Debug : Symbol(Debug, Decl(neverReturningFunctions1.ts, 36, 1))
 >fail : Symbol(Debug.fail, Decl(neverReturningFunctions1.ts, 38, 17))
 
diff --git a/tests/baselines/reference/newWithSpread.symbols b/tests/baselines/reference/newWithSpread.symbols
index 670bdc5fb5a..c38e2e458ce 100644
--- a/tests/baselines/reference/newWithSpread.symbols
+++ b/tests/baselines/reference/newWithSpread.symbols
@@ -137,17 +137,20 @@ new b.f(1, 2, ...a, "string");
 
 // Parenthesised expression
 new (b.f)(1, 2, "string");
+>(b.f) : Symbol(A.f, Decl(newWithSpread.ts, 6, 13))
 >b.f : Symbol(A.f, Decl(newWithSpread.ts, 6, 13))
 >b : Symbol(b, Decl(newWithSpread.ts, 25, 3))
 >f : Symbol(A.f, Decl(newWithSpread.ts, 6, 13))
 
 new (b.f)(1, 2, ...a);
+>(b.f) : Symbol(A.f, Decl(newWithSpread.ts, 6, 13))
 >b.f : Symbol(A.f, Decl(newWithSpread.ts, 6, 13))
 >b : Symbol(b, Decl(newWithSpread.ts, 25, 3))
 >f : Symbol(A.f, Decl(newWithSpread.ts, 6, 13))
 >a : Symbol(a, Decl(newWithSpread.ts, 24, 3))
 
 new (b.f)(1, 2, ...a, "string"); 
+>(b.f) : Symbol(A.f, Decl(newWithSpread.ts, 6, 13))
 >b.f : Symbol(A.f, Decl(newWithSpread.ts, 6, 13))
 >b : Symbol(b, Decl(newWithSpread.ts, 25, 3))
 >f : Symbol(A.f, Decl(newWithSpread.ts, 6, 13))
diff --git a/tests/baselines/reference/newWithSpreadES5.symbols b/tests/baselines/reference/newWithSpreadES5.symbols
index 5baeff2cfb1..91deb377ca0 100644
--- a/tests/baselines/reference/newWithSpreadES5.symbols
+++ b/tests/baselines/reference/newWithSpreadES5.symbols
@@ -136,17 +136,20 @@ new b.f(1, 2, ...a, "string");
 
 // Parenthesised expression
 new (b.f)(1, 2, "string");
+>(b.f) : Symbol(A.f, Decl(newWithSpreadES5.ts, 5, 13))
 >b.f : Symbol(A.f, Decl(newWithSpreadES5.ts, 5, 13))
 >b : Symbol(b, Decl(newWithSpreadES5.ts, 24, 3))
 >f : Symbol(A.f, Decl(newWithSpreadES5.ts, 5, 13))
 
 new (b.f)(1, 2, ...a);
+>(b.f) : Symbol(A.f, Decl(newWithSpreadES5.ts, 5, 13))
 >b.f : Symbol(A.f, Decl(newWithSpreadES5.ts, 5, 13))
 >b : Symbol(b, Decl(newWithSpreadES5.ts, 24, 3))
 >f : Symbol(A.f, Decl(newWithSpreadES5.ts, 5, 13))
 >a : Symbol(a, Decl(newWithSpreadES5.ts, 23, 3))
 
 new (b.f)(1, 2, ...a, "string"); 
+>(b.f) : Symbol(A.f, Decl(newWithSpreadES5.ts, 5, 13))
 >b.f : Symbol(A.f, Decl(newWithSpreadES5.ts, 5, 13))
 >b : Symbol(b, Decl(newWithSpreadES5.ts, 24, 3))
 >f : Symbol(A.f, Decl(newWithSpreadES5.ts, 5, 13))
diff --git a/tests/baselines/reference/newWithSpreadES6.symbols b/tests/baselines/reference/newWithSpreadES6.symbols
index f56e5fe76dc..a49f041e080 100644
--- a/tests/baselines/reference/newWithSpreadES6.symbols
+++ b/tests/baselines/reference/newWithSpreadES6.symbols
@@ -137,17 +137,20 @@ new b.f(1, 2, ...a, "string");
 
 // Parenthesised expression
 new (b.f)(1, 2, "string");
+>(b.f) : Symbol(A.f, Decl(newWithSpreadES6.ts, 6, 13))
 >b.f : Symbol(A.f, Decl(newWithSpreadES6.ts, 6, 13))
 >b : Symbol(b, Decl(newWithSpreadES6.ts, 25, 3))
 >f : Symbol(A.f, Decl(newWithSpreadES6.ts, 6, 13))
 
 new (b.f)(1, 2, ...a);
+>(b.f) : Symbol(A.f, Decl(newWithSpreadES6.ts, 6, 13))
 >b.f : Symbol(A.f, Decl(newWithSpreadES6.ts, 6, 13))
 >b : Symbol(b, Decl(newWithSpreadES6.ts, 25, 3))
 >f : Symbol(A.f, Decl(newWithSpreadES6.ts, 6, 13))
 >a : Symbol(a, Decl(newWithSpreadES6.ts, 24, 3))
 
 new (b.f)(1, 2, ...a, "string"); 
+>(b.f) : Symbol(A.f, Decl(newWithSpreadES6.ts, 6, 13))
 >b.f : Symbol(A.f, Decl(newWithSpreadES6.ts, 6, 13))
 >b : Symbol(b, Decl(newWithSpreadES6.ts, 25, 3))
 >f : Symbol(A.f, Decl(newWithSpreadES6.ts, 6, 13))
diff --git a/tests/baselines/reference/noCrashOnMixin.symbols b/tests/baselines/reference/noCrashOnMixin.symbols
index 3f99f99aa49..10a8314d72b 100644
--- a/tests/baselines/reference/noCrashOnMixin.symbols
+++ b/tests/baselines/reference/noCrashOnMixin.symbols
@@ -25,6 +25,7 @@ function Mixin<TBase extends Constructor>(Base: TBase) {
 >TBase : Symbol(TBase, Decl(noCrashOnMixin.ts, 10, 15))
 
     return class extends Base {
+>class extends Base {    } : Symbol((Anonymous class), Decl(noCrashOnMixin.ts, 11, 10))
 >Base : Symbol(Base, Decl(noCrashOnMixin.ts, 10, 42))
 
     };
diff --git a/tests/baselines/reference/nonNullReferenceMatching.symbols b/tests/baselines/reference/nonNullReferenceMatching.symbols
index ee9c608cea4..45e8784583e 100644
--- a/tests/baselines/reference/nonNullReferenceMatching.symbols
+++ b/tests/baselines/reference/nonNullReferenceMatching.symbols
@@ -54,6 +54,7 @@ class Component {
 >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!.elementRef : Symbol(elementRef, Decl(nonNullReferenceMatching.ts, 2, 19))
 >this.props.thumbYProps : Symbol(thumbYProps, Decl(nonNullReferenceMatching.ts, 6, 23))
 >this.props : Symbol(Component.props, Decl(nonNullReferenceMatching.ts, 11, 17))
@@ -71,8 +72,10 @@ class Component {
 >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!.elementRef : Symbol(elementRef, Decl(nonNullReferenceMatching.ts, 2, 19))
 >(this.props).thumbYProps : Symbol(thumbYProps, Decl(nonNullReferenceMatching.ts, 6, 23))
+>(this.props) : Symbol(Component.props, Decl(nonNullReferenceMatching.ts, 11, 17))
 >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))
@@ -114,6 +117,7 @@ class Component {
 >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))
+>(this.props) : Symbol(Component.props, Decl(nonNullReferenceMatching.ts, 11, 17))
 >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))
@@ -130,6 +134,7 @@ class Component {
 >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))
 >this.props.thumbXProps : Symbol(thumbXProps, Decl(nonNullReferenceMatching.ts, 7, 29))
 >this.props : Symbol(Component.props, Decl(nonNullReferenceMatching.ts, 11, 17))
 >this : Symbol(Component, Decl(nonNullReferenceMatching.ts, 9, 1))
@@ -147,7 +152,9 @@ class Component {
 >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))
 >(this.props)!.thumbXProps : Symbol(thumbXProps, Decl(nonNullReferenceMatching.ts, 7, 29))
+>(this.props) : Symbol(Component.props, Decl(nonNullReferenceMatching.ts, 11, 17))
 >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))
@@ -157,6 +164,7 @@ class Component {
 
         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 : Symbol(thumbXProps, Decl(nonNullReferenceMatching.ts, 7, 29))
 >this.props : Symbol(Component.props, Decl(nonNullReferenceMatching.ts, 11, 17))
 >this : Symbol(Component, Decl(nonNullReferenceMatching.ts, 9, 1))
@@ -164,7 +172,9 @@ class Component {
 >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))
 >(this.props)!.thumbXProps : Symbol(thumbXProps, Decl(nonNullReferenceMatching.ts, 7, 29))
+>(this.props) : Symbol(Component.props, Decl(nonNullReferenceMatching.ts, 11, 17))
 >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))
@@ -181,7 +191,9 @@ class Component {
 >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))
 >(this.props)!.thumbXProps : Symbol(thumbXProps, Decl(nonNullReferenceMatching.ts, 7, 29))
+>(this.props) : Symbol(Component.props, Decl(nonNullReferenceMatching.ts, 11, 17))
 >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))
diff --git a/tests/baselines/reference/override1.symbols b/tests/baselines/reference/override1.symbols
index 18aa50df1d1..e9531212cfa 100644
--- a/tests/baselines/reference/override1.symbols
+++ b/tests/baselines/reference/override1.symbols
@@ -40,6 +40,7 @@ function f () {
 >f : Symbol(f, Decl(override1.ts, 15, 1))
 
     return class extends B {
+>class extends B {        override foo (v: string) {}            fooo (v: string) {}            override bar(v: string) {}    } : Symbol((Anonymous class), Decl(override1.ts, 18, 10))
 >B : Symbol(B, Decl(override1.ts, 0, 0))
 
         override foo (v: string) {}
@@ -58,6 +59,8 @@ function f () {
 
 class E extends (class {
 >E : Symbol(E, Decl(override1.ts, 25, 1))
+>(class {    foo () { }    bar () { }}) : Symbol((Anonymous class), Decl(override1.ts, 27, 17))
+>class {    foo () { }    bar () { }} : Symbol((Anonymous class), Decl(override1.ts, 27, 17))
 
     foo () { }
 >foo : Symbol((Anonymous class).foo, Decl(override1.ts, 27, 24))
@@ -83,6 +86,8 @@ function ff () {
 >ff : Symbol(ff, Decl(override1.ts, 37, 1))
 
     return class {
+>class {        override foo () {}    } : Symbol((Anonymous class), Decl(override1.ts, 40, 10))
+
         override foo () {}
 >foo : Symbol((Anonymous class).foo, Decl(override1.ts, 40, 18))
     }
diff --git a/tests/baselines/reference/override20.symbols b/tests/baselines/reference/override20.symbols
index 69d598e4bb1..d1db8521106 100644
--- a/tests/baselines/reference/override20.symbols
+++ b/tests/baselines/reference/override20.symbols
@@ -5,6 +5,8 @@ const Foo: C1 & C2 =
 >C2 : Symbol(C2, Decl(override20.ts, 17, 1))
 
     class {
+>class {        m1() { }        m2() { }    } : Symbol(Foo, Decl(override20.ts, 0, 20))
+
         m1() { }
 >m1 : Symbol(Foo.m1, Decl(override20.ts, 1, 11))
 
diff --git a/tests/baselines/reference/overrideBaseIntersectionMethod.symbols b/tests/baselines/reference/overrideBaseIntersectionMethod.symbols
index 368c9f50f52..8d72523d0b6 100644
--- a/tests/baselines/reference/overrideBaseIntersectionMethod.symbols
+++ b/tests/baselines/reference/overrideBaseIntersectionMethod.symbols
@@ -14,6 +14,7 @@ const WithLocation = <T extends Constructor<Point>>(Base: T) => class extends Ba
 >Point : Symbol(Point, Decl(overrideBaseIntersectionMethod.ts, 9, 1))
 >Base : Symbol(Base, Decl(overrideBaseIntersectionMethod.ts, 4, 52))
 >T : Symbol(T, Decl(overrideBaseIntersectionMethod.ts, 4, 22))
+>class extends Base {  getLocation(): [number, number] {    const [x,y] = super.getLocation();    return [this.x | x, this.y | y];  }} : Symbol((Anonymous class), Decl(overrideBaseIntersectionMethod.ts, 4, 63))
 >Base : Symbol(Base, Decl(overrideBaseIntersectionMethod.ts, 4, 52))
 
   getLocation(): [number, number] {
diff --git a/tests/baselines/reference/parserForOfStatement24.symbols b/tests/baselines/reference/parserForOfStatement24.symbols
index ef874ffe6a7..e0e4dca9372 100644
--- a/tests/baselines/reference/parserForOfStatement24.symbols
+++ b/tests/baselines/reference/parserForOfStatement24.symbols
@@ -3,5 +3,6 @@ var async;
 >async : Symbol(async, Decl(parserForOfStatement24.ts, 0, 3))
 
 for ((async) of [1, 2]);
+>(async) : Symbol(async, Decl(parserForOfStatement24.ts, 0, 3))
 >async : Symbol(async, Decl(parserForOfStatement24.ts, 0, 3))
 
diff --git a/tests/baselines/reference/parserParenthesizedVariableAndFunctionInTernary.symbols b/tests/baselines/reference/parserParenthesizedVariableAndFunctionInTernary.symbols
index 3b64c950750..7e315f2f975 100644
--- a/tests/baselines/reference/parserParenthesizedVariableAndFunctionInTernary.symbols
+++ b/tests/baselines/reference/parserParenthesizedVariableAndFunctionInTernary.symbols
@@ -4,5 +4,6 @@ let a: any;
 
 const c = true ? (a) : function() {};
 >c : Symbol(c, Decl(parserParenthesizedVariableAndFunctionInTernary.ts, 1, 5))
+>(a) : Symbol(a, Decl(parserParenthesizedVariableAndFunctionInTernary.ts, 0, 3))
 >a : Symbol(a, Decl(parserParenthesizedVariableAndFunctionInTernary.ts, 0, 3))
 
diff --git a/tests/baselines/reference/parserParenthesizedVariableAndParenthesizedFunctionInTernary.symbols b/tests/baselines/reference/parserParenthesizedVariableAndParenthesizedFunctionInTernary.symbols
index c133ddc1157..2386efdb570 100644
--- a/tests/baselines/reference/parserParenthesizedVariableAndParenthesizedFunctionInTernary.symbols
+++ b/tests/baselines/reference/parserParenthesizedVariableAndParenthesizedFunctionInTernary.symbols
@@ -4,9 +4,11 @@ let a: any;
 
 const c = true ? (a) : (function() {});
 >c : Symbol(c, Decl(parserParenthesizedVariableAndParenthesizedFunctionInTernary.ts, 1, 5))
+>(a) : Symbol(a, Decl(parserParenthesizedVariableAndParenthesizedFunctionInTernary.ts, 0, 3))
 >a : Symbol(a, Decl(parserParenthesizedVariableAndParenthesizedFunctionInTernary.ts, 0, 3))
 
 const d = true ? (a) : ((function() {}));
 >d : Symbol(d, Decl(parserParenthesizedVariableAndParenthesizedFunctionInTernary.ts, 2, 5))
+>(a) : Symbol(a, Decl(parserParenthesizedVariableAndParenthesizedFunctionInTernary.ts, 0, 3))
 >a : Symbol(a, Decl(parserParenthesizedVariableAndParenthesizedFunctionInTernary.ts, 0, 3))
 
diff --git a/tests/baselines/reference/parserRealSource11.symbols b/tests/baselines/reference/parserRealSource11.symbols
index 2d155c0e449..7fce3bd4ec5 100644
--- a/tests/baselines/reference/parserRealSource11.symbols
+++ b/tests/baselines/reference/parserRealSource11.symbols
@@ -4216,6 +4216,7 @@ module TypeScript {
 
         public hasExplicitTarget() { return (this.target); }
 >hasExplicitTarget : Symbol(Jump.hasExplicitTarget, Decl(parserRealSource11.ts, 1400, 37))
+>(this.target) : Symbol(Jump.target, Decl(parserRealSource11.ts, 1399, 41))
 >this.target : Symbol(Jump.target, Decl(parserRealSource11.ts, 1399, 41))
 >this : Symbol(Jump, Decl(parserRealSource11.ts, 1397, 5))
 >target : Symbol(Jump.target, Decl(parserRealSource11.ts, 1399, 41))
@@ -5307,6 +5308,7 @@ module TypeScript {
 >nodeType : Symbol(AST.nodeType, Decl(parserRealSource11.ts, 23, 21))
 
                                                 if (((<Identifier>this.lval).actualText) == (<Identifier>arg).actualText) {
+>((<Identifier>this.lval).actualText) : Symbol(Identifier.actualText, Decl(parserRealSource11.ts, 266, 21))
 >(<Identifier>this.lval).actualText : Symbol(Identifier.actualText, Decl(parserRealSource11.ts, 266, 21))
 >Identifier : Symbol(Identifier, Decl(parserRealSource11.ts, 247, 5))
 >this.lval : Symbol(ForInStatement.lval, Decl(parserRealSource11.ts, 1686, 21))
diff --git a/tests/baselines/reference/parserRealSource12.symbols b/tests/baselines/reference/parserRealSource12.symbols
index 280d4044efb..57d9dd986fa 100644
--- a/tests/baselines/reference/parserRealSource12.symbols
+++ b/tests/baselines/reference/parserRealSource12.symbols
@@ -1349,6 +1349,7 @@ module TypeScript {
                 }
                 if ((preAst.operand1) && (walker.options.goNextSibling)) {
 >preAst : Symbol(preAst, Decl(parserRealSource12.ts, 251, 53))
+>(walker.options.goNextSibling) : Symbol(AstWalkOptions.goNextSibling, Decl(parserRealSource12.ts, 13, 33))
 >walker.options.goNextSibling : Symbol(AstWalkOptions.goNextSibling, Decl(parserRealSource12.ts, 13, 33))
 >walker.options : Symbol(IAstWalker.options, Decl(parserRealSource12.ts, 7, 41))
 >walker : Symbol(walker, Decl(parserRealSource12.ts, 251, 91))
@@ -1377,6 +1378,7 @@ module TypeScript {
                 }
                 if ((preAst.operand2) && (walker.options.goNextSibling)) {
 >preAst : Symbol(preAst, Decl(parserRealSource12.ts, 251, 53))
+>(walker.options.goNextSibling) : Symbol(AstWalkOptions.goNextSibling, Decl(parserRealSource12.ts, 13, 33))
 >walker.options.goNextSibling : Symbol(AstWalkOptions.goNextSibling, Decl(parserRealSource12.ts, 13, 33))
 >walker.options : Symbol(IAstWalker.options, Decl(parserRealSource12.ts, 7, 41))
 >walker : Symbol(walker, Decl(parserRealSource12.ts, 251, 91))
@@ -1442,6 +1444,7 @@ module TypeScript {
             }
             if (preAst.arguments && (walker.options.goNextSibling)) {
 >preAst : Symbol(preAst, Decl(parserRealSource12.ts, 275, 51))
+>(walker.options.goNextSibling) : Symbol(AstWalkOptions.goNextSibling, Decl(parserRealSource12.ts, 13, 33))
 >walker.options.goNextSibling : Symbol(AstWalkOptions.goNextSibling, Decl(parserRealSource12.ts, 13, 33))
 >walker.options : Symbol(IAstWalker.options, Decl(parserRealSource12.ts, 7, 41))
 >walker : Symbol(walker, Decl(parserRealSource12.ts, 275, 87))
@@ -1458,11 +1461,13 @@ module TypeScript {
 >preAst : Symbol(preAst, Decl(parserRealSource12.ts, 275, 51))
             }
             if ((walker.options.reverseSiblings) && (walker.options.goNextSibling)) {
+>(walker.options.reverseSiblings) : Symbol(AstWalkOptions.reverseSiblings, Decl(parserRealSource12.ts, 14, 36))
 >walker.options.reverseSiblings : Symbol(AstWalkOptions.reverseSiblings, Decl(parserRealSource12.ts, 14, 36))
 >walker.options : Symbol(IAstWalker.options, Decl(parserRealSource12.ts, 7, 41))
 >walker : Symbol(walker, Decl(parserRealSource12.ts, 275, 87))
 >options : Symbol(IAstWalker.options, Decl(parserRealSource12.ts, 7, 41))
 >reverseSiblings : Symbol(AstWalkOptions.reverseSiblings, Decl(parserRealSource12.ts, 14, 36))
+>(walker.options.goNextSibling) : Symbol(AstWalkOptions.goNextSibling, Decl(parserRealSource12.ts, 13, 33))
 >walker.options.goNextSibling : Symbol(AstWalkOptions.goNextSibling, Decl(parserRealSource12.ts, 13, 33))
 >walker.options : Symbol(IAstWalker.options, Decl(parserRealSource12.ts, 7, 41))
 >walker : Symbol(walker, Decl(parserRealSource12.ts, 275, 87))
@@ -1501,6 +1506,7 @@ module TypeScript {
             }
             if (preAst.operand2 && (walker.options.goNextSibling)) {
 >preAst : Symbol(preAst, Decl(parserRealSource12.ts, 287, 54))
+>(walker.options.goNextSibling) : Symbol(AstWalkOptions.goNextSibling, Decl(parserRealSource12.ts, 13, 33))
 >walker.options.goNextSibling : Symbol(AstWalkOptions.goNextSibling, Decl(parserRealSource12.ts, 13, 33))
 >walker.options : Symbol(IAstWalker.options, Decl(parserRealSource12.ts, 7, 41))
 >walker : Symbol(walker, Decl(parserRealSource12.ts, 287, 97))
@@ -1517,6 +1523,7 @@ module TypeScript {
             }
             if (preAst.operand3 && (walker.options.goNextSibling)) {
 >preAst : Symbol(preAst, Decl(parserRealSource12.ts, 287, 54))
+>(walker.options.goNextSibling) : Symbol(AstWalkOptions.goNextSibling, Decl(parserRealSource12.ts, 13, 33))
 >walker.options.goNextSibling : Symbol(AstWalkOptions.goNextSibling, Decl(parserRealSource12.ts, 13, 33))
 >walker.options : Symbol(IAstWalker.options, Decl(parserRealSource12.ts, 7, 41))
 >walker : Symbol(walker, Decl(parserRealSource12.ts, 287, 97))
@@ -1557,6 +1564,7 @@ module TypeScript {
             if (preAst.arguments && (preAst.arguments.members.length > 0) && (walker.options.goNextSibling)) {
 >preAst : Symbol(preAst, Decl(parserRealSource12.ts, 299, 45))
 >preAst : Symbol(preAst, Decl(parserRealSource12.ts, 299, 45))
+>(walker.options.goNextSibling) : Symbol(AstWalkOptions.goNextSibling, Decl(parserRealSource12.ts, 13, 33))
 >walker.options.goNextSibling : Symbol(AstWalkOptions.goNextSibling, Decl(parserRealSource12.ts, 13, 33))
 >walker.options : Symbol(IAstWalker.options, Decl(parserRealSource12.ts, 7, 41))
 >walker : Symbol(walker, Decl(parserRealSource12.ts, 299, 75))
@@ -1574,6 +1582,7 @@ module TypeScript {
             }
             if (preAst.returnTypeAnnotation && (walker.options.goNextSibling)) {
 >preAst : Symbol(preAst, Decl(parserRealSource12.ts, 299, 45))
+>(walker.options.goNextSibling) : Symbol(AstWalkOptions.goNextSibling, Decl(parserRealSource12.ts, 13, 33))
 >walker.options.goNextSibling : Symbol(AstWalkOptions.goNextSibling, Decl(parserRealSource12.ts, 13, 33))
 >walker.options : Symbol(IAstWalker.options, Decl(parserRealSource12.ts, 7, 41))
 >walker : Symbol(walker, Decl(parserRealSource12.ts, 299, 75))
@@ -1591,6 +1600,7 @@ module TypeScript {
             if (preAst.bod && (preAst.bod.members.length > 0) && (walker.options.goNextSibling)) {
 >preAst : Symbol(preAst, Decl(parserRealSource12.ts, 299, 45))
 >preAst : Symbol(preAst, Decl(parserRealSource12.ts, 299, 45))
+>(walker.options.goNextSibling) : Symbol(AstWalkOptions.goNextSibling, Decl(parserRealSource12.ts, 13, 33))
 >walker.options.goNextSibling : Symbol(AstWalkOptions.goNextSibling, Decl(parserRealSource12.ts, 13, 33))
 >walker.options : Symbol(IAstWalker.options, Decl(parserRealSource12.ts, 7, 41))
 >walker : Symbol(walker, Decl(parserRealSource12.ts, 299, 75))
@@ -1642,6 +1652,7 @@ module TypeScript {
             }
             if ((preAst.typeExpr) && (walker.options.goNextSibling)) {
 >preAst : Symbol(preAst, Decl(parserRealSource12.ts, 314, 46))
+>(walker.options.goNextSibling) : Symbol(AstWalkOptions.goNextSibling, Decl(parserRealSource12.ts, 13, 33))
 >walker.options.goNextSibling : Symbol(AstWalkOptions.goNextSibling, Decl(parserRealSource12.ts, 13, 33))
 >walker.options : Symbol(IAstWalker.options, Decl(parserRealSource12.ts, 7, 41))
 >walker : Symbol(walker, Decl(parserRealSource12.ts, 314, 77))
@@ -1787,6 +1798,7 @@ module TypeScript {
             }
             if (preAst.body && (walker.options.goNextSibling)) {
 >preAst : Symbol(preAst, Decl(parserRealSource12.ts, 350, 51))
+>(walker.options.goNextSibling) : Symbol(AstWalkOptions.goNextSibling, Decl(parserRealSource12.ts, 13, 33))
 >walker.options.goNextSibling : Symbol(AstWalkOptions.goNextSibling, Decl(parserRealSource12.ts, 13, 33))
 >walker.options : Symbol(IAstWalker.options, Decl(parserRealSource12.ts, 7, 41))
 >walker : Symbol(walker, Decl(parserRealSource12.ts, 350, 87))
@@ -1822,6 +1834,7 @@ module TypeScript {
 
             if (preAst.thenBod && (walker.options.goNextSibling)) {
 >preAst : Symbol(preAst, Decl(parserRealSource12.ts, 360, 48))
+>(walker.options.goNextSibling) : Symbol(AstWalkOptions.goNextSibling, Decl(parserRealSource12.ts, 13, 33))
 >walker.options.goNextSibling : Symbol(AstWalkOptions.goNextSibling, Decl(parserRealSource12.ts, 13, 33))
 >walker.options : Symbol(IAstWalker.options, Decl(parserRealSource12.ts, 7, 41))
 >walker : Symbol(walker, Decl(parserRealSource12.ts, 360, 81))
@@ -1838,6 +1851,7 @@ module TypeScript {
             }
             if (preAst.elseBod && (walker.options.goNextSibling)) {
 >preAst : Symbol(preAst, Decl(parserRealSource12.ts, 360, 48))
+>(walker.options.goNextSibling) : Symbol(AstWalkOptions.goNextSibling, Decl(parserRealSource12.ts, 13, 33))
 >walker.options.goNextSibling : Symbol(AstWalkOptions.goNextSibling, Decl(parserRealSource12.ts, 13, 33))
 >walker.options : Symbol(IAstWalker.options, Decl(parserRealSource12.ts, 7, 41))
 >walker : Symbol(walker, Decl(parserRealSource12.ts, 360, 81))
@@ -1873,6 +1887,7 @@ module TypeScript {
 
             if (preAst.body && (walker.options.goNextSibling)) {
 >preAst : Symbol(preAst, Decl(parserRealSource12.ts, 370, 51))
+>(walker.options.goNextSibling) : Symbol(AstWalkOptions.goNextSibling, Decl(parserRealSource12.ts, 13, 33))
 >walker.options.goNextSibling : Symbol(AstWalkOptions.goNextSibling, Decl(parserRealSource12.ts, 13, 33))
 >walker.options : Symbol(IAstWalker.options, Decl(parserRealSource12.ts, 7, 41))
 >walker : Symbol(walker, Decl(parserRealSource12.ts, 370, 87))
@@ -1908,6 +1923,7 @@ module TypeScript {
 
             if (preAst.body && (walker.options.goNextSibling)) {
 >preAst : Symbol(preAst, Decl(parserRealSource12.ts, 377, 53))
+>(walker.options.goNextSibling) : Symbol(AstWalkOptions.goNextSibling, Decl(parserRealSource12.ts, 13, 33))
 >walker.options.goNextSibling : Symbol(AstWalkOptions.goNextSibling, Decl(parserRealSource12.ts, 13, 33))
 >walker.options : Symbol(IAstWalker.options, Decl(parserRealSource12.ts, 7, 41))
 >walker : Symbol(walker, Decl(parserRealSource12.ts, 377, 91))
diff --git a/tests/baselines/reference/parserRealSource4.symbols b/tests/baselines/reference/parserRealSource4.symbols
index f43c35dcaa5..6956895c8d6 100644
--- a/tests/baselines/reference/parserRealSource4.symbols
+++ b/tests/baselines/reference/parserRealSource4.symbols
@@ -889,6 +889,7 @@ module TypeScript {
 >key : Symbol(HashEntry.key, Decl(parserRealSource4.ts, 189, 21))
 
                     return (current.data);
+>(current.data) : Symbol(HashEntry.data, Decl(parserRealSource4.ts, 189, 32))
 >current.data : Symbol(HashEntry.data, Decl(parserRealSource4.ts, 189, 32))
 >current : Symbol(current, Decl(parserRealSource4.ts, 247, 15))
 >data : Symbol(HashEntry.data, Decl(parserRealSource4.ts, 189, 32))
diff --git a/tests/baselines/reference/parserS7.2_A1.5_T2.symbols b/tests/baselines/reference/parserS7.2_A1.5_T2.symbols
index 92ad52899f4..381da599f3c 100644
--- a/tests/baselines/reference/parserS7.2_A1.5_T2.symbols
+++ b/tests/baselines/reference/parserS7.2_A1.5_T2.symbols
@@ -17,6 +17,7 @@ if (x !== 1) {
 >x : Symbol(x, Decl(parserS7.2_A1.5_T2.ts, 17, 4))
 
   $ERROR('#1: eval("\\u00A0var x\\u00A0= 1\\u00A0"); x === 1. Actual: ' + (x));
+>(x) : Symbol(x, Decl(parserS7.2_A1.5_T2.ts, 17, 4))
 >x : Symbol(x, Decl(parserS7.2_A1.5_T2.ts, 17, 4))
 }
 
@@ -28,6 +29,7 @@ if (x !== 1) {
 >x : Symbol(x, Decl(parserS7.2_A1.5_T2.ts, 17, 4))
 
   $ERROR('#2:  var x = 1 ; x === 1. Actual: ' + (x));
+>(x) : Symbol(x, Decl(parserS7.2_A1.5_T2.ts, 17, 4))
 >x : Symbol(x, Decl(parserS7.2_A1.5_T2.ts, 17, 4))
 }
 
diff --git a/tests/baselines/reference/parserS7.3_A1.1_T2.symbols b/tests/baselines/reference/parserS7.3_A1.1_T2.symbols
index 60f0ecac13d..e69fb2b323a 100644
--- a/tests/baselines/reference/parserS7.3_A1.1_T2.symbols
+++ b/tests/baselines/reference/parserS7.3_A1.1_T2.symbols
@@ -20,6 +20,7 @@ if (x !== 1) {
 >x : Symbol(x, Decl(parserS7.3_A1.1_T2.ts, 11, 3))
 
   $ERROR('#1: var\\nx\\n=\\n1\\n; x === 1. Actual: ' + (x));
+>(x) : Symbol(x, Decl(parserS7.3_A1.1_T2.ts, 11, 3))
 >x : Symbol(x, Decl(parserS7.3_A1.1_T2.ts, 11, 3))
 }
 
diff --git a/tests/baselines/reference/parserUnicode1.symbols b/tests/baselines/reference/parserUnicode1.symbols
index 7b4a2a55e7f..60e6a1a3343 100644
--- a/tests/baselines/reference/parserUnicode1.symbols
+++ b/tests/baselines/reference/parserUnicode1.symbols
@@ -7,6 +7,7 @@ try {
 >xx : Symbol(\u0078x, Decl(parserUnicode1.ts, 1, 5))
 
     $ERROR('#6.1: var \\u0078x = 1; xx === 6. Actual: ' + (xx));
+>(xx) : Symbol(\u0078x, Decl(parserUnicode1.ts, 1, 5))
 >xx : Symbol(\u0078x, Decl(parserUnicode1.ts, 1, 5))
   }
 }
@@ -14,6 +15,7 @@ catch (e) {
 >e : Symbol(e, Decl(parserUnicode1.ts, 8, 7))
 
     $ERROR('#6.2: var \\u0078x = 1; xx === 6. Actual: ' + (xx));
+>(xx) : Symbol(\u0078x, Decl(parserUnicode1.ts, 1, 5))
 >xx : Symbol(\u0078x, Decl(parserUnicode1.ts, 1, 5))
 
 }
diff --git a/tests/baselines/reference/parserharness.symbols b/tests/baselines/reference/parserharness.symbols
index 62604cadf5a..ce6e9db199b 100644
--- a/tests/baselines/reference/parserharness.symbols
+++ b/tests/baselines/reference/parserharness.symbols
@@ -4050,6 +4050,7 @@ module Harness {
 >uName : Symbol(uName, Decl(parserharness.ts, 1354, 15))
 >context : Symbol(context, Decl(parserharness.ts, 1343, 120))
 >unitName : Symbol(unitName, Decl(parserharness.ts, 1343, 51))
+>(isDeclareFile) : Symbol(isDeclareFile, Decl(parserharness.ts, 1352, 15))
 >isDeclareFile : Symbol(isDeclareFile, Decl(parserharness.ts, 1352, 15))
 
             scripts.push(addUnit(code, uName, false, isDeclareFile, references));
diff --git a/tests/baselines/reference/privateNameClassExpressionLoop.symbols b/tests/baselines/reference/privateNameClassExpressionLoop.symbols
index 3f303cbdde8..01c8e7e914e 100644
--- a/tests/baselines/reference/privateNameClassExpressionLoop.symbols
+++ b/tests/baselines/reference/privateNameClassExpressionLoop.symbols
@@ -11,6 +11,7 @@ for (let i = 0; i < 10; ++i) {
 >array.push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --))
 >array : Symbol(array, Decl(privateNameClassExpressionLoop.ts, 0, 5))
 >push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --))
+>class C {        #myField = "hello";        #method() {}        get #accessor() { return 42; }        set #accessor(val) { }    } : Symbol(C, Decl(privateNameClassExpressionLoop.ts, 2, 15))
 >C : Symbol(C, Decl(privateNameClassExpressionLoop.ts, 2, 15))
 
         #myField = "hello";
diff --git a/tests/baselines/reference/privateNameFieldClassExpression.symbols b/tests/baselines/reference/privateNameFieldClassExpression.symbols
index 190ee14ca9b..4d45b61d520 100644
--- a/tests/baselines/reference/privateNameFieldClassExpression.symbols
+++ b/tests/baselines/reference/privateNameFieldClassExpression.symbols
@@ -4,6 +4,7 @@ class B {
 
     #foo = class {
 >#foo : Symbol(B.#foo, Decl(privateNameFieldClassExpression.ts, 0, 9))
+>class {        constructor() {            console.log("hello");        }        static test = 123;    } : Symbol((Anonymous class), Decl(privateNameFieldClassExpression.ts, 1, 10))
 
         constructor() {
             console.log("hello");
@@ -17,6 +18,7 @@ class B {
     };
     #foo2 = class Foo {
 >#foo2 : Symbol(B.#foo2, Decl(privateNameFieldClassExpression.ts, 6, 6))
+>class Foo {        static otherClass = 123;    } : Symbol(Foo, Decl(privateNameFieldClassExpression.ts, 7, 11))
 >Foo : Symbol(Foo, Decl(privateNameFieldClassExpression.ts, 7, 11))
 
         static otherClass = 123;
diff --git a/tests/baselines/reference/privateNameFieldUnaryMutation.symbols b/tests/baselines/reference/privateNameFieldUnaryMutation.symbols
index f1481f4c8f0..65c33d82dcd 100644
--- a/tests/baselines/reference/privateNameFieldUnaryMutation.symbols
+++ b/tests/baselines/reference/privateNameFieldUnaryMutation.symbols
@@ -59,38 +59,46 @@ class C {
 >this : Symbol(C, Decl(privateNameFieldUnaryMutation.ts, 0, 0))
 
         (this.#test)++;
+>(this.#test) : Symbol(C.#test, Decl(privateNameFieldUnaryMutation.ts, 0, 9))
 >this.#test : Symbol(C.#test, Decl(privateNameFieldUnaryMutation.ts, 0, 9))
 >this : Symbol(C, Decl(privateNameFieldUnaryMutation.ts, 0, 0))
 
         (this.#test)--;
+>(this.#test) : Symbol(C.#test, Decl(privateNameFieldUnaryMutation.ts, 0, 9))
 >this.#test : Symbol(C.#test, Decl(privateNameFieldUnaryMutation.ts, 0, 9))
 >this : Symbol(C, Decl(privateNameFieldUnaryMutation.ts, 0, 0))
 
         ++(this.#test);
+>(this.#test) : Symbol(C.#test, Decl(privateNameFieldUnaryMutation.ts, 0, 9))
 >this.#test : Symbol(C.#test, Decl(privateNameFieldUnaryMutation.ts, 0, 9))
 >this : Symbol(C, Decl(privateNameFieldUnaryMutation.ts, 0, 0))
 
         --(this.#test);
+>(this.#test) : Symbol(C.#test, Decl(privateNameFieldUnaryMutation.ts, 0, 9))
 >this.#test : Symbol(C.#test, Decl(privateNameFieldUnaryMutation.ts, 0, 9))
 >this : Symbol(C, Decl(privateNameFieldUnaryMutation.ts, 0, 0))
 
         const e = (this.#test)++;
 >e : Symbol(e, Decl(privateNameFieldUnaryMutation.ts, 18, 13))
+>(this.#test) : Symbol(C.#test, Decl(privateNameFieldUnaryMutation.ts, 0, 9))
 >this.#test : Symbol(C.#test, Decl(privateNameFieldUnaryMutation.ts, 0, 9))
 >this : Symbol(C, Decl(privateNameFieldUnaryMutation.ts, 0, 0))
 
         const f = (this.#test)--;
 >f : Symbol(f, Decl(privateNameFieldUnaryMutation.ts, 19, 13))
+>(this.#test) : Symbol(C.#test, Decl(privateNameFieldUnaryMutation.ts, 0, 9))
 >this.#test : Symbol(C.#test, Decl(privateNameFieldUnaryMutation.ts, 0, 9))
 >this : Symbol(C, Decl(privateNameFieldUnaryMutation.ts, 0, 0))
 
         const g = ++(this.#test);
 >g : Symbol(g, Decl(privateNameFieldUnaryMutation.ts, 20, 13))
+>(this.#test) : Symbol(C.#test, Decl(privateNameFieldUnaryMutation.ts, 0, 9))
 >this.#test : Symbol(C.#test, Decl(privateNameFieldUnaryMutation.ts, 0, 9))
 >this : Symbol(C, Decl(privateNameFieldUnaryMutation.ts, 0, 0))
 
         const h = --(this.#test);
 >h : Symbol(h, Decl(privateNameFieldUnaryMutation.ts, 21, 13))
+>(this.#test) : Symbol(C.#test, Decl(privateNameFieldUnaryMutation.ts, 0, 9))
 >this.#test : Symbol(C.#test, Decl(privateNameFieldUnaryMutation.ts, 0, 9))
 >this : Symbol(C, Decl(privateNameFieldUnaryMutation.ts, 0, 0))
 
@@ -99,6 +107,7 @@ class C {
 >this : Symbol(C, Decl(privateNameFieldUnaryMutation.ts, 0, 0))
 >this.#test : Symbol(C.#test, Decl(privateNameFieldUnaryMutation.ts, 0, 9))
 >this : Symbol(C, Decl(privateNameFieldUnaryMutation.ts, 0, 0))
+>(this.#test) : Symbol(C.#test, Decl(privateNameFieldUnaryMutation.ts, 0, 9))
 >this.#test : Symbol(C.#test, Decl(privateNameFieldUnaryMutation.ts, 0, 9))
 >this : Symbol(C, Decl(privateNameFieldUnaryMutation.ts, 0, 0))
 
@@ -107,6 +116,7 @@ class C {
 >this : Symbol(C, Decl(privateNameFieldUnaryMutation.ts, 0, 0))
 >this.#test : Symbol(C.#test, Decl(privateNameFieldUnaryMutation.ts, 0, 9))
 >this : Symbol(C, Decl(privateNameFieldUnaryMutation.ts, 0, 0))
+>(this.#test) : Symbol(C.#test, Decl(privateNameFieldUnaryMutation.ts, 0, 9))
 >this.#test : Symbol(C.#test, Decl(privateNameFieldUnaryMutation.ts, 0, 9))
 >this : Symbol(C, Decl(privateNameFieldUnaryMutation.ts, 0, 0))
     }
@@ -194,24 +204,28 @@ class C {
 >getInstance : Symbol(C.getInstance, Decl(privateNameFieldUnaryMutation.ts, 47, 5))
 
         (this.getInstance().#test)++;
+>(this.getInstance().#test) : Symbol(C.#test, Decl(privateNameFieldUnaryMutation.ts, 0, 9))
 >this.getInstance().#test : Symbol(C.#test, Decl(privateNameFieldUnaryMutation.ts, 0, 9))
 >this.getInstance : Symbol(C.getInstance, Decl(privateNameFieldUnaryMutation.ts, 47, 5))
 >this : Symbol(C, Decl(privateNameFieldUnaryMutation.ts, 0, 0))
 >getInstance : Symbol(C.getInstance, Decl(privateNameFieldUnaryMutation.ts, 47, 5))
 
         (this.getInstance().#test)--;
+>(this.getInstance().#test) : Symbol(C.#test, Decl(privateNameFieldUnaryMutation.ts, 0, 9))
 >this.getInstance().#test : Symbol(C.#test, Decl(privateNameFieldUnaryMutation.ts, 0, 9))
 >this.getInstance : Symbol(C.getInstance, Decl(privateNameFieldUnaryMutation.ts, 47, 5))
 >this : Symbol(C, Decl(privateNameFieldUnaryMutation.ts, 0, 0))
 >getInstance : Symbol(C.getInstance, Decl(privateNameFieldUnaryMutation.ts, 47, 5))
 
         ++(this.getInstance().#test);
+>(this.getInstance().#test) : Symbol(C.#test, Decl(privateNameFieldUnaryMutation.ts, 0, 9))
 >this.getInstance().#test : Symbol(C.#test, Decl(privateNameFieldUnaryMutation.ts, 0, 9))
 >this.getInstance : Symbol(C.getInstance, Decl(privateNameFieldUnaryMutation.ts, 47, 5))
 >this : Symbol(C, Decl(privateNameFieldUnaryMutation.ts, 0, 0))
 >getInstance : Symbol(C.getInstance, Decl(privateNameFieldUnaryMutation.ts, 47, 5))
 
         --(this.getInstance().#test);
+>(this.getInstance().#test) : Symbol(C.#test, Decl(privateNameFieldUnaryMutation.ts, 0, 9))
 >this.getInstance().#test : Symbol(C.#test, Decl(privateNameFieldUnaryMutation.ts, 0, 9))
 >this.getInstance : Symbol(C.getInstance, Decl(privateNameFieldUnaryMutation.ts, 47, 5))
 >this : Symbol(C, Decl(privateNameFieldUnaryMutation.ts, 0, 0))
@@ -219,6 +233,7 @@ class C {
 
         const e = (this.getInstance().#test)++;
 >e : Symbol(e, Decl(privateNameFieldUnaryMutation.ts, 41, 13))
+>(this.getInstance().#test) : Symbol(C.#test, Decl(privateNameFieldUnaryMutation.ts, 0, 9))
 >this.getInstance().#test : Symbol(C.#test, Decl(privateNameFieldUnaryMutation.ts, 0, 9))
 >this.getInstance : Symbol(C.getInstance, Decl(privateNameFieldUnaryMutation.ts, 47, 5))
 >this : Symbol(C, Decl(privateNameFieldUnaryMutation.ts, 0, 0))
@@ -226,6 +241,7 @@ class C {
 
         const f = (this.getInstance().#test)--;
 >f : Symbol(f, Decl(privateNameFieldUnaryMutation.ts, 42, 13))
+>(this.getInstance().#test) : Symbol(C.#test, Decl(privateNameFieldUnaryMutation.ts, 0, 9))
 >this.getInstance().#test : Symbol(C.#test, Decl(privateNameFieldUnaryMutation.ts, 0, 9))
 >this.getInstance : Symbol(C.getInstance, Decl(privateNameFieldUnaryMutation.ts, 47, 5))
 >this : Symbol(C, Decl(privateNameFieldUnaryMutation.ts, 0, 0))
@@ -233,6 +249,7 @@ class C {
 
         const g = ++(this.getInstance().#test);
 >g : Symbol(g, Decl(privateNameFieldUnaryMutation.ts, 43, 13))
+>(this.getInstance().#test) : Symbol(C.#test, Decl(privateNameFieldUnaryMutation.ts, 0, 9))
 >this.getInstance().#test : Symbol(C.#test, Decl(privateNameFieldUnaryMutation.ts, 0, 9))
 >this.getInstance : Symbol(C.getInstance, Decl(privateNameFieldUnaryMutation.ts, 47, 5))
 >this : Symbol(C, Decl(privateNameFieldUnaryMutation.ts, 0, 0))
@@ -240,6 +257,7 @@ class C {
 
         const h = --(this.getInstance().#test);
 >h : Symbol(h, Decl(privateNameFieldUnaryMutation.ts, 44, 13))
+>(this.getInstance().#test) : Symbol(C.#test, Decl(privateNameFieldUnaryMutation.ts, 0, 9))
 >this.getInstance().#test : Symbol(C.#test, Decl(privateNameFieldUnaryMutation.ts, 0, 9))
 >this.getInstance : Symbol(C.getInstance, Decl(privateNameFieldUnaryMutation.ts, 47, 5))
 >this : Symbol(C, Decl(privateNameFieldUnaryMutation.ts, 0, 0))
@@ -254,6 +272,7 @@ class C {
 >this.getInstance : Symbol(C.getInstance, Decl(privateNameFieldUnaryMutation.ts, 47, 5))
 >this : Symbol(C, Decl(privateNameFieldUnaryMutation.ts, 0, 0))
 >getInstance : Symbol(C.getInstance, Decl(privateNameFieldUnaryMutation.ts, 47, 5))
+>(this.getInstance().#test) : Symbol(C.#test, Decl(privateNameFieldUnaryMutation.ts, 0, 9))
 >this.getInstance().#test : Symbol(C.#test, Decl(privateNameFieldUnaryMutation.ts, 0, 9))
 >this.getInstance : Symbol(C.getInstance, Decl(privateNameFieldUnaryMutation.ts, 47, 5))
 >this : Symbol(C, Decl(privateNameFieldUnaryMutation.ts, 0, 0))
@@ -268,6 +287,7 @@ class C {
 >this.getInstance : Symbol(C.getInstance, Decl(privateNameFieldUnaryMutation.ts, 47, 5))
 >this : Symbol(C, Decl(privateNameFieldUnaryMutation.ts, 0, 0))
 >getInstance : Symbol(C.getInstance, Decl(privateNameFieldUnaryMutation.ts, 47, 5))
+>(this.getInstance().#test) : Symbol(C.#test, Decl(privateNameFieldUnaryMutation.ts, 0, 9))
 >this.getInstance().#test : Symbol(C.#test, Decl(privateNameFieldUnaryMutation.ts, 0, 9))
 >this.getInstance : Symbol(C.getInstance, Decl(privateNameFieldUnaryMutation.ts, 47, 5))
 >this : Symbol(C, Decl(privateNameFieldUnaryMutation.ts, 0, 0))
diff --git a/tests/baselines/reference/privateNameInLhsReceiverExpression.symbols b/tests/baselines/reference/privateNameInLhsReceiverExpression.symbols
index eb0c6f7dc80..b3bbbfacd68 100644
--- a/tests/baselines/reference/privateNameInLhsReceiverExpression.symbols
+++ b/tests/baselines/reference/privateNameInLhsReceiverExpression.symbols
@@ -15,6 +15,7 @@ class Test {
 >obj[(new class { #x = 1; readonly s = "prop"; }).s].#y : Symbol(Test.#y, Decl(privateNameInLhsReceiverExpression.ts, 0, 12))
 >obj : Symbol(obj, Decl(privateNameInLhsReceiverExpression.ts, 2, 21))
 >(new class { #x = 1; readonly s = "prop"; }).s : Symbol((Anonymous class).s, Decl(privateNameInLhsReceiverExpression.ts, 3, 32))
+>class { #x = 1; readonly s = "prop"; } : Symbol((Anonymous class), Decl(privateNameInLhsReceiverExpression.ts, 3, 16))
 >#x : Symbol((Anonymous class).#x, Decl(privateNameInLhsReceiverExpression.ts, 3, 24))
 >s : Symbol((Anonymous class).s, Decl(privateNameInLhsReceiverExpression.ts, 3, 32))
 >s : Symbol((Anonymous class).s, Decl(privateNameInLhsReceiverExpression.ts, 3, 32))
@@ -23,6 +24,7 @@ class Test {
 >obj[(new class { #x = 1; readonly s = "prop"; }).s].#y : Symbol(Test.#y, Decl(privateNameInLhsReceiverExpression.ts, 0, 12))
 >obj : Symbol(obj, Decl(privateNameInLhsReceiverExpression.ts, 2, 21))
 >(new class { #x = 1; readonly s = "prop"; }).s : Symbol((Anonymous class).s, Decl(privateNameInLhsReceiverExpression.ts, 4, 32))
+>class { #x = 1; readonly s = "prop"; } : Symbol((Anonymous class), Decl(privateNameInLhsReceiverExpression.ts, 4, 16))
 >#x : Symbol((Anonymous class).#x, Decl(privateNameInLhsReceiverExpression.ts, 4, 24))
 >s : Symbol((Anonymous class).s, Decl(privateNameInLhsReceiverExpression.ts, 4, 32))
 >s : Symbol((Anonymous class).s, Decl(privateNameInLhsReceiverExpression.ts, 4, 32))
diff --git a/tests/baselines/reference/privateNameMethodAsync.symbols b/tests/baselines/reference/privateNameMethodAsync.symbols
index 6503c07c589..c16034b8cad 100644
--- a/tests/baselines/reference/privateNameMethodAsync.symbols
+++ b/tests/baselines/reference/privateNameMethodAsync.symbols
@@ -1,6 +1,7 @@
 === tests/cases/conformance/classes/members/privateNames/privateNameMethodAsync.ts ===
 const C = class {
 >C : Symbol(C, Decl(privateNameMethodAsync.ts, 0, 5))
+>class {    async #bar() { return await Promise.resolve(42); }    async foo() {        const b = await this.#bar();        return b + (this.#baz().next().value || 0) + ((await this.#qux().next()).value || 0);    }    *#baz() { yield 42; }    async *#qux() {        yield (await Promise.resolve(42));    }} : Symbol(C, Decl(privateNameMethodAsync.ts, 0, 9))
 
     async #bar() { return await Promise.resolve(42); }
 >#bar : Symbol(C.#bar, Decl(privateNameMethodAsync.ts, 0, 17))
diff --git a/tests/baselines/reference/privateNameMethodCallExpression.symbols b/tests/baselines/reference/privateNameMethodCallExpression.symbols
index 668953b9b54..f1610615242 100644
--- a/tests/baselines/reference/privateNameMethodCallExpression.symbols
+++ b/tests/baselines/reference/privateNameMethodCallExpression.symbols
@@ -69,6 +69,7 @@ class AA {
 
         const b2 = new (this.getInstance().#method2)(0, ...arr, 3); //Error 
 >b2 : Symbol(b2, Decl(privateNameMethodCallExpression.ts, 18, 13))
+>(this.getInstance().#method2) : Symbol(AA.#method2, Decl(privateNameMethodCallExpression.ts, 1, 31))
 >this.getInstance().#method2 : Symbol(AA.#method2, Decl(privateNameMethodCallExpression.ts, 1, 31))
 >this.getInstance : Symbol(AA.getInstance, Decl(privateNameMethodCallExpression.ts, 20, 5))
 >this : Symbol(AA, Decl(privateNameMethodCallExpression.ts, 0, 0))
diff --git a/tests/baselines/reference/privateNameMethodClassExpression.symbols b/tests/baselines/reference/privateNameMethodClassExpression.symbols
index b24d490bdeb..41276cb3aeb 100644
--- a/tests/baselines/reference/privateNameMethodClassExpression.symbols
+++ b/tests/baselines/reference/privateNameMethodClassExpression.symbols
@@ -1,6 +1,7 @@
 === tests/cases/conformance/classes/members/privateNames/privateNameMethodClassExpression.ts ===
 const C = class {
 >C : Symbol(C, Decl(privateNameMethodClassExpression.ts, 0, 5))
+>class {    #field = this.#method();    #method() { return 42; }    static getInstance() { return new C(); }    getField() { return this.#field };} : Symbol(C, Decl(privateNameMethodClassExpression.ts, 0, 9))
 
     #field = this.#method();
 >#field : Symbol(C.#field, Decl(privateNameMethodClassExpression.ts, 0, 17))
diff --git a/tests/baselines/reference/privateNameNestedMethodAccess.symbols b/tests/baselines/reference/privateNameNestedMethodAccess.symbols
index 689923e5b9d..643d4ad666b 100644
--- a/tests/baselines/reference/privateNameNestedMethodAccess.symbols
+++ b/tests/baselines/reference/privateNameNestedMethodAccess.symbols
@@ -17,6 +17,7 @@ class C {
 >m : Symbol(C.m, Decl(privateNameNestedMethodAccess.ts, 3, 29))
 
         return class D {
+>class D {            #bar() {}            constructor() {                new C().#foo;                new C().#bar; // Error                new C().#baz;                new D().#bar;            }            n(x: any) {                x.#foo;                x.#bar;                x.#unknown; // Error            }        } : Symbol(D, Decl(privateNameNestedMethodAccess.ts, 6, 14))
 >D : Symbol(D, Decl(privateNameNestedMethodAccess.ts, 6, 14))
 
             #bar() {}
diff --git a/tests/baselines/reference/privateNameReadonly.symbols b/tests/baselines/reference/privateNameReadonly.symbols
index 1f4e58cdfd0..99d65cd332c 100644
--- a/tests/baselines/reference/privateNameReadonly.symbols
+++ b/tests/baselines/reference/privateNameReadonly.symbols
@@ -1,6 +1,7 @@
 === tests/cases/conformance/classes/members/privateNames/privateNameReadonly.ts ===
 const C = class {
 >C : Symbol(C, Decl(privateNameReadonly.ts, 0, 5))
+>class {    #bar() {}    foo() {        this.#bar = console.log("should log this then throw");    }} : Symbol(C, Decl(privateNameReadonly.ts, 0, 9))
 
     #bar() {}
 >#bar : Symbol(C.#bar, Decl(privateNameReadonly.ts, 0, 17))
diff --git a/tests/baselines/reference/privateNameSetterNoGetter.symbols b/tests/baselines/reference/privateNameSetterNoGetter.symbols
index 95f0f4f73e9..33239da8a8b 100644
--- a/tests/baselines/reference/privateNameSetterNoGetter.symbols
+++ b/tests/baselines/reference/privateNameSetterNoGetter.symbols
@@ -1,6 +1,7 @@
 === tests/cases/conformance/classes/members/privateNames/privateNameSetterNoGetter.ts ===
 const C = class {
 >C : Symbol(C, Decl(privateNameSetterNoGetter.ts, 0, 5))
+>class {    set #x(x) {}    m() {        this.#x += 2; // Error    }} : Symbol(C, Decl(privateNameSetterNoGetter.ts, 0, 9))
 
     set #x(x) {}
 >#x : Symbol(C.#x, Decl(privateNameSetterNoGetter.ts, 0, 17))
diff --git a/tests/baselines/reference/privateNameStaticFieldClassExpression.symbols b/tests/baselines/reference/privateNameStaticFieldClassExpression.symbols
index f6bee58f5f4..615a4ce351c 100644
--- a/tests/baselines/reference/privateNameStaticFieldClassExpression.symbols
+++ b/tests/baselines/reference/privateNameStaticFieldClassExpression.symbols
@@ -4,6 +4,7 @@ class B {
 
     static #foo = class {
 >#foo : Symbol(B.#foo, Decl(privateNameStaticFieldClassExpression.ts, 0, 9))
+>class {        constructor() {            console.log("hello");            new B.#foo2();        }        static test = 123;        field = 10;    } : Symbol((Anonymous class), Decl(privateNameStaticFieldClassExpression.ts, 1, 17))
 
         constructor() {
             console.log("hello");
@@ -24,6 +25,7 @@ class B {
     };
     static #foo2 = class Foo {
 >#foo2 : Symbol(B.#foo2, Decl(privateNameStaticFieldClassExpression.ts, 8, 6))
+>class Foo {        static otherClass = 123;    } : Symbol(Foo, Decl(privateNameStaticFieldClassExpression.ts, 9, 18))
 >Foo : Symbol(Foo, Decl(privateNameStaticFieldClassExpression.ts, 9, 18))
 
         static otherClass = 123;
diff --git a/tests/baselines/reference/privateNameStaticFieldNoInitializer(target=es2015).symbols b/tests/baselines/reference/privateNameStaticFieldNoInitializer(target=es2015).symbols
index eaca354548f..31eabce4c89 100644
--- a/tests/baselines/reference/privateNameStaticFieldNoInitializer(target=es2015).symbols
+++ b/tests/baselines/reference/privateNameStaticFieldNoInitializer(target=es2015).symbols
@@ -1,6 +1,7 @@
 === tests/cases/conformance/classes/members/privateNames/privateNameStaticFieldNoInitializer.ts ===
 const C = class {
 >C : Symbol(C, Decl(privateNameStaticFieldNoInitializer.ts, 0, 5))
+>class {    static #x;} : Symbol(C, Decl(privateNameStaticFieldNoInitializer.ts, 0, 9))
 
     static #x;
 >#x : Symbol(C.#x, Decl(privateNameStaticFieldNoInitializer.ts, 0, 17))
diff --git a/tests/baselines/reference/privateNameStaticFieldNoInitializer(target=es2022).symbols b/tests/baselines/reference/privateNameStaticFieldNoInitializer(target=es2022).symbols
index eaca354548f..31eabce4c89 100644
--- a/tests/baselines/reference/privateNameStaticFieldNoInitializer(target=es2022).symbols
+++ b/tests/baselines/reference/privateNameStaticFieldNoInitializer(target=es2022).symbols
@@ -1,6 +1,7 @@
 === tests/cases/conformance/classes/members/privateNames/privateNameStaticFieldNoInitializer.ts ===
 const C = class {
 >C : Symbol(C, Decl(privateNameStaticFieldNoInitializer.ts, 0, 5))
+>class {    static #x;} : Symbol(C, Decl(privateNameStaticFieldNoInitializer.ts, 0, 9))
 
     static #x;
 >#x : Symbol(C.#x, Decl(privateNameStaticFieldNoInitializer.ts, 0, 17))
diff --git a/tests/baselines/reference/privateNameStaticFieldNoInitializer(target=esnext).symbols b/tests/baselines/reference/privateNameStaticFieldNoInitializer(target=esnext).symbols
index eaca354548f..31eabce4c89 100644
--- a/tests/baselines/reference/privateNameStaticFieldNoInitializer(target=esnext).symbols
+++ b/tests/baselines/reference/privateNameStaticFieldNoInitializer(target=esnext).symbols
@@ -1,6 +1,7 @@
 === tests/cases/conformance/classes/members/privateNames/privateNameStaticFieldNoInitializer.ts ===
 const C = class {
 >C : Symbol(C, Decl(privateNameStaticFieldNoInitializer.ts, 0, 5))
+>class {    static #x;} : Symbol(C, Decl(privateNameStaticFieldNoInitializer.ts, 0, 9))
 
     static #x;
 >#x : Symbol(C.#x, Decl(privateNameStaticFieldNoInitializer.ts, 0, 17))
diff --git a/tests/baselines/reference/privateNameStaticMethodAsync.symbols b/tests/baselines/reference/privateNameStaticMethodAsync.symbols
index 238e2f1ede4..fddaed30d71 100644
--- a/tests/baselines/reference/privateNameStaticMethodAsync.symbols
+++ b/tests/baselines/reference/privateNameStaticMethodAsync.symbols
@@ -1,6 +1,7 @@
 === tests/cases/conformance/classes/members/privateNames/privateNameStaticMethodAsync.ts ===
 const C = class {
 >C : Symbol(C, Decl(privateNameStaticMethodAsync.ts, 0, 5))
+>class {    static async #bar() { return await Promise.resolve(42); }    static async foo() {        const b = await this.#bar();        return b + (this.#baz().next().value || 0) + ((await this.#qux().next()).value || 0);    }    static *#baz() { yield 42; }    static async *#qux() {        yield (await Promise.resolve(42));    }    async static *#bazBad() { yield 42; }} : Symbol(C, Decl(privateNameStaticMethodAsync.ts, 0, 9))
 
     static async #bar() { return await Promise.resolve(42); }
 >#bar : Symbol(C.#bar, Decl(privateNameStaticMethodAsync.ts, 0, 17))
diff --git a/tests/baselines/reference/privateNameStaticMethodCallExpression.symbols b/tests/baselines/reference/privateNameStaticMethodCallExpression.symbols
index b661493cd69..e67582ca686 100644
--- a/tests/baselines/reference/privateNameStaticMethodCallExpression.symbols
+++ b/tests/baselines/reference/privateNameStaticMethodCallExpression.symbols
@@ -69,6 +69,7 @@ class AA {
 
         const b2 = new (AA.getClass().#method2)(0, ...arr, 3); //Error 
 >b2 : Symbol(b2, Decl(privateNameStaticMethodCallExpression.ts, 18, 13))
+>(AA.getClass().#method2) : Symbol(AA.#method2, Decl(privateNameStaticMethodCallExpression.ts, 1, 38))
 >AA.getClass().#method2 : Symbol(AA.#method2, Decl(privateNameStaticMethodCallExpression.ts, 1, 38))
 >AA.getClass : Symbol(AA.getClass, Decl(privateNameStaticMethodCallExpression.ts, 20, 5))
 >AA : Symbol(AA, Decl(privateNameStaticMethodCallExpression.ts, 0, 0))
diff --git a/tests/baselines/reference/privateNameStaticMethodClassExpression.symbols b/tests/baselines/reference/privateNameStaticMethodClassExpression.symbols
index 1804076d049..87130799a16 100644
--- a/tests/baselines/reference/privateNameStaticMethodClassExpression.symbols
+++ b/tests/baselines/reference/privateNameStaticMethodClassExpression.symbols
@@ -1,6 +1,7 @@
 === tests/cases/conformance/classes/members/privateNames/privateNameStaticMethodClassExpression.ts ===
 const C = class D {
 >C : Symbol(C, Decl(privateNameStaticMethodClassExpression.ts, 0, 5))
+>class D {    static #field = D.#method();    static #method() { return 42; }    static getClass() { return D; }    static getField() { return C.#field };} : Symbol(D, Decl(privateNameStaticMethodClassExpression.ts, 0, 9))
 >D : Symbol(D, Decl(privateNameStaticMethodClassExpression.ts, 0, 9))
 
     static #field = D.#method();
diff --git a/tests/baselines/reference/privateNameWhenNotUseDefineForClassFieldsInEsNext(target=es2020).symbols b/tests/baselines/reference/privateNameWhenNotUseDefineForClassFieldsInEsNext(target=es2020).symbols
index ff4ef055548..0648fdfd50d 100644
--- a/tests/baselines/reference/privateNameWhenNotUseDefineForClassFieldsInEsNext(target=es2020).symbols
+++ b/tests/baselines/reference/privateNameWhenNotUseDefineForClassFieldsInEsNext(target=es2020).symbols
@@ -13,6 +13,7 @@ class TestWithStatics {
     static ["X_ z_ zz"] = class Inner {
 >["X_ z_ zz"] : Symbol(TestWithStatics["X_ z_ zz"], Decl(privateNameWhenNotUseDefineForClassFieldsInEsNext.ts, 2, 44))
 >"X_ z_ zz" : Symbol(TestWithStatics["X_ z_ zz"], Decl(privateNameWhenNotUseDefineForClassFieldsInEsNext.ts, 2, 44))
+>class Inner {        #foo  = 10        m() {            new TestWithStatics().#prop // OK        }        static C = class InnerInner {            m() {                new TestWithStatics().#prop // OK                new Inner().#foo; // OK            }        }        static M(){            return class {                m() {                    new TestWithStatics().#prop // OK                    new Inner().#foo; // OK                }            }        }    } : Symbol(Inner, Decl(privateNameWhenNotUseDefineForClassFieldsInEsNext.ts, 3, 25))
 >Inner : Symbol(Inner, Decl(privateNameWhenNotUseDefineForClassFieldsInEsNext.ts, 3, 25))
 
         #foo  = 10
@@ -27,6 +28,7 @@ class TestWithStatics {
         }
         static C = class InnerInner {
 >C : Symbol(Inner.C, Decl(privateNameWhenNotUseDefineForClassFieldsInEsNext.ts, 7, 9))
+>class InnerInner {            m() {                new TestWithStatics().#prop // OK                new Inner().#foo; // OK            }        } : Symbol(InnerInner, Decl(privateNameWhenNotUseDefineForClassFieldsInEsNext.ts, 8, 18))
 >InnerInner : Symbol(InnerInner, Decl(privateNameWhenNotUseDefineForClassFieldsInEsNext.ts, 8, 18))
 
             m() {
@@ -46,6 +48,8 @@ class TestWithStatics {
 >M : Symbol(Inner.M, Decl(privateNameWhenNotUseDefineForClassFieldsInEsNext.ts, 13, 9))
 
             return class {
+>class {                m() {                    new TestWithStatics().#prop // OK                    new Inner().#foo; // OK                }            } : Symbol((Anonymous class), Decl(privateNameWhenNotUseDefineForClassFieldsInEsNext.ts, 16, 18))
+
                 m() {
 >m : Symbol((Anonymous class).m, Decl(privateNameWhenNotUseDefineForClassFieldsInEsNext.ts, 16, 26))
 
@@ -76,6 +80,7 @@ class TestNonStatics {
     ["X_ z_ zz"] = class Inner {
 >["X_ z_ zz"] : Symbol(TestNonStatics["X_ z_ zz"], Decl(privateNameWhenNotUseDefineForClassFieldsInEsNext.ts, 28, 36))
 >"X_ z_ zz" : Symbol(TestNonStatics["X_ z_ zz"], Decl(privateNameWhenNotUseDefineForClassFieldsInEsNext.ts, 28, 36))
+>class Inner {        #foo  = 10        m() {            new TestNonStatics().#prop // Ok        }        C = class InnerInner {            m() {                new TestNonStatics().#prop // Ok                new Inner().#foo; // Ok            }        }        static M(){            return class {                m() {                    new TestNonStatics().#prop // OK                    new Inner().#foo; // OK                }            }        }    } : Symbol(Inner, Decl(privateNameWhenNotUseDefineForClassFieldsInEsNext.ts, 29, 18))
 >Inner : Symbol(Inner, Decl(privateNameWhenNotUseDefineForClassFieldsInEsNext.ts, 29, 18))
 
         #foo  = 10
@@ -90,6 +95,7 @@ class TestNonStatics {
         }
         C = class InnerInner {
 >C : Symbol(Inner.C, Decl(privateNameWhenNotUseDefineForClassFieldsInEsNext.ts, 33, 9))
+>class InnerInner {            m() {                new TestNonStatics().#prop // Ok                new Inner().#foo; // Ok            }        } : Symbol(InnerInner, Decl(privateNameWhenNotUseDefineForClassFieldsInEsNext.ts, 34, 11))
 >InnerInner : Symbol(InnerInner, Decl(privateNameWhenNotUseDefineForClassFieldsInEsNext.ts, 34, 11))
 
             m() {
@@ -109,6 +115,8 @@ class TestNonStatics {
 >M : Symbol(Inner.M, Decl(privateNameWhenNotUseDefineForClassFieldsInEsNext.ts, 39, 9))
 
             return class {
+>class {                m() {                    new TestNonStatics().#prop // OK                    new Inner().#foo; // OK                }            } : Symbol((Anonymous class), Decl(privateNameWhenNotUseDefineForClassFieldsInEsNext.ts, 42, 18))
+
                 m() {
 >m : Symbol((Anonymous class).m, Decl(privateNameWhenNotUseDefineForClassFieldsInEsNext.ts, 42, 26))
 
diff --git a/tests/baselines/reference/privateNameWhenNotUseDefineForClassFieldsInEsNext(target=esnext).symbols b/tests/baselines/reference/privateNameWhenNotUseDefineForClassFieldsInEsNext(target=esnext).symbols
index ff4ef055548..0648fdfd50d 100644
--- a/tests/baselines/reference/privateNameWhenNotUseDefineForClassFieldsInEsNext(target=esnext).symbols
+++ b/tests/baselines/reference/privateNameWhenNotUseDefineForClassFieldsInEsNext(target=esnext).symbols
@@ -13,6 +13,7 @@ class TestWithStatics {
     static ["X_ z_ zz"] = class Inner {
 >["X_ z_ zz"] : Symbol(TestWithStatics["X_ z_ zz"], Decl(privateNameWhenNotUseDefineForClassFieldsInEsNext.ts, 2, 44))
 >"X_ z_ zz" : Symbol(TestWithStatics["X_ z_ zz"], Decl(privateNameWhenNotUseDefineForClassFieldsInEsNext.ts, 2, 44))
+>class Inner {        #foo  = 10        m() {            new TestWithStatics().#prop // OK        }        static C = class InnerInner {            m() {                new TestWithStatics().#prop // OK                new Inner().#foo; // OK            }        }        static M(){            return class {                m() {                    new TestWithStatics().#prop // OK                    new Inner().#foo; // OK                }            }        }    } : Symbol(Inner, Decl(privateNameWhenNotUseDefineForClassFieldsInEsNext.ts, 3, 25))
 >Inner : Symbol(Inner, Decl(privateNameWhenNotUseDefineForClassFieldsInEsNext.ts, 3, 25))
 
         #foo  = 10
@@ -27,6 +28,7 @@ class TestWithStatics {
         }
         static C = class InnerInner {
 >C : Symbol(Inner.C, Decl(privateNameWhenNotUseDefineForClassFieldsInEsNext.ts, 7, 9))
+>class InnerInner {            m() {                new TestWithStatics().#prop // OK                new Inner().#foo; // OK            }        } : Symbol(InnerInner, Decl(privateNameWhenNotUseDefineForClassFieldsInEsNext.ts, 8, 18))
 >InnerInner : Symbol(InnerInner, Decl(privateNameWhenNotUseDefineForClassFieldsInEsNext.ts, 8, 18))
 
             m() {
@@ -46,6 +48,8 @@ class TestWithStatics {
 >M : Symbol(Inner.M, Decl(privateNameWhenNotUseDefineForClassFieldsInEsNext.ts, 13, 9))
 
             return class {
+>class {                m() {                    new TestWithStatics().#prop // OK                    new Inner().#foo; // OK                }            } : Symbol((Anonymous class), Decl(privateNameWhenNotUseDefineForClassFieldsInEsNext.ts, 16, 18))
+
                 m() {
 >m : Symbol((Anonymous class).m, Decl(privateNameWhenNotUseDefineForClassFieldsInEsNext.ts, 16, 26))
 
@@ -76,6 +80,7 @@ class TestNonStatics {
     ["X_ z_ zz"] = class Inner {
 >["X_ z_ zz"] : Symbol(TestNonStatics["X_ z_ zz"], Decl(privateNameWhenNotUseDefineForClassFieldsInEsNext.ts, 28, 36))
 >"X_ z_ zz" : Symbol(TestNonStatics["X_ z_ zz"], Decl(privateNameWhenNotUseDefineForClassFieldsInEsNext.ts, 28, 36))
+>class Inner {        #foo  = 10        m() {            new TestNonStatics().#prop // Ok        }        C = class InnerInner {            m() {                new TestNonStatics().#prop // Ok                new Inner().#foo; // Ok            }        }        static M(){            return class {                m() {                    new TestNonStatics().#prop // OK                    new Inner().#foo; // OK                }            }        }    } : Symbol(Inner, Decl(privateNameWhenNotUseDefineForClassFieldsInEsNext.ts, 29, 18))
 >Inner : Symbol(Inner, Decl(privateNameWhenNotUseDefineForClassFieldsInEsNext.ts, 29, 18))
 
         #foo  = 10
@@ -90,6 +95,7 @@ class TestNonStatics {
         }
         C = class InnerInner {
 >C : Symbol(Inner.C, Decl(privateNameWhenNotUseDefineForClassFieldsInEsNext.ts, 33, 9))
+>class InnerInner {            m() {                new TestNonStatics().#prop // Ok                new Inner().#foo; // Ok            }        } : Symbol(InnerInner, Decl(privateNameWhenNotUseDefineForClassFieldsInEsNext.ts, 34, 11))
 >InnerInner : Symbol(InnerInner, Decl(privateNameWhenNotUseDefineForClassFieldsInEsNext.ts, 34, 11))
 
             m() {
@@ -109,6 +115,8 @@ class TestNonStatics {
 >M : Symbol(Inner.M, Decl(privateNameWhenNotUseDefineForClassFieldsInEsNext.ts, 39, 9))
 
             return class {
+>class {                m() {                    new TestNonStatics().#prop // OK                    new Inner().#foo; // OK                }            } : Symbol((Anonymous class), Decl(privateNameWhenNotUseDefineForClassFieldsInEsNext.ts, 42, 18))
+
                 m() {
 >m : Symbol((Anonymous class).m, Decl(privateNameWhenNotUseDefineForClassFieldsInEsNext.ts, 42, 26))
 
diff --git a/tests/baselines/reference/privateNamesAndStaticFields.symbols b/tests/baselines/reference/privateNamesAndStaticFields.symbols
index e2109f68a3c..e11623020ce 100644
--- a/tests/baselines/reference/privateNamesAndStaticFields.symbols
+++ b/tests/baselines/reference/privateNamesAndStaticFields.symbols
@@ -43,4 +43,5 @@ class B extends A {
 const willErrorSomeDay: typeof A = class {}; // OK for now
 >willErrorSomeDay : Symbol(willErrorSomeDay, Decl(privateNamesAndStaticFields.ts, 20, 5))
 >A : Symbol(A, Decl(privateNamesAndStaticFields.ts, 0, 0))
+>class {} : Symbol(willErrorSomeDay, Decl(privateNamesAndStaticFields.ts, 20, 34))
 
diff --git a/tests/baselines/reference/quotedConstructors.symbols b/tests/baselines/reference/quotedConstructors.symbols
index a4476a25ae5..c33e2e276fa 100644
--- a/tests/baselines/reference/quotedConstructors.symbols
+++ b/tests/baselines/reference/quotedConstructors.symbols
@@ -39,6 +39,8 @@ class E {
 }
 
 new class {
+>class {    "constructor"() {        console.log(this);    }} : Symbol((Anonymous class), Decl(quotedConstructors.ts, 18, 3))
+
     "constructor"() {
         console.log(this);
 >console.log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --))
diff --git a/tests/baselines/reference/reactReadonlyHOCAssignabilityReal.symbols b/tests/baselines/reference/reactReadonlyHOCAssignabilityReal.symbols
index c0fc1dbafd0..082cd9bf121 100644
--- a/tests/baselines/reference/reactReadonlyHOCAssignabilityReal.symbols
+++ b/tests/baselines/reference/reactReadonlyHOCAssignabilityReal.symbols
@@ -16,6 +16,7 @@ function myHigherOrderComponent<P>(Inner: React.ComponentClass<P & {name: string
 >P : Symbol(P, Decl(reactReadonlyHOCAssignabilityReal.tsx, 3, 32))
 
     return class OuterComponent extends React.Component<P> {
+>class OuterComponent extends React.Component<P> {        render() {            return <Inner {...this.props} name="Matt"/>;        }    } : Symbol(OuterComponent, Decl(reactReadonlyHOCAssignabilityReal.tsx, 4, 10))
 >OuterComponent : Symbol(OuterComponent, Decl(reactReadonlyHOCAssignabilityReal.tsx, 4, 10))
 >React.Component : Symbol(React.Component, Decl(react16.d.ts, 345, 54), Decl(react16.d.ts, 349, 94))
 >React : Symbol(React, Decl(reactReadonlyHOCAssignabilityReal.tsx, 1, 6))
diff --git a/tests/baselines/reference/readonlyAssignmentInSubclassOfClassExpression.symbols b/tests/baselines/reference/readonlyAssignmentInSubclassOfClassExpression.symbols
index 96abda30315..aed68bd8742 100644
--- a/tests/baselines/reference/readonlyAssignmentInSubclassOfClassExpression.symbols
+++ b/tests/baselines/reference/readonlyAssignmentInSubclassOfClassExpression.symbols
@@ -1,6 +1,7 @@
 === tests/cases/compiler/readonlyAssignmentInSubclassOfClassExpression.ts ===
 class C extends (class {} as new () => Readonly<{ attrib: number }>) {
 >C : Symbol(C, Decl(readonlyAssignmentInSubclassOfClassExpression.ts, 0, 0))
+>class {} : Symbol((Anonymous class), Decl(readonlyAssignmentInSubclassOfClassExpression.ts, 0, 17))
 >Readonly : Symbol(Readonly, Decl(lib.es5.d.ts, --, --))
 >attrib : Symbol(attrib, Decl(readonlyAssignmentInSubclassOfClassExpression.ts, 0, 49))
 
diff --git a/tests/baselines/reference/readonlyPropertySubtypeRelationDirected.symbols b/tests/baselines/reference/readonlyPropertySubtypeRelationDirected.symbols
index 9a19925057e..b4d9a0cd7e9 100644
--- a/tests/baselines/reference/readonlyPropertySubtypeRelationDirected.symbols
+++ b/tests/baselines/reference/readonlyPropertySubtypeRelationDirected.symbols
@@ -19,6 +19,7 @@ function doSomething(condition: boolean) {
     // only treated as readonly (i.e. it will produce a diagnostic if you try to assign to it) based on the order of declarations of `one` and `two` above
     const three = (condition) ? one : two;
 >three : Symbol(three, Decl(one.ts, 8, 9))
+>(condition) : Symbol(condition, Decl(one.ts, 5, 21))
 >condition : Symbol(condition, Decl(one.ts, 5, 21))
 >one : Symbol(one, Decl(one.ts, 3, 5))
 >two : Symbol(two, Decl(one.ts, 2, 5))
@@ -59,6 +60,7 @@ function doSomething(condition: boolean) {
     // based on the declaration order of `one` and `two`
     const three = (condition) ? two : one;
 >three : Symbol(three, Decl(two.ts, 8, 9))
+>(condition) : Symbol(condition, Decl(two.ts, 5, 21))
 >condition : Symbol(condition, Decl(two.ts, 5, 21))
 >two : Symbol(two, Decl(two.ts, 2, 5))
 >one : Symbol(one, Decl(two.ts, 3, 5))
@@ -100,6 +102,7 @@ function doSomething(condition: boolean) {
     // only treated as readonly (i.e. it will produce a diagnostic if you try to assign to it) based on the order of declarations of `one` and `two` above
     const three = (condition) ? one : two;
 >three : Symbol(three, Decl(three.ts, 8, 9))
+>(condition) : Symbol(condition, Decl(three.ts, 5, 21))
 >condition : Symbol(condition, Decl(three.ts, 5, 21))
 >one : Symbol(one, Decl(three.ts, 2, 5))
 >two : Symbol(two, Decl(three.ts, 3, 5))
@@ -141,6 +144,7 @@ function doSomething(condition: boolean) {
     // based on the declaration order of `one` and `two`
     const three = (condition) ? two : one;
 >three : Symbol(three, Decl(four.ts, 8, 9))
+>(condition) : Symbol(condition, Decl(four.ts, 5, 21))
 >condition : Symbol(condition, Decl(four.ts, 5, 21))
 >two : Symbol(two, Decl(four.ts, 3, 5))
 >one : Symbol(one, Decl(four.ts, 2, 5))
diff --git a/tests/baselines/reference/recursiveClassBaseType.symbols b/tests/baselines/reference/recursiveClassBaseType.symbols
index 5e41d738d26..afd0ac6fd00 100644
--- a/tests/baselines/reference/recursiveClassBaseType.symbols
+++ b/tests/baselines/reference/recursiveClassBaseType.symbols
@@ -34,6 +34,7 @@ abstract class Base1 {
 
 class Derived1 extends class extends Base1 {
 >Derived1 : Symbol(Derived1, Decl(recursiveClassBaseType.ts, 12, 1))
+>class extends Base1 {    root() {        return undefined as any;    }} : Symbol((Anonymous class), Decl(recursiveClassBaseType.ts, 14, 22))
 >Base1 : Symbol(Base1, Decl(recursiveClassBaseType.ts, 6, 49))
 
     root() {
diff --git a/tests/baselines/reference/scannerS7.2_A1.5_T2.symbols b/tests/baselines/reference/scannerS7.2_A1.5_T2.symbols
index 4aa87fe7df6..0f797463831 100644
--- a/tests/baselines/reference/scannerS7.2_A1.5_T2.symbols
+++ b/tests/baselines/reference/scannerS7.2_A1.5_T2.symbols
@@ -17,6 +17,7 @@ if (x !== 1) {
 >x : Symbol(x, Decl(scannerS7.2_A1.5_T2.ts, 17, 4))
 
   $ERROR('#1: eval("\\u00A0var x\\u00A0= 1\\u00A0"); x === 1. Actual: ' + (x));
+>(x) : Symbol(x, Decl(scannerS7.2_A1.5_T2.ts, 17, 4))
 >x : Symbol(x, Decl(scannerS7.2_A1.5_T2.ts, 17, 4))
 }
 
@@ -28,6 +29,7 @@ if (x !== 1) {
 >x : Symbol(x, Decl(scannerS7.2_A1.5_T2.ts, 17, 4))
 
   $ERROR('#2:  var x = 1 ; x === 1. Actual: ' + (x));
+>(x) : Symbol(x, Decl(scannerS7.2_A1.5_T2.ts, 17, 4))
 >x : Symbol(x, Decl(scannerS7.2_A1.5_T2.ts, 17, 4))
 }
 
diff --git a/tests/baselines/reference/scannerS7.3_A1.1_T2.symbols b/tests/baselines/reference/scannerS7.3_A1.1_T2.symbols
index f4ee039644b..34b2c781f9d 100644
--- a/tests/baselines/reference/scannerS7.3_A1.1_T2.symbols
+++ b/tests/baselines/reference/scannerS7.3_A1.1_T2.symbols
@@ -20,6 +20,7 @@ if (x !== 1) {
 >x : Symbol(x, Decl(scannerS7.3_A1.1_T2.ts, 11, 3))
 
   $ERROR('#1: var\\nx\\n=\\n1\\n; x === 1. Actual: ' + (x));
+>(x) : Symbol(x, Decl(scannerS7.3_A1.1_T2.ts, 11, 3))
 >x : Symbol(x, Decl(scannerS7.3_A1.1_T2.ts, 11, 3))
 }
 
diff --git a/tests/baselines/reference/staticFieldWithInterfaceContext.symbols b/tests/baselines/reference/staticFieldWithInterfaceContext.symbols
index d21fd842c7f..ef53320a0e6 100644
--- a/tests/baselines/reference/staticFieldWithInterfaceContext.symbols
+++ b/tests/baselines/reference/staticFieldWithInterfaceContext.symbols
@@ -9,6 +9,7 @@ interface I {
 let c: I = class {
 >c : Symbol(c, Decl(staticFieldWithInterfaceContext.ts, 3, 3))
 >I : Symbol(I, Decl(staticFieldWithInterfaceContext.ts, 0, 0))
+>class {    // should typecheck the same as the last line    static x = { a: "a" };} : Symbol(c, Decl(staticFieldWithInterfaceContext.ts, 3, 10))
 
     // should typecheck the same as the last line
     static x = { a: "a" };
@@ -28,6 +29,7 @@ const ex = "x";
 let c2: I = class { static [ex] = { a: "a" }; };
 >c2 : Symbol(c2, Decl(staticFieldWithInterfaceContext.ts, 10, 3))
 >I : Symbol(I, Decl(staticFieldWithInterfaceContext.ts, 0, 0))
+>class { static [ex] = { a: "a" }; } : Symbol(c2, Decl(staticFieldWithInterfaceContext.ts, 10, 11))
 >[ex] : Symbol(c2[ex], Decl(staticFieldWithInterfaceContext.ts, 10, 19))
 >ex : Symbol(ex, Decl(staticFieldWithInterfaceContext.ts, 9, 5))
 >a : Symbol(a, Decl(staticFieldWithInterfaceContext.ts, 10, 35))
@@ -41,6 +43,7 @@ function f(c: I = class { static x = { a: "a" } }) { }
 >f : Symbol(f, Decl(staticFieldWithInterfaceContext.ts, 11, 19))
 >c : Symbol(c, Decl(staticFieldWithInterfaceContext.ts, 13, 11))
 >I : Symbol(I, Decl(staticFieldWithInterfaceContext.ts, 0, 0))
+>class { static x = { a: "a" } } : Symbol((Anonymous class), Decl(staticFieldWithInterfaceContext.ts, 13, 17))
 >x : Symbol((Anonymous class).x, Decl(staticFieldWithInterfaceContext.ts, 13, 25))
 >a : Symbol(a, Decl(staticFieldWithInterfaceContext.ts, 13, 38))
 
@@ -50,12 +53,14 @@ let { c: c3 }: { c: I } = { c: class { static x = { a: "a" } } };
 >c : Symbol(c, Decl(staticFieldWithInterfaceContext.ts, 15, 16))
 >I : Symbol(I, Decl(staticFieldWithInterfaceContext.ts, 0, 0))
 >c : Symbol(c, Decl(staticFieldWithInterfaceContext.ts, 15, 27))
+>class { static x = { a: "a" } } : Symbol(c, Decl(staticFieldWithInterfaceContext.ts, 15, 30))
 >x : Symbol(c.x, Decl(staticFieldWithInterfaceContext.ts, 15, 38))
 >a : Symbol(a, Decl(staticFieldWithInterfaceContext.ts, 15, 51))
 
 let { c: c4 = class { static x = { a: "a" } }}: { c?: I } = { };
 >c : Symbol(c, Decl(staticFieldWithInterfaceContext.ts, 16, 49))
 >c4 : Symbol(c4, Decl(staticFieldWithInterfaceContext.ts, 16, 5))
+>class { static x = { a: "a" } } : Symbol(c4, Decl(staticFieldWithInterfaceContext.ts, 16, 13))
 >x : Symbol(c4.x, Decl(staticFieldWithInterfaceContext.ts, 16, 21))
 >a : Symbol(a, Decl(staticFieldWithInterfaceContext.ts, 16, 34))
 >c : Symbol(c, Decl(staticFieldWithInterfaceContext.ts, 16, 49))
@@ -64,51 +69,61 @@ let { c: c4 = class { static x = { a: "a" } }}: { c?: I } = { };
 let { c: c5 = class { static x = { a: "a" } }}: { c?: I } = { c: class { static x = { a: "a" } } };
 >c : Symbol(c, Decl(staticFieldWithInterfaceContext.ts, 17, 49))
 >c5 : Symbol(c5, Decl(staticFieldWithInterfaceContext.ts, 17, 5))
+>class { static x = { a: "a" } } : Symbol(c5, Decl(staticFieldWithInterfaceContext.ts, 17, 13))
 >x : Symbol(c5.x, Decl(staticFieldWithInterfaceContext.ts, 17, 21))
 >a : Symbol(a, Decl(staticFieldWithInterfaceContext.ts, 17, 34))
 >c : Symbol(c, Decl(staticFieldWithInterfaceContext.ts, 17, 49))
 >I : Symbol(I, Decl(staticFieldWithInterfaceContext.ts, 0, 0))
 >c : Symbol(c, Decl(staticFieldWithInterfaceContext.ts, 17, 61))
+>class { static x = { a: "a" } } : Symbol(c, Decl(staticFieldWithInterfaceContext.ts, 17, 64))
 >x : Symbol(c.x, Decl(staticFieldWithInterfaceContext.ts, 17, 72))
 >a : Symbol(a, Decl(staticFieldWithInterfaceContext.ts, 17, 85))
 
 let [ c6 ]: [I] = [class { static x = { a: "a" } }];
 >c6 : Symbol(c6, Decl(staticFieldWithInterfaceContext.ts, 18, 5))
 >I : Symbol(I, Decl(staticFieldWithInterfaceContext.ts, 0, 0))
+>class { static x = { a: "a" } } : Symbol((Anonymous class), Decl(staticFieldWithInterfaceContext.ts, 18, 19))
 >x : Symbol((Anonymous class).x, Decl(staticFieldWithInterfaceContext.ts, 18, 26))
 >a : Symbol(a, Decl(staticFieldWithInterfaceContext.ts, 18, 39))
 
 let [ c7 ]: I[] = [class { static x = { a: "a" } }];
 >c7 : Symbol(c7, Decl(staticFieldWithInterfaceContext.ts, 19, 5))
 >I : Symbol(I, Decl(staticFieldWithInterfaceContext.ts, 0, 0))
+>class { static x = { a: "a" } } : Symbol((Anonymous class), Decl(staticFieldWithInterfaceContext.ts, 19, 19))
 >x : Symbol((Anonymous class).x, Decl(staticFieldWithInterfaceContext.ts, 19, 26))
 >a : Symbol(a, Decl(staticFieldWithInterfaceContext.ts, 19, 39))
 
 let [ c8 = class { static x = { a: "a" } } ]: [I?] = [];
 >c8 : Symbol(c8, Decl(staticFieldWithInterfaceContext.ts, 21, 5))
+>class { static x = { a: "a" } } : Symbol(c8, Decl(staticFieldWithInterfaceContext.ts, 21, 10))
 >x : Symbol(c8.x, Decl(staticFieldWithInterfaceContext.ts, 21, 18))
 >a : Symbol(a, Decl(staticFieldWithInterfaceContext.ts, 21, 31))
 >I : Symbol(I, Decl(staticFieldWithInterfaceContext.ts, 0, 0))
 
 let [ c9 = class { static x = { a: "a" } } ]: I[] = [];
 >c9 : Symbol(c9, Decl(staticFieldWithInterfaceContext.ts, 22, 5))
+>class { static x = { a: "a" } } : Symbol(c9, Decl(staticFieldWithInterfaceContext.ts, 22, 10))
 >x : Symbol(c9.x, Decl(staticFieldWithInterfaceContext.ts, 22, 18))
 >a : Symbol(a, Decl(staticFieldWithInterfaceContext.ts, 22, 31))
 >I : Symbol(I, Decl(staticFieldWithInterfaceContext.ts, 0, 0))
 
 let [ c10 = class { static x = { a: "a" } } ]: [I?] = [class { static x = { a: "a" } }];
 >c10 : Symbol(c10, Decl(staticFieldWithInterfaceContext.ts, 23, 5))
+>class { static x = { a: "a" } } : Symbol(c10, Decl(staticFieldWithInterfaceContext.ts, 23, 11))
 >x : Symbol(c10.x, Decl(staticFieldWithInterfaceContext.ts, 23, 19))
 >a : Symbol(a, Decl(staticFieldWithInterfaceContext.ts, 23, 32))
 >I : Symbol(I, Decl(staticFieldWithInterfaceContext.ts, 0, 0))
+>class { static x = { a: "a" } } : Symbol((Anonymous class), Decl(staticFieldWithInterfaceContext.ts, 23, 55))
 >x : Symbol((Anonymous class).x, Decl(staticFieldWithInterfaceContext.ts, 23, 62))
 >a : Symbol(a, Decl(staticFieldWithInterfaceContext.ts, 23, 75))
 
 let [ c11 = class { static x = { a: "a" } } ]: I[] = [class { static x = { a: "a" } }];
 >c11 : Symbol(c11, Decl(staticFieldWithInterfaceContext.ts, 24, 5))
+>class { static x = { a: "a" } } : Symbol(c11, Decl(staticFieldWithInterfaceContext.ts, 24, 11))
 >x : Symbol(c11.x, Decl(staticFieldWithInterfaceContext.ts, 24, 19))
 >a : Symbol(a, Decl(staticFieldWithInterfaceContext.ts, 24, 32))
 >I : Symbol(I, Decl(staticFieldWithInterfaceContext.ts, 0, 0))
+>class { static x = { a: "a" } } : Symbol((Anonymous class), Decl(staticFieldWithInterfaceContext.ts, 24, 54))
 >x : Symbol((Anonymous class).x, Decl(staticFieldWithInterfaceContext.ts, 24, 61))
 >a : Symbol(a, Decl(staticFieldWithInterfaceContext.ts, 24, 74))
 
diff --git a/tests/baselines/reference/staticIndexSignature6.symbols b/tests/baselines/reference/staticIndexSignature6.symbols
index 7204af7e18d..3bce3f884cc 100644
--- a/tests/baselines/reference/staticIndexSignature6.symbols
+++ b/tests/baselines/reference/staticIndexSignature6.symbols
@@ -3,6 +3,7 @@ function foo () {
 >foo : Symbol(foo, Decl(staticIndexSignature6.ts, 0, 0))
 
     return class<T> {
+>class<T> {        static [s: string]: number        static [s: number]: 42        foo(v: T) { return v }    } : Symbol((Anonymous class), Decl(staticIndexSignature6.ts, 1, 10))
 >T : Symbol(T, Decl(staticIndexSignature6.ts, 1, 17))
 
         static [s: string]: number
diff --git a/tests/baselines/reference/staticPropertyNameConflicts.symbols b/tests/baselines/reference/staticPropertyNameConflicts.symbols
index 841f8592eb9..7596ca22bf7 100644
--- a/tests/baselines/reference/staticPropertyNameConflicts.symbols
+++ b/tests/baselines/reference/staticPropertyNameConflicts.symbols
@@ -111,6 +111,7 @@ class StaticArgumentsFn {
 // name
 var StaticName_Anonymous = class {
 >StaticName_Anonymous : Symbol(StaticName_Anonymous, Decl(staticPropertyNameConflicts.ts, 60, 3))
+>class {    static name: number; // error    name: string; // ok} : Symbol(StaticName_Anonymous, Decl(staticPropertyNameConflicts.ts, 60, 26))
 
     static name: number; // error
 >name : Symbol(StaticName_Anonymous.name, Decl(staticPropertyNameConflicts.ts, 60, 34))
@@ -121,6 +122,7 @@ var StaticName_Anonymous = class {
 
 var StaticNameFn_Anonymous = class {
 >StaticNameFn_Anonymous : Symbol(StaticNameFn_Anonymous, Decl(staticPropertyNameConflicts.ts, 65, 3))
+>class {    static name() {} // error    name() {} // ok} : Symbol(StaticNameFn_Anonymous, Decl(staticPropertyNameConflicts.ts, 65, 28))
 
     static name() {} // error
 >name : Symbol(StaticNameFn_Anonymous.name, Decl(staticPropertyNameConflicts.ts, 65, 36))
@@ -132,6 +134,7 @@ var StaticNameFn_Anonymous = class {
 // length
 var StaticLength_Anonymous = class {
 >StaticLength_Anonymous : Symbol(StaticLength_Anonymous, Decl(staticPropertyNameConflicts.ts, 71, 3))
+>class {    static length: number; // error    length: string; // ok} : Symbol(StaticLength_Anonymous, Decl(staticPropertyNameConflicts.ts, 71, 28))
 
     static length: number; // error
 >length : Symbol(StaticLength_Anonymous.length, Decl(staticPropertyNameConflicts.ts, 71, 36))
@@ -142,6 +145,7 @@ var StaticLength_Anonymous = class {
 
 var StaticLengthFn_Anonymous = class {
 >StaticLengthFn_Anonymous : Symbol(StaticLengthFn_Anonymous, Decl(staticPropertyNameConflicts.ts, 76, 3))
+>class {    static length() {} // error    length() {} // ok} : Symbol(StaticLengthFn_Anonymous, Decl(staticPropertyNameConflicts.ts, 76, 30))
 
     static length() {} // error
 >length : Symbol(StaticLengthFn_Anonymous.length, Decl(staticPropertyNameConflicts.ts, 76, 38))
@@ -153,6 +157,7 @@ var StaticLengthFn_Anonymous = class {
 // prototype
 var StaticPrototype_Anonymous = class {
 >StaticPrototype_Anonymous : Symbol(StaticPrototype_Anonymous, Decl(staticPropertyNameConflicts.ts, 82, 3))
+>class {    static prototype: number; // error    prototype: string; // ok} : Symbol(StaticPrototype_Anonymous, Decl(staticPropertyNameConflicts.ts, 82, 31))
 
     static prototype: number; // error
 >prototype : Symbol(StaticPrototype_Anonymous.prototype, Decl(staticPropertyNameConflicts.ts, 82, 39))
@@ -163,6 +168,7 @@ var StaticPrototype_Anonymous = class {
 
 var StaticPrototypeFn_Anonymous = class {
 >StaticPrototypeFn_Anonymous : Symbol(StaticPrototypeFn_Anonymous, Decl(staticPropertyNameConflicts.ts, 87, 3))
+>class {    static prototype() {} // error    prototype() {} // ok} : Symbol(StaticPrototypeFn_Anonymous, Decl(staticPropertyNameConflicts.ts, 87, 33))
 
     static prototype() {} // error
 >prototype : Symbol(StaticPrototypeFn_Anonymous.prototype, Decl(staticPropertyNameConflicts.ts, 87, 41))
@@ -174,6 +180,7 @@ var StaticPrototypeFn_Anonymous = class {
 // caller
 var StaticCaller_Anonymous = class {
 >StaticCaller_Anonymous : Symbol(StaticCaller_Anonymous, Decl(staticPropertyNameConflicts.ts, 93, 3))
+>class {    static caller: number; // error    caller: string; // ok} : Symbol(StaticCaller_Anonymous, Decl(staticPropertyNameConflicts.ts, 93, 28))
 
     static caller: number; // error
 >caller : Symbol(StaticCaller_Anonymous.caller, Decl(staticPropertyNameConflicts.ts, 93, 36))
@@ -184,6 +191,7 @@ var StaticCaller_Anonymous = class {
 
 var StaticCallerFn_Anonymous = class {
 >StaticCallerFn_Anonymous : Symbol(StaticCallerFn_Anonymous, Decl(staticPropertyNameConflicts.ts, 98, 3))
+>class {    static caller() {} // error    caller() {} // ok} : Symbol(StaticCallerFn_Anonymous, Decl(staticPropertyNameConflicts.ts, 98, 30))
 
     static caller() {} // error
 >caller : Symbol(StaticCallerFn_Anonymous.caller, Decl(staticPropertyNameConflicts.ts, 98, 38))
@@ -195,6 +203,7 @@ var StaticCallerFn_Anonymous = class {
 // arguments
 var StaticArguments_Anonymous = class {
 >StaticArguments_Anonymous : Symbol(StaticArguments_Anonymous, Decl(staticPropertyNameConflicts.ts, 104, 3))
+>class {    static arguments: number; // error    arguments: string; // ok} : Symbol(StaticArguments_Anonymous, Decl(staticPropertyNameConflicts.ts, 104, 31))
 
     static arguments: number; // error
 >arguments : Symbol(StaticArguments_Anonymous.arguments, Decl(staticPropertyNameConflicts.ts, 104, 39))
@@ -205,6 +214,7 @@ var StaticArguments_Anonymous = class {
 
 var StaticArgumentsFn_Anonymous = class {
 >StaticArgumentsFn_Anonymous : Symbol(StaticArgumentsFn_Anonymous, Decl(staticPropertyNameConflicts.ts, 109, 3))
+>class {    static arguments() {} // error    arguments() {} // ok} : Symbol(StaticArgumentsFn_Anonymous, Decl(staticPropertyNameConflicts.ts, 109, 33))
 
     static arguments() {} // error
 >arguments : Symbol(StaticArgumentsFn_Anonymous.arguments, Decl(staticPropertyNameConflicts.ts, 109, 41))
diff --git a/tests/baselines/reference/statics.symbols b/tests/baselines/reference/statics.symbols
index 32a053f7dad..761568d1f2d 100644
--- a/tests/baselines/reference/statics.symbols
+++ b/tests/baselines/reference/statics.symbols
@@ -96,10 +96,12 @@ module M {
 
         result+=(c);
 >result : Symbol(result, Decl(statics.ts, 18, 11))
+>(c) : Symbol(c, Decl(statics.ts, 16, 7))
 >c : Symbol(c, Decl(statics.ts, 16, 7))
 
         result+=(new C(0,1,2).x);
 >result : Symbol(result, Decl(statics.ts, 18, 11))
+>(new C(0,1,2).x) : Symbol(C.x, Decl(statics.ts, 1, 20))
 >new C(0,1,2).x : Symbol(C.x, Decl(statics.ts, 1, 20))
 >C : Symbol(C, Decl(statics.ts, 0, 10))
 >x : Symbol(C.x, Decl(statics.ts, 1, 20))
diff --git a/tests/baselines/reference/strictModeReservedWord.symbols b/tests/baselines/reference/strictModeReservedWord.symbols
index 560be923acd..f6b43f69fa1 100644
--- a/tests/baselines/reference/strictModeReservedWord.symbols
+++ b/tests/baselines/reference/strictModeReservedWord.symbols
@@ -47,6 +47,7 @@ function foo() {
 
     var myClass = class package extends public {}
 >myClass : Symbol(myClass, Decl(strictModeReservedWord.ts, 14, 7))
+>class package extends public {} : Symbol(package, Decl(strictModeReservedWord.ts, 14, 17))
 >package : Symbol(package, Decl(strictModeReservedWord.ts, 14, 17))
 >public : Symbol(public, Decl(strictModeReservedWord.ts, 4, 7))
 
diff --git a/tests/baselines/reference/superCallInsideClassExpression.symbols b/tests/baselines/reference/superCallInsideClassExpression.symbols
index 5eb4ce322f2..20463efca7d 100644
--- a/tests/baselines/reference/superCallInsideClassExpression.symbols
+++ b/tests/baselines/reference/superCallInsideClassExpression.symbols
@@ -15,6 +15,7 @@ class B extends A {
 
         var D = class extends C {
 >D : Symbol(D, Decl(superCallInsideClassExpression.ts, 9, 11))
+>class extends C {            constructor() {                super();            }        } : Symbol(D, Decl(superCallInsideClassExpression.ts, 9, 15))
 >C : Symbol(C, Decl(superCallInsideClassExpression.ts, 1, 1))
 
             constructor() {
diff --git a/tests/baselines/reference/superPropertyAccessInComputedPropertiesOfNestedType_ES5.symbols b/tests/baselines/reference/superPropertyAccessInComputedPropertiesOfNestedType_ES5.symbols
index 766aa9cd33c..46e020ef084 100644
--- a/tests/baselines/reference/superPropertyAccessInComputedPropertiesOfNestedType_ES5.symbols
+++ b/tests/baselines/reference/superPropertyAccessInComputedPropertiesOfNestedType_ES5.symbols
@@ -17,6 +17,8 @@ class B extends A {
 >bar : Symbol(B.bar, Decl(superPropertyAccessInComputedPropertiesOfNestedType_ES5.ts, 5, 23))
 
         return class {
+>class {            [super.foo()]() {                return 100;            }        } : Symbol((Anonymous class), Decl(superPropertyAccessInComputedPropertiesOfNestedType_ES5.ts, 7, 14))
+
             [super.foo()]() {
 >[super.foo()] : Symbol((Anonymous class)[super.foo()], Decl(superPropertyAccessInComputedPropertiesOfNestedType_ES5.ts, 7, 22))
 >super.foo : Symbol(A.foo, Decl(superPropertyAccessInComputedPropertiesOfNestedType_ES5.ts, 0, 9))
diff --git a/tests/baselines/reference/superPropertyAccessInComputedPropertiesOfNestedType_ES6.symbols b/tests/baselines/reference/superPropertyAccessInComputedPropertiesOfNestedType_ES6.symbols
index fd80f6e430c..b7dd778d31c 100644
--- a/tests/baselines/reference/superPropertyAccessInComputedPropertiesOfNestedType_ES6.symbols
+++ b/tests/baselines/reference/superPropertyAccessInComputedPropertiesOfNestedType_ES6.symbols
@@ -17,6 +17,8 @@ class B extends A {
 >bar : Symbol(B.bar, Decl(superPropertyAccessInComputedPropertiesOfNestedType_ES6.ts, 5, 23))
 
         return class {
+>class {            [super.foo()]() {                return 100;            }        } : Symbol((Anonymous class), Decl(superPropertyAccessInComputedPropertiesOfNestedType_ES6.ts, 7, 14))
+
             [super.foo()]() {
 >[super.foo()] : Symbol((Anonymous class)[super.foo()], Decl(superPropertyAccessInComputedPropertiesOfNestedType_ES6.ts, 7, 22))
 >super.foo : Symbol(A.foo, Decl(superPropertyAccessInComputedPropertiesOfNestedType_ES6.ts, 0, 9))
diff --git a/tests/baselines/reference/thisIndexOnExistingReadonlyFieldIsNotNever.symbols b/tests/baselines/reference/thisIndexOnExistingReadonlyFieldIsNotNever.symbols
index 6cedbe269bf..9a7ee452c87 100644
--- a/tests/baselines/reference/thisIndexOnExistingReadonlyFieldIsNotNever.symbols
+++ b/tests/baselines/reference/thisIndexOnExistingReadonlyFieldIsNotNever.symbols
@@ -41,6 +41,7 @@ class CoachMarkAnchorDecorator {
 >P : Symbol(P, Decl(thisIndexOnExistingReadonlyFieldIsNotNever.ts, 10, 22))
 
         return class CoachMarkAnchor extends Component<CoachMarkAnchorProps<AnchorType<P>> & P, {}> {
+>class CoachMarkAnchor extends Component<CoachMarkAnchorProps<AnchorType<P>> & P, {}> {            private _onAnchorRef = (anchor: AnchorType<P>) => {                const anchorRef = this.props.anchorRef;                if (anchorRef) {                    anchorRef(anchor);                }            }        } : Symbol(CoachMarkAnchor, Decl(thisIndexOnExistingReadonlyFieldIsNotNever.ts, 11, 14))
 >CoachMarkAnchor : Symbol(CoachMarkAnchor, Decl(thisIndexOnExistingReadonlyFieldIsNotNever.ts, 11, 14))
 >Component : Symbol(Component, Decl(thisIndexOnExistingReadonlyFieldIsNotNever.ts, 0, 0))
 >CoachMarkAnchorProps : Symbol(CoachMarkAnchorProps, Decl(thisIndexOnExistingReadonlyFieldIsNotNever.ts, 3, 1))
diff --git a/tests/baselines/reference/thisTypeInTaggedTemplateCall.symbols b/tests/baselines/reference/thisTypeInTaggedTemplateCall.symbols
index 4bb013c4da1..7358fbfe63f 100644
--- a/tests/baselines/reference/thisTypeInTaggedTemplateCall.symbols
+++ b/tests/baselines/reference/thisTypeInTaggedTemplateCall.symbols
@@ -21,6 +21,7 @@ Foo.m`test`;
 >m : Symbol(Foo.m, Decl(thisTypeInTaggedTemplateCall.ts, 0, 11))
 
 (Foo.m)`test`;
+>(Foo.m) : Symbol(Foo.m, Decl(thisTypeInTaggedTemplateCall.ts, 0, 11))
 >Foo.m : Symbol(Foo.m, Decl(thisTypeInTaggedTemplateCall.ts, 0, 11))
 >Foo : Symbol(Foo, Decl(thisTypeInTaggedTemplateCall.ts, 0, 0))
 >m : Symbol(Foo.m, Decl(thisTypeInTaggedTemplateCall.ts, 0, 11))
diff --git a/tests/baselines/reference/thisTypeSyntacticContext.symbols b/tests/baselines/reference/thisTypeSyntacticContext.symbols
index 07ea27bbff2..4a0e303e48c 100644
--- a/tests/baselines/reference/thisTypeSyntacticContext.symbols
+++ b/tests/baselines/reference/thisTypeSyntacticContext.symbols
@@ -45,6 +45,7 @@ o.test!!!();
 >test : Symbol(test, Decl(thisTypeSyntacticContext.ts, 3, 21))
 
 (o.test)();
+>(o.test) : Symbol(test, Decl(thisTypeSyntacticContext.ts, 3, 21))
 >o.test : Symbol(test, Decl(thisTypeSyntacticContext.ts, 3, 21))
 >o : Symbol(o, Decl(thisTypeSyntacticContext.ts, 3, 5))
 >test : Symbol(test, Decl(thisTypeSyntacticContext.ts, 3, 21))
diff --git a/tests/baselines/reference/topLevelAwait.1(module=es2022,target=es2015).symbols b/tests/baselines/reference/topLevelAwait.1(module=es2022,target=es2015).symbols
index 1f089db0d04..cf19b75f39a 100644
--- a/tests/baselines/reference/topLevelAwait.1(module=es2022,target=es2015).symbols
+++ b/tests/baselines/reference/topLevelAwait.1(module=es2022,target=es2015).symbols
@@ -18,6 +18,7 @@ declare function f(): number;
 >f : Symbol(f, Decl(index.ts, 5, 13))
 
 await (x);
+>(x) : Symbol(x, Decl(index.ts, 0, 12))
 >x : Symbol(x, Decl(index.ts, 0, 12))
 
 await (f(), x);
@@ -25,6 +26,7 @@ await (f(), x);
 >x : Symbol(x, Decl(index.ts, 0, 12))
 
 await <number>(x);
+>(x) : Symbol(x, Decl(index.ts, 0, 12))
 >x : Symbol(x, Decl(index.ts, 0, 12))
 
 await <number>(f(), x);
diff --git a/tests/baselines/reference/topLevelAwait.1(module=es2022,target=es2017).symbols b/tests/baselines/reference/topLevelAwait.1(module=es2022,target=es2017).symbols
index 1f089db0d04..cf19b75f39a 100644
--- a/tests/baselines/reference/topLevelAwait.1(module=es2022,target=es2017).symbols
+++ b/tests/baselines/reference/topLevelAwait.1(module=es2022,target=es2017).symbols
@@ -18,6 +18,7 @@ declare function f(): number;
 >f : Symbol(f, Decl(index.ts, 5, 13))
 
 await (x);
+>(x) : Symbol(x, Decl(index.ts, 0, 12))
 >x : Symbol(x, Decl(index.ts, 0, 12))
 
 await (f(), x);
@@ -25,6 +26,7 @@ await (f(), x);
 >x : Symbol(x, Decl(index.ts, 0, 12))
 
 await <number>(x);
+>(x) : Symbol(x, Decl(index.ts, 0, 12))
 >x : Symbol(x, Decl(index.ts, 0, 12))
 
 await <number>(f(), x);
diff --git a/tests/baselines/reference/topLevelAwait.1(module=esnext,target=es2015).symbols b/tests/baselines/reference/topLevelAwait.1(module=esnext,target=es2015).symbols
index 1f089db0d04..cf19b75f39a 100644
--- a/tests/baselines/reference/topLevelAwait.1(module=esnext,target=es2015).symbols
+++ b/tests/baselines/reference/topLevelAwait.1(module=esnext,target=es2015).symbols
@@ -18,6 +18,7 @@ declare function f(): number;
 >f : Symbol(f, Decl(index.ts, 5, 13))
 
 await (x);
+>(x) : Symbol(x, Decl(index.ts, 0, 12))
 >x : Symbol(x, Decl(index.ts, 0, 12))
 
 await (f(), x);
@@ -25,6 +26,7 @@ await (f(), x);
 >x : Symbol(x, Decl(index.ts, 0, 12))
 
 await <number>(x);
+>(x) : Symbol(x, Decl(index.ts, 0, 12))
 >x : Symbol(x, Decl(index.ts, 0, 12))
 
 await <number>(f(), x);
diff --git a/tests/baselines/reference/topLevelAwait.1(module=esnext,target=es2017).symbols b/tests/baselines/reference/topLevelAwait.1(module=esnext,target=es2017).symbols
index 1f089db0d04..cf19b75f39a 100644
--- a/tests/baselines/reference/topLevelAwait.1(module=esnext,target=es2017).symbols
+++ b/tests/baselines/reference/topLevelAwait.1(module=esnext,target=es2017).symbols
@@ -18,6 +18,7 @@ declare function f(): number;
 >f : Symbol(f, Decl(index.ts, 5, 13))
 
 await (x);
+>(x) : Symbol(x, Decl(index.ts, 0, 12))
 >x : Symbol(x, Decl(index.ts, 0, 12))
 
 await (f(), x);
@@ -25,6 +26,7 @@ await (f(), x);
 >x : Symbol(x, Decl(index.ts, 0, 12))
 
 await <number>(x);
+>(x) : Symbol(x, Decl(index.ts, 0, 12))
 >x : Symbol(x, Decl(index.ts, 0, 12))
 
 await <number>(f(), x);
diff --git a/tests/baselines/reference/topLevelAwait.1(module=system,target=es2015).symbols b/tests/baselines/reference/topLevelAwait.1(module=system,target=es2015).symbols
index 1f089db0d04..cf19b75f39a 100644
--- a/tests/baselines/reference/topLevelAwait.1(module=system,target=es2015).symbols
+++ b/tests/baselines/reference/topLevelAwait.1(module=system,target=es2015).symbols
@@ -18,6 +18,7 @@ declare function f(): number;
 >f : Symbol(f, Decl(index.ts, 5, 13))
 
 await (x);
+>(x) : Symbol(x, Decl(index.ts, 0, 12))
 >x : Symbol(x, Decl(index.ts, 0, 12))
 
 await (f(), x);
@@ -25,6 +26,7 @@ await (f(), x);
 >x : Symbol(x, Decl(index.ts, 0, 12))
 
 await <number>(x);
+>(x) : Symbol(x, Decl(index.ts, 0, 12))
 >x : Symbol(x, Decl(index.ts, 0, 12))
 
 await <number>(f(), x);
diff --git a/tests/baselines/reference/topLevelAwait.1(module=system,target=es2017).symbols b/tests/baselines/reference/topLevelAwait.1(module=system,target=es2017).symbols
index 1f089db0d04..cf19b75f39a 100644
--- a/tests/baselines/reference/topLevelAwait.1(module=system,target=es2017).symbols
+++ b/tests/baselines/reference/topLevelAwait.1(module=system,target=es2017).symbols
@@ -18,6 +18,7 @@ declare function f(): number;
 >f : Symbol(f, Decl(index.ts, 5, 13))
 
 await (x);
+>(x) : Symbol(x, Decl(index.ts, 0, 12))
 >x : Symbol(x, Decl(index.ts, 0, 12))
 
 await (f(), x);
@@ -25,6 +26,7 @@ await (f(), x);
 >x : Symbol(x, Decl(index.ts, 0, 12))
 
 await <number>(x);
+>(x) : Symbol(x, Decl(index.ts, 0, 12))
 >x : Symbol(x, Decl(index.ts, 0, 12))
 
 await <number>(f(), x);
diff --git a/tests/baselines/reference/transformsElideNullUndefinedType.symbols b/tests/baselines/reference/transformsElideNullUndefinedType.symbols
index a3e3f60aa64..fea25b4992a 100644
--- a/tests/baselines/reference/transformsElideNullUndefinedType.symbols
+++ b/tests/baselines/reference/transformsElideNullUndefinedType.symbols
@@ -114,10 +114,12 @@ class C5 {
 
 var C6 = class { constructor(p12: null) { } }
 >C6 : Symbol(C6, Decl(transformsElideNullUndefinedType.ts, 48, 3))
+>class { constructor(p12: null) { } } : Symbol(C6, Decl(transformsElideNullUndefinedType.ts, 48, 8))
 >p12 : Symbol(p12, Decl(transformsElideNullUndefinedType.ts, 48, 29))
 
 var C7 = class { constructor(p13: undefined) { } }
 >C7 : Symbol(C7, Decl(transformsElideNullUndefinedType.ts, 49, 3))
+>class { constructor(p13: undefined) { } } : Symbol(C7, Decl(transformsElideNullUndefinedType.ts, 49, 8))
 >p13 : Symbol(p13, Decl(transformsElideNullUndefinedType.ts, 49, 29))
 
 declare function fn<T>();
diff --git a/tests/baselines/reference/truthinessPromiseCoercion.symbols b/tests/baselines/reference/truthinessPromiseCoercion.symbols
index f025113b868..6e245c619b7 100644
--- a/tests/baselines/reference/truthinessPromiseCoercion.symbols
+++ b/tests/baselines/reference/truthinessPromiseCoercion.symbols
@@ -84,6 +84,13 @@ async function g() {
 >p : Symbol(p, Decl(truthinessPromiseCoercion.ts, 0, 13))
 
                 !!await (((((((p)))))));
+>(((((((p))))))) : Symbol(p, Decl(truthinessPromiseCoercion.ts, 0, 13))
+>((((((p)))))) : Symbol(p, Decl(truthinessPromiseCoercion.ts, 0, 13))
+>(((((p))))) : Symbol(p, Decl(truthinessPromiseCoercion.ts, 0, 13))
+>((((p)))) : Symbol(p, Decl(truthinessPromiseCoercion.ts, 0, 13))
+>(((p))) : Symbol(p, Decl(truthinessPromiseCoercion.ts, 0, 13))
+>((p)) : Symbol(p, Decl(truthinessPromiseCoercion.ts, 0, 13))
+>(p) : Symbol(p, Decl(truthinessPromiseCoercion.ts, 0, 13))
 >p : Symbol(p, Decl(truthinessPromiseCoercion.ts, 0, 13))
             }
         }
diff --git a/tests/baselines/reference/tsxGenericAttributesType9.symbols b/tests/baselines/reference/tsxGenericAttributesType9.symbols
index 2771e0a07eb..e0eb9fd0c7d 100644
--- a/tests/baselines/reference/tsxGenericAttributesType9.symbols
+++ b/tests/baselines/reference/tsxGenericAttributesType9.symbols
@@ -11,6 +11,7 @@ export function makeP<P>(Ctor: React.ComponentClass<P>) {
 >P : Symbol(P, Decl(file.tsx, 2, 22))
 
 	return class extends React.PureComponent<P, void> {
+>class extends React.PureComponent<P, void> {		public render(): JSX.Element {			return (				<Ctor {...this.props } />			);		}	} : Symbol((Anonymous class), Decl(file.tsx, 3, 7))
 >React.PureComponent : Symbol(React.PureComponent, Decl(react.d.ts, 180, 5))
 >React : Symbol(React, Decl(file.tsx, 0, 0))
 >PureComponent : Symbol(React.PureComponent, Decl(react.d.ts, 180, 5))
diff --git a/tests/baselines/reference/typeAliasFunctionTypeSharedSymbol.symbols b/tests/baselines/reference/typeAliasFunctionTypeSharedSymbol.symbols
index b3e176f72ab..14e49b77687 100644
--- a/tests/baselines/reference/typeAliasFunctionTypeSharedSymbol.symbols
+++ b/tests/baselines/reference/typeAliasFunctionTypeSharedSymbol.symbols
@@ -9,6 +9,7 @@ function Mixin<TBase extends {new (...args: any[]): {}}>(Base: TBase) {
 >TBase : Symbol(TBase, Decl(typeAliasFunctionTypeSharedSymbol.ts, 2, 15))
 
     return class extends Base {
+>class extends Base {    } : Symbol((Anonymous class), Decl(typeAliasFunctionTypeSharedSymbol.ts, 3, 10))
 >Base : Symbol(Base, Decl(typeAliasFunctionTypeSharedSymbol.ts, 2, 57))
 
     };
diff --git a/tests/baselines/reference/typeArgumentInferenceWithClassExpression1.symbols b/tests/baselines/reference/typeArgumentInferenceWithClassExpression1.symbols
index b998e24bf0a..e68dfe3700d 100644
--- a/tests/baselines/reference/typeArgumentInferenceWithClassExpression1.symbols
+++ b/tests/baselines/reference/typeArgumentInferenceWithClassExpression1.symbols
@@ -3,6 +3,7 @@ function foo<T>(x = class { static prop: T }): T {
 >foo : Symbol(foo, Decl(typeArgumentInferenceWithClassExpression1.ts, 0, 0))
 >T : Symbol(T, Decl(typeArgumentInferenceWithClassExpression1.ts, 0, 13))
 >x : Symbol(x, Decl(typeArgumentInferenceWithClassExpression1.ts, 0, 16))
+>class { static prop: T } : Symbol((Anonymous class), Decl(typeArgumentInferenceWithClassExpression1.ts, 0, 19))
 >prop : Symbol((Anonymous class).prop, Decl(typeArgumentInferenceWithClassExpression1.ts, 0, 27))
 >T : Symbol(T, Decl(typeArgumentInferenceWithClassExpression1.ts, 0, 13))
 >T : Symbol(T, Decl(typeArgumentInferenceWithClassExpression1.ts, 0, 13))
@@ -14,6 +15,7 @@ function foo<T>(x = class { static prop: T }): T {
 foo(class { static prop = "hello" }).length;
 >foo(class { static prop = "hello" }).length : Symbol(String.length, Decl(lib.es5.d.ts, --, --))
 >foo : Symbol(foo, Decl(typeArgumentInferenceWithClassExpression1.ts, 0, 0))
+>class { static prop = "hello" } : Symbol((Anonymous class), Decl(typeArgumentInferenceWithClassExpression1.ts, 4, 4))
 >prop : Symbol((Anonymous class).prop, Decl(typeArgumentInferenceWithClassExpression1.ts, 4, 11))
 >length : Symbol(String.length, Decl(lib.es5.d.ts, --, --))
 
diff --git a/tests/baselines/reference/typeArgumentInferenceWithClassExpression2.symbols b/tests/baselines/reference/typeArgumentInferenceWithClassExpression2.symbols
index 8b40b210c77..d86b746a1ed 100644
--- a/tests/baselines/reference/typeArgumentInferenceWithClassExpression2.symbols
+++ b/tests/baselines/reference/typeArgumentInferenceWithClassExpression2.symbols
@@ -3,6 +3,7 @@ function foo<T>(x = class { prop: T }): T {
 >foo : Symbol(foo, Decl(typeArgumentInferenceWithClassExpression2.ts, 0, 0))
 >T : Symbol(T, Decl(typeArgumentInferenceWithClassExpression2.ts, 0, 13))
 >x : Symbol(x, Decl(typeArgumentInferenceWithClassExpression2.ts, 0, 16))
+>class { prop: T } : Symbol((Anonymous class), Decl(typeArgumentInferenceWithClassExpression2.ts, 0, 19))
 >prop : Symbol((Anonymous class).prop, Decl(typeArgumentInferenceWithClassExpression2.ts, 0, 27))
 >T : Symbol(T, Decl(typeArgumentInferenceWithClassExpression2.ts, 0, 13))
 >T : Symbol(T, Decl(typeArgumentInferenceWithClassExpression2.ts, 0, 13))
@@ -14,5 +15,6 @@ function foo<T>(x = class { prop: T }): T {
 // Should not infer string because it is a static property
 foo(class { static prop = "hello" }).length;
 >foo : Symbol(foo, Decl(typeArgumentInferenceWithClassExpression2.ts, 0, 0))
+>class { static prop = "hello" } : Symbol((Anonymous class), Decl(typeArgumentInferenceWithClassExpression2.ts, 5, 4))
 >prop : Symbol((Anonymous class).prop, Decl(typeArgumentInferenceWithClassExpression2.ts, 5, 11))
 
diff --git a/tests/baselines/reference/typeArgumentInferenceWithClassExpression3.symbols b/tests/baselines/reference/typeArgumentInferenceWithClassExpression3.symbols
index 7f988eb2110..8bf5cc9d0b4 100644
--- a/tests/baselines/reference/typeArgumentInferenceWithClassExpression3.symbols
+++ b/tests/baselines/reference/typeArgumentInferenceWithClassExpression3.symbols
@@ -3,6 +3,7 @@ function foo<T>(x = class { prop: T }): T {
 >foo : Symbol(foo, Decl(typeArgumentInferenceWithClassExpression3.ts, 0, 0))
 >T : Symbol(T, Decl(typeArgumentInferenceWithClassExpression3.ts, 0, 13))
 >x : Symbol(x, Decl(typeArgumentInferenceWithClassExpression3.ts, 0, 16))
+>class { prop: T } : Symbol((Anonymous class), Decl(typeArgumentInferenceWithClassExpression3.ts, 0, 19))
 >prop : Symbol((Anonymous class).prop, Decl(typeArgumentInferenceWithClassExpression3.ts, 0, 27))
 >T : Symbol(T, Decl(typeArgumentInferenceWithClassExpression3.ts, 0, 13))
 >T : Symbol(T, Decl(typeArgumentInferenceWithClassExpression3.ts, 0, 13))
@@ -14,6 +15,7 @@ function foo<T>(x = class { prop: T }): T {
 foo(class { prop = "hello" }).length;
 >foo(class { prop = "hello" }).length : Symbol(String.length, Decl(lib.es5.d.ts, --, --))
 >foo : Symbol(foo, Decl(typeArgumentInferenceWithClassExpression3.ts, 0, 0))
+>class { prop = "hello" } : Symbol((Anonymous class), Decl(typeArgumentInferenceWithClassExpression3.ts, 4, 4))
 >prop : Symbol((Anonymous class).prop, Decl(typeArgumentInferenceWithClassExpression3.ts, 4, 11))
 >length : Symbol(String.length, Decl(lib.es5.d.ts, --, --))
 
diff --git a/tests/baselines/reference/typeFromParamTagForFunction.symbols b/tests/baselines/reference/typeFromParamTagForFunction.symbols
index 9f655be0bb9..522ee227c4a 100644
--- a/tests/baselines/reference/typeFromParamTagForFunction.symbols
+++ b/tests/baselines/reference/typeFromParamTagForFunction.symbols
@@ -39,6 +39,7 @@ exports.B = class {
 >exports.B : Symbol(B, Decl(b-ext.js, 0, 0))
 >exports : Symbol(B, Decl(b-ext.js, 0, 0))
 >B : Symbol(B, Decl(b-ext.js, 0, 0))
+>class {    constructor() {        this.x = 1;    }} : Symbol(B, Decl(b-ext.js, 0, 11))
 
     constructor() {
         this.x = 1;
diff --git a/tests/baselines/reference/typeFromPropertyAssignment.symbols b/tests/baselines/reference/typeFromPropertyAssignment.symbols
index f58a6620264..b80cc47eba3 100644
--- a/tests/baselines/reference/typeFromPropertyAssignment.symbols
+++ b/tests/baselines/reference/typeFromPropertyAssignment.symbols
@@ -1,6 +1,7 @@
 === tests/cases/conformance/salsa/a.js ===
 var Outer = class O {
 >Outer : Symbol(Outer, Decl(a.js, 0, 3), Decl(a.js, 2, 1))
+>class O {    m(x, y) { }} : Symbol(O, Decl(a.js, 0, 11))
 >O : Symbol(O, Decl(a.js, 0, 11))
 
     m(x, y) { }
@@ -12,6 +13,7 @@ Outer.Inner = class I {
 >Outer.Inner : Symbol(Outer.Inner, Decl(a.js, 2, 1))
 >Outer : Symbol(Outer, Decl(a.js, 0, 3), Decl(a.js, 2, 1))
 >Inner : Symbol(Outer.Inner, Decl(a.js, 2, 1))
+>class I {    n(a, b) { }} : Symbol(I, Decl(a.js, 3, 13))
 >I : Symbol(I, Decl(a.js, 3, 13))
 
     n(a, b) { }
diff --git a/tests/baselines/reference/typeFromPropertyAssignment10.symbols b/tests/baselines/reference/typeFromPropertyAssignment10.symbols
index ffe2ae1219e..3c299bcbeda 100644
--- a/tests/baselines/reference/typeFromPropertyAssignment10.symbols
+++ b/tests/baselines/reference/typeFromPropertyAssignment10.symbols
@@ -35,6 +35,7 @@ Outer.app.Inner = class {
 >Outer : Symbol(Outer, Decl(module.js, 0, 3), Decl(module.js, 0, 24), Decl(someview.js, 0, 0), Decl(someview.js, 5, 5), Decl(someview.js, 13, 10) ... and 1 more)
 >app : Symbol(Outer.app, Decl(module.js, 0, 24), Decl(someview.js, 0, 6), Decl(someview.js, 6, 6), Decl(someview.js, 15, 6), Decl(application.js, 0, 6))
 >Inner : Symbol(Outer.app.Inner, Decl(someview.js, 5, 5))
+>class {    constructor() {        /** @type {number} */        this.y = 12;    }} : Symbol(Inner, Decl(someview.js, 6, 17))
 
     constructor() {
         /** @type {number} */
diff --git a/tests/baselines/reference/typeFromPropertyAssignment10_1.symbols b/tests/baselines/reference/typeFromPropertyAssignment10_1.symbols
index 6945130f419..b7008777727 100644
--- a/tests/baselines/reference/typeFromPropertyAssignment10_1.symbols
+++ b/tests/baselines/reference/typeFromPropertyAssignment10_1.symbols
@@ -35,6 +35,7 @@ Outer.app.Inner = class {
 >Outer : Symbol(Outer, Decl(module.js, 0, 3), Decl(module.js, 0, 24), Decl(someview.js, 0, 0), Decl(someview.js, 5, 5), Decl(someview.js, 13, 10) ... and 1 more)
 >app : Symbol(Outer.app, Decl(module.js, 0, 24), Decl(someview.js, 0, 6), Decl(someview.js, 6, 6), Decl(someview.js, 15, 6), Decl(application.js, 0, 6))
 >Inner : Symbol(Outer.app.Inner, Decl(someview.js, 5, 5))
+>class {    constructor() {        /** @type {number} */        this.y = 12;    }} : Symbol(Inner, Decl(someview.js, 6, 17))
 
     constructor() {
         /** @type {number} */
diff --git a/tests/baselines/reference/typeFromPropertyAssignment15.symbols b/tests/baselines/reference/typeFromPropertyAssignment15.symbols
index ce9a3205857..cc52936db29 100644
--- a/tests/baselines/reference/typeFromPropertyAssignment15.symbols
+++ b/tests/baselines/reference/typeFromPropertyAssignment15.symbols
@@ -6,6 +6,7 @@ Outer.Inner = class {
 >Outer.Inner : Symbol(Outer.Inner, Decl(a.js, 0, 15))
 >Outer : Symbol(Outer, Decl(a.js, 0, 3), Decl(a.js, 0, 15))
 >Inner : Symbol(Outer.Inner, Decl(a.js, 0, 15))
+>class {    constructor() {        this.x = 1    }    m() { }} : Symbol(Inner, Decl(a.js, 2, 13))
 
     constructor() {
         this.x = 1
diff --git a/tests/baselines/reference/typeFromPropertyAssignment2.symbols b/tests/baselines/reference/typeFromPropertyAssignment2.symbols
index 76d88fb41b4..1a158df7bd2 100644
--- a/tests/baselines/reference/typeFromPropertyAssignment2.symbols
+++ b/tests/baselines/reference/typeFromPropertyAssignment2.symbols
@@ -11,6 +11,7 @@ Outer.Inner = class I {
 >Outer.Inner : Symbol(Outer.Inner, Decl(a.js, 2, 1))
 >Outer : Symbol(Outer, Decl(a.js, 0, 0), Decl(a.js, 2, 1))
 >Inner : Symbol(Outer.Inner, Decl(a.js, 2, 1))
+>class I {    constructor() {        this.x = 1    }} : Symbol(I, Decl(a.js, 3, 13))
 >I : Symbol(I, Decl(a.js, 3, 13))
 
     constructor() {
diff --git a/tests/baselines/reference/typeFromPropertyAssignment24.symbols b/tests/baselines/reference/typeFromPropertyAssignment24.symbols
index 9120b2fa171..7cb0685f53c 100644
--- a/tests/baselines/reference/typeFromPropertyAssignment24.symbols
+++ b/tests/baselines/reference/typeFromPropertyAssignment24.symbols
@@ -37,6 +37,7 @@ Outer.Inner = class {
 >Outer.Inner : Symbol(Outer.Inner, Decl(usage.js, 1, 6), Decl(def.js, 0, 14))
 >Outer : Symbol(Outer, Decl(usage.js, 0, 0), Decl(def.js, 0, 3), Decl(def.js, 0, 14))
 >Inner : Symbol(Outer.Inner, Decl(usage.js, 1, 6), Decl(def.js, 0, 14))
+>class {  name() {    return 'hi'  }} : Symbol(Inner, Decl(def.js, 1, 13))
 
   name() {
 >name : Symbol(Inner.name, Decl(def.js, 1, 21))
diff --git a/tests/baselines/reference/typeFromPropertyAssignment25.symbols b/tests/baselines/reference/typeFromPropertyAssignment25.symbols
index d2be36efd2e..225bd9d64d7 100644
--- a/tests/baselines/reference/typeFromPropertyAssignment25.symbols
+++ b/tests/baselines/reference/typeFromPropertyAssignment25.symbols
@@ -6,6 +6,7 @@ Common.I = class {
 >Common.I : Symbol(Common.I, Decl(bug24703.js, 0, 16))
 >Common : Symbol(Common, Decl(bug24703.js, 0, 3), Decl(bug24703.js, 0, 16), Decl(bug24703.js, 5, 1))
 >I : Symbol(Common.I, Decl(bug24703.js, 0, 16))
+>class {    constructor() {        this.i = 1    }} : Symbol(I, Decl(bug24703.js, 1, 10))
 
     constructor() {
         this.i = 1
@@ -18,6 +19,7 @@ Common.O = class extends Common.I {
 >Common.O : Symbol(Common.O, Decl(bug24703.js, 5, 1))
 >Common : Symbol(Common, Decl(bug24703.js, 0, 3), Decl(bug24703.js, 0, 16), Decl(bug24703.js, 5, 1))
 >O : Symbol(Common.O, Decl(bug24703.js, 5, 1))
+>class extends Common.I {    constructor() {        super()        this.o = 2    }} : Symbol(O, Decl(bug24703.js, 6, 10))
 >Common.I : Symbol(Common.I, Decl(bug24703.js, 0, 16))
 >Common : Symbol(Common, Decl(bug24703.js, 0, 3), Decl(bug24703.js, 0, 16), Decl(bug24703.js, 5, 1))
 >I : Symbol(Common.I, Decl(bug24703.js, 0, 16))
diff --git a/tests/baselines/reference/typeFromPropertyAssignment26.symbols b/tests/baselines/reference/typeFromPropertyAssignment26.symbols
index 77e48ed24b0..65627795ec0 100644
--- a/tests/baselines/reference/typeFromPropertyAssignment26.symbols
+++ b/tests/baselines/reference/typeFromPropertyAssignment26.symbols
@@ -6,6 +6,7 @@ UI.TreeElement = class {
 >UI.TreeElement : Symbol(UI.TreeElement, Decl(bug24730.js, 0, 11))
 >UI : Symbol(UI, Decl(bug24730.js, 0, 3), Decl(bug24730.js, 0, 11), Decl(bug24730.js, 5, 2))
 >TreeElement : Symbol(UI.TreeElement, Decl(bug24730.js, 0, 11))
+>class {    constructor() {        this.treeOutline = 12    }} : Symbol(TreeElement, Decl(bug24730.js, 1, 16))
 
     constructor() {
         this.treeOutline = 12
diff --git a/tests/baselines/reference/typeFromPropertyAssignment29.symbols b/tests/baselines/reference/typeFromPropertyAssignment29.symbols
index dd53b85df00..bc3c423376c 100644
--- a/tests/baselines/reference/typeFromPropertyAssignment29.symbols
+++ b/tests/baselines/reference/typeFromPropertyAssignment29.symbols
@@ -240,6 +240,7 @@ var n = ExpandoClass.prop + ExpandoClass.m(12) + new ExpandoClass().n
 // Class expressions shouldn't work in typescript either
 var ExpandoExpr3 = class {
 >ExpandoExpr3 : Symbol(ExpandoExpr3, Decl(typeFromPropertyAssignment29.ts, 76, 3))
+>class {    n = 10001;} : Symbol(ExpandoExpr3, Decl(typeFromPropertyAssignment29.ts, 76, 18))
 
     n = 10001;
 >n : Symbol(ExpandoExpr3.n, Decl(typeFromPropertyAssignment29.ts, 76, 26))
diff --git a/tests/baselines/reference/typeFromPropertyAssignment3.symbols b/tests/baselines/reference/typeFromPropertyAssignment3.symbols
index 96ea0270eb0..f9cc942cc92 100644
--- a/tests/baselines/reference/typeFromPropertyAssignment3.symbols
+++ b/tests/baselines/reference/typeFromPropertyAssignment3.symbols
@@ -12,6 +12,7 @@ Outer.Inner = class I {
 >Outer.Inner : Symbol(Outer.Inner, Decl(a.js, 2, 1))
 >Outer : Symbol(Outer, Decl(a.js, 0, 3), Decl(a.js, 2, 1))
 >Inner : Symbol(Outer.Inner, Decl(a.js, 2, 1))
+>class I {    constructor() {        this.x = 1    }} : Symbol(I, Decl(a.js, 3, 13))
 >I : Symbol(I, Decl(a.js, 3, 13))
 
     constructor() {
diff --git a/tests/baselines/reference/typeFromPropertyAssignment35.symbols b/tests/baselines/reference/typeFromPropertyAssignment35.symbols
index d651748d1cc..d5b4829b8b0 100644
--- a/tests/baselines/reference/typeFromPropertyAssignment35.symbols
+++ b/tests/baselines/reference/typeFromPropertyAssignment35.symbols
@@ -27,6 +27,7 @@ Emu.D = class {
 >Emu.D : Symbol(Emu.D, Decl(bug26877.js, 5, 1), Decl(second.js, 2, 4))
 >Emu : Symbol(Emu, Decl(bug26877.js, 5, 1), Decl(second.js, 0, 3), Decl(second.js, 0, 12))
 >D : Symbol(Emu.D, Decl(bug26877.js, 5, 1), Decl(second.js, 2, 4))
+>class {    constructor() {        this._model = 1    }} : Symbol(D, Decl(bug26877.js, 6, 7))
 
     constructor() {
         this._model = 1
diff --git a/tests/baselines/reference/typeFromPropertyAssignment4.symbols b/tests/baselines/reference/typeFromPropertyAssignment4.symbols
index 9dde5afa0a3..f725f128e6a 100644
--- a/tests/baselines/reference/typeFromPropertyAssignment4.symbols
+++ b/tests/baselines/reference/typeFromPropertyAssignment4.symbols
@@ -7,6 +7,7 @@ Outer.Inner = class {
 >Outer.Inner : Symbol(Outer.Inner, Decl(a.js, 0, 0))
 >Outer : Symbol(Outer, Decl(def.js, 0, 3), Decl(a.js, 0, 0))
 >Inner : Symbol(Outer.Inner, Decl(a.js, 0, 0))
+>class {    constructor() {        /** @type {number} */        this.y = 12    }} : Symbol(Inner, Decl(a.js, 0, 13))
 
     constructor() {
         /** @type {number} */
diff --git a/tests/baselines/reference/typeFromPropertyAssignment5.symbols b/tests/baselines/reference/typeFromPropertyAssignment5.symbols
index 648741df878..5395ec2d6ff 100644
--- a/tests/baselines/reference/typeFromPropertyAssignment5.symbols
+++ b/tests/baselines/reference/typeFromPropertyAssignment5.symbols
@@ -6,6 +6,7 @@ MyClass.bar = class C {
 >MyClass.bar : Symbol(MyClass.bar, Decl(a.js, 1, 1))
 >MyClass : Symbol(MyClass, Decl(a.js, 0, 0), Decl(a.js, 1, 1))
 >bar : Symbol(MyClass.bar, Decl(a.js, 1, 1))
+>class C {} : Symbol(C, Decl(a.js, 2, 13))
 >C : Symbol(C, Decl(a.js, 2, 13))
 }
 MyClass.bar
diff --git a/tests/baselines/reference/typeFromPropertyAssignment6.symbols b/tests/baselines/reference/typeFromPropertyAssignment6.symbols
index fa5248fd13c..978693ca1ef 100644
--- a/tests/baselines/reference/typeFromPropertyAssignment6.symbols
+++ b/tests/baselines/reference/typeFromPropertyAssignment6.symbols
@@ -7,6 +7,7 @@ Outer.Inner = class I {
 >Outer.Inner : Symbol(Outer.Inner, Decl(a.js, 0, 0))
 >Outer : Symbol(Outer, Decl(def.js, 0, 0), Decl(a.js, 0, 0), Decl(a.js, 2, 1))
 >Inner : Symbol(Outer.Inner, Decl(a.js, 0, 0))
+>class I {    messages() { return [] }} : Symbol(I, Decl(a.js, 0, 13))
 >I : Symbol(I, Decl(a.js, 0, 13))
 
     messages() { return [] }
diff --git a/tests/baselines/reference/typeFromPropertyAssignment9.symbols b/tests/baselines/reference/typeFromPropertyAssignment9.symbols
index 070bff89170..17330c92476 100644
--- a/tests/baselines/reference/typeFromPropertyAssignment9.symbols
+++ b/tests/baselines/reference/typeFromPropertyAssignment9.symbols
@@ -105,6 +105,7 @@ my.predicate.type = class {
 >my : Symbol(my, Decl(a.js, 0, 3), Decl(a.js, 0, 18), Decl(a.js, 4, 1), Decl(a.js, 5, 14), Decl(a.js, 6, 15) ... and 5 more)
 >predicate : Symbol(my.predicate, Decl(a.js, 6, 15), Decl(a.js, 8, 3), Decl(a.js, 13, 3), Decl(a.js, 16, 3), Decl(a.js, 20, 3) ... and 1 more)
 >type : Symbol(my.predicate.type, Decl(a.js, 22, 1))
+>class {    m() { return 101; }} : Symbol(type, Decl(a.js, 23, 19))
 
     m() { return 101; }
 >m : Symbol(type.m, Decl(a.js, 23, 27))
@@ -141,6 +142,7 @@ min.nest.other = self.min.nest.other || class { };
 >min : Symbol(min, Decl(a.js, 29, 3), Decl(a.js, 29, 27), Decl(a.js, 30, 44), Decl(a.js, 31, 50))
 >nest : Symbol(min.nest, Decl(a.js, 29, 27), Decl(a.js, 31, 4))
 >other : Symbol(min.nest.other, Decl(a.js, 30, 44))
+>class { } : Symbol(other, Decl(a.js, 31, 39))
 
 min.property = global.min.property || {};
 >min.property : Symbol(min.property, Decl(a.js, 31, 50))
diff --git a/tests/baselines/reference/typeFromPropertyAssignment9_1.symbols b/tests/baselines/reference/typeFromPropertyAssignment9_1.symbols
index 2ed5b463266..6ed00331f31 100644
--- a/tests/baselines/reference/typeFromPropertyAssignment9_1.symbols
+++ b/tests/baselines/reference/typeFromPropertyAssignment9_1.symbols
@@ -105,6 +105,7 @@ my.predicate.type = class {
 >my : Symbol(my, Decl(a.js, 0, 3), Decl(a.js, 0, 18), Decl(a.js, 4, 1), Decl(a.js, 5, 14), Decl(a.js, 6, 15) ... and 5 more)
 >predicate : Symbol(my.predicate, Decl(a.js, 6, 15), Decl(a.js, 8, 3), Decl(a.js, 13, 3), Decl(a.js, 16, 3), Decl(a.js, 20, 3) ... and 1 more)
 >type : Symbol(my.predicate.type, Decl(a.js, 22, 1))
+>class {    m() { return 101; }} : Symbol(type, Decl(a.js, 23, 19))
 
     m() { return 101; }
 >m : Symbol(type.m, Decl(a.js, 23, 27))
@@ -141,6 +142,7 @@ min.nest.other = self.min.nest.other ?? class { };
 >min : Symbol(min, Decl(a.js, 29, 3), Decl(a.js, 29, 27), Decl(a.js, 30, 44), Decl(a.js, 31, 50))
 >nest : Symbol(min.nest, Decl(a.js, 29, 27), Decl(a.js, 31, 4))
 >other : Symbol(min.nest.other, Decl(a.js, 30, 44))
+>class { } : Symbol(other, Decl(a.js, 31, 39))
 
 min.property = global.min.property ?? {};
 >min.property : Symbol(min.property, Decl(a.js, 31, 50))
diff --git a/tests/baselines/reference/typeFromPropertyAssignmentOutOfOrder.symbols b/tests/baselines/reference/typeFromPropertyAssignmentOutOfOrder.symbols
index f31de75386a..29b2d469427 100644
--- a/tests/baselines/reference/typeFromPropertyAssignmentOutOfOrder.symbols
+++ b/tests/baselines/reference/typeFromPropertyAssignmentOutOfOrder.symbols
@@ -3,12 +3,14 @@ First.Item = class I {}
 >First.Item : Symbol(First.Item, Decl(index.js, 0, 0))
 >First : Symbol(First, Decl(index.js, 0, 0), Decl(roots.js, 0, 3))
 >Item : Symbol(First.Item, Decl(index.js, 0, 0))
+>class I {} : Symbol(I, Decl(index.js, 0, 12))
 >I : Symbol(I, Decl(index.js, 0, 12))
 
 Common.Object = class extends First.Item {}
 >Common.Object : Symbol(Common.Object, Decl(index.js, 0, 23))
 >Common : Symbol(Common, Decl(index.js, 0, 23), Decl(roots.js, 1, 3))
 >Object : Symbol(Common.Object, Decl(index.js, 0, 23))
+>class extends First.Item {} : Symbol(Object, Decl(index.js, 1, 15))
 >First.Item : Symbol(First.Item, Decl(index.js, 0, 0))
 >First : Symbol(First, Decl(index.js, 0, 0), Decl(roots.js, 0, 3))
 >Item : Symbol(First.Item, Decl(index.js, 0, 0))
@@ -17,6 +19,7 @@ Workspace.Object = class extends Common.Object {}
 >Workspace.Object : Symbol(Workspace.Object, Decl(index.js, 1, 43))
 >Workspace : Symbol(Workspace, Decl(index.js, 1, 43), Decl(roots.js, 2, 3))
 >Object : Symbol(Workspace.Object, Decl(index.js, 1, 43))
+>class extends Common.Object {} : Symbol(Object, Decl(index.js, 3, 18))
 >Common.Object : Symbol(Common.Object, Decl(index.js, 0, 23))
 >Common : Symbol(Common, Decl(index.js, 0, 23), Decl(roots.js, 1, 3))
 >Object : Symbol(Common.Object, Decl(index.js, 0, 23))
diff --git a/tests/baselines/reference/typeGuardInClass.symbols b/tests/baselines/reference/typeGuardInClass.symbols
index cc0e745e4de..79be36735e6 100644
--- a/tests/baselines/reference/typeGuardInClass.symbols
+++ b/tests/baselines/reference/typeGuardInClass.symbols
@@ -7,6 +7,7 @@ if (typeof x === "string") {
 
     let n = class {
 >n : Symbol(n, Decl(typeGuardInClass.ts, 3, 7))
+>class {        constructor() {            let y: string = x;        }    } : Symbol(n, Decl(typeGuardInClass.ts, 3, 11))
 
         constructor() {
             let y: string = x;
@@ -18,6 +19,7 @@ if (typeof x === "string") {
 else {
     let m = class {
 >m : Symbol(m, Decl(typeGuardInClass.ts, 10, 7))
+>class {        constructor() {            let y: number = x;        }    } : Symbol(m, Decl(typeGuardInClass.ts, 10, 11))
 
         constructor() {
             let y: number = x;
diff --git a/tests/baselines/reference/typeGuardOfFromPropNameInUnionType.symbols b/tests/baselines/reference/typeGuardOfFromPropNameInUnionType.symbols
index 845fdcf69d6..19599eb192c 100644
--- a/tests/baselines/reference/typeGuardOfFromPropNameInUnionType.symbols
+++ b/tests/baselines/reference/typeGuardOfFromPropNameInUnionType.symbols
@@ -138,6 +138,7 @@ function inParenthesizedExpression(x: A | B) {
 >B : Symbol(B, Decl(typeGuardOfFromPropNameInUnionType.ts, 0, 22))
 
     if ("a" in (x)) {
+>(x) : Symbol(x, Decl(typeGuardOfFromPropNameInUnionType.ts, 42, 35))
 >x : Symbol(x, Decl(typeGuardOfFromPropNameInUnionType.ts, 42, 35))
 
         let y: string = x.a;
diff --git a/tests/baselines/reference/typeGuardOnContainerTypeNoHang.symbols b/tests/baselines/reference/typeGuardOnContainerTypeNoHang.symbols
index eacc6b7f100..0a104b42a5c 100644
--- a/tests/baselines/reference/typeGuardOnContainerTypeNoHang.symbols
+++ b/tests/baselines/reference/typeGuardOnContainerTypeNoHang.symbols
@@ -9,6 +9,7 @@ export namespace TypeGuards {
 >index : Symbol(index, Decl(typeGuardOnContainerTypeNoHang.ts, 1, 54))
 
         return typeof(value) === 'object'
+>(value) : Symbol(value, Decl(typeGuardOnContainerTypeNoHang.ts, 1, 29))
 >value : Symbol(value, Decl(typeGuardOnContainerTypeNoHang.ts, 1, 29))
     }
 
diff --git a/tests/baselines/reference/typeOfThisInStaticMembers12(target=es2022).symbols b/tests/baselines/reference/typeOfThisInStaticMembers12(target=es2022).symbols
index 16ad5c64fd0..ce9e26e7682 100644
--- a/tests/baselines/reference/typeOfThisInStaticMembers12(target=es2022).symbols
+++ b/tests/baselines/reference/typeOfThisInStaticMembers12(target=es2022).symbols
@@ -7,6 +7,7 @@ class C {
 
     static bar =  class Inner {
 >bar : Symbol(C.bar, Decl(typeOfThisInStaticMembers12.ts, 1, 36))
+>class Inner {        static [this.c] = 123;        [this.c] = 123;    } : Symbol(Inner, Decl(typeOfThisInStaticMembers12.ts, 2, 16))
 >Inner : Symbol(Inner, Decl(typeOfThisInStaticMembers12.ts, 2, 16))
 
         static [this.c] = 123;
diff --git a/tests/baselines/reference/typeOfThisInStaticMembers12(target=es5).symbols b/tests/baselines/reference/typeOfThisInStaticMembers12(target=es5).symbols
index 16ad5c64fd0..ce9e26e7682 100644
--- a/tests/baselines/reference/typeOfThisInStaticMembers12(target=es5).symbols
+++ b/tests/baselines/reference/typeOfThisInStaticMembers12(target=es5).symbols
@@ -7,6 +7,7 @@ class C {
 
     static bar =  class Inner {
 >bar : Symbol(C.bar, Decl(typeOfThisInStaticMembers12.ts, 1, 36))
+>class Inner {        static [this.c] = 123;        [this.c] = 123;    } : Symbol(Inner, Decl(typeOfThisInStaticMembers12.ts, 2, 16))
 >Inner : Symbol(Inner, Decl(typeOfThisInStaticMembers12.ts, 2, 16))
 
         static [this.c] = 123;
diff --git a/tests/baselines/reference/typeOfThisInStaticMembers12(target=es6).symbols b/tests/baselines/reference/typeOfThisInStaticMembers12(target=es6).symbols
index 16ad5c64fd0..ce9e26e7682 100644
--- a/tests/baselines/reference/typeOfThisInStaticMembers12(target=es6).symbols
+++ b/tests/baselines/reference/typeOfThisInStaticMembers12(target=es6).symbols
@@ -7,6 +7,7 @@ class C {
 
     static bar =  class Inner {
 >bar : Symbol(C.bar, Decl(typeOfThisInStaticMembers12.ts, 1, 36))
+>class Inner {        static [this.c] = 123;        [this.c] = 123;    } : Symbol(Inner, Decl(typeOfThisInStaticMembers12.ts, 2, 16))
 >Inner : Symbol(Inner, Decl(typeOfThisInStaticMembers12.ts, 2, 16))
 
         static [this.c] = 123;
diff --git a/tests/baselines/reference/typeOfThisInStaticMembers12(target=esnext).symbols b/tests/baselines/reference/typeOfThisInStaticMembers12(target=esnext).symbols
index 16ad5c64fd0..ce9e26e7682 100644
--- a/tests/baselines/reference/typeOfThisInStaticMembers12(target=esnext).symbols
+++ b/tests/baselines/reference/typeOfThisInStaticMembers12(target=esnext).symbols
@@ -7,6 +7,7 @@ class C {
 
     static bar =  class Inner {
 >bar : Symbol(C.bar, Decl(typeOfThisInStaticMembers12.ts, 1, 36))
+>class Inner {        static [this.c] = 123;        [this.c] = 123;    } : Symbol(Inner, Decl(typeOfThisInStaticMembers12.ts, 2, 16))
 >Inner : Symbol(Inner, Decl(typeOfThisInStaticMembers12.ts, 2, 16))
 
         static [this.c] = 123;
diff --git a/tests/baselines/reference/typeOfThisInStaticMembers13(target=es2022).symbols b/tests/baselines/reference/typeOfThisInStaticMembers13(target=es2022).symbols
index 806a34350b5..77cc1eb4d32 100644
--- a/tests/baselines/reference/typeOfThisInStaticMembers13(target=es2022).symbols
+++ b/tests/baselines/reference/typeOfThisInStaticMembers13(target=es2022).symbols
@@ -7,6 +7,7 @@ class C {
 
     static bar =  class Inner {
 >bar : Symbol(C.bar, Decl(typeOfThisInStaticMembers13.ts, 1, 36))
+>class Inner {        static [this.c] = 123;        [this.c] = 123;    } : Symbol(Inner, Decl(typeOfThisInStaticMembers13.ts, 2, 16))
 >Inner : Symbol(Inner, Decl(typeOfThisInStaticMembers13.ts, 2, 16))
 
         static [this.c] = 123;
diff --git a/tests/baselines/reference/typeOfThisInStaticMembers13(target=es5).symbols b/tests/baselines/reference/typeOfThisInStaticMembers13(target=es5).symbols
index 806a34350b5..77cc1eb4d32 100644
--- a/tests/baselines/reference/typeOfThisInStaticMembers13(target=es5).symbols
+++ b/tests/baselines/reference/typeOfThisInStaticMembers13(target=es5).symbols
@@ -7,6 +7,7 @@ class C {
 
     static bar =  class Inner {
 >bar : Symbol(C.bar, Decl(typeOfThisInStaticMembers13.ts, 1, 36))
+>class Inner {        static [this.c] = 123;        [this.c] = 123;    } : Symbol(Inner, Decl(typeOfThisInStaticMembers13.ts, 2, 16))
 >Inner : Symbol(Inner, Decl(typeOfThisInStaticMembers13.ts, 2, 16))
 
         static [this.c] = 123;
diff --git a/tests/baselines/reference/typeOfThisInStaticMembers13(target=es6).symbols b/tests/baselines/reference/typeOfThisInStaticMembers13(target=es6).symbols
index 806a34350b5..77cc1eb4d32 100644
--- a/tests/baselines/reference/typeOfThisInStaticMembers13(target=es6).symbols
+++ b/tests/baselines/reference/typeOfThisInStaticMembers13(target=es6).symbols
@@ -7,6 +7,7 @@ class C {
 
     static bar =  class Inner {
 >bar : Symbol(C.bar, Decl(typeOfThisInStaticMembers13.ts, 1, 36))
+>class Inner {        static [this.c] = 123;        [this.c] = 123;    } : Symbol(Inner, Decl(typeOfThisInStaticMembers13.ts, 2, 16))
 >Inner : Symbol(Inner, Decl(typeOfThisInStaticMembers13.ts, 2, 16))
 
         static [this.c] = 123;
diff --git a/tests/baselines/reference/typeOfThisInStaticMembers13(target=esnext).symbols b/tests/baselines/reference/typeOfThisInStaticMembers13(target=esnext).symbols
index 806a34350b5..77cc1eb4d32 100644
--- a/tests/baselines/reference/typeOfThisInStaticMembers13(target=esnext).symbols
+++ b/tests/baselines/reference/typeOfThisInStaticMembers13(target=esnext).symbols
@@ -7,6 +7,7 @@ class C {
 
     static bar =  class Inner {
 >bar : Symbol(C.bar, Decl(typeOfThisInStaticMembers13.ts, 1, 36))
+>class Inner {        static [this.c] = 123;        [this.c] = 123;    } : Symbol(Inner, Decl(typeOfThisInStaticMembers13.ts, 2, 16))
 >Inner : Symbol(Inner, Decl(typeOfThisInStaticMembers13.ts, 2, 16))
 
         static [this.c] = 123;
diff --git a/tests/baselines/reference/typeOfThisInStaticMembers7(target=es2022).symbols b/tests/baselines/reference/typeOfThisInStaticMembers7(target=es2022).symbols
index dfc319293d7..44fb934c492 100644
--- a/tests/baselines/reference/typeOfThisInStaticMembers7(target=es2022).symbols
+++ b/tests/baselines/reference/typeOfThisInStaticMembers7(target=es2022).symbols
@@ -27,6 +27,7 @@ class D extends C {
 
     static e = 1 + (super.a) + (this.c + 1) + 1;
 >e : Symbol(D.e, Decl(typeOfThisInStaticMembers7.ts, 7, 26))
+>(super.a) : Symbol(C.a, Decl(typeOfThisInStaticMembers7.ts, 0, 9))
 >super.a : Symbol(C.a, Decl(typeOfThisInStaticMembers7.ts, 0, 9))
 >super : Symbol(C, Decl(typeOfThisInStaticMembers7.ts, 0, 0))
 >a : Symbol(C.a, Decl(typeOfThisInStaticMembers7.ts, 0, 9))
diff --git a/tests/baselines/reference/typeOfThisInStaticMembers7(target=es5).symbols b/tests/baselines/reference/typeOfThisInStaticMembers7(target=es5).symbols
index dfc319293d7..44fb934c492 100644
--- a/tests/baselines/reference/typeOfThisInStaticMembers7(target=es5).symbols
+++ b/tests/baselines/reference/typeOfThisInStaticMembers7(target=es5).symbols
@@ -27,6 +27,7 @@ class D extends C {
 
     static e = 1 + (super.a) + (this.c + 1) + 1;
 >e : Symbol(D.e, Decl(typeOfThisInStaticMembers7.ts, 7, 26))
+>(super.a) : Symbol(C.a, Decl(typeOfThisInStaticMembers7.ts, 0, 9))
 >super.a : Symbol(C.a, Decl(typeOfThisInStaticMembers7.ts, 0, 9))
 >super : Symbol(C, Decl(typeOfThisInStaticMembers7.ts, 0, 0))
 >a : Symbol(C.a, Decl(typeOfThisInStaticMembers7.ts, 0, 9))
diff --git a/tests/baselines/reference/typeOfThisInStaticMembers7(target=es6).symbols b/tests/baselines/reference/typeOfThisInStaticMembers7(target=es6).symbols
index dfc319293d7..44fb934c492 100644
--- a/tests/baselines/reference/typeOfThisInStaticMembers7(target=es6).symbols
+++ b/tests/baselines/reference/typeOfThisInStaticMembers7(target=es6).symbols
@@ -27,6 +27,7 @@ class D extends C {
 
     static e = 1 + (super.a) + (this.c + 1) + 1;
 >e : Symbol(D.e, Decl(typeOfThisInStaticMembers7.ts, 7, 26))
+>(super.a) : Symbol(C.a, Decl(typeOfThisInStaticMembers7.ts, 0, 9))
 >super.a : Symbol(C.a, Decl(typeOfThisInStaticMembers7.ts, 0, 9))
 >super : Symbol(C, Decl(typeOfThisInStaticMembers7.ts, 0, 0))
 >a : Symbol(C.a, Decl(typeOfThisInStaticMembers7.ts, 0, 9))
diff --git a/tests/baselines/reference/typeOfThisInStaticMembers7(target=esnext).symbols b/tests/baselines/reference/typeOfThisInStaticMembers7(target=esnext).symbols
index dfc319293d7..44fb934c492 100644
--- a/tests/baselines/reference/typeOfThisInStaticMembers7(target=esnext).symbols
+++ b/tests/baselines/reference/typeOfThisInStaticMembers7(target=esnext).symbols
@@ -27,6 +27,7 @@ class D extends C {
 
     static e = 1 + (super.a) + (this.c + 1) + 1;
 >e : Symbol(D.e, Decl(typeOfThisInStaticMembers7.ts, 7, 26))
+>(super.a) : Symbol(C.a, Decl(typeOfThisInStaticMembers7.ts, 0, 9))
 >super.a : Symbol(C.a, Decl(typeOfThisInStaticMembers7.ts, 0, 9))
 >super : Symbol(C, Decl(typeOfThisInStaticMembers7.ts, 0, 0))
 >a : Symbol(C.a, Decl(typeOfThisInStaticMembers7.ts, 0, 9))
diff --git a/tests/baselines/reference/typeOfThisInStaticMembers8(target=es2022).symbols b/tests/baselines/reference/typeOfThisInStaticMembers8(target=es2022).symbols
index 6579e0eac2a..30ee967919d 100644
--- a/tests/baselines/reference/typeOfThisInStaticMembers8(target=es2022).symbols
+++ b/tests/baselines/reference/typeOfThisInStaticMembers8(target=es2022).symbols
@@ -16,6 +16,7 @@ class C {
 
     static classExprBoundary = class { a = this.f + 3 };
 >classExprBoundary : Symbol(C.classExprBoundary, Decl(typeOfThisInStaticMembers8.ts, 3, 68))
+>class { a = this.f + 3 } : Symbol((Anonymous class), Decl(typeOfThisInStaticMembers8.ts, 4, 30))
 >a : Symbol((Anonymous class).a, Decl(typeOfThisInStaticMembers8.ts, 4, 38))
 >this : Symbol((Anonymous class), Decl(typeOfThisInStaticMembers8.ts, 4, 30))
 
diff --git a/tests/baselines/reference/typeOfThisInStaticMembers8(target=es5).symbols b/tests/baselines/reference/typeOfThisInStaticMembers8(target=es5).symbols
index 6579e0eac2a..30ee967919d 100644
--- a/tests/baselines/reference/typeOfThisInStaticMembers8(target=es5).symbols
+++ b/tests/baselines/reference/typeOfThisInStaticMembers8(target=es5).symbols
@@ -16,6 +16,7 @@ class C {
 
     static classExprBoundary = class { a = this.f + 3 };
 >classExprBoundary : Symbol(C.classExprBoundary, Decl(typeOfThisInStaticMembers8.ts, 3, 68))
+>class { a = this.f + 3 } : Symbol((Anonymous class), Decl(typeOfThisInStaticMembers8.ts, 4, 30))
 >a : Symbol((Anonymous class).a, Decl(typeOfThisInStaticMembers8.ts, 4, 38))
 >this : Symbol((Anonymous class), Decl(typeOfThisInStaticMembers8.ts, 4, 30))
 
diff --git a/tests/baselines/reference/typeOfThisInStaticMembers8(target=es6).symbols b/tests/baselines/reference/typeOfThisInStaticMembers8(target=es6).symbols
index 6579e0eac2a..30ee967919d 100644
--- a/tests/baselines/reference/typeOfThisInStaticMembers8(target=es6).symbols
+++ b/tests/baselines/reference/typeOfThisInStaticMembers8(target=es6).symbols
@@ -16,6 +16,7 @@ class C {
 
     static classExprBoundary = class { a = this.f + 3 };
 >classExprBoundary : Symbol(C.classExprBoundary, Decl(typeOfThisInStaticMembers8.ts, 3, 68))
+>class { a = this.f + 3 } : Symbol((Anonymous class), Decl(typeOfThisInStaticMembers8.ts, 4, 30))
 >a : Symbol((Anonymous class).a, Decl(typeOfThisInStaticMembers8.ts, 4, 38))
 >this : Symbol((Anonymous class), Decl(typeOfThisInStaticMembers8.ts, 4, 30))
 
diff --git a/tests/baselines/reference/typeOfThisInStaticMembers8(target=esnext).symbols b/tests/baselines/reference/typeOfThisInStaticMembers8(target=esnext).symbols
index 6579e0eac2a..30ee967919d 100644
--- a/tests/baselines/reference/typeOfThisInStaticMembers8(target=esnext).symbols
+++ b/tests/baselines/reference/typeOfThisInStaticMembers8(target=esnext).symbols
@@ -16,6 +16,7 @@ class C {
 
     static classExprBoundary = class { a = this.f + 3 };
 >classExprBoundary : Symbol(C.classExprBoundary, Decl(typeOfThisInStaticMembers8.ts, 3, 68))
+>class { a = this.f + 3 } : Symbol((Anonymous class), Decl(typeOfThisInStaticMembers8.ts, 4, 30))
 >a : Symbol((Anonymous class).a, Decl(typeOfThisInStaticMembers8.ts, 4, 38))
 >this : Symbol((Anonymous class), Decl(typeOfThisInStaticMembers8.ts, 4, 30))
 
diff --git a/tests/baselines/reference/typeOfThisInStaticMembers9(target=es2022).symbols b/tests/baselines/reference/typeOfThisInStaticMembers9(target=es2022).symbols
index 15dd3c13164..306304502d2 100644
--- a/tests/baselines/reference/typeOfThisInStaticMembers9(target=es2022).symbols
+++ b/tests/baselines/reference/typeOfThisInStaticMembers9(target=es2022).symbols
@@ -21,6 +21,7 @@ class D extends C {
 
     static classExprBoundary = class { a = super.f + 3 };
 >classExprBoundary : Symbol(D.classExprBoundary, Decl(typeOfThisInStaticMembers9.ts, 6, 69))
+>class { a = super.f + 3 } : Symbol((Anonymous class), Decl(typeOfThisInStaticMembers9.ts, 7, 30))
 >a : Symbol((Anonymous class).a, Decl(typeOfThisInStaticMembers9.ts, 7, 38))
 
     static functionAndClassDeclBoundary = (() => {
diff --git a/tests/baselines/reference/typeOfThisInStaticMembers9(target=es5).symbols b/tests/baselines/reference/typeOfThisInStaticMembers9(target=es5).symbols
index 15dd3c13164..306304502d2 100644
--- a/tests/baselines/reference/typeOfThisInStaticMembers9(target=es5).symbols
+++ b/tests/baselines/reference/typeOfThisInStaticMembers9(target=es5).symbols
@@ -21,6 +21,7 @@ class D extends C {
 
     static classExprBoundary = class { a = super.f + 3 };
 >classExprBoundary : Symbol(D.classExprBoundary, Decl(typeOfThisInStaticMembers9.ts, 6, 69))
+>class { a = super.f + 3 } : Symbol((Anonymous class), Decl(typeOfThisInStaticMembers9.ts, 7, 30))
 >a : Symbol((Anonymous class).a, Decl(typeOfThisInStaticMembers9.ts, 7, 38))
 
     static functionAndClassDeclBoundary = (() => {
diff --git a/tests/baselines/reference/typeOfThisInStaticMembers9(target=es6).symbols b/tests/baselines/reference/typeOfThisInStaticMembers9(target=es6).symbols
index 15dd3c13164..306304502d2 100644
--- a/tests/baselines/reference/typeOfThisInStaticMembers9(target=es6).symbols
+++ b/tests/baselines/reference/typeOfThisInStaticMembers9(target=es6).symbols
@@ -21,6 +21,7 @@ class D extends C {
 
     static classExprBoundary = class { a = super.f + 3 };
 >classExprBoundary : Symbol(D.classExprBoundary, Decl(typeOfThisInStaticMembers9.ts, 6, 69))
+>class { a = super.f + 3 } : Symbol((Anonymous class), Decl(typeOfThisInStaticMembers9.ts, 7, 30))
 >a : Symbol((Anonymous class).a, Decl(typeOfThisInStaticMembers9.ts, 7, 38))
 
     static functionAndClassDeclBoundary = (() => {
diff --git a/tests/baselines/reference/typeOfThisInStaticMembers9(target=esnext).symbols b/tests/baselines/reference/typeOfThisInStaticMembers9(target=esnext).symbols
index 15dd3c13164..306304502d2 100644
--- a/tests/baselines/reference/typeOfThisInStaticMembers9(target=esnext).symbols
+++ b/tests/baselines/reference/typeOfThisInStaticMembers9(target=esnext).symbols
@@ -21,6 +21,7 @@ class D extends C {
 
     static classExprBoundary = class { a = super.f + 3 };
 >classExprBoundary : Symbol(D.classExprBoundary, Decl(typeOfThisInStaticMembers9.ts, 6, 69))
+>class { a = super.f + 3 } : Symbol((Anonymous class), Decl(typeOfThisInStaticMembers9.ts, 7, 30))
 >a : Symbol((Anonymous class).a, Decl(typeOfThisInStaticMembers9.ts, 7, 38))
 
     static functionAndClassDeclBoundary = (() => {
diff --git a/tests/baselines/reference/typedefCrossModule2.symbols b/tests/baselines/reference/typedefCrossModule2.symbols
index adea03ca980..2e39f67170a 100644
--- a/tests/baselines/reference/typedefCrossModule2.symbols
+++ b/tests/baselines/reference/typedefCrossModule2.symbols
@@ -28,6 +28,7 @@ exports.Bar = class { }
 >exports.Bar : Symbol(Bar, Decl(mod1.js, 3, 13), Decl(mod1.js, 5, 4))
 >exports : Symbol(Bar, Decl(mod1.js, 3, 13), Decl(mod1.js, 5, 4))
 >Bar : Symbol(Bar, Decl(mod1.js, 3, 13), Decl(mod1.js, 5, 4))
+>class { } : Symbol(Bar, Decl(mod1.js, 6, 13))
 
 /** @typedef {number} Baz */
 module.exports = {
@@ -37,6 +38,7 @@ module.exports = {
 
     Baz: class { }
 >Baz : Symbol(Baz, Decl(mod1.js, 9, 18))
+>class { } : Symbol(Baz, Decl(mod1.js, 10, 8))
 }
 
 // ok
diff --git a/tests/baselines/reference/typedefCrossModule3.symbols b/tests/baselines/reference/typedefCrossModule3.symbols
index 1cb42970940..34bb409dc55 100644
--- a/tests/baselines/reference/typedefCrossModule3.symbols
+++ b/tests/baselines/reference/typedefCrossModule3.symbols
@@ -7,6 +7,7 @@ ns.Foo = class {}
 >ns.Foo : Symbol(Foo, Decl(mod2.js, 1, 14), Decl(mod2.js, 0, 4))
 >ns : Symbol(ns, Decl(mod2.js, 1, 5), Decl(mod2.js, 1, 14))
 >Foo : Symbol(Foo, Decl(mod2.js, 1, 14), Decl(mod2.js, 0, 4))
+>class {} : Symbol(Foo, Decl(mod2.js, 2, 8))
 
 module.exports = ns;
 >module.exports : Symbol(module.exports, Decl(mod2.js, 0, 0))
diff --git a/tests/baselines/reference/uncalledFunctionChecksInConditionalPerf.symbols b/tests/baselines/reference/uncalledFunctionChecksInConditionalPerf.symbols
index 1e4d10c56f3..504aa13f0cd 100644
--- a/tests/baselines/reference/uncalledFunctionChecksInConditionalPerf.symbols
+++ b/tests/baselines/reference/uncalledFunctionChecksInConditionalPerf.symbols
@@ -3,6 +3,7 @@ declare const b: boolean;
 >b : Symbol(b, Decl(uncalledFunctionChecksInConditionalPerf.ts, 0, 13))
 
 ((((((((((((((((((((((((((b) && b) && b) && b) && b) && b) && b) && b) && b) && b) && b) && b) && b) && b) && b) && b) && b) && b) && b) && b) && b) && b) && b) && b) && b) && b);
+>(b) : Symbol(b, Decl(uncalledFunctionChecksInConditionalPerf.ts, 0, 13))
 >b : Symbol(b, Decl(uncalledFunctionChecksInConditionalPerf.ts, 0, 13))
 >b : Symbol(b, Decl(uncalledFunctionChecksInConditionalPerf.ts, 0, 13))
 >b : Symbol(b, Decl(uncalledFunctionChecksInConditionalPerf.ts, 0, 13))
diff --git a/tests/baselines/reference/uniqueSymbols.symbols b/tests/baselines/reference/uniqueSymbols.symbols
index 6b75247727a..8ab60b3ff60 100644
--- a/tests/baselines/reference/uniqueSymbols.symbols
+++ b/tests/baselines/reference/uniqueSymbols.symbols
@@ -829,6 +829,7 @@ const o4 = {
 
 const ce0 = class {
 >ce0 : Symbol(ce0, Decl(uniqueSymbols.ts, 254, 5))
+>class {    method1(p: typeof s): typeof s {        return p;    }    method2(p: I["readonlyType"]): I["readonlyType"] {        return p;    }} : Symbol(ce0, Decl(uniqueSymbols.ts, 254, 11))
 
     method1(p: typeof s): typeof s {
 >method1 : Symbol(ce0.method1, Decl(uniqueSymbols.ts, 254, 19))
diff --git a/tests/baselines/reference/uniqueSymbolsDeclarationsErrors.symbols b/tests/baselines/reference/uniqueSymbolsDeclarationsErrors.symbols
index 9e948fb3420..265b7ed11e7 100644
--- a/tests/baselines/reference/uniqueSymbolsDeclarationsErrors.symbols
+++ b/tests/baselines/reference/uniqueSymbolsDeclarationsErrors.symbols
@@ -34,6 +34,7 @@ export const obj = {
 
 export const classExpression = class {
 >classExpression : Symbol(classExpression, Decl(uniqueSymbolsDeclarationsErrors.ts, 14, 12))
+>class {    method1(p: typeof s): typeof s {        return p;    }    method2(p: I["readonlyType"]): I["readonlyType"] {        return p;    }} : Symbol(classExpression, Decl(uniqueSymbolsDeclarationsErrors.ts, 14, 30))
 
     method1(p: typeof s): typeof s {
 >method1 : Symbol(classExpression.method1, Decl(uniqueSymbolsDeclarationsErrors.ts, 14, 38))
diff --git a/tests/baselines/reference/unusedLocalsAndParameters.symbols b/tests/baselines/reference/unusedLocalsAndParameters.symbols
index f8cf1503eea..7bb58d9e3b2 100644
--- a/tests/baselines/reference/unusedLocalsAndParameters.symbols
+++ b/tests/baselines/reference/unusedLocalsAndParameters.symbols
@@ -43,6 +43,7 @@ class C {
 
 var E = class {
 >E : Symbol(E, Decl(unusedLocalsAndParameters.ts, 26, 3))
+>class {    // Method declaration paramter    method(a) {    }    // Accessor declaration paramter    set x(v: number) {    }} : Symbol(E, Decl(unusedLocalsAndParameters.ts, 26, 7))
 
     // Method declaration paramter
     method(a) {
@@ -137,6 +138,7 @@ for (let x: y) {
 
     z(x);
 >z : Symbol(z, Decl(unusedLocalsAndParameters.ts, 82, 16))
+>(x) : Symbol(x, Decl(unusedLocalsAndParameters.ts, 82, 8))
 >x : Symbol(x, Decl(unusedLocalsAndParameters.ts, 82, 8))
 }
 
diff --git a/tests/baselines/reference/unusedLocalsAndParametersDeferred.symbols b/tests/baselines/reference/unusedLocalsAndParametersDeferred.symbols
index 19da604a124..4530df17697 100644
--- a/tests/baselines/reference/unusedLocalsAndParametersDeferred.symbols
+++ b/tests/baselines/reference/unusedLocalsAndParametersDeferred.symbols
@@ -111,6 +111,7 @@ let prop2;
 
 var E = class {
 >E : Symbol(E, Decl(unusedLocalsAndParametersDeferred.ts, 55, 3))
+>class {    // Method declaration paramter    method(a) {        defered(() => {            a;        });    }    // Accessor declaration paramter    set x(v: number) {        defered(() => {            v;        });    }    // in a property initalizer    p = defered(() => {        prop2;    });} : Symbol(E, Decl(unusedLocalsAndParametersDeferred.ts, 55, 7))
 
     // Method declaration paramter
     method(a) {
diff --git a/tests/baselines/reference/useBeforeDeclaration_propertyAssignment.symbols b/tests/baselines/reference/useBeforeDeclaration_propertyAssignment.symbols
index 7c8acfc5375..21c76cdfed2 100644
--- a/tests/baselines/reference/useBeforeDeclaration_propertyAssignment.symbols
+++ b/tests/baselines/reference/useBeforeDeclaration_propertyAssignment.symbols
@@ -35,6 +35,7 @@ class D {
 
     static A = class extends D.B {
 >A : Symbol(D.A, Decl(useBeforeDeclaration_propertyAssignment.ts, 6, 9))
+>class extends D.B {        [D.D]() {} // should be an error    } : Symbol((Anonymous class), Decl(useBeforeDeclaration_propertyAssignment.ts, 7, 14))
 >D.B : Symbol(D.B, Decl(useBeforeDeclaration_propertyAssignment.ts, 9, 5))
 >D : Symbol(D, Decl(useBeforeDeclaration_propertyAssignment.ts, 4, 1))
 >B : Symbol(D.B, Decl(useBeforeDeclaration_propertyAssignment.ts, 9, 5))
@@ -47,6 +48,7 @@ class D {
     }
     static B = class {}
 >B : Symbol(D.B, Decl(useBeforeDeclaration_propertyAssignment.ts, 9, 5))
+>class {} : Symbol((Anonymous class), Decl(useBeforeDeclaration_propertyAssignment.ts, 10, 14))
 
     static C = {
 >C : Symbol(D.C, Decl(useBeforeDeclaration_propertyAssignment.ts, 10, 23))
diff --git a/tests/baselines/reference/varianceAnnotations.symbols b/tests/baselines/reference/varianceAnnotations.symbols
index a000fe43e79..c02dbcdf1b7 100644
--- a/tests/baselines/reference/varianceAnnotations.symbols
+++ b/tests/baselines/reference/varianceAnnotations.symbols
@@ -452,6 +452,7 @@ createMachine<{ type: "PLAY"; value: number } | { type: "RESET" }>(qq);  // Erro
 
 let Anon = class <out T> {
 >Anon : Symbol(Anon, Decl(varianceAnnotations.ts, 163, 3))
+>class <out T> {    foo(): InstanceType<(typeof Anon<T>)> {        return this;    }} : Symbol(Anon, Decl(varianceAnnotations.ts, 163, 10))
 >T : Symbol(T, Decl(varianceAnnotations.ts, 163, 18))
 
     foo(): InstanceType<(typeof Anon<T>)> {
@@ -467,6 +468,7 @@ let Anon = class <out T> {
 
 let OuterC = class C<out T> {
 >OuterC : Symbol(OuterC, Decl(varianceAnnotations.ts, 169, 3))
+>class C<out T> {    foo(): C<T> {        return this;    }} : Symbol(C, Decl(varianceAnnotations.ts, 169, 12))
 >C : Symbol(C, Decl(varianceAnnotations.ts, 169, 12))
 >T : Symbol(T, Decl(varianceAnnotations.ts, 169, 21))