@tslite/services 0.0.0-stage → 1.13.0

package/dist/symbolDisplay.js

@@ -0,0 +1,400 @@
+// Modificado de microsoft/TypeScript v3.9.10, src/services/symbolDisplay.ts: o namespace virou módulo ES, com os imports explícitos.
+import { CheckFlags, Debug, EmitHint, ListFormat, NodeBuilderFlags, ObjectFlags, SymbolDisplayPartKind, SymbolFlags, SymbolFormatFlags, SyntaxKind, TypeFormatFlags, addRange, contains, createPrinter, displayPart, forEach, getCombinedLocalAndExportSymbolFlags, getDeclarationOfKind, getMeaningFromLocation, getNameOfDeclaration, getNodeModifiers, getObjectFlags, getParseTreeNode, getRootDeclaration, getSourceFileOfNode, isArrowFunction, isCallExpression, isCallExpressionTarget, isCatchClause, isFirstDeclarationOfSymbolParameter, isFunctionBlock, isFunctionLike, isFunctionLikeKind, isJsxOpeningLikeElement, isLet, isParameter, isVarConst, isVariableDeclaration, keywordPart, lineBreakPart, mapToDisplayParts, operatorPart, punctuationPart, signatureToDisplayParts, some, spacePart, symbolToDisplayParts, textOrKeywordPart, textPart, typeToDisplayParts, } from "./_namespaces/ts.js";
+const symbolDisplayNodeBuilderFlags = NodeBuilderFlags.OmitParameterModifiers | NodeBuilderFlags.IgnoreErrors | NodeBuilderFlags.UseAliasDefinedOutsideCurrentScope;
+export function getSymbolKind(typeChecker, symbol, location) {
+    const result = getSymbolKindOfConstructorPropertyMethodAccessorFunctionOrVar(typeChecker, symbol, location);
+    if (result !== "" /* ScriptElementKind.unknown */) {
+        return result;
+    }
+    const flags = getCombinedLocalAndExportSymbolFlags(symbol);
+    if (flags & SymbolFlags.TypeAlias)
+        return "type" /* ScriptElementKind.typeElement */;
+    // A interface é a dos embutidos que nascem no checker (CK-48): um programa da Linguagem não a declara.
+    if (flags & SymbolFlags.Interface)
+        return "interface" /* ScriptElementKind.interfaceElement */;
+    if (flags & SymbolFlags.TypeParameter)
+        return "type parameter" /* ScriptElementKind.typeParameterElement */;
+    if (flags & SymbolFlags.Alias)
+        return "alias" /* ScriptElementKind.alias */;
+    if (flags & SymbolFlags.Module)
+        return "module" /* ScriptElementKind.moduleElement */;
+    return result;
+}
+function getSymbolKindOfConstructorPropertyMethodAccessorFunctionOrVar(typeChecker, symbol, location) {
+    // O `undefined` global é uma constante. Na tag, `var` (CK-68).
+    if (typeChecker.isUndefinedSymbol(symbol)) {
+        return "const" /* ScriptElementKind.constElement */;
+    }
+    const flags = getCombinedLocalAndExportSymbolFlags(symbol);
+    if (flags & SymbolFlags.Variable) {
+        // O nome desestruturado num parâmetro e a variável do `catch` também são parâmetros. Na tag, `var`, o rótulo do que
+        // não é `const` nem `let` (CK-68).
+        const rootDeclaration = symbol.valueDeclaration && getRootDeclaration(symbol.valueDeclaration);
+        if (isFirstDeclarationOfSymbolParameter(symbol) ||
+            rootDeclaration && (isParameter(rootDeclaration) || isVariableDeclaration(rootDeclaration) && isCatchClause(rootDeclaration.parent))) {
+            return "parameter" /* ScriptElementKind.parameterElement */;
+        }
+        else if (symbol.valueDeclaration && isVarConst(symbol.valueDeclaration)) {
+            return "const" /* ScriptElementKind.constElement */;
+        }
+        else if (forEach(symbol.declarations, isLet)) {
+            return "let" /* ScriptElementKind.letElement */;
+        }
+        return isLocalVariableOrFunction(symbol) ? "local var" /* ScriptElementKind.localVariableElement */ : "var" /* ScriptElementKind.variableElement */;
+    }
+    if (flags & SymbolFlags.Function)
+        return isLocalVariableOrFunction(symbol) ? "local function" /* ScriptElementKind.localFunctionElement */ : "function" /* ScriptElementKind.functionElement */;
+    if (flags & SymbolFlags.Property) {
+        if (flags & SymbolFlags.Transient && symbol.checkFlags & CheckFlags.Synthetic) {
+            // A propriedade de uma união que só junta o que não é método (propriedade, variável) é propriedade.
+            const unionPropertyKind = forEach(typeChecker.getRootSymbols(symbol), rootSymbol => {
+                const rootSymbolFlags = rootSymbol.getFlags();
+                // Na tag, também o acessor (CK-02).
+                if (rootSymbolFlags & (SymbolFlags.Property | SymbolFlags.Variable)) {
+                    return "property" /* ScriptElementKind.memberVariableElement */;
+                }
+                // Pode ser uma função, num `typeof N` de um namespace que a declara.
+                Debug.assert(!!(rootSymbolFlags & (SymbolFlags.Method | SymbolFlags.Function)));
+            });
+            if (!unionPropertyKind) {
+                // A união só de funções é método, se o tipo dela tem assinatura de chamada.
+                const typeOfUnionProperty = typeChecker.getTypeOfSymbolAtLocation(symbol, location);
+                if (typeOfUnionProperty.getCallSignatures().length) {
+                    return "method" /* ScriptElementKind.memberFunctionElement */;
+                }
+                return "property" /* ScriptElementKind.memberVariableElement */;
+            }
+            return unionPropertyKind;
+        }
+        // O completion depois de `x.` no topo pode estar no arquivo.
+        switch (location.parent && location.parent.kind) {
+            // Com um caractere do nome do atributo escrito, é o `JsxAttribute`; senão, o `JsxOpeningElement`.
+            case SyntaxKind.JsxOpeningElement:
+            case SyntaxKind.JsxElement:
+            case SyntaxKind.JsxSelfClosingElement:
+                return location.kind === SyntaxKind.Identifier ? "property" /* ScriptElementKind.memberVariableElement */ : "JSX attribute" /* ScriptElementKind.jsxAttribute */;
+            case SyntaxKind.JsxAttribute:
+                return "JSX attribute" /* ScriptElementKind.jsxAttribute */;
+            default:
+                return "property" /* ScriptElementKind.memberVariableElement */;
+        }
+    }
+    return "" /* ScriptElementKind.unknown */;
+}
+export function getSymbolModifiers(symbol) {
+    const nodeModifiers = symbol && symbol.declarations && symbol.declarations.length > 0
+        ? getNodeModifiers(symbol.declarations[0])
+        : "" /* ScriptElementKindModifier.none */;
+    const symbolModifiers = symbol && symbol.flags & SymbolFlags.Optional ?
+        "optional" /* ScriptElementKindModifier.optionalModifier */
+        : "" /* ScriptElementKindModifier.none */;
+    return nodeModifiers && symbolModifiers ? nodeModifiers + "," + symbolModifiers : nodeModifiers || symbolModifiers;
+}
+/**
+ * O texto do símbolo no ponto (`displayParts`), o tipo de símbolo e a documentação. A documentação e as tags vinham do
+ * JSDoc, que a cópia não tem (CK-03): saem vazias.
+ */
+export function getSymbolDisplayPartsDocumentationAndSymbolKind(typeChecker, symbol, sourceFile, enclosingDeclaration, location, semanticMeaning = getMeaningFromLocation(location), alias) {
+    const displayParts = [];
+    const symbolFlags = getCombinedLocalAndExportSymbolFlags(symbol);
+    let symbolKind = semanticMeaning & 1 /* SemanticMeaning.Value */ ? getSymbolKindOfConstructorPropertyMethodAccessorFunctionOrVar(typeChecker, symbol, location) : "" /* ScriptElementKind.unknown */;
+    let hasAddedSymbolInfo = false;
+    let type;
+    let printer;
+    if (symbolKind !== "" /* ScriptElementKind.unknown */ || symbolFlags & SymbolFlags.Alias) {
+        let signature;
+        type = typeChecker.getTypeOfSymbolAtLocation(symbol.exportSymbol || symbol, location);
+        if (location.parent && location.parent.kind === SyntaxKind.PropertyAccessExpression) {
+            const right = location.parent.name;
+            // O ponto está à direita de um acesso, ou à esquerda com a direita faltando.
+            if (right === location || (right && right.getFullWidth() === 0)) {
+                location = location.parent;
+            }
+        }
+        // a assinatura da chamada, quando o ponto é uma
+        let callExpressionLike;
+        if (isCallExpression(location)) {
+            callExpressionLike = location;
+        }
+        else if (isCallExpressionTarget(location)) {
+            callExpressionLike = location.parent;
+        }
+        else if (location.parent && isJsxOpeningLikeElement(location.parent) && isFunctionLike(symbol.valueDeclaration)) {
+            callExpressionLike = location.parent;
+        }
+        if (callExpressionLike) {
+            signature = typeChecker.getResolvedSignature(callExpressionLike);
+            const allSignatures = type.getCallSignatures();
+            if (!contains(allSignatures, signature.target) && !contains(allSignatures, signature)) {
+                // A primeira assinatura, se há: a lista pode ter a original ou o alvo dela.
+                signature = allSignatures.length ? allSignatures[0] : undefined;
+            }
+            if (signature) {
+                if (symbolFlags & SymbolFlags.Alias) {
+                    symbolKind = "alias" /* ScriptElementKind.alias */;
+                    pushSymbolKind(symbolKind);
+                    displayParts.push(spacePart());
+                    addFullSymbolName(symbol);
+                }
+                else {
+                    addPrefixForAnyFunctionOrVar(symbol, symbolKind);
+                }
+                switch (symbolKind) {
+                    case "JSX attribute" /* ScriptElementKind.jsxAttribute */:
+                    case "property" /* ScriptElementKind.memberVariableElement */:
+                    case "var" /* ScriptElementKind.variableElement */:
+                    case "const" /* ScriptElementKind.constElement */:
+                    case "let" /* ScriptElementKind.letElement */:
+                    case "parameter" /* ScriptElementKind.parameterElement */:
+                    case "local var" /* ScriptElementKind.localVariableElement */:
+                        // A assinatura de uma arrow escreve o nome do tipo.
+                        displayParts.push(punctuationPart(SyntaxKind.ColonToken));
+                        displayParts.push(spacePart());
+                        if (!(getObjectFlags(type) & ObjectFlags.Anonymous) && type.symbol) {
+                            addRange(displayParts, symbolToDisplayParts(typeChecker, type.symbol, enclosingDeclaration, /*meaning*/ undefined, SymbolFormatFlags.AllowAnyNodeKind | SymbolFormatFlags.WriteTypeParametersOrArguments));
+                            displayParts.push(lineBreakPart());
+                        }
+                        addSignatureDisplayParts(signature, allSignatures, TypeFormatFlags.WriteArrowStyleSignature);
+                        break;
+                    default:
+                        // só a assinatura
+                        addSignatureDisplayParts(signature, allSignatures);
+                }
+                hasAddedSymbolInfo = true;
+            }
+        }
+    }
+    if ((symbolFlags & SymbolFlags.Interface) && (semanticMeaning & 2 /* SemanticMeaning.Type */)) {
+        prefixNextMeaning();
+        // A interface que fica é a do embutido, que nasce no checker (CK-48), e a Linguagem descreve um tipo com o `type`.
+        // Na tag, a palavra `interface`, que saiu do scanner (CK-56) (CK-68).
+        displayParts.push(keywordPart(SyntaxKind.TypeKeyword));
+        displayParts.push(spacePart());
+        addFullSymbolName(symbol);
+        writeTypeParametersOfSymbol(symbol, sourceFile);
+    }
+    if ((symbolFlags & SymbolFlags.TypeAlias) && (semanticMeaning & 2 /* SemanticMeaning.Type */)) {
+        prefixNextMeaning();
+        displayParts.push(keywordPart(SyntaxKind.TypeKeyword));
+        displayParts.push(spacePart());
+        addFullSymbolName(symbol);
+        writeTypeParametersOfSymbol(symbol, sourceFile);
+        displayParts.push(spacePart());
+        displayParts.push(operatorPart(SyntaxKind.EqualsToken));
+        displayParts.push(spacePart());
+        addRange(displayParts, typeToDisplayParts(typeChecker, typeChecker.getDeclaredTypeOfSymbol(symbol), enclosingDeclaration, TypeFormatFlags.InTypeAlias));
+    }
+    if (symbolFlags & SymbolFlags.Module) {
+        prefixNextMeaning();
+        const declaration = getDeclarationOfKind(symbol, SyntaxKind.ModuleDeclaration);
+        const isNamespace = declaration && declaration.name && declaration.name.kind === SyntaxKind.Identifier;
+        // O módulo ES é da Linguagem (CK-46), mas a palavra `module` saiu do scanner (CK-56): ela se escreve como texto, com
+        // o tipo de palavra-chave que a tag dava (CK-68).
+        displayParts.push(isNamespace ? keywordPart(SyntaxKind.NamespaceKeyword) : displayPart("module", SymbolDisplayPartKind.keyword));
+        displayParts.push(spacePart());
+        addFullSymbolName(symbol);
+    }
+    if ((symbolFlags & SymbolFlags.TypeParameter) && (semanticMeaning & 2 /* SemanticMeaning.Type */)) {
+        prefixNextMeaning();
+        displayParts.push(punctuationPart(SyntaxKind.OpenParenToken));
+        displayParts.push(textPart("type parameter"));
+        displayParts.push(punctuationPart(SyntaxKind.CloseParenToken));
+        displayParts.push(spacePart());
+        addFullSymbolName(symbol);
+        if (symbol.parent) {
+            // o parâmetro de tipo de uma interface
+            addInPrefix();
+            addFullSymbolName(symbol.parent, enclosingDeclaration);
+            writeTypeParametersOfSymbol(symbol.parent, enclosingDeclaration);
+        }
+        else {
+            // o parâmetro de tipo de uma função ou de um alias
+            const decl = getDeclarationOfKind(symbol, SyntaxKind.TypeParameter);
+            if (decl === undefined)
+                return Debug.fail();
+            const declaration = decl.parent;
+            if (declaration) {
+                if (isFunctionLikeKind(declaration.kind)) {
+                    addInPrefix();
+                    const signature = typeChecker.getSignatureFromDeclaration(declaration);
+                    if (declaration.kind !== SyntaxKind.CallSignature && declaration.name) {
+                        addFullSymbolName(declaration.symbol);
+                    }
+                    addRange(displayParts, signatureToDisplayParts(typeChecker, signature, sourceFile, TypeFormatFlags.WriteTypeArgumentsOfSignature));
+                }
+                else if (declaration.kind === SyntaxKind.TypeAliasDeclaration) {
+                    // O parâmetro de tipo de um alias: em `type list<T> = T[]`, os dois `T` passam por aqui.
+                    addInPrefix();
+                    displayParts.push(keywordPart(SyntaxKind.TypeKeyword));
+                    displayParts.push(spacePart());
+                    addFullSymbolName(declaration.symbol);
+                    writeTypeParametersOfSymbol(declaration.symbol, sourceFile);
+                }
+            }
+        }
+    }
+    if (symbolFlags & SymbolFlags.Alias) {
+        prefixNextMeaning();
+        if (!hasAddedSymbolInfo) {
+            const resolvedSymbol = typeChecker.getAliasedSymbol(symbol);
+            if (resolvedSymbol !== symbol && resolvedSymbol.declarations && resolvedSymbol.declarations.length > 0) {
+                const resolvedNode = resolvedSymbol.declarations[0];
+                const declarationName = getNameOfDeclaration(resolvedNode);
+                if (declarationName) {
+                    // Na tag, o alias de um `declare module "x"` mostrava o nome do módulo; ele saiu (CK-02).
+                    const shouldUseAliasName = symbol.name !== "default";
+                    const resolvedInfo = getSymbolDisplayPartsDocumentationAndSymbolKind(typeChecker, resolvedSymbol, getSourceFileOfNode(resolvedNode), resolvedNode, declarationName, semanticMeaning, shouldUseAliasName ? symbol : resolvedSymbol);
+                    displayParts.push(...resolvedInfo.displayParts);
+                    displayParts.push(lineBreakPart());
+                }
+            }
+        }
+        switch (symbol.declarations[0].kind) {
+            case SyntaxKind.ExportAssignment:
+                // Na tag, o `export =` dava o `=` no lugar do `default` (CK-03).
+                displayParts.push(keywordPart(SyntaxKind.ExportKeyword));
+                displayParts.push(spacePart());
+                displayParts.push(keywordPart(SyntaxKind.DefaultKeyword));
+                break;
+            case SyntaxKind.ExportSpecifier:
+                displayParts.push(keywordPart(SyntaxKind.ExportKeyword));
+                break;
+            default:
+                displayParts.push(keywordPart(SyntaxKind.ImportKeyword));
+        }
+        displayParts.push(spacePart());
+        addFullSymbolName(symbol);
+    }
+    if (!hasAddedSymbolInfo) {
+        if (symbolKind !== "" /* ScriptElementKind.unknown */) {
+            if (type) {
+                addPrefixForAnyFunctionOrVar(symbol, symbolKind);
+                // a propriedade, a variável e o local mostram o tipo
+                if (symbolKind === "property" /* ScriptElementKind.memberVariableElement */ ||
+                    symbolKind === "JSX attribute" /* ScriptElementKind.jsxAttribute */ ||
+                    symbolFlags & SymbolFlags.Variable ||
+                    symbolKind === "local var" /* ScriptElementKind.localVariableElement */) {
+                    displayParts.push(punctuationPart(SyntaxKind.ColonToken));
+                    displayParts.push(spacePart());
+                    // o parâmetro de tipo se escreve como a declaração dele
+                    if (type.symbol && type.symbol.flags & SymbolFlags.TypeParameter) {
+                        const typeParameterParts = mapToDisplayParts(writer => {
+                            const param = typeChecker.typeParameterToDeclaration(type, enclosingDeclaration, symbolDisplayNodeBuilderFlags);
+                            getPrinter().writeNode(EmitHint.Unspecified, param, getSourceFileOfNode(getParseTreeNode(enclosingDeclaration)), writer);
+                        });
+                        addRange(displayParts, typeParameterParts);
+                    }
+                    else {
+                        addRange(displayParts, typeToDisplayParts(typeChecker, type, enclosingDeclaration));
+                    }
+                }
+                else if (symbolFlags & SymbolFlags.Function ||
+                    symbolFlags & SymbolFlags.Signature ||
+                    symbolKind === "method" /* ScriptElementKind.memberFunctionElement */) {
+                    const allSignatures = type.getNonNullableType().getCallSignatures();
+                    if (allSignatures.length) {
+                        addSignatureDisplayParts(allSignatures[0], allSignatures);
+                    }
+                }
+            }
+        }
+        else {
+            symbolKind = getSymbolKind(typeChecker, symbol, location);
+        }
+    }
+    return { displayParts, documentation: [], symbolKind, tags: undefined };
+    function getPrinter() {
+        if (!printer) {
+            printer = createPrinter({ removeComments: true });
+        }
+        return printer;
+    }
+    function prefixNextMeaning() {
+        if (displayParts.length) {
+            displayParts.push(lineBreakPart());
+        }
+        addAliasPrefixIfNecessary();
+    }
+    function addAliasPrefixIfNecessary() {
+        if (alias) {
+            pushSymbolKind("alias" /* ScriptElementKind.alias */);
+            displayParts.push(spacePart());
+        }
+    }
+    function addInPrefix() {
+        displayParts.push(spacePart());
+        displayParts.push(keywordPart(SyntaxKind.InKeyword));
+        displayParts.push(spacePart());
+    }
+    function addFullSymbolName(symbolToDisplay, enclosingDeclaration) {
+        if (alias && symbolToDisplay === symbol) {
+            symbolToDisplay = alias;
+        }
+        const fullSymbolDisplayParts = symbolToDisplayParts(typeChecker, symbolToDisplay, enclosingDeclaration || sourceFile, /*meaning*/ undefined, SymbolFormatFlags.WriteTypeParametersOrArguments | SymbolFormatFlags.UseOnlyExternalAliasing | SymbolFormatFlags.AllowAnyNodeKind);
+        addRange(displayParts, fullSymbolDisplayParts);
+        if (symbol.flags & SymbolFlags.Optional) {
+            displayParts.push(punctuationPart(SyntaxKind.QuestionToken));
+        }
+    }
+    function addPrefixForAnyFunctionOrVar(symbol, symbolKind) {
+        prefixNextMeaning();
+        if (symbolKind) {
+            pushSymbolKind(symbolKind);
+            if (symbol && !some(symbol.declarations, d => isArrowFunction(d))) {
+                displayParts.push(spacePart());
+                addFullSymbolName(symbol);
+            }
+        }
+    }
+    function pushSymbolKind(symbolKind) {
+        switch (symbolKind) {
+            case "var" /* ScriptElementKind.variableElement */:
+            case "function" /* ScriptElementKind.functionElement */:
+            case "let" /* ScriptElementKind.letElement */:
+            case "const" /* ScriptElementKind.constElement */:
+                displayParts.push(textOrKeywordPart(symbolKind));
+                return;
+            default:
+                displayParts.push(punctuationPart(SyntaxKind.OpenParenToken));
+                displayParts.push(textOrKeywordPart(symbolKind));
+                displayParts.push(punctuationPart(SyntaxKind.CloseParenToken));
+                return;
+        }
+    }
+    function addSignatureDisplayParts(signature, allSignatures, flags = TypeFormatFlags.None) {
+        addRange(displayParts, signatureToDisplayParts(typeChecker, signature, enclosingDeclaration, flags | TypeFormatFlags.WriteTypeArgumentsOfSignature));
+        if (allSignatures.length > 1) {
+            displayParts.push(spacePart());
+            displayParts.push(punctuationPart(SyntaxKind.OpenParenToken));
+            displayParts.push(operatorPart(SyntaxKind.PlusToken));
+            displayParts.push(displayPart((allSignatures.length - 1).toString(), SymbolDisplayPartKind.numericLiteral));
+            displayParts.push(spacePart());
+            displayParts.push(textPart(allSignatures.length === 2 ? "overload" : "overloads"));
+            displayParts.push(punctuationPart(SyntaxKind.CloseParenToken));
+        }
+    }
+    function writeTypeParametersOfSymbol(symbol, enclosingDeclaration) {
+        const typeParameterParts = mapToDisplayParts(writer => {
+            const params = typeChecker.symbolToTypeParameterDeclarations(symbol, enclosingDeclaration, symbolDisplayNodeBuilderFlags);
+            getPrinter().writeList(ListFormat.TypeParameters, params, getSourceFileOfNode(getParseTreeNode(enclosingDeclaration)), writer);
+        });
+        addRange(displayParts, typeParameterParts);
+    }
+}
+function isLocalVariableOrFunction(symbol) {
+    if (symbol.parent) {
+        return false; // o símbolo exportado
+    }
+    return forEach(symbol.declarations, declaration => {
+        if (declaration.kind !== SyntaxKind.VariableDeclaration) {
+            return false;
+        }
+        // A variável é local se o caminho até o arquivo ou o bloco de módulo passa pelo bloco de uma função.
+        for (let parent = declaration.parent; !isFunctionBlock(parent); parent = parent.parent) {
+            if (parent.kind === SyntaxKind.SourceFile || parent.kind === SyntaxKind.ModuleBlock) {
+                return false;
+            }
+        }
+        return true;
+    });
+}

package/dist/textChanges.d.ts

@@ -0,0 +1,161 @@
+import { ScriptKind, SyntaxKind, formatting } from "./_namespaces/edit.js";
+import type { DeclarationStatement, Expression, FileTextChanges, LanguageServiceHost, Modifier, Node, NodeArray, ObjectLiteralElementLike, ObjectLiteralExpression, ParameterDeclaration, PropertyAssignment, PropertySignature, SignatureDeclaration, SourceFile, Statement, TextChange, TextRange, TypeNode, TypeParameterDeclaration, UserPreferences, VariableDeclaration, VariableStatement } from "./_namespaces/edit.js";
+export interface ConfigurableStart {
+    leadingTriviaOption?: LeadingTriviaOption;
+}
+export interface ConfigurableEnd {
+    trailingTriviaOption?: TrailingTriviaOption;
+}
+export declare enum LeadingTriviaOption {
+    /** Exclude all leading trivia (use getStart()) */
+    Exclude = 0,
+    /** Include leading trivia and,
+     * if there are no line breaks between the node and the previous token,
+     * include all trivia between the node and the previous token
+     */
+    IncludeAll = 1,
+    /**
+     * Only delete trivia on the same line as getStart().
+     * Used to avoid deleting leading comments
+     */
+    StartLine = 2
+}
+export declare enum TrailingTriviaOption {
+    /** Exclude all trailing trivia (use getEnd()) */
+    Exclude = 0,
+    /** Include trailing trivia */
+    Include = 1
+}
+/**
+ * Usually node.pos points to a position immediately after the previous token.
+ * If this position is used as a beginning of the span to remove - it might lead to removing the trailing trivia of the previous node, i.e:
+ * const x; // this is x
+ *        ^ - pos for the next variable declaration will point here
+ * const y; // this is y
+ *        ^ - end for previous variable declaration
+ * Usually leading trivia of the variable declaration 'y' should not include trailing trivia (whitespace, comment 'this is x' and newline) from the preceding
+ * variable declaration and trailing trivia for 'y' should include (whitespace, comment 'this is y', newline).
+ * By default when removing nodes we adjust start and end positions to respect specification of the trivia above.
+ * If pos\end should be interpreted literally (that is, withouth including leading and trailing trivia), `leadingTriviaOption` should be set to `LeadingTriviaOption.Exclude`
+ * and `trailingTriviaOption` to `TrailingTriviaOption.Exclude`.
+ */
+export interface ConfigurableStartEnd extends ConfigurableStart, ConfigurableEnd {
+}
+export interface InsertNodeOptions {
+    /**
+     * Text to be inserted before the new node
+     */
+    prefix?: string;
+    /**
+     * Text to be inserted after the new node
+     */
+    suffix?: string;
+    /**
+     * Text of inserted node will be formatted with this indentation, otherwise indentation will be inferred from the old node
+     */
+    indentation?: number;
+    /**
+     * Text of inserted node will be formatted with this delta, otherwise delta will be inferred from the new node kind
+     */
+    delta?: number;
+    /**
+     * Do not trim leading white spaces in the edit range
+     */
+    preserveLeadingWhitespace?: boolean;
+}
+export interface ReplaceWithMultipleNodesOptions extends InsertNodeOptions {
+    readonly joiner?: string;
+}
+export interface ChangeNodeOptions extends ConfigurableStartEnd, InsertNodeOptions {
+}
+export interface TextChangesContext {
+    host: LanguageServiceHost;
+    formatContext: formatting.FormatContext;
+    preferences: UserPreferences;
+}
+export type TypeAnnotatable = SignatureDeclaration | VariableDeclaration | ParameterDeclaration | PropertySignature;
+export declare class ChangeTracker {
+    private readonly newLineCharacter;
+    private readonly formatContext;
+    private readonly changes;
+    private readonly newFiles;
+    private readonly classesWithNodesInsertedAtStart;
+    private readonly deletedNodes;
+    static fromContext(context: TextChangesContext): ChangeTracker;
+    static with(context: TextChangesContext, cb: (tracker: ChangeTracker) => void): FileTextChanges[];
+    /** Public for tests only. Other callers should use `ChangeTracker.with`. */
+    constructor(newLineCharacter: string, formatContext: formatting.FormatContext);
+    pushRaw(sourceFile: SourceFile, change: FileTextChanges): void;
+    deleteRange(sourceFile: SourceFile, range: TextRange): void;
+    delete(sourceFile: SourceFile, node: Node | NodeArray<TypeParameterDeclaration>): void;
+    deleteNode(sourceFile: SourceFile, node: Node, options?: ConfigurableStartEnd): void;
+    deleteModifier(sourceFile: SourceFile, modifier: Modifier): void;
+    deleteNodeRange(sourceFile: SourceFile, startNode: Node, endNode: Node, options?: ConfigurableStartEnd): void;
+    deleteNodeRangeExcludingEnd(sourceFile: SourceFile, startNode: Node, afterEndNode: Node | undefined, options?: ConfigurableStartEnd): void;
+    replaceRange(sourceFile: SourceFile, range: TextRange, newNode: Node, options?: InsertNodeOptions): void;
+    replaceNode(sourceFile: SourceFile, oldNode: Node, newNode: Node, options?: ChangeNodeOptions): void;
+    replaceNodeRange(sourceFile: SourceFile, startNode: Node, endNode: Node, newNode: Node, options?: ChangeNodeOptions): void;
+    private replaceRangeWithNodes;
+    replaceNodeWithNodes(sourceFile: SourceFile, oldNode: Node, newNodes: readonly Node[], options?: ChangeNodeOptions): void;
+    replaceNodeWithText(sourceFile: SourceFile, oldNode: Node, text: string): void;
+    replaceNodeRangeWithNodes(sourceFile: SourceFile, startNode: Node, endNode: Node, newNodes: readonly Node[], options?: ReplaceWithMultipleNodesOptions & ConfigurableStartEnd): void;
+    private nextCommaToken;
+    replacePropertyAssignment(sourceFile: SourceFile, oldNode: PropertyAssignment, newNode: PropertyAssignment): void;
+    insertNodeAt(sourceFile: SourceFile, pos: number, newNode: Node, options?: InsertNodeOptions): void;
+    private insertNodesAt;
+    insertNodeAtTopOfFile(sourceFile: SourceFile, newNode: Statement, blankLineBetween: boolean): void;
+    insertNodesAtTopOfFile(sourceFile: SourceFile, newNodes: readonly Statement[], blankLineBetween: boolean): void;
+    private insertAtTopOfFile;
+    insertFirstParameter(sourceFile: SourceFile, parameters: NodeArray<ParameterDeclaration>, newParam: ParameterDeclaration): void;
+    insertNodeBefore(sourceFile: SourceFile, before: Node, newNode: Node, blankLineBetween?: boolean): void;
+    insertModifierBefore(sourceFile: SourceFile, modifier: SyntaxKind, before: Node): void;
+    insertLastModifierBefore(sourceFile: SourceFile, modifier: SyntaxKind, before: Node): void;
+    insertCommentBeforeLine(sourceFile: SourceFile, lineNumber: number, position: number, commentText: string): void;
+    replaceRangeWithText(sourceFile: SourceFile, range: TextRange, text: string): void;
+    insertText(sourceFile: SourceFile, pos: number, text: string): void;
+    /** Prefer this over replacing a node with another that has a type annotation, as it avoids reformatting the other parts of the node. */
+    tryInsertTypeAnnotation(sourceFile: SourceFile, node: TypeAnnotatable, type: TypeNode): boolean;
+    insertTypeParameters(sourceFile: SourceFile, node: SignatureDeclaration, typeParameters: readonly TypeParameterDeclaration[]): void;
+    private getOptionsForInsertNodeBefore;
+    insertNodeAtEndOfScope(sourceFile: SourceFile, scope: Node, newNode: Node): void;
+    insertNodeAtObjectStart(sourceFile: SourceFile, obj: ObjectLiteralExpression, newElement: ObjectLiteralElementLike): void;
+    private insertNodeAtStartWorker;
+    /**
+     * Tries to guess the indentation from the existing members of a class/interface/object. All members must be on
+     * new lines and must share the same indentation.
+     */
+    private guessIndentationFromExistingMembers;
+    private computeIndentationForNewMember;
+    private getInsertNodeAtStartInsertOptions;
+    insertNodeAfterComma(sourceFile: SourceFile, after: Node, newNode: Node): void;
+    insertNodeAfter(sourceFile: SourceFile, after: Node, newNode: Node): void;
+    insertNodeAtEndOfList(sourceFile: SourceFile, list: NodeArray<Node>, newNode: Node): void;
+    insertNodesAfter(sourceFile: SourceFile, after: Node, newNodes: readonly Node[]): void;
+    private insertNodeAfterWorker;
+    private getInsertNodeAfterOptions;
+    private getInsertNodeAfterOptionsWorker;
+    insertExportModifier(sourceFile: SourceFile, node: DeclarationStatement | VariableStatement): void;
+    /**
+     * This function should be used to insert nodes in lists when nodes don't carry separators as the part of the node range,
+     * i.e. arguments in arguments lists, parameters in parameter lists etc.
+     * Note that separators are part of the node in statements and class elements.
+     */
+    insertNodeInListAfter(sourceFile: SourceFile, after: Node, newNode: Node, containingList?: NodeArray<Node> | undefined): void;
+    parenthesizeExpression(sourceFile: SourceFile, expression: Expression): void;
+    private finishClassesWithNodesInsertedAtStart;
+    private finishDeleteDeclarations;
+    /**
+     * Note: after calling this, the TextChanges object must be discarded!
+     * @param validate only for tests
+     *    The reason we must validate as part of this method is that `getNonFormattedText` changes the node's positions,
+     *    so we can only call this once and can't get the non-formatted text separately.
+     */
+    getChanges(validate?: ValidateNonFormattedText): FileTextChanges[];
+    createNewFile(oldFile: SourceFile | undefined, fileName: string, statements: readonly Statement[]): void;
+}
+export type ValidateNonFormattedText = (node: Node, text: string) => void;
+export declare function getNewFileText(statements: readonly Statement[], scriptKind: ScriptKind, newLineCharacter: string, formatContext: formatting.FormatContext): string;
+export declare function applyChanges(text: string, changes: readonly TextChange[]): string;
+export declare function isValidLocationToAddComment(sourceFile: SourceFile, position: number): boolean;
+/** Warning: This deletes comments too. See `copyComments` in `convertFunctionToEs6Class`. */
+export declare function deleteNode(changes: ChangeTracker, sourceFile: SourceFile, node: Node, options?: ConfigurableStartEnd): void;