createGetCanonicalFileName,

createGetSymbolWalker,

createModeAwareCacheKey,

createPropertyNameNodeForIdentifierOrLiteral,

createSymbolTable,

createTextWriter,

function symbolToStringWorker(writer: EmitTextWriter) {

const entity = builder(symbol, meaning!, enclosingDeclaration, nodeFlags)!; // TODO: GH#18217

// add neverAsciiEscape for GH#39027

const sourceFile = enclosingDeclaration && getSourceFileOfNode(enclosingDeclaration);

printer.writeNode(EmitHint.Unspecified, entity, /*sourceFile*/ sourceFile, writer);

return writer;

sigOutput = kind === SignatureKind.Construct ? SyntaxKind.ConstructSignature : SyntaxKind.CallSignature;

}

const sig = nodeBuilder.signatureToSignatureDeclaration(signature, sigOutput, enclosingDeclaration, toNodeBuilderFlags(flags) | NodeBuilderFlags.IgnoreErrors | NodeBuilderFlags.WriteTypeParametersInQualifiedName);

const sourceFile = enclosingDeclaration && getSourceFileOfNode(enclosingDeclaration);

printer.writeNode(EmitHint.Unspecified, sig!, /*sourceFile*/ sourceFile, getTrailingSemicolonDeferringWriter(writer)); // TODO: GH#18217

return writer;

if (typeNode === undefined) return Debug.fail("should always get typenode");

// The unresolved type gets a synthesized comment on `any` to hint to users that it's not a plain `any`.

// Otherwise, we always strip comments out.

const sourceFile = enclosingDeclaration && getSourceFileOfNode(enclosingDeclaration);

printer.writeNode(EmitHint.Unspecified, typeNode, /*sourceFile*/ sourceFile, writer);

const result = writer.getText();

typePredicate.kind === TypePredicateKind.Identifier || typePredicate.kind === TypePredicateKind.AssertsIdentifier ? factory.createIdentifier(typePredicate.parameterName) : factory.createThisTypeNode(),

typePredicate.type && nodeBuilder.typeToTypeNode(typePredicate.type, enclosingDeclaration, toNodeBuilderFlags(flags) | NodeBuilderFlags.IgnoreErrors | NodeBuilderFlags.WriteTypeParametersInQualifiedName)! // TODO: GH#18217

);

const sourceFile = enclosingDeclaration && getSourceFileOfNode(enclosingDeclaration);

printer.writeNode(EmitHint.Unspecified, predicate, /*sourceFile*/ sourceFile, writer);

return writer;

Emit,

export function createPrinter(printerOptions: PrinterOptions = {}, handlers: PrintHandlers = {}): Printer {

const {

hasGlobalName,

ClassLikeDeclaration,

ClassStaticBlockDeclaration,

compareStringsCaseSensitive,

createTextRangeFromNode,

createTextSpanFromBounds,

createTextSpanFromRange,

}

if (text === undefined) {

// get the text from printing the node on a single line without comments...

text = usingSingleLineStringWriter(writer => printer.writeNode(EmitHint.Unspecified, node, node.getSourceFile(), writer));

}

return { text, pos: declName.getStart(), end: declName.getEnd() };

__String,

ArrowFunction,

CallExpression,

Debug,

EmitHint,

EnumMember,

NodeBuilderFlags,

ParameterDeclaration,

PrefixUnaryExpression,

PropertyDeclaration,

Signature,

skipParentheses,

function printTypeInSingleLine(type: Type) {

const flags = NodeBuilderFlags.IgnoreErrors | TypeFormatFlags.AllowUniqueESSymbolType | TypeFormatFlags.UseAliasDefinedOutsideCurrentScope;

return usingSingleLineStringWriter(writer => {

const typeNode = checker.typeToTypeNode(type, /*enclosingDeclaration*/ undefined, flags);

CheckFlags,

contains,

countWhere,

createTextSpan,

createTextSpanFromBounds,

createTextSpanFromNode,

function getTypeHelpItem(symbol: Symbol, typeParameters: readonly TypeParameter[], checker: TypeChecker, enclosingDeclaration: Node, sourceFile: SourceFile): SignatureHelpItem {

const typeSymbolDisplay = symbolToDisplayParts(checker, symbol);

const parameters = typeParameters.map(t => createSignatureHelpParameterForTypeParameter(t, checker, enclosingDeclaration, sourceFile, printer));

const documentation = symbol.getDocumentationComment(checker);

function itemInfoForTypeParameters(candidateSignature: Signature, checker: TypeChecker, enclosingDeclaration: Node, sourceFile: SourceFile): SignatureHelpItemInfo[] {

const typeParameters = (candidateSignature.target || candidateSignature).typeParameters;

const parameters = (typeParameters || emptyArray).map(t => createSignatureHelpParameterForTypeParameter(t, checker, enclosingDeclaration, sourceFile, printer));

const thisParameter = candidateSignature.thisParameter ? [checker.symbolToParameterDeclaration(candidateSignature.thisParameter, enclosingDeclaration, signatureHelpNodeBuilderFlags)!] : [];

function itemInfoForParameters(candidateSignature: Signature, checker: TypeChecker, enclosingDeclaration: Node, sourceFile: SourceFile): SignatureHelpItemInfo[] {

const typeParameterParts = mapToDisplayParts(writer => {

if (candidateSignature.typeParameters && candidateSignature.typeParameters.length) {

const args = factory.createNodeArray(candidateSignature.typeParameters.map(p => checker.typeParameterToDeclaration(p, enclosingDeclaration, signatureHelpNodeBuilderFlags)!));

CallExpression,

CheckFlags,

contains,

Debug,

displayPart,

EmitHint,

NodeBuilderFlags,

ObjectFlags,

operatorPart,

PropertyAccessExpression,

PropertyDeclaration,

punctuationPart,

let hasAddedSymbolInfo = false;

const isThisExpression = location.kind === SyntaxKind.ThisKeyword && isInExpressionContext(location) || isThisInTypeQuery(location);

let type: Type | undefined;

let documentationFromAlias: SymbolDisplayPart[] | undefined;

let tagsFromAlias: JSDocTagInfo[] | undefined;

let hasMultipleSignatures = false;

return { displayParts, documentation, symbolKind, tags: tags.length === 0 ? undefined : tags };

function getPrinter() {

}

function prefixNextMeaning() {

ConditionalExpression,

contains,

ContextFlags,

createRange,

createScanner,

createTextSpan,

export function nodeToDisplayParts(node: Node, enclosingDeclaration: Node): SymbolDisplayPart[] {

const file = enclosingDeclaration.getSourceFile();

return mapToDisplayParts(writer => {

printer.writeNode(EmitHint.Unspecified, node, file, writer);

});