@tslite/services 0.0.0-stage → 1.13.0

package/dist/codefixes/removeUnnecessaryAwait.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/codefixes/removeUnnecessaryAwait.js

@@ -0,0 +1,41 @@
+// Modificado de microsoft/TypeScript v3.9.10, src/services/codefixes/removeUnnecessaryAwait.ts: o namespace virou módulo ES, com os imports explícitos.
+import { Diagnostics, SyntaxKind, findPrecedingToken, getLeftmostExpression, getTokenAtPosition, isAwaitExpression, isIdentifier, isParenthesizedExpression, textChanges, tryCast, } from "../_namespaces/edit.js";
+import { codeFixAll, createCodeFixAction, registerCodeFix, } from "../_namespaces/ts.codefix.js";
+const fixId = "removeUnnecessaryAwait";
+const errorCodes = [
+    Diagnostics.await_has_no_effect_on_the_type_of_this_expression.code,
+];
+registerCodeFix({
+    errorCodes,
+    getCodeActions: (context) => {
+        const changes = textChanges.ChangeTracker.with(context, t => makeChange(t, context.sourceFile, context.span));
+        if (changes.length > 0) {
+            return [createCodeFixAction(fixId, changes, Diagnostics.Remove_unnecessary_await, fixId, Diagnostics.Remove_all_unnecessary_uses_of_await)];
+        }
+    },
+    fixIds: [fixId],
+    getAllCodeActions: context => {
+        return codeFixAll(context, errorCodes, (changes, diag) => makeChange(changes, diag.file, diag));
+    },
+});
+function makeChange(changeTracker, sourceFile, span) {
+    const awaitKeyword = tryCast(getTokenAtPosition(sourceFile, span.start), (node) => node.kind === SyntaxKind.AwaitKeyword);
+    const awaitExpression = awaitKeyword && tryCast(awaitKeyword.parent, isAwaitExpression);
+    if (!awaitExpression) {
+        return;
+    }
+    let expressionToReplace = awaitExpression;
+    const hasSurroundingParens = isParenthesizedExpression(awaitExpression.parent);
+    if (hasSurroundingParens) {
+        // Na tag, com o `stopAtCallExpressions` desligado, que a cópia tirou porque todo chamador o desligava.
+        const leftMostExpression = getLeftmostExpression(awaitExpression.expression);
+        if (isIdentifier(leftMostExpression)) {
+            const precedingToken = findPrecedingToken(awaitExpression.parent.pos, sourceFile);
+            // Na tag, o `new (await x)()` ficava com os parênteses; o `new` saiu (CK-02, CK-56).
+            if (precedingToken) {
+                expressionToReplace = awaitExpression.parent;
+            }
+        }
+    }
+    changeTracker.replaceNode(sourceFile, expressionToReplace, awaitExpression.expression);
+}

package/dist/codefixes/returnValueCorrect.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/codefixes/returnValueCorrect.js

@@ -0,0 +1,132 @@
+// Modificado de microsoft/TypeScript v3.9.10, src/services/codefixes/returnValueCorrect.ts: o namespace virou módulo ES, com os imports explícitos.
+import { Debug, Diagnostics, SyntaxKind, append, copyComments, createBlock, createParen, createReturn, findAncestor, first, getTokenAtPosition, isArrowFunction, isBlock, isCallExpression, isDeclarationName, isExpressionStatement, isFunctionLikeDeclaration, isJsxAttribute, isJsxExpression, isVariableLike, length, needsParentheses, probablyUsesSemicolons, rangeContainsRange, suppressLeadingAndTrailingTrivia, textChanges, updateFunctionLikeBody, } from "../_namespaces/edit.js";
+import { codeFixAll, createCodeFixAction, registerCodeFix, } from "../_namespaces/ts.codefix.js";
+const fixId = "returnValueCorrect";
+const fixIdAddReturnStatement = "fixAddReturnStatement";
+const fixIdRemoveBlockBodyBrace = "fixRemoveBlockBodyBrace";
+// Na tag, também o `fixWrapTheBlockWithParen`, que punha entre parênteses o corpo de uma arrow que o parser lia como um
+// statement com label (`() => { a: 1 }`); o label saiu (CK-02), e com ele o caso que o fix tratava.
+const errorCodes = [
+    Diagnostics.A_function_whose_declared_type_is_neither_void_nor_any_must_return_a_value.code,
+    Diagnostics.Type_0_is_not_assignable_to_type_1.code,
+    Diagnostics.Argument_of_type_0_is_not_assignable_to_parameter_of_type_1.code
+];
+// Na tag, também o problema dos parênteses que faltavam em volta de um object literal lido como label (CK-02).
+var ProblemKind;
+(function (ProblemKind) {
+    ProblemKind[ProblemKind["MissingReturnStatement"] = 0] = "MissingReturnStatement";
+})(ProblemKind || (ProblemKind = {}));
+registerCodeFix({
+    errorCodes,
+    fixIds: [fixIdAddReturnStatement, fixIdRemoveBlockBodyBrace],
+    getCodeActions: context => {
+        const { program, sourceFile, span: { start }, errorCode } = context;
+        const info = getInfo(program.getTypeChecker(), sourceFile, start, errorCode);
+        if (!info)
+            return undefined;
+        return append([getActionForfixAddReturnStatement(context, info.expression, info.statement)], isArrowFunction(info.declaration) ? getActionForfixRemoveBlockBodyBrace(context, info.declaration, info.expression, info.commentSource) : undefined);
+    },
+    getAllCodeActions: context => codeFixAll(context, errorCodes, (changes, diag) => {
+        const info = getInfo(context.program.getTypeChecker(), diag.file, diag.start, diag.code);
+        if (!info)
+            return undefined;
+        switch (context.fixId) {
+            case fixIdAddReturnStatement:
+                addReturnStatement(changes, diag.file, info.expression, info.statement);
+                break;
+            case fixIdRemoveBlockBodyBrace:
+                if (!isArrowFunction(info.declaration))
+                    return undefined;
+                removeBlockBodyBrace(changes, diag.file, info.declaration, info.expression, info.commentSource, /* withParen */ false);
+                break;
+            default:
+                Debug.fail(JSON.stringify(context.fixId));
+        }
+    }),
+});
+function getFixInfo(checker, declaration, expectType, isFunctionType) {
+    if (!declaration.body || !isBlock(declaration.body) || length(declaration.body.statements) !== 1)
+        return undefined;
+    const firstStatement = first(declaration.body.statements);
+    if (isExpressionStatement(firstStatement) && checkFixedAssignableTo(checker, declaration, firstStatement.expression, expectType, isFunctionType)) {
+        return {
+            declaration,
+            kind: ProblemKind.MissingReturnStatement,
+            expression: firstStatement.expression,
+            statement: firstStatement,
+            commentSource: firstStatement.expression
+        };
+    }
+    // Na tag, também o statement com label, sozinho ou num bloco, que o parser lia onde se queria um object literal
+    // (`{ a: 1 }`), e que o fix trocava pelo objeto (CK-02).
+    return undefined;
+}
+function checkFixedAssignableTo(checker, declaration, expr, type, isFunctionType) {
+    return checker.isTypeAssignableTo(checker.getTypeAtLocation(isFunctionType ? updateFunctionLikeBody(declaration, createBlock([createReturn(expr)])) : expr), type);
+}
+function getInfo(checker, sourceFile, position, errorCode) {
+    const node = getTokenAtPosition(sourceFile, position);
+    if (!node.parent)
+        return undefined;
+    const declaration = findAncestor(node.parent, isFunctionLikeDeclaration);
+    switch (errorCode) {
+        case Diagnostics.A_function_whose_declared_type_is_neither_void_nor_any_must_return_a_value.code:
+            if (!declaration || !declaration.body || !declaration.type || !rangeContainsRange(declaration.type, node))
+                return undefined;
+            return getFixInfo(checker, declaration, checker.getTypeFromTypeNode(declaration.type), /* isFunctionType */ false);
+        case Diagnostics.Argument_of_type_0_is_not_assignable_to_parameter_of_type_1.code:
+            if (!declaration || !isCallExpression(declaration.parent) || !declaration.body)
+                return undefined;
+            const pos = declaration.parent.arguments.indexOf(declaration);
+            const type = checker.getContextualTypeForArgumentAtIndex(declaration.parent, pos);
+            if (!type)
+                return undefined;
+            return getFixInfo(checker, declaration, type, /* isFunctionType */ true);
+        case Diagnostics.Type_0_is_not_assignable_to_type_1.code:
+            if (!isDeclarationName(node) || !isVariableLike(node.parent) && !isJsxAttribute(node.parent))
+                return undefined;
+            const initializer = getVariableLikeInitializer(node.parent);
+            if (!initializer || !isFunctionLikeDeclaration(initializer) || !initializer.body)
+                return undefined;
+            return getFixInfo(checker, initializer, checker.getTypeAtLocation(node.parent), /* isFunctionType */ true);
+    }
+    return undefined;
+}
+// Na tag, também a propriedade de classe, o membro de enum (CK-02) e as tags do JSDoc (CK-03).
+function getVariableLikeInitializer(declaration) {
+    switch (declaration.kind) {
+        case SyntaxKind.VariableDeclaration:
+        case SyntaxKind.Parameter:
+        case SyntaxKind.BindingElement:
+        case SyntaxKind.PropertyAssignment:
+            return declaration.initializer;
+        case SyntaxKind.JsxAttribute:
+            return declaration.initializer && (isJsxExpression(declaration.initializer) ? declaration.initializer.expression : undefined);
+        case SyntaxKind.ShorthandPropertyAssignment:
+        case SyntaxKind.PropertySignature:
+            return undefined;
+    }
+}
+function addReturnStatement(changes, sourceFile, expression, statement) {
+    suppressLeadingAndTrailingTrivia(expression);
+    const probablyNeedSemi = probablyUsesSemicolons(sourceFile);
+    changes.replaceNode(sourceFile, statement, createReturn(expression), {
+        leadingTriviaOption: textChanges.LeadingTriviaOption.Exclude,
+        trailingTriviaOption: textChanges.TrailingTriviaOption.Exclude,
+        suffix: probablyNeedSemi ? ";" : undefined
+    });
+}
+function removeBlockBodyBrace(changes, sourceFile, declaration, expression, commentSource, withParen) {
+    const newBody = (withParen || needsParentheses(expression)) ? createParen(expression) : expression;
+    suppressLeadingAndTrailingTrivia(commentSource);
+    copyComments(commentSource, newBody);
+    changes.replaceNode(sourceFile, declaration.body, newBody);
+}
+function getActionForfixAddReturnStatement(context, expression, statement) {
+    const changes = textChanges.ChangeTracker.with(context, t => addReturnStatement(t, context.sourceFile, expression, statement));
+    return createCodeFixAction(fixId, changes, Diagnostics.Add_a_return_statement, fixIdAddReturnStatement, Diagnostics.Add_all_missing_return_statement);
+}
+function getActionForfixRemoveBlockBodyBrace(context, declaration, expression, commentSource) {
+    const changes = textChanges.ChangeTracker.with(context, t => removeBlockBodyBrace(t, context.sourceFile, declaration, expression, commentSource, /* withParen */ false));
+    return createCodeFixAction(fixId, changes, Diagnostics.Remove_block_body_braces, fixIdRemoveBlockBodyBrace, Diagnostics.Remove_all_incorrect_body_block_braces);
+}

package/dist/codefixes/splitTypeOnlyImport.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/codefixes/splitTypeOnlyImport.js

@@ -0,0 +1,32 @@
+// Modificado de microsoft/TypeScript v3.9.10, src/services/codefixes/splitTypeOnlyImport.ts: o namespace virou módulo ES, com os imports explícitos.
+import { Debug, Diagnostics, createImportDeclaration, findAncestor, getTokenAtPosition, isImportDeclaration, textChanges, updateImportClause, updateImportDeclaration, } from "../_namespaces/edit.js";
+import { codeFixAll, createCodeFixAction, registerCodeFix, } from "../_namespaces/ts.codefix.js";
+const errorCodes = [Diagnostics.A_type_only_import_can_specify_a_default_import_or_named_bindings_but_not_both.code];
+const fixId = "splitTypeOnlyImport";
+registerCodeFix({
+    errorCodes,
+    fixIds: [fixId],
+    getCodeActions: context => {
+        const changes = textChanges.ChangeTracker.with(context, t => {
+            return splitTypeOnlyImport(t, getImportDeclaration(context.sourceFile, context.span), context);
+        });
+        if (changes.length) {
+            return [createCodeFixAction(fixId, changes, Diagnostics.Split_into_two_separate_import_declarations, fixId, Diagnostics.Split_all_invalid_type_only_imports)];
+        }
+    },
+    getAllCodeActions: context => codeFixAll(context, errorCodes, (changes, error) => {
+        splitTypeOnlyImport(changes, getImportDeclaration(context.sourceFile, error), context);
+    }),
+});
+function getImportDeclaration(sourceFile, span) {
+    return findAncestor(getTokenAtPosition(sourceFile, span.start), isImportDeclaration);
+}
+function splitTypeOnlyImport(changes, importDeclaration, context) {
+    if (!importDeclaration) {
+        return;
+    }
+    const importClause = Debug.checkDefined(importDeclaration.importClause);
+    changes.replaceNode(context.sourceFile, importDeclaration, updateImportDeclaration(importDeclaration, importDeclaration.modifiers, updateImportClause(importClause, importClause.name, /*namedBindings*/ undefined, importClause.isTypeOnly), importDeclaration.moduleSpecifier));
+    changes.insertNodeAfter(context.sourceFile, importDeclaration, createImportDeclaration(
+    /*modifiers*/ undefined, updateImportClause(importClause, /*name*/ undefined, importClause.namedBindings, importClause.isTypeOnly), importDeclaration.moduleSpecifier));
+}

package/dist/codefixes/useBigintLiteral.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/codefixes/useBigintLiteral.js

@@ -0,0 +1,29 @@
+// Modificado de microsoft/TypeScript v3.9.10, src/services/codefixes/useBigintLiteral.ts: o namespace virou módulo ES, com os imports explícitos.
+import { Diagnostics, createBigIntLiteral, getTokenAtPosition, isNumericLiteral, textChanges, tryCast, } from "../_namespaces/edit.js";
+import { codeFixAll, createCodeFixAction, registerCodeFix, } from "../_namespaces/ts.codefix.js";
+const fixId = "useBigintLiteral";
+const errorCodes = [
+    Diagnostics.Numeric_literals_with_absolute_values_equal_to_2_53_or_greater_are_too_large_to_be_represented_accurately_as_integers.code,
+];
+registerCodeFix({
+    errorCodes,
+    getCodeActions: context => {
+        const changes = textChanges.ChangeTracker.with(context, t => makeChange(t, context.sourceFile, context.span));
+        if (changes.length > 0) {
+            return [createCodeFixAction(fixId, changes, Diagnostics.Convert_to_a_bigint_numeric_literal, fixId, Diagnostics.Convert_all_to_bigint_numeric_literals)];
+        }
+    },
+    fixIds: [fixId],
+    getAllCodeActions: context => {
+        return codeFixAll(context, errorCodes, (changes, diag) => makeChange(changes, diag.file, diag));
+    },
+});
+function makeChange(changeTracker, sourceFile, span) {
+    const numericLiteral = tryCast(getTokenAtPosition(sourceFile, span.start), isNumericLiteral);
+    if (!numericLiteral) {
+        return;
+    }
+    // We use .getText to overcome parser inaccuracies: https://github.com/microsoft/TypeScript/issues/33298
+    const newText = numericLiteral.getText(sourceFile) + "n";
+    changeTracker.replaceNode(sourceFile, numericLiteral, createBigIntLiteral(newText));
+}

package/dist/completions.d.ts

@@ -0,0 +1,83 @@
+import { ScriptElementKind, ScriptTarget } from "./_namespaces/ts.js";
+import type { CancellationToken, CheckResult, CodeAction, CompletionEntry, CompletionEntryDetails, CompletionInfo, CompletionsTriggerCharacter, FormatCodeSettings, Identifier, JSDocTagInfo, LanguageServiceHost, Node, PropertyAccessExpression, Push, SourceFile, Symbol, SymbolDisplayPart, TypeChecker, UserPreferences } from "./_namespaces/ts.js";
+/**
+ * O auto-import do completion: o que lista os módulos de que se importa e o que monta a edição do import. Os dois são
+ * da edição (o `importFixes.ts` da tag, com o `textChanges` e o `formatting`), e a leitura não os carrega: a edição os
+ * registra ao carregar (CK-67). Sem ela, o completion não oferece o auto-import.
+ */
+export interface AutoImportProvider {
+    forEachExternalModuleToImportFrom(program: CheckResult, host: LanguageServiceHost, from: SourceFile, cb: (module: Symbol) => void): void;
+    getImportCompletionAction(exportedSymbol: Symbol, moduleSymbol: Symbol, sourceFile: SourceFile, symbolName: string, host: LanguageServiceHost, program: CheckResult, formatOptions: FormatCodeSettings | undefined, position: number, preferences: UserPreferences): {
+        readonly moduleSpecifier: string;
+        readonly codeAction: CodeAction;
+    };
+}
+/** Registra o auto-import do completion: quem o chama é a edição, ao carregar (CK-67). */
+export declare function registerAutoImportProvider(provider: AutoImportProvider): void;
+export declare enum SortText {
+    LocationPriority = "0",
+    OptionalMember = "1",
+    MemberDeclaredBySpreadAssignment = "2",
+    SuggestedClassMembers = "3",
+    GlobalsOrKeywords = "4",
+    AutoImportSuggestions = "5",
+    JavascriptIdentifiers = "6"
+}
+export type Log = (message: string) => void;
+declare enum SymbolOriginInfoKind {
+    SymbolMember = 2,
+    Export = 4,
+    Promise = 8,
+    Nullable = 16,
+    SymbolMemberNoExport = 2,
+    SymbolMemberExport = 6
+}
+interface SymbolOriginInfo {
+    kind: SymbolOriginInfoKind;
+}
+interface SymbolOriginInfoExport extends SymbolOriginInfo {
+    kind: SymbolOriginInfoKind;
+    moduleSymbol: Symbol;
+    isDefaultExport: boolean;
+}
+interface UniqueNameSet {
+    add(name: string): void;
+    has(name: string): boolean;
+}
+/**
+ * Map from symbol id -> SymbolOriginInfo.
+ * Only populated for symbols that come from other modules.
+ */
+type SymbolOriginInfoMap = (SymbolOriginInfo | SymbolOriginInfoExport | undefined)[];
+type SymbolSortTextMap = (SortText | undefined)[];
+export interface AutoImportSuggestion {
+    symbol: Symbol;
+    symbolName: string;
+    skipFilter: boolean;
+    origin: SymbolOriginInfoExport;
+}
+export declare function getCompletionsAtPosition(host: LanguageServiceHost, program: CheckResult, log: Log, sourceFile: SourceFile, position: number, preferences: UserPreferences, triggerCharacter: CompletionsTriggerCharacter | undefined): CompletionInfo | undefined;
+export declare function getCompletionEntriesFromSymbols(symbols: readonly Symbol[], entries: Push<CompletionEntry>, contextToken: Node | undefined, location: Node | undefined, sourceFile: SourceFile, typeChecker: TypeChecker, target: ScriptTarget, log: Log, kind: CompletionKind, preferences: UserPreferences, propertyAccessToConvert?: PropertyAccessExpression, jsxIdentifierExpected?: boolean, isJsxInitializer?: IsJsxInitializer, symbolToOriginInfoMap?: SymbolOriginInfoMap, symbolToSortTextMap?: SymbolSortTextMap): UniqueNameSet;
+export interface CompletionEntryIdentifier {
+    name: string;
+    source?: string;
+}
+/**
+ * O detalhe de um item do completion. Na tag, quem chama monta o contexto de formatação, que só a ação do auto-import
+ * usa; aqui, as opções de formatação seguem cruas até o auto-import da edição, que monta o contexto (CK-67).
+ */
+export declare function getCompletionEntryDetails(program: CheckResult, log: Log, sourceFile: SourceFile, position: number, entryId: CompletionEntryIdentifier, host: LanguageServiceHost, formatOptions: FormatCodeSettings | undefined, preferences: UserPreferences, cancellationToken: CancellationToken): CompletionEntryDetails | undefined;
+export declare function createCompletionDetailsForSymbol(symbol: Symbol, checker: TypeChecker, sourceFile: SourceFile, location: Node, cancellationToken: CancellationToken, codeActions?: CodeAction[], sourceDisplay?: SymbolDisplayPart[]): CompletionEntryDetails;
+export declare function createCompletionDetails(name: string, kindModifiers: string, kind: ScriptElementKind, displayParts: SymbolDisplayPart[], documentation?: SymbolDisplayPart[], tags?: JSDocTagInfo[], codeActions?: CodeAction[], source?: SymbolDisplayPart[]): CompletionEntryDetails;
+export declare function getCompletionEntrySymbol(program: CheckResult, log: Log, sourceFile: SourceFile, position: number, entryId: CompletionEntryIdentifier, host: LanguageServiceHost, preferences: UserPreferences): Symbol | undefined;
+/** true: after the `=` sign but no identifier has been typed yet. Else is the Identifier after the initializer. */
+type IsJsxInitializer = boolean | Identifier;
+export declare enum CompletionKind {
+    ObjectPropertyDeclaration = 0,
+    Global = 1,
+    PropertyAccess = 2,
+    MemberLike = 3,
+    String = 4,
+    None = 5
+}
+export {};