@tslite/services 0.0.0-stage → 1.12.0

package/dist/codefixes/addMissingAsync.js

@@ -0,0 +1,75 @@
+// Modificado de microsoft/TypeScript v3.9.10, src/services/codefixes/addMissingAsync.ts: o namespace virou módulo ES, com os imports explícitos.
+import { Diagnostics, ModifierFlags, createMap, createModifiersFromModifierFlags, createNodeArray, createTextSpanFromNode, find, findAncestor, getModifierFlags, getNodeId, getSynthesizedDeepClone, getTokenAtPosition, isArrowFunction, isNumber, some, textChanges, textSpanEnd, textSpansEqual, } from "../_namespaces/edit.js";
+import { codeFixAll, createCodeFixAction, registerCodeFix, } from "../_namespaces/ts.codefix.js";
+const fixId = "addMissingAsync";
+const errorCodes = [
+    Diagnostics.Argument_of_type_0_is_not_assignable_to_parameter_of_type_1.code,
+    Diagnostics.Type_0_is_not_assignable_to_type_1.code,
+    Diagnostics.Type_0_is_not_comparable_to_type_1.code
+];
+registerCodeFix({
+    fixIds: [fixId],
+    errorCodes,
+    getCodeActions: context => {
+        const { sourceFile, errorCode, cancellationToken, program, span } = context;
+        // Na tag, o checker que produz os diagnósticos do `Program`; o do `check` é um só (CK-47).
+        const diagnostic = find(program.getTypeChecker().getDiagnostics(sourceFile, cancellationToken), getIsMatchingAsyncError(span, errorCode));
+        const directSpan = diagnostic && diagnostic.relatedInformation && find(diagnostic.relatedInformation, r => r.code === Diagnostics.Did_you_mean_to_mark_this_function_as_async.code);
+        const decl = getFixableErrorSpanDeclaration(sourceFile, directSpan);
+        if (!decl) {
+            return;
+        }
+        const trackChanges = cb => textChanges.ChangeTracker.with(context, cb);
+        return [getFix(context, decl, trackChanges)];
+    },
+    getAllCodeActions: context => {
+        const { sourceFile } = context;
+        const fixedDeclarations = createMap();
+        return codeFixAll(context, errorCodes, (t, diagnostic) => {
+            const span = diagnostic.relatedInformation && find(diagnostic.relatedInformation, r => r.code === Diagnostics.Did_you_mean_to_mark_this_function_as_async.code);
+            const decl = getFixableErrorSpanDeclaration(sourceFile, span);
+            if (!decl) {
+                return;
+            }
+            const trackChanges = cb => (cb(t), []);
+            return getFix(context, decl, trackChanges, fixedDeclarations);
+        });
+    },
+});
+function getFix(context, decl, trackChanges, fixedDeclarations) {
+    const changes = trackChanges(t => makeChange(t, context.sourceFile, decl, fixedDeclarations));
+    return createCodeFixAction(fixId, changes, Diagnostics.Add_async_modifier_to_containing_function, fixId, Diagnostics.Add_all_missing_async_modifiers);
+}
+function makeChange(changeTracker, sourceFile, insertionSite, fixedDeclarations) {
+    if (fixedDeclarations) {
+        if (fixedDeclarations.has(getNodeId(insertionSite).toString())) {
+            return;
+        }
+    }
+    fixedDeclarations?.set(getNodeId(insertionSite).toString(), true);
+    const cloneWithModifier = getSynthesizedDeepClone(insertionSite, /*includeTrivia*/ true);
+    cloneWithModifier.modifiers = createNodeArray(createModifiersFromModifierFlags(getModifierFlags(insertionSite) | ModifierFlags.Async));
+    cloneWithModifier.modifierFlagsCache = 0;
+    changeTracker.replaceNode(sourceFile, insertionSite, cloneWithModifier);
+}
+function getFixableErrorSpanDeclaration(sourceFile, span) {
+    if (!span)
+        return undefined;
+    const token = getTokenAtPosition(sourceFile, span.start);
+    // Checker has already done work to determine that async might be possible, and has attached
+    // related info to the node, so start by finding the signature that exactly matches up
+    // with the diagnostic range.
+    const decl = findAncestor(token, node => {
+        if (node.getStart(sourceFile) < span.start || node.getEnd() > textSpanEnd(span)) {
+            return "quit";
+        }
+        return isArrowFunction(node) && textSpansEqual(span, createTextSpanFromNode(node, sourceFile));
+    });
+    return decl;
+}
+function getIsMatchingAsyncError(span, errorCode) {
+    return ({ start, length, relatedInformation, code }) => isNumber(start) && isNumber(length) && textSpansEqual({ start, length }, span) &&
+        code === errorCode &&
+        !!relatedInformation &&
+        some(relatedInformation, related => related.code === Diagnostics.Did_you_mean_to_mark_this_function_as_async.code);
+}

package/dist/codefixes/addMissingAwait.d.ts

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

package/dist/codefixes/addMissingAwait.js

@@ -0,0 +1,236 @@
+// Modificado de microsoft/TypeScript v3.9.10, src/services/codefixes/addMissingAwait.ts: o namespace virou módulo ES, com os imports explícitos.
+import { Diagnostics, FindAllReferences, ModifierFlags, NodeFlags, SyntaxKind, TypeFlags, addToSeen, compact, contains, createAwait, createMap, createParen, createTextSpanFromNode, find, findAncestor, findPrecedingToken, forEach, getAncestor, getSymbolId, getTokenAtPosition, hasModifier, isArrowFunction, isBinaryExpression, isBlock, isCallOrNewExpression, isExpression, isIdentifier, isNumber, isPropertyAccessExpression, isVariableDeclaration, positionIsASICandidate, some, textChanges, textSpanEnd, textSpansEqual, tryCast, } from "../_namespaces/edit.js";
+import { codeFixAll, createCodeFixAction, createCodeFixActionWithoutFixAll, registerCodeFix, } from "../_namespaces/ts.codefix.js";
+const fixId = "addMissingAwait";
+const propertyAccessCode = Diagnostics.Property_0_does_not_exist_on_type_1.code;
+// Na tag, também o que não se constrói (o `new`, CK-02).
+const callableConstructableErrorCodes = [
+    Diagnostics.This_expression_is_not_callable.code,
+];
+// Na tag, também as mensagens do `for…of` que a cópia não acusa: as do alvo abaixo do ES2015 e do `downlevelIteration`
+// (CK-24), e as do `Symbol.iterator` e do `Symbol.asyncIterator`, do protocolo de iteração (CK-55).
+const errorCodes = [
+    Diagnostics.An_arithmetic_operand_must_be_of_type_any_number_bigint_or_an_enum_type.code,
+    Diagnostics.The_left_hand_side_of_an_arithmetic_operation_must_be_of_type_any_number_bigint_or_an_enum_type.code,
+    Diagnostics.The_right_hand_side_of_an_arithmetic_operation_must_be_of_type_any_number_bigint_or_an_enum_type.code,
+    Diagnostics.Operator_0_cannot_be_applied_to_type_1.code,
+    Diagnostics.Operator_0_cannot_be_applied_to_types_1_and_2.code,
+    Diagnostics.This_condition_will_always_return_0_since_the_types_1_and_2_have_no_overlap.code,
+    Diagnostics.Type_0_is_not_an_array_type.code,
+    Diagnostics.Argument_of_type_0_is_not_assignable_to_parameter_of_type_1.code,
+    propertyAccessCode,
+    ...callableConstructableErrorCodes,
+];
+registerCodeFix({
+    fixIds: [fixId],
+    errorCodes,
+    getCodeActions: context => {
+        const { sourceFile, errorCode, span, cancellationToken, program } = context;
+        const expression = getFixableErrorSpanExpression(sourceFile, errorCode, span, cancellationToken, program);
+        if (!expression) {
+            return;
+        }
+        const checker = context.program.getTypeChecker();
+        const trackChanges = cb => textChanges.ChangeTracker.with(context, cb);
+        return compact([
+            getDeclarationSiteFix(context, expression, errorCode, checker, trackChanges),
+            getUseSiteFix(context, expression, errorCode, checker, trackChanges)
+        ]);
+    },
+    getAllCodeActions: context => {
+        const { sourceFile, program, cancellationToken } = context;
+        const checker = context.program.getTypeChecker();
+        const fixedDeclarations = createMap();
+        return codeFixAll(context, errorCodes, (t, diagnostic) => {
+            const expression = getFixableErrorSpanExpression(sourceFile, diagnostic.code, diagnostic, cancellationToken, program);
+            if (!expression) {
+                return;
+            }
+            const trackChanges = cb => (cb(t), []);
+            return getDeclarationSiteFix(context, expression, diagnostic.code, checker, trackChanges, fixedDeclarations)
+                || getUseSiteFix(context, expression, diagnostic.code, checker, trackChanges, fixedDeclarations);
+        });
+    },
+});
+function getDeclarationSiteFix(context, expression, errorCode, checker, trackChanges, fixedDeclarations) {
+    const { sourceFile, program, cancellationToken } = context;
+    const awaitableInitializers = findAwaitableInitializers(expression, sourceFile, cancellationToken, program, checker);
+    if (awaitableInitializers) {
+        const initializerChanges = trackChanges(t => {
+            forEach(awaitableInitializers.initializers, ({ expression }) => makeChange(t, errorCode, sourceFile, checker, expression, fixedDeclarations));
+            if (fixedDeclarations && awaitableInitializers.needsSecondPassForFixAll) {
+                makeChange(t, errorCode, sourceFile, checker, expression, fixedDeclarations);
+            }
+        });
+        // No fix-all because it will already be included once with the use site fix,
+        // and for simplicity the fix-all doesn‘t let the user choose between use-site and declaration-site fixes.
+        return createCodeFixActionWithoutFixAll("addMissingAwaitToInitializer", initializerChanges, awaitableInitializers.initializers.length === 1
+            ? [Diagnostics.Add_await_to_initializer_for_0, awaitableInitializers.initializers[0].declarationSymbol.name]
+            : Diagnostics.Add_await_to_initializers);
+    }
+}
+function getUseSiteFix(context, expression, errorCode, checker, trackChanges, fixedDeclarations) {
+    const changes = trackChanges(t => makeChange(t, errorCode, context.sourceFile, checker, expression, fixedDeclarations));
+    return createCodeFixAction(fixId, changes, Diagnostics.Add_await, fixId, Diagnostics.Fix_all_expressions_possibly_missing_await);
+}
+function isMissingAwaitError(sourceFile, errorCode, span, cancellationToken, program) {
+    // Na tag, o checker que produz os diagnósticos do `Program`; o do `check` é um só (CK-47).
+    const checker = program.getTypeChecker();
+    const diagnostics = checker.getDiagnostics(sourceFile, cancellationToken);
+    return some(diagnostics, ({ start, length, relatedInformation, code }) => isNumber(start) && isNumber(length) && textSpansEqual({ start, length }, span) &&
+        code === errorCode &&
+        !!relatedInformation &&
+        some(relatedInformation, related => related.code === Diagnostics.Did_you_forget_to_use_await.code));
+}
+function getFixableErrorSpanExpression(sourceFile, errorCode, span, cancellationToken, program) {
+    const token = getTokenAtPosition(sourceFile, span.start);
+    // Checker has already done work to determine that await might be possible, and has attached
+    // related info to the node, so start by finding the expression that exactly matches up
+    // with the diagnostic range.
+    const expression = findAncestor(token, node => {
+        if (node.getStart(sourceFile) < span.start || node.getEnd() > textSpanEnd(span)) {
+            return "quit";
+        }
+        return isExpression(node) && textSpansEqual(span, createTextSpanFromNode(node, sourceFile));
+    });
+    return expression
+        && isMissingAwaitError(sourceFile, errorCode, span, cancellationToken, program)
+        && isInsideAwaitableBody(expression) ? expression : undefined;
+}
+function findAwaitableInitializers(expression, sourceFile, cancellationToken, program, checker) {
+    const identifiers = getIdentifiersFromErrorSpanExpression(expression, checker);
+    if (!identifiers) {
+        return;
+    }
+    let isCompleteFix = identifiers.isCompleteFix;
+    let initializers;
+    for (const identifier of identifiers.identifiers) {
+        const symbol = checker.getSymbolAtLocation(identifier);
+        if (!symbol) {
+            continue;
+        }
+        const declaration = tryCast(symbol.valueDeclaration, isVariableDeclaration);
+        const variableName = declaration && tryCast(declaration.name, isIdentifier);
+        const variableStatement = getAncestor(declaration, SyntaxKind.VariableStatement);
+        if (!declaration || !variableStatement ||
+            declaration.type ||
+            !declaration.initializer ||
+            variableStatement.getSourceFile() !== sourceFile ||
+            hasModifier(variableStatement, ModifierFlags.Export) ||
+            !variableName ||
+            !isInsideAwaitableBody(declaration.initializer)) {
+            isCompleteFix = false;
+            continue;
+        }
+        const diagnostics = program.getSemanticDiagnostics(sourceFile, cancellationToken);
+        const isUsedElsewhere = FindAllReferences.Core.eachSymbolReferenceInFile(variableName, checker, sourceFile, reference => {
+            return identifier !== reference && !symbolReferenceIsAlsoMissingAwait(reference, diagnostics, sourceFile, checker);
+        });
+        if (isUsedElsewhere) {
+            isCompleteFix = false;
+            continue;
+        }
+        (initializers || (initializers = [])).push({
+            expression: declaration.initializer,
+            declarationSymbol: symbol,
+        });
+    }
+    return initializers && {
+        initializers,
+        needsSecondPassForFixAll: !isCompleteFix,
+    };
+}
+function getIdentifiersFromErrorSpanExpression(expression, checker) {
+    if (isPropertyAccessExpression(expression.parent) && isIdentifier(expression.parent.expression)) {
+        return { identifiers: [expression.parent.expression], isCompleteFix: true };
+    }
+    if (isIdentifier(expression)) {
+        return { identifiers: [expression], isCompleteFix: true };
+    }
+    if (isBinaryExpression(expression)) {
+        let sides;
+        let isCompleteFix = true;
+        for (const side of [expression.left, expression.right]) {
+            const type = checker.getTypeAtLocation(side);
+            if (checker.getPromisedTypeOfPromise(type)) {
+                if (!isIdentifier(side)) {
+                    isCompleteFix = false;
+                    continue;
+                }
+                (sides || (sides = [])).push(side);
+            }
+        }
+        return sides && { identifiers: sides, isCompleteFix };
+    }
+}
+function symbolReferenceIsAlsoMissingAwait(reference, diagnostics, sourceFile, checker) {
+    const errorNode = isPropertyAccessExpression(reference.parent) ? reference.parent.name :
+        isBinaryExpression(reference.parent) ? reference.parent :
+            reference;
+    const diagnostic = find(diagnostics, diagnostic => diagnostic.start === errorNode.getStart(sourceFile) &&
+        (diagnostic.start + diagnostic.length) === errorNode.getEnd());
+    return diagnostic && contains(errorCodes, diagnostic.code) ||
+        // A Promise is usually not correct in a binary expression (it’s not valid
+        // in an arithmetic expression and an equality comparison seems unusual),
+        // but if the other side of the binary expression has an error, the side
+        // is typed `any` which will squash the error that would identify this
+        // Promise as an invalid operand. So if the whole binary expression is
+        // typed `any` as a result, there is a strong likelihood that this Promise
+        // is accidentally missing `await`.
+        checker.getTypeAtLocation(errorNode).flags & TypeFlags.Any;
+}
+// Na tag, também o bloco de uma `function` declarada, de uma function expression e de um método (CK-02).
+function isInsideAwaitableBody(node) {
+    return node.kind & NodeFlags.AwaitContext || !!findAncestor(node, ancestor => ancestor.parent && isArrowFunction(ancestor.parent) && ancestor.parent.body === ancestor ||
+        isBlock(ancestor) && (ancestor.parent.kind === SyntaxKind.ArrowFunction));
+}
+function makeChange(changeTracker, errorCode, sourceFile, checker, insertionSite, fixedDeclarations) {
+    if (isBinaryExpression(insertionSite)) {
+        for (const side of [insertionSite.left, insertionSite.right]) {
+            if (fixedDeclarations && isIdentifier(side)) {
+                const symbol = checker.getSymbolAtLocation(side);
+                if (symbol && fixedDeclarations.has(getSymbolId(symbol).toString())) {
+                    continue;
+                }
+            }
+            const type = checker.getTypeAtLocation(side);
+            const newNode = checker.getPromisedTypeOfPromise(type) ? createAwait(side) : side;
+            changeTracker.replaceNode(sourceFile, side, newNode);
+        }
+    }
+    else if (errorCode === propertyAccessCode && isPropertyAccessExpression(insertionSite.parent)) {
+        if (fixedDeclarations && isIdentifier(insertionSite.parent.expression)) {
+            const symbol = checker.getSymbolAtLocation(insertionSite.parent.expression);
+            if (symbol && fixedDeclarations.has(getSymbolId(symbol).toString())) {
+                return;
+            }
+        }
+        changeTracker.replaceNode(sourceFile, insertionSite.parent.expression, createParen(createAwait(insertionSite.parent.expression)));
+        insertLeadingSemicolonIfNeeded(changeTracker, insertionSite.parent.expression, sourceFile);
+    }
+    else if (contains(callableConstructableErrorCodes, errorCode) && isCallOrNewExpression(insertionSite.parent)) {
+        if (fixedDeclarations && isIdentifier(insertionSite)) {
+            const symbol = checker.getSymbolAtLocation(insertionSite);
+            if (symbol && fixedDeclarations.has(getSymbolId(symbol).toString())) {
+                return;
+            }
+        }
+        changeTracker.replaceNode(sourceFile, insertionSite, createParen(createAwait(insertionSite)));
+        insertLeadingSemicolonIfNeeded(changeTracker, insertionSite, sourceFile);
+    }
+    else {
+        if (fixedDeclarations && isVariableDeclaration(insertionSite.parent) && isIdentifier(insertionSite.parent.name)) {
+            const symbol = checker.getSymbolAtLocation(insertionSite.parent.name);
+            if (symbol && !addToSeen(fixedDeclarations, getSymbolId(symbol))) {
+                return;
+            }
+        }
+        changeTracker.replaceNode(sourceFile, insertionSite, createAwait(insertionSite));
+    }
+}
+function insertLeadingSemicolonIfNeeded(changeTracker, beforeNode, sourceFile) {
+    const precedingToken = findPrecedingToken(beforeNode.pos, sourceFile);
+    if (precedingToken && positionIsASICandidate(precedingToken.end, precedingToken.parent, sourceFile)) {
+        changeTracker.insertText(sourceFile, beforeNode.getStart(sourceFile), ";");
+    }
+}

package/dist/codefixes/addMissingConst.d.ts

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

package/dist/codefixes/addMissingConst.js

@@ -0,0 +1,91 @@
+// Modificado de microsoft/TypeScript v3.9.10, src/services/codefixes/addMissingConst.ts: o namespace virou módulo ES, com os imports explícitos.
+import { Diagnostics, NodeSet, SyntaxKind, every, findAncestor, getTokenAtPosition, isArrayLiteralExpression, isAssignmentExpression, isBinaryExpression, isExpressionStatement, isForInOrOfStatement, isIdentifier, textChanges, } from "../_namespaces/edit.js";
+import { codeFixAll, createCodeFixAction, registerCodeFix, } from "../_namespaces/ts.codefix.js";
+const fixId = "addMissingConst";
+const errorCodes = [
+    Diagnostics.Cannot_find_name_0.code,
+    Diagnostics.No_value_exists_in_scope_for_the_shorthand_property_0_Either_declare_one_or_provide_an_initializer.code
+];
+registerCodeFix({
+    errorCodes,
+    getCodeActions: (context) => {
+        const changes = textChanges.ChangeTracker.with(context, t => makeChange(t, context.sourceFile, context.span.start, context.program));
+        if (changes.length > 0) {
+            return [createCodeFixAction(fixId, changes, Diagnostics.Add_const_to_unresolved_variable, fixId, Diagnostics.Add_const_to_all_unresolved_variables)];
+        }
+    },
+    fixIds: [fixId],
+    getAllCodeActions: context => {
+        const fixedNodes = new NodeSet();
+        return codeFixAll(context, errorCodes, (changes, diag) => makeChange(changes, diag.file, diag.start, context.program, fixedNodes));
+    },
+});
+function makeChange(changeTracker, sourceFile, pos, program, fixedNodes) {
+    const token = getTokenAtPosition(sourceFile, pos);
+    const forInitializer = findAncestor(token, node => isForInOrOfStatement(node.parent) ? node.parent.initializer === node :
+        isPossiblyPartOfDestructuring(node) ? false : "quit");
+    if (forInitializer)
+        return applyChange(changeTracker, forInitializer, sourceFile, fixedNodes);
+    const parent = token.parent;
+    if (isBinaryExpression(parent) && parent.operatorToken.kind === SyntaxKind.EqualsToken && isExpressionStatement(parent.parent)) {
+        return applyChange(changeTracker, token, sourceFile, fixedNodes);
+    }
+    if (isArrayLiteralExpression(parent)) {
+        const checker = program.getTypeChecker();
+        if (!every(parent.elements, element => arrayElementCouldBeVariableDeclaration(element, checker))) {
+            return;
+        }
+        return applyChange(changeTracker, parent, sourceFile, fixedNodes);
+    }
+    const commaExpression = findAncestor(token, node => isExpressionStatement(node.parent) ? true :
+        isPossiblyPartOfCommaSeperatedInitializer(node) ? false : "quit");
+    if (commaExpression) {
+        const checker = program.getTypeChecker();
+        if (!expressionCouldBeVariableDeclaration(commaExpression, checker)) {
+            return;
+        }
+        return applyChange(changeTracker, commaExpression, sourceFile, fixedNodes);
+    }
+}
+function applyChange(changeTracker, initializer, sourceFile, fixedNodes) {
+    if (!fixedNodes || fixedNodes.tryAdd(initializer)) {
+        changeTracker.insertModifierBefore(sourceFile, SyntaxKind.ConstKeyword, initializer);
+    }
+}
+function isPossiblyPartOfDestructuring(node) {
+    switch (node.kind) {
+        case SyntaxKind.Identifier:
+        case SyntaxKind.ArrayLiteralExpression:
+        case SyntaxKind.ObjectLiteralExpression:
+        case SyntaxKind.PropertyAssignment:
+        case SyntaxKind.ShorthandPropertyAssignment:
+            return true;
+        default:
+            return false;
+    }
+}
+function arrayElementCouldBeVariableDeclaration(expression, checker) {
+    const identifier = isIdentifier(expression) ? expression :
+        isAssignmentExpression(expression, /*excludeCompoundAssignment*/ true) && isIdentifier(expression.left) ? expression.left :
+            undefined;
+    return !!identifier && !checker.getSymbolAtLocation(identifier);
+}
+// Na tag, também a vírgula do operador vírgula (CK-02).
+function isPossiblyPartOfCommaSeperatedInitializer(node) {
+    switch (node.kind) {
+        case SyntaxKind.Identifier:
+        case SyntaxKind.BinaryExpression:
+            return true;
+        default:
+            return false;
+    }
+}
+function expressionCouldBeVariableDeclaration(expression, checker) {
+    if (!isBinaryExpression(expression)) {
+        return false;
+    }
+    // Na tag, os dois lados de um operador vírgula, cada um como uma declaração (CK-02).
+    return expression.operatorToken.kind === SyntaxKind.EqualsToken
+        && isIdentifier(expression.left)
+        && !checker.getSymbolAtLocation(expression.left);
+}

package/dist/codefixes/addNameToNamelessParameter.d.ts

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

package/dist/codefixes/addNameToNamelessParameter.js

@@ -0,0 +1,29 @@
+// Modificado de microsoft/TypeScript v3.9.10, src/services/codefixes/addNameToNamelessParameter.ts: o namespace virou módulo ES, com os imports explícitos.
+import { Debug, Diagnostics, createParameter, createTypeReferenceNode, getTokenAtPosition, isIdentifier, isParameter, textChanges, } from "../_namespaces/edit.js";
+import { codeFixAll, createCodeFixAction, registerCodeFix, } from "../_namespaces/ts.codefix.js";
+const fixId = "addNameToNamelessParameter";
+const errorCodes = [Diagnostics.Parameter_has_a_name_but_no_type_Did_you_mean_0_Colon_1.code];
+registerCodeFix({
+    errorCodes,
+    getCodeActions: (context) => {
+        const changes = textChanges.ChangeTracker.with(context, t => makeChange(t, context.sourceFile, context.span.start));
+        return [createCodeFixAction(fixId, changes, Diagnostics.Add_parameter_name, fixId, Diagnostics.Add_names_to_all_parameters_without_names)];
+    },
+    fixIds: [fixId],
+    getAllCodeActions: context => codeFixAll(context, errorCodes, (changes, diag) => makeChange(changes, diag.file, diag.start)),
+});
+function makeChange(changeTracker, sourceFile, pos) {
+    const token = getTokenAtPosition(sourceFile, pos);
+    if (!isIdentifier(token)) {
+        return Debug.fail("add-name-to-nameless-parameter operates on identifiers, but got a " + Debug.formatSyntaxKind(token.kind));
+    }
+    const param = token.parent;
+    if (!isParameter(param)) {
+        return Debug.fail("Tried to add a parameter name to a non-parameter: " + Debug.formatSyntaxKind(token.kind));
+    }
+    const i = param.parent.parameters.indexOf(param);
+    Debug.assert(!param.type, "Tried to add a parameter name to a parameter that already had one.");
+    Debug.assert(i > -1, "Parameter not found in parent parameter list.");
+    const replacement = createParameter(param.modifiers, param.dotDotDotToken, "arg" + i, param.questionToken, createTypeReferenceNode(token, /*typeArguments*/ undefined), param.initializer);
+    changeTracker.replaceNode(sourceFile, token, replacement);
+}

package/dist/codefixes/convertConstToLet.d.ts

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

package/dist/codefixes/convertConstToLet.js

@@ -0,0 +1,30 @@
+// Modificado de microsoft/TypeScript v3.9.10, src/services/codefixes/convertConstToLet.ts: o namespace virou módulo ES, com os imports explícitos.
+import { Diagnostics, getTokenAtPosition, textChanges, } from "../_namespaces/edit.js";
+import { createCodeFixAction, registerCodeFix, } from "../_namespaces/ts.codefix.js";
+const fixId = "fixConvertConstToLet";
+const errorCodes = [Diagnostics.Cannot_assign_to_0_because_it_is_a_constant.code];
+registerCodeFix({
+    errorCodes,
+    getCodeActions: context => {
+        const { sourceFile, span, program } = context;
+        const variableStatement = getVariableStatement(sourceFile, span.start, program);
+        const changes = textChanges.ChangeTracker.with(context, t => doChange(t, sourceFile, variableStatement));
+        return [createCodeFixAction(fixId, changes, Diagnostics.Convert_const_to_let, fixId, Diagnostics.Convert_const_to_let)];
+    },
+    fixIds: [fixId]
+});
+function getVariableStatement(sourceFile, pos, program) {
+    const token = getTokenAtPosition(sourceFile, pos);
+    const checker = program.getTypeChecker();
+    const symbol = checker.getSymbolAtLocation(token);
+    if (symbol) {
+        return symbol.valueDeclaration.parent.parent;
+    }
+}
+function doChange(changes, sourceFile, variableStatement) {
+    if (!variableStatement) {
+        return;
+    }
+    const start = variableStatement.getStart();
+    changes.replaceRangeWithText(sourceFile, { pos: start, end: start + 5 }, "let");
+}

package/dist/codefixes/convertToAsyncFunction.d.ts

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