@tslite/services 0.0.0-stage → 1.12.0

package/dist/codefixes/fixAwaitInSyncFunction.js

@@ -0,0 +1,69 @@
+// Modificado de microsoft/TypeScript v3.9.10, src/services/codefixes/fixAwaitInSyncFunction.ts: o namespace virou módulo ES, com os imports explícitos.
+import { Diagnostics, SyntaxKind, addToSeen, createMap, createNodeArray, createTypeReferenceNode, findChildOfKind, first, getContainingFunction, getEntityNameFromTypeNode, getNodeId, getTokenAtPosition, isFunctionTypeNode, isVariableDeclaration, textChanges, } from "../_namespaces/edit.js";
+import { codeFixAll, createCodeFixAction, registerCodeFix, } from "../_namespaces/ts.codefix.js";
+const fixId = "fixAwaitInSyncFunction";
+const errorCodes = [
+    Diagnostics.await_expressions_are_only_allowed_within_async_functions_and_at_the_top_levels_of_modules.code,
+    Diagnostics.A_for_await_of_statement_is_only_allowed_within_an_async_function_or_async_generator.code,
+];
+registerCodeFix({
+    errorCodes,
+    getCodeActions(context) {
+        const { sourceFile, span } = context;
+        const nodes = getNodes(sourceFile, span.start);
+        if (!nodes)
+            return undefined;
+        const changes = textChanges.ChangeTracker.with(context, t => doChange(t, sourceFile, nodes));
+        return [createCodeFixAction(fixId, changes, Diagnostics.Add_async_modifier_to_containing_function, fixId, Diagnostics.Add_all_missing_async_modifiers)];
+    },
+    fixIds: [fixId],
+    getAllCodeActions: context => {
+        const seen = createMap();
+        return codeFixAll(context, errorCodes, (changes, diag) => {
+            const nodes = getNodes(diag.file, diag.start);
+            if (!nodes || !addToSeen(seen, getNodeId(nodes.insertBefore)))
+                return;
+            doChange(changes, context.sourceFile, nodes);
+        });
+    },
+});
+// Na tag, também a `function` declarada, o método e a function expression (CK-02).
+function getReturnType(expr) {
+    if (expr.type) {
+        return expr.type;
+    }
+    if (isVariableDeclaration(expr.parent) &&
+        expr.parent.type &&
+        isFunctionTypeNode(expr.parent.type)) {
+        return expr.parent.type.type;
+    }
+}
+function getNodes(sourceFile, start) {
+    const token = getTokenAtPosition(sourceFile, start);
+    const containingFunction = getContainingFunction(token);
+    if (!containingFunction) {
+        return;
+    }
+    let insertBefore;
+    // Na tag, o `async` entrava também antes do nome de um método e antes do `function` (CK-02).
+    switch (containingFunction.kind) {
+        case SyntaxKind.ArrowFunction:
+            insertBefore = findChildOfKind(containingFunction, SyntaxKind.OpenParenToken, sourceFile) || first(containingFunction.parameters);
+            break;
+        default:
+            return;
+    }
+    return insertBefore && {
+        insertBefore,
+        returnType: getReturnType(containingFunction)
+    };
+}
+function doChange(changes, sourceFile, { insertBefore, returnType }) {
+    if (returnType) {
+        const entityName = getEntityNameFromTypeNode(returnType);
+        if (!entityName || entityName.kind !== SyntaxKind.Identifier || entityName.text !== "Promise") {
+            changes.replaceNode(sourceFile, returnType, createTypeReferenceNode("Promise", createNodeArray([returnType])));
+        }
+    }
+    changes.insertModifierBefore(sourceFile, SyntaxKind.AsyncKeyword, insertBefore);
+}

package/dist/codefixes/fixExpectedComma.d.ts

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

package/dist/codefixes/fixExpectedComma.js

@@ -0,0 +1,35 @@
+// Modificado de microsoft/TypeScript v3.9.10, src/services/codefixes/fixExpectedComma.ts: o namespace virou módulo ES, com os imports explícitos.
+import { Diagnostics, SyntaxKind, createNode, getTokenAtPosition, isArrayLiteralExpression, isObjectLiteralExpression, textChanges, } from "../_namespaces/edit.js";
+import { codeFixAll, createCodeFixAction, registerCodeFix, } from "../_namespaces/ts.codefix.js";
+const fixId = "fixExpectedComma";
+const expectedErrorCode = Diagnostics._0_expected.code;
+const errorCodes = [expectedErrorCode];
+registerCodeFix({
+    errorCodes,
+    getCodeActions(context) {
+        const { sourceFile } = context;
+        const info = getInfo(sourceFile, context.span.start, context.errorCode);
+        if (!info) {
+            return undefined;
+        }
+        const changes = textChanges.ChangeTracker.with(context, t => doChange(t, sourceFile, info));
+        return [createCodeFixAction(fixId, changes, [Diagnostics.Change_0_to_1, ";", ","], fixId, [Diagnostics.Change_0_to_1, ";", ","])];
+    },
+    fixIds: [fixId],
+    getAllCodeActions: context => codeFixAll(context, errorCodes, (changes, diag) => {
+        const info = getInfo(diag.file, diag.start, diag.code);
+        if (info)
+            doChange(changes, context.sourceFile, info);
+    }),
+});
+function getInfo(sourceFile, pos, _) {
+    const node = getTokenAtPosition(sourceFile, pos);
+    return (node.kind === SyntaxKind.SemicolonToken &&
+        node.parent &&
+        (isObjectLiteralExpression(node.parent) ||
+            isArrayLiteralExpression(node.parent))) ? { node } : undefined;
+}
+function doChange(changes, sourceFile, { node }) {
+    const newNode = createNode(SyntaxKind.CommaToken);
+    changes.replaceNode(sourceFile, node, newNode);
+}

package/dist/codefixes/fixInvalidJsxCharacters.d.ts

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

package/dist/codefixes/fixInvalidJsxCharacters.js

@@ -0,0 +1,41 @@
+// Modificado de microsoft/TypeScript v3.9.10, src/services/codefixes/fixInvalidJsxCharacters.ts: o namespace virou módulo ES, com os imports explícitos.
+import { Diagnostics, hasProperty, quote, textChanges, } from "../_namespaces/edit.js";
+import { codeFixAll, createCodeFixAction, registerCodeFix, } from "../_namespaces/ts.codefix.js";
+const fixIdExpression = "fixInvalidJsxCharacters_expression";
+const fixIdHtmlEntity = "fixInvalidJsxCharacters_htmlEntity";
+const errorCodes = [
+    Diagnostics.Unexpected_token_Did_you_mean_or_gt.code,
+    Diagnostics.Unexpected_token_Did_you_mean_or_rbrace.code
+];
+registerCodeFix({
+    errorCodes,
+    fixIds: [fixIdExpression, fixIdHtmlEntity],
+    getCodeActions(context) {
+        const { sourceFile, preferences, span } = context;
+        const changeToExpression = textChanges.ChangeTracker.with(context, t => doChange(t, preferences, sourceFile, span.start, /* useHtmlEntity */ false));
+        const changeToHtmlEntity = textChanges.ChangeTracker.with(context, t => doChange(t, preferences, sourceFile, span.start, /* useHtmlEntity */ true));
+        return [
+            createCodeFixAction(fixIdExpression, changeToExpression, Diagnostics.Wrap_invalid_character_in_an_expression_container, fixIdExpression, Diagnostics.Wrap_all_invalid_characters_in_an_expression_container),
+            createCodeFixAction(fixIdHtmlEntity, changeToHtmlEntity, Diagnostics.Convert_invalid_character_to_its_html_entity_code, fixIdHtmlEntity, Diagnostics.Convert_all_invalid_characters_to_HTML_entity_code)
+        ];
+    },
+    getAllCodeActions(context) {
+        return codeFixAll(context, errorCodes, (changes, diagnostic) => doChange(changes, context.preferences, diagnostic.file, diagnostic.start, context.fixId === fixIdHtmlEntity));
+    }
+});
+const htmlEntity = {
+    ">": ">",
+    "}": "}",
+};
+function isValidCharacter(character) {
+    return hasProperty(htmlEntity, character);
+}
+function doChange(changes, preferences, sourceFile, start, useHtmlEntity) {
+    const character = sourceFile.getText()[start];
+    // sanity check
+    if (!isValidCharacter(character)) {
+        return;
+    }
+    const replacement = useHtmlEntity ? htmlEntity[character] : `{${quote(character, preferences)}}`;
+    changes.replaceRangeWithText(sourceFile, { pos: start, end: start + 1 }, replacement);
+}

package/dist/codefixes/fixMissingCallParentheses.d.ts

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

package/dist/codefixes/fixMissingCallParentheses.js

@@ -0,0 +1,42 @@
+// Modificado de microsoft/TypeScript v3.9.10, src/services/codefixes/fixMissingCallParentheses.ts: o namespace virou módulo ES, com os imports explícitos.
+import { Diagnostics, getTokenAtPosition, isIdentifier, isPropertyAccessExpression, textChanges, } from "../_namespaces/edit.js";
+import { codeFixAll, createCodeFixAction, registerCodeFix, } from "../_namespaces/ts.codefix.js";
+const fixId = "fixMissingCallParentheses";
+const errorCodes = [
+    Diagnostics.This_condition_will_always_return_true_since_the_function_is_always_defined_Did_you_mean_to_call_it_instead.code,
+];
+registerCodeFix({
+    errorCodes,
+    fixIds: [fixId],
+    getCodeActions(context) {
+        const { sourceFile, span } = context;
+        const callName = getCallName(sourceFile, span.start);
+        if (!callName)
+            return;
+        const changes = textChanges.ChangeTracker.with(context, t => doChange(t, context.sourceFile, callName));
+        return [createCodeFixAction(fixId, changes, Diagnostics.Add_missing_call_parentheses, fixId, Diagnostics.Add_all_missing_call_parentheses)];
+    },
+    getAllCodeActions: context => codeFixAll(context, errorCodes, (changes, diag) => {
+        const callName = getCallName(diag.file, diag.start);
+        if (callName)
+            doChange(changes, diag.file, callName);
+    })
+});
+// Na tag, o nome podia ser também um `#private` (CK-02).
+function doChange(changes, sourceFile, name) {
+    changes.replaceNodeWithText(sourceFile, name, `${name.text}()`);
+}
+function getCallName(sourceFile, start) {
+    const token = getTokenAtPosition(sourceFile, start);
+    if (isPropertyAccessExpression(token.parent)) {
+        let current = token.parent;
+        while (isPropertyAccessExpression(current.parent)) {
+            current = current.parent;
+        }
+        return current.name;
+    }
+    if (isIdentifier(token)) {
+        return token;
+    }
+    return undefined;
+}

package/dist/codefixes/fixSpelling.d.ts

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

package/dist/codefixes/fixSpelling.js

@@ -0,0 +1,94 @@
+// Modificado de microsoft/TypeScript v3.9.10, src/services/codefixes/fixSpelling.ts: o namespace virou módulo ES, com os imports explícitos.
+import { Debug, Diagnostics, NodeFlags, ScriptTarget, SymbolFlags, createElementAccess, createIdentifier, createLiteral, findAncestor, getMeaningFromLocation, getResolvedModule, getTextOfNode, getTokenAtPosition, isIdentifier, isIdentifierText, isImportDeclaration, isImportSpecifier, isPropertyAccessExpression, isStringLiteralLike, symbolName, textChanges, } from "../_namespaces/edit.js";
+import { codeFixAll, createCodeFixAction, registerCodeFix, } from "../_namespaces/ts.codefix.js";
+const fixId = "fixSpelling";
+// Na tag, também o nome que seria um membro do `this` ou um membro estático (CK-02): a cópia não acusa esses erros.
+const errorCodes = [
+    Diagnostics.Property_0_does_not_exist_on_type_1_Did_you_mean_2.code,
+    Diagnostics.Cannot_find_name_0_Did_you_mean_1.code,
+    Diagnostics.Module_0_has_no_exported_member_1_Did_you_mean_2.code,
+];
+// O alvo da configuração fixa (CK-24): na tag, ele vinha das opções do host.
+const languageVersion = ScriptTarget.ES2020;
+registerCodeFix({
+    errorCodes,
+    getCodeActions(context) {
+        const { sourceFile } = context;
+        const info = getInfo(sourceFile, context.span.start, context);
+        if (!info)
+            return undefined;
+        const { node, suggestedSymbol } = info;
+        const changes = textChanges.ChangeTracker.with(context, t => doChange(t, sourceFile, node, suggestedSymbol, languageVersion));
+        return [createCodeFixAction("spelling", changes, [Diagnostics.Change_spelling_to_0, symbolName(suggestedSymbol)], fixId, Diagnostics.Fix_all_detected_spelling_errors)];
+    },
+    fixIds: [fixId],
+    getAllCodeActions: context => codeFixAll(context, errorCodes, (changes, diag) => {
+        const info = getInfo(diag.file, diag.start, context);
+        if (info)
+            doChange(changes, context.sourceFile, info.node, info.suggestedSymbol, languageVersion);
+    }),
+});
+function getInfo(sourceFile, pos, context) {
+    // This is the identifier of the misspelled word. eg:
+    // this.speling = 1;
+    //      ^^^^^^^
+    const node = getTokenAtPosition(sourceFile, pos);
+    const parent = node.parent;
+    const checker = context.program.getTypeChecker();
+    let suggestedSymbol;
+    if (isPropertyAccessExpression(parent) && parent.name === node) {
+        // Na tag, o nome podia ser também um `#private` (CK-02).
+        Debug.assert(isIdentifier(node), "Expected an identifier for spelling (property access)");
+        let containingType = checker.getTypeAtLocation(parent.expression);
+        if (parent.flags & NodeFlags.OptionalChain) {
+            containingType = checker.getNonNullableType(containingType);
+        }
+        suggestedSymbol = checker.getSuggestedSymbolForNonexistentProperty(node, containingType);
+    }
+    else if (isImportSpecifier(parent) && parent.name === node) {
+        Debug.assertNode(node, isIdentifier, "Expected an identifier for spelling (import)");
+        const importDeclaration = findAncestor(node, isImportDeclaration);
+        const resolvedSourceFile = getResolvedSourceFileFromImportDeclaration(sourceFile, context, importDeclaration);
+        if (resolvedSourceFile && resolvedSourceFile.symbol) {
+            suggestedSymbol = checker.getSuggestedSymbolForNonexistentModule(node, resolvedSourceFile.symbol);
+        }
+    }
+    else {
+        const meaning = getMeaningFromLocation(node);
+        const name = getTextOfNode(node);
+        Debug.assert(name !== undefined, "name should be defined");
+        suggestedSymbol = checker.getSuggestedSymbolForNonexistentSymbol(node, name, convertSemanticMeaningToSymbolFlags(meaning));
+    }
+    return suggestedSymbol === undefined ? undefined : { node, suggestedSymbol };
+}
+function doChange(changes, sourceFile, node, suggestedSymbol, target) {
+    const suggestion = symbolName(suggestedSymbol);
+    if (!isIdentifierText(suggestion, target) && isPropertyAccessExpression(node.parent)) {
+        // Na tag, o `#private` sugerido trocava só o nome (CK-02).
+        changes.replaceNode(sourceFile, node.parent, createElementAccess(node.parent.expression, createLiteral(suggestion)));
+    }
+    else {
+        changes.replaceNode(sourceFile, node, createIdentifier(suggestion));
+    }
+}
+function convertSemanticMeaningToSymbolFlags(meaning) {
+    let flags = 0;
+    if (meaning & 4 /* SemanticMeaning.Namespace */) {
+        flags |= SymbolFlags.Namespace;
+    }
+    if (meaning & 2 /* SemanticMeaning.Type */) {
+        flags |= SymbolFlags.Type;
+    }
+    if (meaning & 1 /* SemanticMeaning.Value */) {
+        flags |= SymbolFlags.Value;
+    }
+    return flags;
+}
+function getResolvedSourceFileFromImportDeclaration(sourceFile, context, importDeclaration) {
+    if (!importDeclaration || !isStringLiteralLike(importDeclaration.moduleSpecifier))
+        return undefined;
+    const resolvedModule = getResolvedModule(sourceFile, importDeclaration.moduleSpecifier.text);
+    if (!resolvedModule)
+        return undefined;
+    return context.program.getSourceFile(resolvedModule.resolvedFileName);
+}

package/dist/codefixes/fixUnreachableCode.d.ts

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

package/dist/codefixes/fixUnreachableCode.js

@@ -0,0 +1,65 @@
+// Modificado de microsoft/TypeScript v3.9.10, src/services/codefixes/fixUnreachableCode.ts: o namespace virou módulo ES, com os imports explícitos.
+import { Debug, Diagnostics, SyntaxKind, createBlock, emptyArray, findAncestor, first, getTokenAtPosition, isBlock, isStatement, sliceAfter, textChanges, } from "../_namespaces/edit.js";
+import { codeFixAll, createCodeFixAction, registerCodeFix, } from "../_namespaces/ts.codefix.js";
+const fixId = "fixUnreachableCode";
+const errorCodes = [Diagnostics.Unreachable_code_detected.code];
+registerCodeFix({
+    errorCodes,
+    getCodeActions(context) {
+        const changes = textChanges.ChangeTracker.with(context, t => doChange(t, context.sourceFile, context.span.start, context.span.length, context.errorCode));
+        return [createCodeFixAction(fixId, changes, Diagnostics.Remove_unreachable_code, fixId, Diagnostics.Remove_all_unreachable_code)];
+    },
+    fixIds: [fixId],
+    getAllCodeActions: context => codeFixAll(context, errorCodes, (changes, diag) => doChange(changes, diag.file, diag.start, diag.length, diag.code)),
+});
+function doChange(changes, sourceFile, start, length, errorCode) {
+    const token = getTokenAtPosition(sourceFile, start);
+    const statement = findAncestor(token, isStatement);
+    if (statement.getStart(sourceFile) !== token.getStart(sourceFile)) {
+        const logData = JSON.stringify({
+            statementKind: Debug.formatSyntaxKind(statement.kind),
+            tokenKind: Debug.formatSyntaxKind(token.kind),
+            errorCode,
+            start,
+            length
+        });
+        Debug.fail("Token and statement should start at the same point. " + logData);
+    }
+    const container = (isBlock(statement.parent) ? statement.parent : statement).parent;
+    if (!isBlock(statement.parent) || statement === first(statement.parent.statements)) {
+        switch (container.kind) {
+            case SyntaxKind.IfStatement:
+                if (container.elseStatement) {
+                    if (isBlock(statement.parent)) {
+                        break;
+                    }
+                    else {
+                        changes.replaceNode(sourceFile, statement, createBlock(emptyArray));
+                    }
+                    return;
+                }
+            // falls through
+            case SyntaxKind.WhileStatement:
+            case SyntaxKind.ForStatement:
+                changes.delete(sourceFile, container);
+                return;
+        }
+    }
+    if (isBlock(statement.parent)) {
+        const end = start + length;
+        const lastStatement = Debug.checkDefined(lastWhere(sliceAfter(statement.parent.statements, statement), s => s.pos < end), "Some statement should be last");
+        changes.deleteNodeRange(sourceFile, statement, lastStatement);
+    }
+    else {
+        changes.delete(sourceFile, statement);
+    }
+}
+function lastWhere(a, pred) {
+    let last;
+    for (const value of a) {
+        if (!pred(value))
+            break;
+        last = value;
+    }
+    return last;
+}

package/dist/codefixes/fixUnusedIdentifier.d.ts

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

package/dist/codefixes/fixUnusedIdentifier.js

@@ -0,0 +1,224 @@
+// Modificado de microsoft/TypeScript v3.9.10, src/services/codefixes/fixUnusedIdentifier.ts: o namespace virou módulo ES, com os imports explícitos.
+import { Debug, Diagnostics, FindAllReferences, SyntaxKind, cast, createIdentifier, createKeywordTypeNode, getTokenAtPosition, isBinaryExpression, isComputedPropertyName, isDeclarationWithTypeParameterChildren, isExpressionStatement, isIdentifier, isImportClause, isImportDeclaration, isInferTypeNode, isObjectBindingPattern, isParameter, isPropertyAccessExpression, isVariableDeclarationList, showModuleSpecifier, textChanges, tryCast, } from "../_namespaces/edit.js";
+import { codeFixAll, createCodeFixAction, registerCodeFix, } from "../_namespaces/ts.codefix.js";
+const fixName = "unusedIdentifier";
+const fixIdPrefix = "unusedIdentifier_prefix";
+const fixIdDelete = "unusedIdentifier_delete";
+const fixIdInfer = "unusedIdentifier_infer";
+const errorCodes = [
+    Diagnostics._0_is_declared_but_its_value_is_never_read.code,
+    Diagnostics._0_is_declared_but_never_used.code,
+    Diagnostics.Property_0_is_declared_but_its_value_is_never_read.code,
+    Diagnostics.All_imports_in_import_declaration_are_unused.code,
+    Diagnostics.All_destructured_elements_are_unused.code,
+    Diagnostics.All_variables_are_unused.code,
+    Diagnostics.All_type_parameters_are_unused.code,
+];
+registerCodeFix({
+    errorCodes,
+    getCodeActions(context) {
+        const { errorCode, sourceFile, program } = context;
+        const checker = program.getTypeChecker();
+        const sourceFiles = program.getSourceFiles();
+        const token = getTokenAtPosition(sourceFile, context.span.start);
+        // Na tag, também a remoção de um `@template` do JSDoc (CK-03).
+        if (token.kind === SyntaxKind.LessThanToken) {
+            const changes = textChanges.ChangeTracker.with(context, t => deleteTypeParameters(t, sourceFile, token));
+            return [createDeleteFix(changes, Diagnostics.Remove_type_parameters)];
+        }
+        const importDecl = tryGetFullImport(token);
+        if (importDecl) {
+            const changes = textChanges.ChangeTracker.with(context, t => t.delete(sourceFile, importDecl));
+            return [createDeleteFix(changes, [Diagnostics.Remove_import_from_0, showModuleSpecifier(importDecl)])];
+        }
+        const delDestructure = textChanges.ChangeTracker.with(context, t => tryDeleteFullDestructure(token, t, sourceFile, checker, sourceFiles, /*isFixAll*/ false));
+        if (delDestructure.length) {
+            return [createDeleteFix(delDestructure, Diagnostics.Remove_destructuring)];
+        }
+        const delVar = textChanges.ChangeTracker.with(context, t => tryDeleteFullVariableStatement(sourceFile, token, t));
+        if (delVar.length) {
+            return [createDeleteFix(delVar, Diagnostics.Remove_variable_statement)];
+        }
+        const result = [];
+        if (token.kind === SyntaxKind.InferKeyword) {
+            const changes = textChanges.ChangeTracker.with(context, t => changeInferToUnknown(t, sourceFile, token));
+            const name = cast(token.parent, isInferTypeNode).typeParameter.name.text;
+            result.push(createCodeFixAction(fixName, changes, [Diagnostics.Replace_infer_0_with_unknown, name], fixIdInfer, Diagnostics.Replace_all_unused_infer_with_unknown));
+        }
+        else {
+            const deletion = textChanges.ChangeTracker.with(context, t => tryDeleteDeclaration(sourceFile, token, t, checker, sourceFiles, /*isFixAll*/ false));
+            if (deletion.length) {
+                const name = isComputedPropertyName(token.parent) ? token.parent : token;
+                result.push(createDeleteFix(deletion, [Diagnostics.Remove_unused_declaration_for_Colon_0, name.getText(sourceFile)]));
+            }
+        }
+        const prefix = textChanges.ChangeTracker.with(context, t => tryPrefixDeclaration(t, errorCode, sourceFile, token));
+        if (prefix.length) {
+            result.push(createCodeFixAction(fixName, prefix, [Diagnostics.Prefix_0_with_an_underscore, token.getText(sourceFile)], fixIdPrefix, Diagnostics.Prefix_all_unused_declarations_with_where_possible));
+        }
+        return result;
+    },
+    fixIds: [fixIdPrefix, fixIdDelete, fixIdInfer],
+    getAllCodeActions: context => {
+        const { sourceFile, program } = context;
+        const checker = program.getTypeChecker();
+        const sourceFiles = program.getSourceFiles();
+        return codeFixAll(context, errorCodes, (changes, diag) => {
+            const token = getTokenAtPosition(sourceFile, diag.start);
+            switch (context.fixId) {
+                case fixIdPrefix:
+                    tryPrefixDeclaration(changes, diag.code, sourceFile, token);
+                    break;
+                case fixIdDelete: {
+                    if (token.kind === SyntaxKind.InferKeyword)
+                        break; // Can't delete
+                    const importDecl = tryGetFullImport(token);
+                    if (importDecl) {
+                        changes.delete(sourceFile, importDecl);
+                    }
+                    // Na tag, também a remoção de um `@template` do JSDoc (CK-03).
+                    else if (token.kind === SyntaxKind.LessThanToken) {
+                        deleteTypeParameters(changes, sourceFile, token);
+                    }
+                    else if (!tryDeleteFullDestructure(token, changes, sourceFile, checker, sourceFiles, /*isFixAll*/ true) &&
+                        !tryDeleteFullVariableStatement(sourceFile, token, changes)) {
+                        tryDeleteDeclaration(sourceFile, token, changes, checker, sourceFiles, /*isFixAll*/ true);
+                    }
+                    break;
+                }
+                case fixIdInfer:
+                    if (token.kind === SyntaxKind.InferKeyword) {
+                        changeInferToUnknown(changes, sourceFile, token);
+                    }
+                    break;
+                default:
+                    Debug.fail(JSON.stringify(context.fixId));
+            }
+        });
+    },
+});
+function changeInferToUnknown(changes, sourceFile, token) {
+    changes.replaceNode(sourceFile, token.parent, createKeywordTypeNode(SyntaxKind.UnknownKeyword));
+}
+function createDeleteFix(changes, diag) {
+    return createCodeFixAction(fixName, changes, diag, fixIdDelete, Diagnostics.Delete_all_unused_declarations);
+}
+function deleteTypeParameters(changes, sourceFile, token) {
+    changes.delete(sourceFile, Debug.checkDefined(cast(token.parent, isDeclarationWithTypeParameterChildren).typeParameters, "The type parameter to delete should exist"));
+}
+// Sometimes the diagnostic span is an entire ImportDeclaration, so we should remove the whole thing.
+function tryGetFullImport(token) {
+    return token.kind === SyntaxKind.ImportKeyword ? tryCast(token.parent, isImportDeclaration) : undefined;
+}
+function tryDeleteFullDestructure(token, changes, sourceFile, checker, sourceFiles, isFixAll) {
+    if (token.kind !== SyntaxKind.OpenBraceToken || !isObjectBindingPattern(token.parent))
+        return false;
+    const decl = token.parent.parent;
+    if (decl.kind === SyntaxKind.Parameter) {
+        tryDeleteParameter(changes, sourceFile, decl, checker, sourceFiles, isFixAll);
+    }
+    else {
+        changes.delete(sourceFile, decl);
+    }
+    return true;
+}
+function tryDeleteFullVariableStatement(sourceFile, token, changes) {
+    const declarationList = tryCast(token.parent, isVariableDeclarationList);
+    if (declarationList && declarationList.getChildren(sourceFile)[0] === token) {
+        changes.delete(sourceFile, declarationList.parent.kind === SyntaxKind.VariableStatement ? declarationList.parent : declarationList);
+        return true;
+    }
+    return false;
+}
+function tryPrefixDeclaration(changes, errorCode, sourceFile, token) {
+    // Don't offer to prefix a property.
+    if (errorCode === Diagnostics.Property_0_is_declared_but_its_value_is_never_read.code)
+        return;
+    if (token.kind === SyntaxKind.InferKeyword) {
+        token = cast(token.parent, isInferTypeNode).typeParameter.name;
+    }
+    if (isIdentifier(token) && canPrefix(token)) {
+        changes.replaceNode(sourceFile, token, createIdentifier(`_${token.text}`));
+        // Na tag, o parâmetro renomeado renomeava também o `@param` dele no JSDoc (CK-03).
+    }
+}
+function canPrefix(token) {
+    switch (token.parent.kind) {
+        case SyntaxKind.Parameter:
+        case SyntaxKind.TypeParameter:
+            return true;
+        case SyntaxKind.VariableDeclaration: {
+            const varDecl = token.parent;
+            switch (varDecl.parent.parent.kind) {
+                case SyntaxKind.ForOfStatement:
+                case SyntaxKind.ForInStatement:
+                    return true;
+            }
+        }
+    }
+    return false;
+}
+function tryDeleteDeclaration(sourceFile, token, changes, checker, sourceFiles, isFixAll) {
+    tryDeleteDeclarationWorker(token, changes, sourceFile, checker, sourceFiles, isFixAll);
+    if (isIdentifier(token))
+        deleteAssignments(changes, sourceFile, token, checker);
+}
+function deleteAssignments(changes, sourceFile, token, checker) {
+    FindAllReferences.Core.eachSymbolReferenceInFile(token, checker, sourceFile, (ref) => {
+        if (isPropertyAccessExpression(ref.parent) && ref.parent.name === ref)
+            ref = ref.parent;
+        if (isBinaryExpression(ref.parent) && isExpressionStatement(ref.parent.parent) && ref.parent.left === ref) {
+            changes.delete(sourceFile, ref.parent.parent);
+        }
+    });
+}
+function tryDeleteDeclarationWorker(token, changes, sourceFile, checker, sourceFiles, isFixAll) {
+    const { parent } = token;
+    if (isParameter(parent)) {
+        tryDeleteParameter(changes, sourceFile, parent, checker, sourceFiles, isFixAll);
+    }
+    else {
+        changes.delete(sourceFile, isImportClause(parent) ? token : isComputedPropertyName(parent) ? parent.parent : parent);
+    }
+}
+function tryDeleteParameter(changes, sourceFile, p, checker, sourceFiles, isFixAll) {
+    if (mayDeleteParameter(p, isFixAll)) {
+        if (p.modifiers && p.modifiers.length > 0
+            && (!isIdentifier(p.name) || FindAllReferences.Core.isSymbolReferencedInFile(p.name, checker, sourceFile))) {
+            p.modifiers.forEach(modifier => {
+                changes.deleteModifier(sourceFile, modifier);
+            });
+        }
+        else {
+            changes.delete(sourceFile, p);
+            deleteUnusedArguments(changes, sourceFile, p, sourceFiles, checker);
+        }
+    }
+}
+// Na tag, recebia também o checker, que só o método usava.
+function mayDeleteParameter(p, isFixAll) {
+    const { parent } = p;
+    // Na tag, também o método (que não perdia o parâmetro quando sobrescrevia o de um tipo base), o construtor, a
+    // `function` declarada, a function expression e o setter, que não perdia o parâmetro dele (CK-02).
+    switch (parent.kind) {
+        case SyntaxKind.ArrowFunction: {
+            // Can't remove a non-last parameter in a callback. Can remove a parameter in code-fix-all if future parameters are also unused.
+            const { parameters } = parent;
+            const index = parameters.indexOf(p);
+            Debug.assert(index !== -1, "The parameter should already be in the list");
+            return isFixAll
+                ? parameters.slice(index + 1).every(p => p.name.kind === SyntaxKind.Identifier && !p.symbol.isReferenced)
+                : index === parameters.length - 1;
+        }
+        default:
+            return Debug.failBadSyntaxKind(parent);
+    }
+}
+function deleteUnusedArguments(changes, sourceFile, deletedParameter, sourceFiles, checker) {
+    FindAllReferences.Core.eachSignatureCall(deletedParameter.parent, sourceFiles, checker, call => {
+        const index = deletedParameter.parent.parameters.indexOf(deletedParameter);
+        if (call.arguments.length > index) { // Just in case the call didn't provide enough arguments.
+            changes.delete(sourceFile, call.arguments[index]);
+        }
+    });
+}

package/dist/codefixes/helpers.d.ts

@@ -0,0 +1,8 @@
+import type { Node, NodeBuilderFlags, ScriptTarget, Symbol, SymbolTracker, Type, TypeChecker, TypeNode } from "../_namespaces/edit.js";
+import type { ImportAdder } from "../_namespaces/ts.codefix.js";
+export declare function typeToAutoImportableTypeNode(checker: TypeChecker, importAdder: ImportAdder, type: Type, contextNode: Node, scriptTarget: ScriptTarget, flags?: NodeBuilderFlags, tracker?: SymbolTracker): TypeNode | undefined;
+export declare function tryGetAutoImportableReferenceFromImportTypeNode(importTypeNode: TypeNode | undefined, type: Type | undefined, scriptTarget: ScriptTarget): {
+    symbols: Symbol[];
+    typeReference: import("@tslite/parser").TypeReferenceNode;
+} | undefined;
+export declare function importSymbols(importAdder: ImportAdder, symbols: readonly Symbol[]): void;

package/dist/codefixes/helpers.js

@@ -0,0 +1,53 @@
+// Modificado de microsoft/TypeScript v3.9.10, src/services/codefixes/helpers.ts: o namespace virou módulo ES, com os imports explícitos.
+// O arquivo entra com o que os code fixes que já vieram usam (a troca do `import("./a").T` por uma referência que se
+// importa, que o `inferFromUsage` pede, e o nó de tipo que importa o que nomeia, que o `extractSymbol` pede); o resto dele
+// vem com o fix que o usa (o docs/ARCHITECTURE.md do pacote).
+import { SyntaxKind, createIdentifier, createQualifiedName, createTypeReferenceNode, getFirstIdentifier, getNameForExportedSymbol, isImportTypeNode, isLiteralImportTypeNode, } from "../_namespaces/edit.js";
+export function typeToAutoImportableTypeNode(checker, importAdder, type, contextNode, scriptTarget, flags, tracker) {
+    const typeNode = checker.typeToTypeNode(type, contextNode, flags, tracker);
+    if (typeNode && isImportTypeNode(typeNode)) {
+        const importableReference = tryGetAutoImportableReferenceFromImportTypeNode(typeNode, type, scriptTarget);
+        if (importableReference) {
+            importSymbols(importAdder, importableReference.symbols);
+            return importableReference.typeReference;
+        }
+    }
+    return typeNode;
+}
+export function tryGetAutoImportableReferenceFromImportTypeNode(importTypeNode, type, scriptTarget) {
+    if (importTypeNode && isLiteralImportTypeNode(importTypeNode) && importTypeNode.qualifier && (!type || type.symbol)) {
+        // Symbol for the left-most thing after the dot
+        const firstIdentifier = getFirstIdentifier(importTypeNode.qualifier);
+        const name = getNameForExportedSymbol(firstIdentifier.symbol, scriptTarget);
+        const qualifier = name !== firstIdentifier.text
+            ? replaceFirstIdentifierOfEntityName(importTypeNode.qualifier, createIdentifier(name))
+            : importTypeNode.qualifier;
+        const symbols = [firstIdentifier.symbol];
+        const typeArguments = [];
+        if (importTypeNode.typeArguments) {
+            importTypeNode.typeArguments.forEach(arg => {
+                const ref = tryGetAutoImportableReferenceFromImportTypeNode(arg, /*undefined*/ type, scriptTarget);
+                if (ref) {
+                    symbols.push(...ref.symbols);
+                    typeArguments.push(ref.typeReference);
+                }
+                else {
+                    typeArguments.push(arg);
+                }
+            });
+        }
+        return {
+            symbols,
+            typeReference: createTypeReferenceNode(qualifier, typeArguments)
+        };
+    }
+}
+function replaceFirstIdentifierOfEntityName(name, newIdentifier) {
+    if (name.kind === SyntaxKind.Identifier) {
+        return newIdentifier;
+    }
+    return createQualifiedName(replaceFirstIdentifierOfEntityName(name.left, newIdentifier), name.right);
+}
+export function importSymbols(importAdder, symbols) {
+    symbols.forEach(s => importAdder.addImportFromExportedSymbol(s, /*usageIsTypeOnly*/ true));
+}