From 428d327728cfe2ad1399db2ed9b4f1c95db3667c Mon Sep 17 00:00:00 2001 From: Ron Buckton Date: Mon, 23 Oct 2023 20:28:20 -0400 Subject: [PATCH 1/4] Fix incorrect flags in modifierFlagsCache --- src/compiler/types.ts | 16 +++++---- src/compiler/utilities.ts | 36 +++++++++++++++++-- src/testRunner/unittests/publicApi.ts | 31 ++++++++++++++++ tests/baselines/reference/api/typescript.d.ts | 22 ++++++------ ...CompilationPublicParameterModifier.symbols | 2 +- 5 files changed, 86 insertions(+), 21 deletions(-) diff --git a/src/compiler/types.ts b/src/compiler/types.ts index 3a45f9e277642..4edada99e16cc 100644 --- a/src/compiler/types.ts +++ b/src/compiler/types.ts @@ -863,13 +863,14 @@ export const enum ModifierFlags { Async = 1 << 9, // Property/Method/Function Default = 1 << 10, // Function/Class (export default declaration) Const = 1 << 11, // Const enum - HasComputedJSDocModifiers = 1 << 12, // Indicates the computed modifier flags include modifiers from JSDoc. - - Deprecated = 1 << 13, // Deprecated tag. - Override = 1 << 14, // Override method. - In = 1 << 15, // Contravariance modifier - Out = 1 << 16, // Covariance modifier - Decorator = 1 << 17, // Contains a decorator. + Deprecated = 1 << 12, // Deprecated tag. + Override = 1 << 13, // Override method. + In = 1 << 14, // Contravariance modifier + Out = 1 << 15, // Covariance modifier + Decorator = 1 << 16, // Contains a decorator. + + HasComputedJSDocModifiers = 1 << 27, // Indicates the computed modifier flags include modifiers from JSDoc. + HasExcessJDocModifiers = 1 << 28, // Indicates that there are JSDoc modifiers that are not in the cache and must be recalculated. For use with nodes in TS files only. HasComputedFlags = 1 << 29, // Modifier flags have been computed AccessibilityModifier = Public | Private | Protected, @@ -878,6 +879,7 @@ export const enum ModifierFlags { NonPublicAccessibilityModifier = Private | Protected, TypeScriptModifier = Ambient | Public | Private | Protected | Readonly | Abstract | Const | Override | In | Out, + JSDocOnlyModifier = Deprecated, ExportDefault = Export | Default, All = Export | Ambient | Public | Private | Protected | Static | Readonly | Abstract | Accessor | Async | Default | Const | Deprecated | Override | In | Out | Decorator, Modifier = All & ~Decorator, diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts index 0d1e4a4ac6836..e2f2f0a713052 100644 --- a/src/compiler/utilities.ts +++ b/src/compiler/utilities.ts @@ -6924,15 +6924,45 @@ function getModifierFlagsWorker(node: Node, includeJSDoc: boolean, alwaysInclude return ModifierFlags.None; } + // Calculate the modifier flags for a given node, and cache them based on the file containing the node. + // For a TypeScript file, the cache will only contain syntactic modifiers and potentially the `Deprecated` JSDoc modifier. + // For a JavaScript file, the cache will contain both syntactic and JSDoc modifiers. + if (!(node.modifierFlagsCache & ModifierFlags.HasComputedFlags)) { node.modifierFlagsCache = getSyntacticModifierFlagsNoCache(node) | ModifierFlags.HasComputedFlags; } - if (includeJSDoc && !(node.modifierFlagsCache & ModifierFlags.HasComputedJSDocModifiers) && (alwaysIncludeJSDoc || isInJSFile(node)) && node.parent) { - node.modifierFlagsCache |= getJSDocModifierFlagsNoCache(node) | ModifierFlags.HasComputedJSDocModifiers; + let jsdocModifierFlags: ModifierFlags | undefined; + if (includeJSDoc && !(node.modifierFlagsCache & ModifierFlags.HasComputedJSDocModifiers) && node.parent) { + jsdocModifierFlags = getJSDocModifierFlagsNoCache(node); + if (isInJSFile(node)) { + node.modifierFlagsCache |= jsdocModifierFlags | ModifierFlags.HasComputedJSDocModifiers; + } + else { + node.modifierFlagsCache |= (jsdocModifierFlags & ModifierFlags.Deprecated) | ModifierFlags.HasComputedJSDocModifiers; + if (jsdocModifierFlags & ~node.modifierFlagsCache & ~ModifierFlags.Deprecated) { + // If there are other JSDoc modifiers aside from `@deprecated` that aren't also in the set of syntactic modifiers for the node, + // we can add a flag indicating we need to recompute JSDoc modifiers when `alwaysIncludeJSDoc` is true. + node.modifierFlagsCache |= ModifierFlags.HasExcessJDocModifiers; + } + } } - return node.modifierFlagsCache & ~(ModifierFlags.HasComputedFlags | ModifierFlags.HasComputedJSDocModifiers); + const modifiers = node.modifierFlagsCache & ~(ModifierFlags.HasComputedFlags | ModifierFlags.HasComputedJSDocModifiers | ModifierFlags.HasExcessJDocModifiers); + if (includeJSDoc || alwaysIncludeJSDoc) { + if (!isInJSFile(node) && alwaysIncludeJSDoc && node.modifierFlagsCache & ModifierFlags.HasExcessJDocModifiers) { + // If we are requesting JSDoc modifiers in a TS file, we only need to recalculate additional JSDoc modifiers if the cache indicates there are any to find. + // We recalculate the JSDoc modifiers since they may overlap with the syntactic modifiers in the cache. While this isn't as efficient as caching the modifiers, + // it is rare to use JSDoc for modifiers like `@private` in a TS file. + jsdocModifierFlags ??= getJSDocModifierFlagsNoCache(node); + return modifiers | jsdocModifierFlags; + } + return modifiers; + } + else { + // We are requesting only syntactic modifiers. filter out any JSDoc modifiers in the cache. + return (isInJSFile(node) ? modifiers & ~ModifierFlags.TypeScriptModifier : modifiers) & ~ModifierFlags.JSDocOnlyModifier; + } } /** diff --git a/src/testRunner/unittests/publicApi.ts b/src/testRunner/unittests/publicApi.ts index 7fb4fb096c122..1b5ab93f0a187 100644 --- a/src/testRunner/unittests/publicApi.ts +++ b/src/testRunner/unittests/publicApi.ts @@ -231,3 +231,34 @@ describe("unittests:: Public APIs:: getChild* methods on EndOfFileToken with JSD assert.notEqual(endOfFileToken.getChildAt(0), /*expected*/ undefined); }); }); + +describe("unittests:: Public APIs:: get syntactic and effective modifiers", () => { + it("caches and reports correct flags in TS file", () => { + // https://github.com/microsoft/TypeScript/issues/42189 + const content = ` +class C { + /** @private */ + prop = 1; +}`; + const sourceFile = ts.createSourceFile("/file.ts", content, ts.ScriptTarget.ESNext, /*setParentNodes*/ true); + const classNode = sourceFile.statements[0] as ts.ClassDeclaration; + const propNode = classNode.members[0] as ts.PropertyDeclaration; + assert.equal(ts.ModifierFlags.None, ts.getSyntacticModifierFlags(propNode)); + assert.equal(ts.ModifierFlags.None, ts.getEffectiveModifierFlags(propNode)); + assert.equal(ts.ModifierFlags.None, ts.getSyntacticModifierFlags(propNode)); + }); + it("caches and reports correct flags in JS file", () => { + // https://github.com/microsoft/TypeScript/issues/42189 + const content = ` +class C { + /** @private */ + prop = 1; +}`; + const sourceFile = ts.createSourceFile("/file.js", content, ts.ScriptTarget.ESNext, /*setParentNodes*/ true); + const classNode = sourceFile.statements[0] as ts.ClassDeclaration; + const propNode = classNode.members[0] as ts.PropertyDeclaration; + assert.equal(ts.ModifierFlags.None, ts.getSyntacticModifierFlags(propNode)); + assert.equal(ts.ModifierFlags.Private, ts.getEffectiveModifierFlags(propNode)); + assert.equal(ts.ModifierFlags.None, ts.getSyntacticModifierFlags(propNode)); + }); +}); diff --git a/tests/baselines/reference/api/typescript.d.ts b/tests/baselines/reference/api/typescript.d.ts index d785077fd9e4e..678e7549fa00e 100644 --- a/tests/baselines/reference/api/typescript.d.ts +++ b/tests/baselines/reference/api/typescript.d.ts @@ -4764,20 +4764,22 @@ declare namespace ts { Async = 512, Default = 1024, Const = 2048, - HasComputedJSDocModifiers = 4096, - Deprecated = 8192, - Override = 16384, - In = 32768, - Out = 65536, - Decorator = 131072, + Deprecated = 4096, + Override = 8192, + In = 16384, + Out = 32768, + Decorator = 65536, + HasComputedJSDocModifiers = 134217728, + HasExcessJDocModifiers = 268435456, HasComputedFlags = 536870912, AccessibilityModifier = 28, - ParameterPropertyModifier = 16476, + ParameterPropertyModifier = 8284, NonPublicAccessibilityModifier = 24, - TypeScriptModifier = 117086, + TypeScriptModifier = 59742, + JSDocOnlyModifier = 4096, ExportDefault = 1025, - All = 258047, - Modifier = 126975, + All = 131071, + Modifier = 65535, } enum JsxFlags { None = 0, diff --git a/tests/baselines/reference/jsFileCompilationPublicParameterModifier.symbols b/tests/baselines/reference/jsFileCompilationPublicParameterModifier.symbols index 5e05e4a172d88..fa17c0e79166d 100644 --- a/tests/baselines/reference/jsFileCompilationPublicParameterModifier.symbols +++ b/tests/baselines/reference/jsFileCompilationPublicParameterModifier.symbols @@ -3,5 +3,5 @@ === a.js === class C { constructor(public x) { }} >C : Symbol(C, Decl(a.js, 0, 0)) ->x : Symbol(C.x, Decl(a.js, 0, 22)) +>x : Symbol(x, Decl(a.js, 0, 22)) From 6a48508b7b8736fb868fe9bd41c914c365fd7de3 Mon Sep 17 00:00:00 2001 From: Ron Buckton Date: Tue, 24 Oct 2023 10:59:16 -0400 Subject: [PATCH 2/4] Use effective 'override' modifier in fixSpelling codefix --- src/services/codefixes/fixSpelling.ts | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/src/services/codefixes/fixSpelling.ts b/src/services/codefixes/fixSpelling.ts index 687c16cbb9915..ede869cfea944 100644 --- a/src/services/codefixes/fixSpelling.ts +++ b/src/services/codefixes/fixSpelling.ts @@ -10,7 +10,7 @@ import { getModeForUsageLocation, getTextOfNode, getTokenAtPosition, - hasSyntacticModifier, + hasOverrideModifier, ImportDeclaration, isBinaryExpression, isClassElement, @@ -27,7 +27,6 @@ import { isPropertyAccessExpression, isQualifiedName, isStringLiteralLike, - ModifierFlags, Node, NodeFlags, ScriptTarget, @@ -131,7 +130,7 @@ function getInfo(sourceFile: SourceFile, pos: number, context: CodeFixContextBas const props = checker.getContextualTypeForArgumentAtIndex(tag, 0); suggestedSymbol = checker.getSuggestedSymbolForNonexistentJSXAttribute(node, props!); } - else if (hasSyntacticModifier(parent, ModifierFlags.Override) && isClassElement(parent) && parent.name === node) { + else if (hasOverrideModifier(parent) && isClassElement(parent) && parent.name === node) { const baseDeclaration = findAncestor(node, isClassLike); const baseTypeNode = baseDeclaration ? getEffectiveBaseTypeNode(baseDeclaration) : undefined; const baseType = baseTypeNode ? checker.getTypeAtLocation(baseTypeNode) : undefined; From f4253de2b7ba2509b986366c7c4638942ae8bebd Mon Sep 17 00:00:00 2001 From: Ron Buckton Date: Tue, 24 Oct 2023 13:15:46 -0400 Subject: [PATCH 3/4] Give JSDoc-provided modifiers their own entries in ModifierFlags --- src/compiler/types.ts | 60 +++++++++++------- src/compiler/utilities.ts | 62 +++++++------------ tests/baselines/reference/api/typescript.d.ts | 50 +++++++-------- ...CompilationPublicParameterModifier.symbols | 2 +- 4 files changed, 88 insertions(+), 86 deletions(-) diff --git a/src/compiler/types.ts b/src/compiler/types.ts index 4edada99e16cc..a74b4ba0d9e70 100644 --- a/src/compiler/types.ts +++ b/src/compiler/types.ts @@ -851,26 +851,45 @@ export const enum NodeFlags { // dprint-ignore export const enum ModifierFlags { None = 0, - Export = 1 << 0, // Declarations - Ambient = 1 << 1, // Declarations - Public = 1 << 2, // Property/Method - Private = 1 << 3, // Property/Method - Protected = 1 << 4, // Property/Method - Static = 1 << 5, // Property/Method - Readonly = 1 << 6, // Property/Method - Accessor = 1 << 7, // Property - Abstract = 1 << 8, // Class/Method/ConstructSignature - Async = 1 << 9, // Property/Method/Function - Default = 1 << 10, // Function/Class (export default declaration) - Const = 1 << 11, // Const enum - Deprecated = 1 << 12, // Deprecated tag. - Override = 1 << 13, // Override method. - In = 1 << 14, // Contravariance modifier - Out = 1 << 15, // Covariance modifier - Decorator = 1 << 16, // Contains a decorator. - - HasComputedJSDocModifiers = 1 << 27, // Indicates the computed modifier flags include modifiers from JSDoc. - HasExcessJDocModifiers = 1 << 28, // Indicates that there are JSDoc modifiers that are not in the cache and must be recalculated. For use with nodes in TS files only. + + // Syntactic/JSDoc modifiers + Public = 1 << 0, // Property/Method + Private = 1 << 1, // Property/Method + Protected = 1 << 2, // Property/Method + Readonly = 1 << 3, // Property/Method + Override = 1 << 4, // Override method. + + // Syntactic-only modifiers + Export = 1 << 5, // Declarations + Abstract = 1 << 6, // Class/Method/ConstructSignature + Ambient = 1 << 7, // Declarations + Static = 1 << 8, // Property/Method + Accessor = 1 << 9, // Property + Async = 1 << 10, // Property/Method/Function + Default = 1 << 11, // Function/Class (export default declaration) + Const = 1 << 12, // Const enum + In = 1 << 13, // Contravariance modifier + Out = 1 << 14, // Covariance modifier + Decorator = 1 << 15, // Contains a decorator. + + // JSDoc-only modifiers + Deprecated = 1 << 16, // Deprecated tag. + + // Cache-only JSDoc-modifiers. Should match order of Syntactic/JSDoc modifiers, above. + /** @internal */ JSDocPublic = 1 << 23, // if this value changes, `adjustJSDocModifierFlags` must change accordingly + /** @internal */ JSDocPrivate = 1 << 24, + /** @internal */ JSDocProtected = 1 << 25, + /** @internal */ JSDocReadonly = 1 << 26, + /** @internal */ JSDocOverride = 1 << 27, + + /** @internal */ SyntacticOrJSDocModifiers = Public | Private | Protected | Readonly | Override, + /** @internal */ SyntacticOnlyModifiers = Export | Ambient | Abstract | Static | Accessor | Async | Default | Const | In | Out | Decorator, + /** @internal */ SyntacticModifiers = SyntacticOrJSDocModifiers | SyntacticOnlyModifiers, + /** @internal */ JSDocCacheOnlyModifiers = JSDocPublic | JSDocPrivate | JSDocProtected | JSDocReadonly | JSDocOverride, + /** @internal */ JSDocOnlyModifiers = Deprecated, + /** @internal */ NonCacheOnlyModifiers = SyntacticOrJSDocModifiers | SyntacticOnlyModifiers | JSDocOnlyModifiers, + + HasComputedJSDocModifiers = 1 << 28, // Indicates the computed modifier flags include modifiers from JSDoc. HasComputedFlags = 1 << 29, // Modifier flags have been computed AccessibilityModifier = Public | Private | Protected, @@ -879,7 +898,6 @@ export const enum ModifierFlags { NonPublicAccessibilityModifier = Private | Protected, TypeScriptModifier = Ambient | Public | Private | Protected | Readonly | Abstract | Const | Override | In | Out, - JSDocOnlyModifier = Deprecated, ExportDefault = Export | Default, All = Export | Ambient | Public | Private | Protected | Static | Readonly | Abstract | Accessor | Async | Default | Const | Deprecated | Override | In | Out | Decorator, Modifier = All & ~Decorator, diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts index e2f2f0a713052..ac4e6cb95d575 100644 --- a/src/compiler/utilities.ts +++ b/src/compiler/utilities.ts @@ -6924,45 +6924,18 @@ function getModifierFlagsWorker(node: Node, includeJSDoc: boolean, alwaysInclude return ModifierFlags.None; } - // Calculate the modifier flags for a given node, and cache them based on the file containing the node. - // For a TypeScript file, the cache will only contain syntactic modifiers and potentially the `Deprecated` JSDoc modifier. - // For a JavaScript file, the cache will contain both syntactic and JSDoc modifiers. - if (!(node.modifierFlagsCache & ModifierFlags.HasComputedFlags)) { node.modifierFlagsCache = getSyntacticModifierFlagsNoCache(node) | ModifierFlags.HasComputedFlags; } - let jsdocModifierFlags: ModifierFlags | undefined; - if (includeJSDoc && !(node.modifierFlagsCache & ModifierFlags.HasComputedJSDocModifiers) && node.parent) { - jsdocModifierFlags = getJSDocModifierFlagsNoCache(node); - if (isInJSFile(node)) { - node.modifierFlagsCache |= jsdocModifierFlags | ModifierFlags.HasComputedJSDocModifiers; - } - else { - node.modifierFlagsCache |= (jsdocModifierFlags & ModifierFlags.Deprecated) | ModifierFlags.HasComputedJSDocModifiers; - if (jsdocModifierFlags & ~node.modifierFlagsCache & ~ModifierFlags.Deprecated) { - // If there are other JSDoc modifiers aside from `@deprecated` that aren't also in the set of syntactic modifiers for the node, - // we can add a flag indicating we need to recompute JSDoc modifiers when `alwaysIncludeJSDoc` is true. - node.modifierFlagsCache |= ModifierFlags.HasExcessJDocModifiers; - } + if (alwaysIncludeJSDoc || includeJSDoc && isInJSFile(node)) { + if (!(node.modifierFlagsCache & ModifierFlags.HasComputedJSDocModifiers) && node.parent) { + node.modifierFlagsCache |= getRawJSDocModifierFlagsNoCache(node) | ModifierFlags.HasComputedJSDocModifiers; } + return selectEffectiveModifierFlags(node.modifierFlagsCache); } - const modifiers = node.modifierFlagsCache & ~(ModifierFlags.HasComputedFlags | ModifierFlags.HasComputedJSDocModifiers | ModifierFlags.HasExcessJDocModifiers); - if (includeJSDoc || alwaysIncludeJSDoc) { - if (!isInJSFile(node) && alwaysIncludeJSDoc && node.modifierFlagsCache & ModifierFlags.HasExcessJDocModifiers) { - // If we are requesting JSDoc modifiers in a TS file, we only need to recalculate additional JSDoc modifiers if the cache indicates there are any to find. - // We recalculate the JSDoc modifiers since they may overlap with the syntactic modifiers in the cache. While this isn't as efficient as caching the modifiers, - // it is rare to use JSDoc for modifiers like `@private` in a TS file. - jsdocModifierFlags ??= getJSDocModifierFlagsNoCache(node); - return modifiers | jsdocModifierFlags; - } - return modifiers; - } - else { - // We are requesting only syntactic modifiers. filter out any JSDoc modifiers in the cache. - return (isInJSFile(node) ? modifiers & ~ModifierFlags.TypeScriptModifier : modifiers) & ~ModifierFlags.JSDocOnlyModifier; - } + return selectSyntacticModifierFlags(node.modifierFlagsCache); } /** @@ -6992,15 +6965,15 @@ export function getSyntacticModifierFlags(node: Node): ModifierFlags { return getModifierFlagsWorker(node, /*includeJSDoc*/ false); } -function getJSDocModifierFlagsNoCache(node: Node): ModifierFlags { +function getRawJSDocModifierFlagsNoCache(node: Node): ModifierFlags { let flags = ModifierFlags.None; if (!!node.parent && !isParameter(node)) { if (isInJSFile(node)) { - if (getJSDocPublicTagNoCache(node)) flags |= ModifierFlags.Public; - if (getJSDocPrivateTagNoCache(node)) flags |= ModifierFlags.Private; - if (getJSDocProtectedTagNoCache(node)) flags |= ModifierFlags.Protected; - if (getJSDocReadonlyTagNoCache(node)) flags |= ModifierFlags.Readonly; - if (getJSDocOverrideTagNoCache(node)) flags |= ModifierFlags.Override; + if (getJSDocPublicTagNoCache(node)) flags |= ModifierFlags.JSDocPublic; + if (getJSDocPrivateTagNoCache(node)) flags |= ModifierFlags.JSDocPrivate; + if (getJSDocProtectedTagNoCache(node)) flags |= ModifierFlags.JSDocProtected; + if (getJSDocReadonlyTagNoCache(node)) flags |= ModifierFlags.JSDocReadonly; + if (getJSDocOverrideTagNoCache(node)) flags |= ModifierFlags.JSDocOverride; } if (getJSDocDeprecatedTagNoCache(node)) flags |= ModifierFlags.Deprecated; } @@ -7008,6 +6981,19 @@ function getJSDocModifierFlagsNoCache(node: Node): ModifierFlags { return flags; } +function selectSyntacticModifierFlags(flags: ModifierFlags) { + return flags & ModifierFlags.SyntacticModifiers; +} + +function selectEffectiveModifierFlags(flags: ModifierFlags) { + return (flags & ModifierFlags.NonCacheOnlyModifiers) | + ((flags & ModifierFlags.JSDocCacheOnlyModifiers) >>> 23); // shift ModifierFlags.JSDoc* to match ModifierFlags.* +} + +function getJSDocModifierFlagsNoCache(node: Node): ModifierFlags { + return selectEffectiveModifierFlags(getRawJSDocModifierFlagsNoCache(node)); +} + /** * Gets the effective ModifierFlags for the provided node, including JSDoc modifiers. The modifier flags cache on the node is ignored. * diff --git a/tests/baselines/reference/api/typescript.d.ts b/tests/baselines/reference/api/typescript.d.ts index 678e7549fa00e..09c7f5995bc03 100644 --- a/tests/baselines/reference/api/typescript.d.ts +++ b/tests/baselines/reference/api/typescript.d.ts @@ -4752,34 +4752,32 @@ declare namespace ts { } enum ModifierFlags { None = 0, - Export = 1, - Ambient = 2, - Public = 4, - Private = 8, - Protected = 16, - Static = 32, - Readonly = 64, - Accessor = 128, - Abstract = 256, - Async = 512, - Default = 1024, - Const = 2048, - Deprecated = 4096, - Override = 8192, - In = 16384, - Out = 32768, - Decorator = 65536, - HasComputedJSDocModifiers = 134217728, - HasExcessJDocModifiers = 268435456, + Public = 1, + Private = 2, + Protected = 4, + Readonly = 8, + Override = 16, + Export = 32, + Abstract = 64, + Ambient = 128, + Static = 256, + Accessor = 512, + Async = 1024, + Default = 2048, + Const = 4096, + In = 8192, + Out = 16384, + Decorator = 32768, + Deprecated = 65536, + HasComputedJSDocModifiers = 268435456, HasComputedFlags = 536870912, - AccessibilityModifier = 28, - ParameterPropertyModifier = 8284, - NonPublicAccessibilityModifier = 24, - TypeScriptModifier = 59742, - JSDocOnlyModifier = 4096, - ExportDefault = 1025, + AccessibilityModifier = 7, + ParameterPropertyModifier = 31, + NonPublicAccessibilityModifier = 6, + TypeScriptModifier = 28895, + ExportDefault = 2080, All = 131071, - Modifier = 65535, + Modifier = 98303, } enum JsxFlags { None = 0, diff --git a/tests/baselines/reference/jsFileCompilationPublicParameterModifier.symbols b/tests/baselines/reference/jsFileCompilationPublicParameterModifier.symbols index fa17c0e79166d..5e05e4a172d88 100644 --- a/tests/baselines/reference/jsFileCompilationPublicParameterModifier.symbols +++ b/tests/baselines/reference/jsFileCompilationPublicParameterModifier.symbols @@ -3,5 +3,5 @@ === a.js === class C { constructor(public x) { }} >C : Symbol(C, Decl(a.js, 0, 0)) ->x : Symbol(x, Decl(a.js, 0, 22)) +>x : Symbol(C.x, Decl(a.js, 0, 22)) From 4774cec46adfb0f77bf69b785580acbc80811979 Mon Sep 17 00:00:00 2001 From: Ron Buckton Date: Tue, 24 Oct 2023 16:18:02 -0400 Subject: [PATCH 4/4] Correct function name in comments --- src/compiler/types.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/compiler/types.ts b/src/compiler/types.ts index a74b4ba0d9e70..671cc715db21d 100644 --- a/src/compiler/types.ts +++ b/src/compiler/types.ts @@ -876,7 +876,7 @@ export const enum ModifierFlags { Deprecated = 1 << 16, // Deprecated tag. // Cache-only JSDoc-modifiers. Should match order of Syntactic/JSDoc modifiers, above. - /** @internal */ JSDocPublic = 1 << 23, // if this value changes, `adjustJSDocModifierFlags` must change accordingly + /** @internal */ JSDocPublic = 1 << 23, // if this value changes, `selectEffectiveModifierFlags` must change accordingly /** @internal */ JSDocPrivate = 1 << 24, /** @internal */ JSDocProtected = 1 << 25, /** @internal */ JSDocReadonly = 1 << 26,