tsc-ts 0.0.5 → 0.0.7

package/dist/api/compiler/node-builder-names.js

@@ -13,9 +13,9 @@ import { ModuleSpecifierHost, ModuleSpecifierPreferences, countPathComponents, g
 import { ModuleKind, ModuleResolutionKind, getModuleResolutionKind } from './options.js';
 import { isExternalModuleAugmentation } from './transformers/declarations-syntactic.js';
 import { isIdentifierText } from './scanner.js';
-import { escapeInternalSymbolName, getSymbolId, } from './symbol.js';
 import { getAccessibleSymbolChain, getAliasForSymbolInContainer, getContainersOfSymbol, getFileSymbolIfFileSymbolExportEqualsContainer, getQualifiedLeftMeaning, getSymbolIfSameReference, hasNonGlobalAugmentationExternalModuleDeclaration, needsQualification, } from './symbol-accessibility.js';
 import { classifyPropertyName, isNumericLiteralName } from './node-builder.js';
+import { declarationCount, escapeInternalSymbolName, getDeclarations, getSymbolId, } from './symbol.js';
 // ---- Symbol chains
 /** The chain of symbols naming `symbol`, reported to the tracker. */
 export function lookupSymbolChain(b, symbol, meaning, yieldModuleSymbol) {
@@ -207,7 +207,7 @@ function createAccessFromSymbolChain(b, chain, index, stopper, overrideTypeArgum
     }
     if (symbolName.length === 0) {
         let name = undefined;
-        for (const d of symbol.declarations) {
+        for (const d of getDeclarations(symbol)) {
             name = getNameOfDeclaration(d);
             if (name !== undefined)
                 break;
@@ -490,13 +490,13 @@ export function getNameOfSymbolAsWritten(b, symbol) {
         (b.flags & 16384 /* NodeBuilderFlags.UseAliasDefinedOutsideCurrentScope */) === 0 &&
         // Not the first part of an entity name, synthesized, or from another binding context.
         ((b.flags & 16777216 /* NodeBuilderFlags.InInitialEntityName */) === 0 ||
-            symbol.declarations.length === 0 ||
+            declarationCount(symbol) === 0 ||
             (b.enclosingDeclaration !== undefined &&
-                findDefaultBindingContext(symbol.declarations[0]) !== findDefaultBindingContext(b.enclosingDeclaration))))
+                findDefaultBindingContext(symbol.declaration) !== findDefaultBindingContext(b.enclosingDeclaration))))
         return 'default';
-    if (symbol.declarations.length > 0) {
+    if (declarationCount(symbol) > 0) {
         let name = undefined;
-        for (const d of symbol.declarations) {
+        for (const d of getDeclarations(symbol)) {
             name = getNameOfDeclaration(d);
             if (name !== undefined)
                 break;
@@ -512,7 +512,7 @@ export function getNameOfSymbolAsWritten(b, symbol) {
             }
             return declarationNameToString(getSourceFileOfNode(name), name);
         }
-        const declaration = symbol.declarations[0];
+        const declaration = symbol.declaration;
         const parent = declaration.parent;
         if (parent !== undefined && parent.kind === 261 /* SyntaxKind.VariableDeclaration */) {
             const parentName = getName(parent);
@@ -556,7 +556,7 @@ export function getPropertyNameNodeForSymbol(b, symbol) {
         if (declarationName !== undefined && declarationName.kind === 80 /* SyntaxKind.PrivateIdentifier */)
             return b.cloneSynthesized(declarationName);
     }
-    const declarations = symbol.declarations;
+    const declarations = getDeclarations(symbol);
     let stringNamed = declarations.length !== 0;
     for (const d of declarations)
         if (!isStringNamed(b, d)) {
@@ -622,7 +622,7 @@ export function getSpecifierForModuleSymbol(b, symbol, overrideImportMode) {
     const c = b.c;
     let file = asSourceFile(getDeclarationOfKind(symbol, 307 /* SyntaxKind.SourceFile */));
     if (file === undefined)
-        for (const d of symbol.declarations) {
+        for (const d of getDeclarations(symbol)) {
             const equivalent = getFileSymbolIfFileSymbolExportEqualsContainer(c, d, symbol);
             if (equivalent !== undefined) {
                 file = asSourceFile(getDeclarationOfKind(equivalent, 307 /* SyntaxKind.SourceFile */));
@@ -684,14 +684,14 @@ function getModuleSpecifierHost(c) {
 }
 /** The name of an ambient module declaring `moduleSymbol`, or of the one whose `export =` it is, else `''`. */
 function tryGetModuleNameFromAmbientModule(c, moduleSymbol) {
-    for (const d of moduleSymbol.declarations) {
+    for (const d of getDeclarations(moduleSymbol)) {
         const name = isModuleWithStringLiteralName(d) ? getName(d) : undefined;
         if (name !== undefined && (!isModuleAugmentationExternal(d) || !isExternalModuleNameRelative(getText(name))))
             return getText(name);
     }
     // A namespace exported with `export =` from an ambient module: `import { c } from "m"` names
     // `ns.c` for `declare module "m" { namespace ns { class c {} } export = ns; }`.
-    for (const d of moduleSymbol.declarations) {
+    for (const d of getDeclarations(moduleSymbol)) {
         if (d.kind !== 268 /* SyntaxKind.ModuleDeclaration */)
             continue;
         let container = d;
@@ -845,7 +845,7 @@ function asSourceFile(node) {
 function getSourceFileOfModule(symbol) {
     let d = symbol.valueDeclaration;
     if (d === undefined)
-        for (const declaration of symbol.declarations)
+        for (const declaration of getDeclarations(symbol))
             if (!isExternalModuleAugmentation(declaration) && !isGlobalScopeAugmentation(declaration)) {
                 d = declaration;
                 break;

package/dist/api/compiler/node-builder-pseudo.d.ts

@@ -2,8 +2,8 @@ import { type Node } from './ast.js';
 import type { Checker } from './checker.js';
 import { type Type, type TypePredicate } from './checker-types.js';
 import { type NodeBuilder } from './node-builder.js';
-import { type Symbol } from './symbol.js';
 import { PseudoChecker, type PseudoType } from './transformers/declarations-pseudo.js';
+import { type Symbol } from './symbol.js';
 /** A pseudochecker for declaration emit with the checker. */
 export declare function newPseudoChecker(c: Checker): PseudoChecker;
 export declare function containsNonMissingUndefinedType(c: Checker, t: Type): boolean;

package/dist/api/compiler/node-builder-pseudo.js

@@ -19,6 +19,7 @@ import { tryReuseExistingNode } from './node-builder-reuse.js';
 import { compareTypesIdentical } from './relations.js';
 import { DirectType, InferredType, PseudoChecker, isInConstContext, } from './transformers/declarations-pseudo.js';
 import { tryGetTextOfPropertyName } from './transformers/declarations-syntactic.js';
+import { declarationCount } from './symbol.js';
 /** Resolves no names: `undefined` in an expression is the undefined value, as tsgo's pseudochecker assumes. */
 class NoNames extends NameResolver {
     resolve(_location, _name, _meaning, _nameNotFoundMessage, _isUse, _excludeGlobals) {
@@ -397,7 +398,7 @@ export function pseudoTypeEquivalentToType(b, t, type_, isOptionalAnnotated, rep
             // Accessor pairs are two members but one property.
             let targetDeclCount = 0;
             for (const prop of targetProps)
-                targetDeclCount += prop.declarations.length;
+                targetDeclCount += declarationCount(prop);
             if (pt.members.length !== targetDeclCount)
                 return false;
             for (const e of pt.members) {

package/dist/api/compiler/node-builder.d.ts

@@ -3,10 +3,10 @@ import { type Checker } from './checker.js';
 import { ElementFlags, type IndexInfo, Signature, type Type, type TypeMapper, type TypePredicate } from './checker-types.js';
 import { EmitContext } from './printer/emit-context.js';
 import type { NodeFactory } from './printer/factory.js';
-import { type Symbol, SymbolFlags } from './symbol.js';
 import { SyntaxKind } from './syntax-kind.js';
 import { NodeBuilderFlags, NodeBuilderInternalFlags, SymbolAccessibilityResult, SymbolTracker } from './transformers/declarations-resolver.js';
 import { type PseudoChecker } from './transformers/declarations-pseudo.js';
+import { type Symbol, SymbolFlags } from './symbol.js';
 /** A symbol the builder named, kept with a cached result so it can be tracked again. */
 export declare class TrackedSymbol {
     readonly symbol: Symbol;

package/dist/api/compiler/node-builder.js

@@ -30,7 +30,6 @@ import { Printer, PrinterOptions } from './printer/printer.js';
 import { TextWriter } from './printer/text-writer.js';
 import { isTypeIdenticalTo } from './relations.js';
 import { isIdentifierText } from './scanner.js';
-import { getSymbolId } from './symbol.js';
 import { SymbolAccessibilityResult, SymbolTracker, accessible, } from './transformers/declarations-resolver.js';
 import { getMeaningOfEntityNameReference } from './transformers/declarations-syntactic.js';
 import { formatUnionTypes, symbolToString } from './type-printer.js';
@@ -39,6 +38,7 @@ import { getPropertyNameNodeForSymbol, symbolToEntityNameNode, symbolToExpressio
 import { tryReuseExistingNode } from './node-builder-reuse.js';
 import { containsNonMissingUndefinedType, hasInferredTypeKind, hasQuestionToken, isAccessorKind, pseudoReturnTypeMatchesPredicate, pseudoTypeEquivalentToType, pseudoTypeToNodeWithCheckerFallback, pseudoTypeToType, newPseudoChecker, requiresAddingImplicitUndefinedForDeclaration, } from './node-builder-pseudo.js';
 import { InferredType, UnionType as PseudoUnionType, couldAlreadyReferToUndefined, undefinedType as pseudoUndefinedType, } from './transformers/declarations-pseudo.js';
+import { declarationCount, getDeclarations, getSymbolId, } from './symbol.js';
 const defaultMaximumTruncationLength = 160;
 const noTruncationMaximumTruncationLength = 1_000_000;
 const maxReverseMappedNestingInspectionDepth = 3;
@@ -389,7 +389,7 @@ export class NodeBuilder {
     }
     /** Adds the names bound by a destructured parameter; false if `param` isn't one. */
     addBindingPatternParameters(param, table) {
-        for (const d of param.declarations) {
+        for (const d of getDeclarations(param)) {
             if (d.kind !== 170 /* SyntaxKind.Parameter */)
                 continue;
             const name = asBindingPattern(getName(d));
@@ -1051,7 +1051,7 @@ export class NodeBuilder {
         const c = this.c;
         let isStaticMethodSymbol = false;
         if ((symbol.flags & 8192 /* SymbolFlags.Method */) !== 0)
-            for (const d of symbol.declarations)
+            for (const d of getDeclarations(symbol))
                 if (isStatic(d) && !hasLateBindableIndexSignature(c, d))
                     isStaticMethodSymbol = true;
         let isNonLocalFunctionSymbol = false;
@@ -1060,7 +1060,7 @@ export class NodeBuilder {
             if (symbol.parent !== undefined)
                 isNonLocalFunctionSymbol = true;
             else
-                for (const d of symbol.declarations) {
+                for (const d of getDeclarations(symbol)) {
                     const parent = d.parent;
                     if (parent.kind === 307 /* SyntaxKind.SourceFile */ || parent.kind === 269 /* SyntaxKind.ModuleBlock */) {
                         isNonLocalFunctionSymbol = true;
@@ -1315,8 +1315,8 @@ export class NodeBuilder {
         const saveEnclosingDeclaration = this.enclosingDeclaration;
         this.enclosingDeclaration = undefined;
         if (isLateBoundName(propertySymbol.name)) {
-            if (propertySymbol.declarations.length > 0) {
-                const decl = propertySymbol.declarations[0];
+            if (declarationCount(propertySymbol) > 0) {
+                const decl = propertySymbol.declaration;
                 if (hasLateBindableName(c, decl)) {
                     if (decl instanceof BinaryExpression) {
                         const name = getNameOfDeclaration(decl);
@@ -1333,7 +1333,7 @@ export class NodeBuilder {
         }
         this.enclosingDeclaration =
             propertySymbol.valueDeclaration ??
-                (propertySymbol.declarations.length > 0 ? propertySymbol.declarations[0] : saveEnclosingDeclaration);
+                (declarationCount(propertySymbol) > 0 ? propertySymbol.declaration : saveEnclosingDeclaration);
         const propertyName = getPropertyNameNodeForSymbol(this, propertySymbol);
         this.enclosingDeclaration = saveEnclosingDeclaration;
         this.approximateLength += symbolName(propertySymbol).length + 1;
@@ -1415,7 +1415,7 @@ export class NodeBuilder {
             this.context.assignCommentRange(node, range);
     }
     isDeclaredInEnclosingFile(symbol) {
-        for (const d of symbol.declarations)
+        for (const d of getDeclarations(symbol))
             if (getSourceFileOfNode(d) === this.enclosingFile)
                 return true;
         return false;
@@ -1575,8 +1575,8 @@ export class NodeBuilder {
         if (!(result instanceof Identifier))
             return this.identifier('(Missing type parameter)');
         const symbol = typeParameter.symbol;
-        if (symbol !== undefined && symbol.declarations.length > 0) {
-            const decl = symbol.declarations[0];
+        if (symbol !== undefined && declarationCount(symbol) > 0) {
+            const decl = symbol.declaration;
             if (decl.kind === 169 /* SyntaxKind.TypeParameter */)
                 result = this.setTextRange(result, getName(decl));
         }
@@ -1835,7 +1835,7 @@ export class NodeBuilder {
     serializeTypeForDeclaration(declaration, type, symbol, tryReuse) {
         const c = this.c;
         if (declaration === undefined && symbol !== undefined)
-            declaration = symbol.valueDeclaration ?? (symbol.declarations.length > 0 ? symbol.declarations[0] : undefined);
+            declaration = symbol.valueDeclaration ?? (declarationCount(symbol) > 0 ? symbol.declaration : undefined);
         if (symbol === undefined && declaration !== undefined)
             symbol = getSymbolOfDeclaration(c, declaration);
         let t = type;
@@ -1905,7 +1905,7 @@ export class NodeBuilder {
                 : pseudo.getTypeOfDeclaration(declaration);
             if (pt.kind === 2 /* PseudoTypeKind.NoResult */ && declaration.kind === 227 /* SyntaxKind.BinaryExpression */) {
                 // The first annotated assignment declares the type for the rest.
-                for (const d of symbol.declarations)
+                for (const d of getDeclarations(symbol))
                     if (getType(d) !== undefined) {
                         pt = pseudo.getTypeOfDeclaration(d);
                         break;
@@ -2123,9 +2123,9 @@ function isClassInstanceSide(c, t) {
 }
 function getTypeAliasForTypeLiteral(c, t) {
     const symbol = t.symbol;
-    if (symbol === undefined || (symbol.flags & 2048 /* SymbolFlags.TypeLiteral */) === 0 || symbol.declarations.length === 0)
+    if (symbol === undefined || (symbol.flags & 2048 /* SymbolFlags.TypeLiteral */) === 0 || declarationCount(symbol) === 0)
         return undefined;
-    let node = symbol.declarations[0].parent;
+    let node = symbol.declaration.parent;
     while (node !== undefined && node.kind === 197 /* SyntaxKind.ParenthesizedType */)
         node = node.parent;
     if (node !== undefined && node.kind === 266 /* SyntaxKind.TypeAliasDeclaration */)
@@ -2136,7 +2136,7 @@ function getTypeAliasForTypeLiteral(c, t) {
 function getResolvedTypeWithoutAbstractConstructSignatures(c, t, resolved) {
     if (resolved.constructSignatures.length === 0)
         return t;
-    const side = sideOf(c, t);
+    const side = membersHolder(c, t);
     if (side.objectTypeWithoutAbstractConstructSignatures !== undefined)
         return side.objectTypeWithoutAbstractConstructSignatures;
     const constructSignatures = resolved.constructSignatures.filter((s) => (s.flags & 8 /* SignatureFlags.Abstract */) === 0);
@@ -2174,7 +2174,7 @@ function getEffectiveConstraint(typeParameter) {
 function getTypeParameterModifiers(tp) {
     let flags = 0 /* ModifierFlags.None */;
     if (tp.symbol !== undefined)
-        for (const d of tp.symbol.declarations)
+        for (const d of getDeclarations(tp.symbol))
             flags |= getCombinedModifierFlags(d);
     return flags & (8192 /* ModifierFlags.In */ | 16384 /* ModifierFlags.Out */ | 4096 /* ModifierFlags.Const */);
 }

package/dist/api/compiler/parallel-parse.d.ts

@@ -45,6 +45,8 @@ export declare class PreparedFile {
 }
 /** The version a parse thread computed for `file` (`PreparedFile.version`), or `''`. */
 export declare function preparedVersion(file: SourceFile): string;
+/** Whether a parse thread prepared `fileName`. */
+export declare function isPrepared(fileName: string): boolean;
 /** What a parse thread's FileLoader found loading `fileName`, if the thread prepared it. */
 export declare function preparedLoad(fileName: string): LoadedFile | undefined;
 /** What a parse thread sends back for a chunk: its bound files and the files they add. */

package/dist/api/compiler/parallel-parse.js

@@ -73,6 +73,10 @@ export function preparedVersion(file) {
     const prepared = parallelParse.files.get(file.fileName);
     return prepared !== undefined && prepared.file === file ? prepared.version : '';
 }
+/** Whether a parse thread prepared `fileName`. */
+export function isPrepared(fileName) {
+    return parallelParse.files.has(fileName);
+}
 /** What a parse thread's FileLoader found loading `fileName`, if the thread prepared it. */
 export function preparedLoad(fileName) {
     if (parallelParse.files.size === 0)
@@ -441,7 +445,9 @@ export class ParseSession {
             this.onIdle(batch);
     }
     post(i, chunk) {
-        this.workers[i].postMessage(chunk);
+        // Published, the chunk reaches the thread by pointer: copying its names into the message took the
+        // main thread 25-45 us per chunk, which during config read delays the matching of root files.
+        this.workers[i].postMessage(publish(chunk));
         this.outstanding[i] = this.outstanding[i] + 1;
         if (chunk.kinds[0] === 2 /* LoadKind.Library */ && largeLibraries.has(chunk.names[0]))
             this.blocked[i] = true;

package/dist/api/compiler/parser.d.ts

@@ -71,6 +71,15 @@ export declare const enum ParseFlags {
     IgnoreMissingOpenBrace = 16,
     JSDoc = 32
 }
+/** How an identifier is used, which decides whether it holds a flow node. */
+export declare const enum IdentifierUse {
+    /** An expression or another reference: a `ReferenceIdentifier`. */
+    Reference = 0,
+    /** A declaration, property, property access or type name, whose flow node nothing reads: an `Identifier`. */
+    Name = 1,
+    /** An object literal element's name: a name before `:`, `(` or `<`, a reference in a shorthand property. */
+    ElementName = 2
+}
 /** What the scanner saw of the JSDoc comments preceding a token. */
 export declare const enum JSDocScannerInfo {
     None = 0,
@@ -135,7 +144,7 @@ export declare class Parser extends ScannerErrorReporter {
     signatureParameterAllowAmbiguity: boolean;
     signatureParameterFlags: ParseFlags;
     /** Parses JSDoc comments and, in JavaScript files, reparses their tags. */
-    readonly jsdoc: JSDocParser;
+    jsdoc: JSDocParser;
     /**
      * Returned instead of `undefined` by hot element parsers: a `Node | undefined` result is boxed natively
      * for every node returned.
@@ -147,9 +156,10 @@ export declare class Parser extends ScannerErrorReporter {
     /** The scanner copies the code units of only the ranges it is asked to (`Scanner.loadUnits`). */
     unitsOnDemand?: boolean);
     /**
-     * Frees the scanner's copy of the text once the parser is done. The parser and its scanner and
-     * JSDoc parser refer to each other, so natively they're freed only by a cycle collection, which may
-     * come much later.
+     * Frees the scanner's copy of the text once the parser is done, and drops the references back to
+     * this parser from its scanner and JSDoc parser. Natively, the parser is then freed as soon as its
+     * caller lets go of it, instead of at a cycle collection, which may come much later (on a parse
+     * thread, not before the thread exits).
      */
     release(): void;
     token(): SyntaxKind;
@@ -340,14 +350,21 @@ export declare class Parser extends ScannerErrorReporter {
     parseLiteralTypeNode(negative: boolean): TypeNode;
     parseTypeReference(): TypeNode;
     parseEntityNameOfTypeReference(): EntityName;
-    parseEntityName(allowReservedWords: boolean, diagnosticMessage: DiagnosticMessage | undefined): EntityName;
+    /** An entity name; `use` is for its first identifier, the qualified names' right sides are names. */
+    parseEntityName(allowReservedWords: boolean, diagnosticMessage: DiagnosticMessage | undefined, use?: IdentifierUse): EntityName;
     parseRightSideOfDot(allowIdentifierNames: boolean, allowPrivateIdentifiers: boolean, allowUnicodeEscapeSequenceInIdentifierName: boolean): Node;
     /** `parseRightSideOfDot` without private identifiers. */
     parseRightSideOfDotIdentifier(allowIdentifierNames: boolean, allowUnicodeEscapeSequenceInIdentifierName: boolean): Identifier;
     /** An identifier or keyword after a line break, followed by another on the same line. */
     isKeywordStartingNextLine(): boolean;
-    newIdentifier(text: string): Identifier;
-    createMissingIdentifier(): Identifier;
+    /**
+     * A new identifier of the class `use` calls for. Callers create it after the identifier's token, so
+     * for an element name the current token tells a shorthand property from an assignment or a method.
+     */
+    newIdentifier(text: string, use?: IdentifierUse): Identifier;
+    /** Whether the current token ends an object literal element name that is not a shorthand property. */
+    isElementNameEnd(): boolean;
+    createMissingIdentifier(use?: IdentifierUse): Identifier;
     parsePrivateIdentifier(): Node;
     reScanLessThanToken(): SyntaxKind;
     reScanGreaterThanToken(): SyntaxKind;
@@ -381,8 +398,8 @@ export declare class Parser extends ScannerErrorReporter {
     /** Type members are separated by commas or (possibly ASI) semicolons. */
     parseTypeMemberSemicolon(): boolean;
     parseAccessorDeclaration(pos: number, jsdoc: JSDocScannerInfo, modifiers: ModifierList | undefined, kind: SyntaxKind, flags: ParseFlags): Node;
-    parsePropertyName(): Node;
-    parsePropertyNameWorker(allowComputedPropertyNames: boolean): Node;
+    parsePropertyName(use?: IdentifierUse): Node;
+    parsePropertyNameWorker(allowComputedPropertyNames: boolean, use?: IdentifierUse): Node;
     parseComputedPropertyName(): Node;
     parseFunctionBlockOrSemicolon(flags: ParseFlags, diagnosticMessage: DiagnosticMessage | undefined): Block | undefined;
     parseFunctionBlock(flags: ParseFlags, diagnosticMessage: DiagnosticMessage | undefined): Block;
@@ -511,15 +528,15 @@ export declare class Parser extends ScannerErrorReporter {
     parseNewExpressionOrNewDotTarget(): Expression;
     parseKeywordExpression(): Expression;
     parseLiteralExpression(intern: boolean): Expression;
-    parseIdentifierNameErrorOnUnicodeEscapeSequence(): Identifier;
+    parseIdentifierNameErrorOnUnicodeEscapeSequence(use?: IdentifierUse): Identifier;
     parseBindingIdentifier(): Identifier;
     parseBindingIdentifierWithDiagnostic(privateIdentifierDiagnosticMessage: DiagnosticMessage | undefined): Identifier;
-    parseIdentifierName(): Identifier;
-    parseIdentifierNameWithDiagnostic(diagnosticMessage: DiagnosticMessage | undefined): Identifier;
-    parseIdentifier(): Identifier;
-    parseIdentifierWithDiagnostic(diagnosticMessage: DiagnosticMessage | undefined, privateIdentifierDiagnosticMessage: DiagnosticMessage | undefined): Identifier;
-    createIdentifier(isIdentifier: boolean): Identifier;
-    createIdentifierWithDiagnostic(isIdentifier: boolean, diagnosticMessage: DiagnosticMessage | undefined, privateIdentifierDiagnosticMessage: DiagnosticMessage | undefined): Identifier;
+    parseIdentifierName(use?: IdentifierUse): Identifier;
+    parseIdentifierNameWithDiagnostic(diagnosticMessage: DiagnosticMessage | undefined, use?: IdentifierUse): Identifier;
+    parseIdentifier(use?: IdentifierUse): Identifier;
+    parseIdentifierWithDiagnostic(diagnosticMessage: DiagnosticMessage | undefined, privateIdentifierDiagnosticMessage: DiagnosticMessage | undefined, use?: IdentifierUse): Identifier;
+    createIdentifier(isIdentifier: boolean, use?: IdentifierUse): Identifier;
+    createIdentifierWithDiagnostic(isIdentifier: boolean, diagnosticMessage: DiagnosticMessage | undefined, privateIdentifierDiagnosticMessage: DiagnosticMessage | undefined, use?: IdentifierUse): Identifier;
     internIdentifier(text: string): string;
     /** Whether the current token can start a signature member, after any modifiers. */
     scanTypeMemberStart(): boolean;