@tslite/services 0.0.0-stage → 1.12.0

package/dist/refactors/extractSymbol.js

@@ -0,0 +1,1281 @@
+// Modificado de microsoft/TypeScript v3.9.10, src/services/refactors/extractSymbol.ts: o namespace virou módulo ES, com os imports explícitos.
+// A extração para uma função escreve a forma da Linguagem: um `const` com uma arrow, e não a `function` declarada (CK-69).
+// Como o `const` não é içado, ele entra antes do statement que o usa, onde a extração para uma constante o põe. Saem a
+// classe como escopo, com o método, a propriedade `readonly` e o que é estático; o `this` e o `super`; o generator; o
+// statement com label; o enum; e a function expression (CK-02). Saem também o arquivo JavaScript e o JSDoc (CK-03).
+import { Debug, DiagnosticCategory, Diagnostics, EmitFlags, ModifierFlags, NodeBuilderFlags, NodeFlags, SymbolFlags, SyntaxKind, ScriptTarget, TypeFlags, arrayFrom, codefix, compareProperties, compareStringsCaseSensitive, compareValues, createArrowFunction, createAssignment, createAwait, createBindingElement, createBlock, createCall, createDiagnosticForNode, createFileDiagnostic, createIdentifier, createKeywordTypeNode, createMap, createNodeArray, createObjectBindingPattern, createObjectLiteral, createParameter, createPropertyAccess, createPropertyAssignment, createPropertySignature, createQualifiedName, createReturn, createShorthandPropertyAssignment, createStatement, createToken, createTypeLiteralNode, createTypeReferenceNode, createUnionTypeNode, createVariableDeclaration, createVariableDeclarationList, createVariableStatement, emptyArray, find, findAncestor, findTokenOnLeftOfPosition, first, forEachChild, formatStringFromArgs, getEffectiveTypeParameterDeclarations, getEnclosingBlockScopeContainer, getLocaleSpecificMessage, getNodeId, getParentNodeInSpan, getRefactorContextSpan, getRenameLocation, getSymbolId, getSynthesizedDeepClone, getTokenAtPosition, getUniqueName, hasModifier, isArray, isArrowFunction, isAssignmentExpression, isBlock, isBlockScope, isCaseClause, isDeclaration, isDeclarationWithTypeParameters, isElementAccessExpression, isExpression, isExpressionNode, isExpressionStatement, isFunctionLikeDeclaration, isIdentifier, isIterationStatement, isModuleBlock, isParenthesizedTypeNode, isPartOfTypeNode, isPropertyAccessExpression, isQualifiedName, isReturnStatement, isShorthandPropertyAssignment, isSourceFile, isStatement, isSwitchStatement, isUnaryExpressionWithWrite, isUnionTypeNode, isVariableDeclaration, isVariableDeclarationList, isVariableStatement, last, map, nullTransformationContext, positionIsSynthesized, rangeContainsStartEnd, setEmitFlags, singleOrUndefined, suppressLeadingAndTrailingTrivia, textChanges, textSpanEnd, updateArrowFunction, updateParameter, visitEachChild, visitNode, visitNodes, } from "../_namespaces/edit.js";
+import { registerRefactor, } from "../_namespaces/ts.refactor.js";
+const refactorName = "Extract Symbol";
+registerRefactor(refactorName, { getAvailableActions, getEditsForAction });
+/**
+ * Compute the associated code actions
+ * Exported for tests.
+ */
+export function getAvailableActions(context) {
+    const rangeToExtract = getRangeToExtract(context.file, getRefactorContextSpan(context));
+    const targetRange = rangeToExtract.targetRange;
+    if (targetRange === undefined) {
+        return emptyArray;
+    }
+    const extractions = getPossibleExtractions(targetRange, context);
+    if (extractions === undefined) {
+        // No extractions possible
+        return emptyArray;
+    }
+    const functionActions = [];
+    const usedFunctionNames = createMap();
+    const constantActions = [];
+    const usedConstantNames = createMap();
+    let i = 0;
+    for (const { functionExtraction, constantExtraction } of extractions) {
+        // Skip these since we don't have a way to report errors yet
+        if (functionExtraction.errors.length === 0) {
+            // Don't issue refactorings with duplicated names.
+            // Scopes come back in "innermost first" order, so extractions will
+            // preferentially go into nearer scopes
+            const description = functionExtraction.description;
+            if (!usedFunctionNames.has(description)) {
+                usedFunctionNames.set(description, true);
+                functionActions.push({
+                    description,
+                    name: `function_scope_${i}`
+                });
+            }
+        }
+        // Skip these since we don't have a way to report errors yet
+        if (constantExtraction.errors.length === 0) {
+            // Don't issue refactorings with duplicated names.
+            // Scopes come back in "innermost first" order, so extractions will
+            // preferentially go into nearer scopes
+            const description = constantExtraction.description;
+            if (!usedConstantNames.has(description)) {
+                usedConstantNames.set(description, true);
+                constantActions.push({
+                    description,
+                    name: `constant_scope_${i}`
+                });
+            }
+        }
+        // *do* increment i anyway because we'll look for the i-th scope
+        // later when actually doing the refactoring if the user requests it
+        i++;
+    }
+    const infos = [];
+    if (constantActions.length) {
+        infos.push({
+            name: refactorName,
+            description: getLocaleSpecificMessage(Diagnostics.Extract_constant),
+            actions: constantActions
+        });
+    }
+    if (functionActions.length) {
+        infos.push({
+            name: refactorName,
+            description: getLocaleSpecificMessage(Diagnostics.Extract_function),
+            actions: functionActions
+        });
+    }
+    return infos.length ? infos : emptyArray;
+}
+/* Exported for tests */
+export function getEditsForAction(context, actionName) {
+    const rangeToExtract = getRangeToExtract(context.file, getRefactorContextSpan(context));
+    const targetRange = rangeToExtract.targetRange; // TODO:GH#18217
+    const parsedFunctionIndexMatch = /^function_scope_(\d+)$/.exec(actionName);
+    if (parsedFunctionIndexMatch) {
+        const index = +parsedFunctionIndexMatch[1];
+        Debug.assert(isFinite(index), "Expected to parse a finite number from the function scope index");
+        return getFunctionExtractionAtIndex(targetRange, context, index);
+    }
+    const parsedConstantIndexMatch = /^constant_scope_(\d+)$/.exec(actionName);
+    if (parsedConstantIndexMatch) {
+        const index = +parsedConstantIndexMatch[1];
+        Debug.assert(isFinite(index), "Expected to parse a finite number from the constant scope index");
+        return getConstantExtractionAtIndex(targetRange, context, index);
+    }
+    Debug.fail("Unrecognized action name");
+}
+// Move these into diagnostic messages if they become user-facing. Na tag, também as do `super`, do JSDoc, do label, do
+// generator, da propriedade `readonly` de uma classe, da classe de um arquivo JavaScript e da `function` global que a
+// extração deixaria fora do alcance, que saem com o que as dispara (CK-02, CK-03).
+export var Messages;
+(function (Messages) {
+    function createMessage(message) {
+        return { message, code: 0, category: DiagnosticCategory.Message, key: message };
+    }
+    Messages.cannotExtractRange = createMessage("Cannot extract range.");
+    Messages.cannotExtractImport = createMessage("Cannot extract import statement.");
+    Messages.cannotExtractEmpty = createMessage("Cannot extract empty range.");
+    Messages.expressionExpected = createMessage("expression expected.");
+    Messages.uselessConstantType = createMessage("No reason to extract constant of type.");
+    Messages.statementOrExpressionExpected = createMessage("Statement or expression expected.");
+    Messages.cannotExtractRangeContainingConditionalBreakOrContinueStatements = createMessage("Cannot extract range containing conditional break or continue statements.");
+    Messages.cannotExtractRangeContainingConditionalReturnStatement = createMessage("Cannot extract range containing conditional return statement.");
+    Messages.typeWillNotBeVisibleInTheNewScope = createMessage("Type will not visible in the new scope.");
+    Messages.cannotExtractIdentifier = createMessage("Select more than a single identifier.");
+    Messages.cannotExtractExportedEntity = createMessage("Cannot extract exported declaration");
+    Messages.cannotWriteInExpression = createMessage("Cannot write back side-effects when extracting an expression");
+    Messages.cannotExtractAmbientBlock = createMessage("Cannot extract code from ambient contexts");
+    Messages.cannotAccessVariablesFromNestedScopes = createMessage("Cannot access variables from nested scopes");
+    Messages.cannotExtractToOtherFunctionLike = createMessage("Cannot extract method to a function-like scope that is not a function");
+    Messages.cannotExtractToExpressionArrowFunction = createMessage("Cannot extract constant to an arrow function without a block");
+})(Messages || (Messages = {}));
+// Na tag, também o generator, o uso do `this` e a região estática de uma classe (CK-02).
+var RangeFacts;
+(function (RangeFacts) {
+    RangeFacts[RangeFacts["None"] = 0] = "None";
+    RangeFacts[RangeFacts["HasReturn"] = 1] = "HasReturn";
+    RangeFacts[RangeFacts["IsAsyncFunction"] = 4] = "IsAsyncFunction";
+})(RangeFacts || (RangeFacts = {}));
+/**
+ * getRangeToExtract takes a span inside a text file and returns either an expression or an array
+ * of statements representing the minimum set of nodes needed to extract the entire span. This
+ * process may fail, in which case a set of errors is returned instead (these are currently
+ * not shown to the user, but can be used by us diagnostically)
+ */
+// exported only for tests
+export function getRangeToExtract(sourceFile, span) {
+    const { length } = span;
+    if (length === 0) {
+        return { errors: [createFileDiagnostic(sourceFile, span.start, length, Messages.cannotExtractEmpty)] };
+    }
+    // Walk up starting from the the start position until we find a non-SourceFile node that subsumes the selected span.
+    // This may fail (e.g. you select two statements in the root of a source file)
+    const start = getParentNodeInSpan(getTokenAtPosition(sourceFile, span.start), sourceFile, span);
+    // Do the same for the ending position
+    const end = getParentNodeInSpan(findTokenOnLeftOfPosition(sourceFile, textSpanEnd(span)), sourceFile, span);
+    const declarations = [];
+    // We'll modify these flags as we walk the tree to collect data
+    // about what things need to be done as part of the extraction.
+    let rangeFacts = RangeFacts.None;
+    if (!start || !end) {
+        // cannot find either start or end node
+        return { errors: [createFileDiagnostic(sourceFile, span.start, length, Messages.cannotExtractRange)] };
+    }
+    if (start.parent !== end.parent) {
+        // start and end nodes belong to different subtrees
+        return { errors: [createFileDiagnostic(sourceFile, span.start, length, Messages.cannotExtractRange)] };
+    }
+    if (start !== end) {
+        // start and end should be statements and parent should be either block or a source file
+        if (!isBlockLike(start.parent)) {
+            return { errors: [createFileDiagnostic(sourceFile, span.start, length, Messages.cannotExtractRange)] };
+        }
+        const statements = [];
+        const start2 = start; // TODO: GH#18217 Need to alias `start` to get this to compile. See https://github.com/Microsoft/TypeScript/issues/19955#issuecomment-344118248
+        for (const statement of start2.parent.statements) {
+            if (statement === start || statements.length) {
+                const errors = checkNode(statement);
+                if (errors) {
+                    return { errors };
+                }
+                statements.push(statement);
+            }
+            if (statement === end) {
+                break;
+            }
+        }
+        if (!statements.length) {
+            // https://github.com/Microsoft/TypeScript/issues/20559
+            // Ranges like [|case 1: break;|] will fail to populate `statements` because
+            // they will never find `start` in `start.parent.statements`.
+            // Consider: We could support ranges like [|case 1:|] by refining them to just
+            // the expression.
+            return { errors: [createFileDiagnostic(sourceFile, span.start, length, Messages.cannotExtractRange)] };
+        }
+        return { targetRange: { range: statements, facts: rangeFacts, declarations } };
+    }
+    // Na tag, a seleção de um JSDoc dava o erro dele (CK-03).
+    if (isReturnStatement(start) && !start.expression) {
+        // Makes no sense to extract an expression-less return statement.
+        return { errors: [createFileDiagnostic(sourceFile, span.start, length, Messages.cannotExtractRange)] };
+    }
+    // We have a single node (start)
+    const node = refineNode(start);
+    const errors = checkRootNode(node) || checkNode(node);
+    if (errors) {
+        return { errors };
+    }
+    return { targetRange: { range: getStatementOrExpressionRange(node), facts: rangeFacts, declarations } }; // TODO: GH#18217
+    /**
+     * Attempt to refine the extraction node (generally, by shrinking it) to produce better results.
+     * @param node The unrefined extraction node.
+     */
+    function refineNode(node) {
+        if (isReturnStatement(node)) {
+            if (node.expression) {
+                return node.expression;
+            }
+        }
+        else if (isVariableStatement(node)) {
+            let numInitializers = 0;
+            let lastInitializer;
+            for (const declaration of node.declarationList.declarations) {
+                if (declaration.initializer) {
+                    numInitializers++;
+                    lastInitializer = declaration.initializer;
+                }
+            }
+            if (numInitializers === 1) {
+                return lastInitializer;
+            }
+            // No special handling if there are multiple initializers.
+        }
+        else if (isVariableDeclaration(node)) {
+            if (node.initializer) {
+                return node.initializer;
+            }
+        }
+        return node;
+    }
+    function checkRootNode(node) {
+        if (isIdentifier(isExpressionStatement(node) ? node.expression : node)) {
+            return [createDiagnosticForNode(node, Messages.cannotExtractIdentifier)];
+        }
+        return undefined;
+    }
+    // Na tag, o `checkForStaticContext` marcava a região estática de uma classe (CK-02).
+    // Verifies whether we can actually extract this node or not.
+    function checkNode(nodeToCheck) {
+        let PermittedJumps;
+        (function (PermittedJumps) {
+            PermittedJumps[PermittedJumps["None"] = 0] = "None";
+            PermittedJumps[PermittedJumps["Break"] = 1] = "Break";
+            PermittedJumps[PermittedJumps["Continue"] = 2] = "Continue";
+            PermittedJumps[PermittedJumps["Return"] = 4] = "Return";
+        })(PermittedJumps || (PermittedJumps = {}));
+        // We believe it's true because the node is from the (unmodified) tree.
+        Debug.assert(nodeToCheck.pos <= nodeToCheck.end, "This failure could trigger https://github.com/Microsoft/TypeScript/issues/20809 (1)");
+        // For understanding how skipTrivia functioned:
+        Debug.assert(!positionIsSynthesized(nodeToCheck.pos), "This failure could trigger https://github.com/Microsoft/TypeScript/issues/20809 (2)");
+        if (!isStatement(nodeToCheck) && !(isExpressionNode(nodeToCheck) && isExtractableExpression(nodeToCheck))) {
+            return [createDiagnosticForNode(nodeToCheck, Messages.statementOrExpressionExpected)];
+        }
+        if (nodeToCheck.flags & NodeFlags.Ambient) {
+            return [createDiagnosticForNode(nodeToCheck, Messages.cannotExtractAmbientBlock)];
+        }
+        let errors;
+        let permittedJumps = 4 /* PermittedJumps.Return */;
+        visit(nodeToCheck);
+        return errors;
+        function visit(node) {
+            if (errors) {
+                // already found an error - can stop now
+                return true;
+            }
+            if (isDeclaration(node)) {
+                const declaringNode = (node.kind === SyntaxKind.VariableDeclaration) ? node.parent.parent : node;
+                if (hasModifier(declaringNode, ModifierFlags.Export)) {
+                    // TODO: GH#18217 Silly to use `errors ||` since it's definitely not defined (see top of `visit`)
+                    // Also, if we're only pushing one error, just use `let error: Diagnostic | undefined`!
+                    // Also TODO: GH#19956
+                    (errors || (errors = [])).push(createDiagnosticForNode(node, Messages.cannotExtractExportedEntity));
+                    return true;
+                }
+                declarations.push(node.symbol);
+            }
+            // Some things can't be extracted in certain situations. Na tag, também o `super` (CK-02).
+            switch (node.kind) {
+                case SyntaxKind.ImportDeclaration:
+                    (errors || (errors = [])).push(createDiagnosticForNode(node, Messages.cannotExtractImport));
+                    return true;
+            }
+            // Na tag, também a classe, e a `function` e a classe globais, que a extração tiraria do alcance (CK-02).
+            if (isFunctionLikeDeclaration(node)) {
+                // do not dive into functions
+                return false;
+            }
+            const savedPermittedJumps = permittedJumps;
+            switch (node.kind) {
+                case SyntaxKind.IfStatement:
+                    permittedJumps = 0 /* PermittedJumps.None */;
+                    break;
+                case SyntaxKind.TryStatement:
+                    // forbid all jumps inside try blocks
+                    permittedJumps = 0 /* PermittedJumps.None */;
+                    break;
+                case SyntaxKind.Block:
+                    if (node.parent && node.parent.kind === SyntaxKind.TryStatement && node.parent.finallyBlock === node) {
+                        // allow unconditional returns from finally blocks
+                        permittedJumps = 4 /* PermittedJumps.Return */;
+                    }
+                    break;
+                case SyntaxKind.DefaultClause:
+                case SyntaxKind.CaseClause:
+                    // allow unlabeled break inside case clauses
+                    permittedJumps |= 1 /* PermittedJumps.Break */;
+                    break;
+                default:
+                    if (isIterationStatement(node)) {
+                        // allow unlabeled break/continue inside loops
+                        permittedJumps |= 1 /* PermittedJumps.Break */ | 2 /* PermittedJumps.Continue */;
+                    }
+                    break;
+            }
+            // Na tag, também o `this` e o tipo `this`, o statement com label com o salto para ele, e o `yield` (CK-02).
+            switch (node.kind) {
+                case SyntaxKind.BreakStatement:
+                case SyntaxKind.ContinueStatement: {
+                    if (!(permittedJumps & (node.kind === SyntaxKind.BreakStatement ? 1 /* PermittedJumps.Break */ : 2 /* PermittedJumps.Continue */))) {
+                        // attempt to break or continue in a forbidden context
+                        (errors || (errors = [])).push(createDiagnosticForNode(node, Messages.cannotExtractRangeContainingConditionalBreakOrContinueStatements));
+                    }
+                    break;
+                }
+                case SyntaxKind.AwaitExpression:
+                    rangeFacts |= RangeFacts.IsAsyncFunction;
+                    break;
+                case SyntaxKind.ReturnStatement:
+                    if (permittedJumps & 4 /* PermittedJumps.Return */) {
+                        rangeFacts |= RangeFacts.HasReturn;
+                    }
+                    else {
+                        (errors || (errors = [])).push(createDiagnosticForNode(node, Messages.cannotExtractRangeContainingConditionalReturnStatement));
+                    }
+                    break;
+                default:
+                    forEachChild(node, visit);
+                    break;
+            }
+            permittedJumps = savedPermittedJumps;
+        }
+    }
+}
+function getStatementOrExpressionRange(node) {
+    if (isStatement(node)) {
+        return [node];
+    }
+    else if (isExpressionNode(node)) {
+        // If our selection is the expression in an ExpressionStatement, expand
+        // the selection to include the enclosing Statement (this stops us
+        // from trying to care about the return value of the extracted function
+        // and eliminates double semicolon insertion in certain scenarios)
+        return isExpressionStatement(node.parent) ? [node.parent] : node;
+    }
+    return undefined;
+}
+function isScope(node) {
+    return isFunctionLikeDeclaration(node) || isSourceFile(node) || isModuleBlock(node);
+}
+/**
+ * Computes possible places we could extract the function into. For example,
+ * you may be able to extract into a class method *or* local closure *or* namespace function,
+ * depending on what's in the extracted body.
+ */
+function collectEnclosingScopes(range) {
+    let current = isReadonlyArray(range.range) ? first(range.range) : range.range;
+    // Na tag, o trecho que usava o `this` numa classe só ia para um método dela (CK-02).
+    const scopes = [];
+    while (true) {
+        current = current.parent;
+        // A function parameter's initializer is actually in the outer scope, not the function declaration
+        if (current.kind === SyntaxKind.Parameter) {
+            // Skip all the way to the outer scope of the function that declared this parameter
+            current = findAncestor(current, parent => isFunctionLikeDeclaration(parent)).parent;
+        }
+        // We want to find the nearest parent where we can place an "equivalent" sibling to the node we're extracting out of.
+        // Walk up to the closest parent of a place where we can logically put a sibling:
+        //  * Function declaration
+        //  * Class declaration or expression
+        //  * Module/namespace or source file
+        if (isScope(current)) {
+            scopes.push(current);
+            if (current.kind === SyntaxKind.SourceFile) {
+                return scopes;
+            }
+        }
+    }
+}
+function getFunctionExtractionAtIndex(targetRange, context, requestedChangesIndex) {
+    const { scopes, readsAndWrites: { target, usagesPerScope, functionErrorsPerScope, exposedVariableDeclarations } } = getPossibleExtractionsWorker(targetRange, context);
+    Debug.assert(!functionErrorsPerScope[requestedChangesIndex].length, "The extraction went missing? How?");
+    context.cancellationToken.throwIfCancellationRequested(); // TODO: GH#18217
+    return extractFunctionInScope(target, scopes[requestedChangesIndex], usagesPerScope[requestedChangesIndex], exposedVariableDeclarations, targetRange, context);
+}
+function getConstantExtractionAtIndex(targetRange, context, requestedChangesIndex) {
+    const { scopes, readsAndWrites: { target, usagesPerScope, constantErrorsPerScope, exposedVariableDeclarations } } = getPossibleExtractionsWorker(targetRange, context);
+    Debug.assert(!constantErrorsPerScope[requestedChangesIndex].length, "The extraction went missing? How?");
+    Debug.assert(exposedVariableDeclarations.length === 0, "Extract constant accepted a range containing a variable declaration?");
+    context.cancellationToken.throwIfCancellationRequested();
+    const expression = isExpression(target)
+        ? target
+        : target.statements[0].expression;
+    return extractConstantInScope(expression, scopes[requestedChangesIndex], usagesPerScope[requestedChangesIndex], context);
+}
+/**
+ * Given a piece of text to extract ('targetRange'), computes a list of possible extractions.
+ * Each returned ExtractResultForScope corresponds to a possible target scope and is either a set of changes
+ * or an error explaining why we can't extract into that scope.
+ */
+function getPossibleExtractions(targetRange, context) {
+    const { scopes, readsAndWrites: { functionErrorsPerScope, constantErrorsPerScope } } = getPossibleExtractionsWorker(targetRange, context);
+    // Need the inner type annotation to avoid https://github.com/Microsoft/TypeScript/issues/7547
+    const extractions = scopes.map((scope, i) => {
+        const functionDescriptionPart = getDescriptionForFunctionInScope(scope);
+        const constantDescriptionPart = getDescriptionForConstantInScope(scope);
+        const scopeDescription = isFunctionLikeDeclaration(scope)
+            ? getDescriptionForFunctionLikeDeclaration(scope)
+            : getDescriptionForModuleLikeDeclaration(scope);
+        let functionDescription;
+        let constantDescription;
+        if (scopeDescription === 1 /* SpecialScope.Global */) {
+            functionDescription = formatStringFromArgs(getLocaleSpecificMessage(Diagnostics.Extract_to_0_in_1_scope), [functionDescriptionPart, "global"]);
+            constantDescription = formatStringFromArgs(getLocaleSpecificMessage(Diagnostics.Extract_to_0_in_1_scope), [constantDescriptionPart, "global"]);
+        }
+        else if (scopeDescription === 0 /* SpecialScope.Module */) {
+            functionDescription = formatStringFromArgs(getLocaleSpecificMessage(Diagnostics.Extract_to_0_in_1_scope), [functionDescriptionPart, "module"]);
+            constantDescription = formatStringFromArgs(getLocaleSpecificMessage(Diagnostics.Extract_to_0_in_1_scope), [constantDescriptionPart, "module"]);
+        }
+        else {
+            functionDescription = formatStringFromArgs(getLocaleSpecificMessage(Diagnostics.Extract_to_0_in_1), [functionDescriptionPart, scopeDescription]);
+            constantDescription = formatStringFromArgs(getLocaleSpecificMessage(Diagnostics.Extract_to_0_in_1), [constantDescriptionPart, scopeDescription]);
+        }
+        // Customize the phrasing for the innermost scope to increase clarity.
+        if (i === 0) {
+            constantDescription = formatStringFromArgs(getLocaleSpecificMessage(Diagnostics.Extract_to_0_in_enclosing_scope), [constantDescriptionPart]);
+        }
+        return {
+            functionExtraction: {
+                description: functionDescription,
+                errors: functionErrorsPerScope[i],
+            },
+            constantExtraction: {
+                description: constantDescription,
+                errors: constantErrorsPerScope[i],
+            },
+        };
+    });
+    return extractions;
+}
+function getPossibleExtractionsWorker(targetRange, context) {
+    const { file: sourceFile } = context;
+    const scopes = collectEnclosingScopes(targetRange);
+    const enclosingTextRange = getEnclosingTextRange(targetRange, sourceFile);
+    const readsAndWrites = collectReadsAndWrites(targetRange, scopes, enclosingTextRange, sourceFile, context.program.getTypeChecker(), context.cancellationToken);
+    return { scopes, readsAndWrites };
+}
+// Na tag, o método e o campo `readonly` de uma classe (CK-02).
+function getDescriptionForFunctionInScope(scope) {
+    return isFunctionLikeDeclaration(scope)
+        ? "inner function"
+        : "function";
+}
+function getDescriptionForConstantInScope(_scope) {
+    return "constant";
+}
+// Na tag, também o construtor, a `function` e a function expression, o método e os acessores, e a classe (CK-02).
+function getDescriptionForFunctionLikeDeclaration(_scope) {
+    return "arrow function";
+}
+function getDescriptionForModuleLikeDeclaration(scope) {
+    return scope.kind === SyntaxKind.ModuleBlock
+        ? `namespace '${scope.parent.name.getText()}'`
+        : scope.externalModuleIndicator ? 0 /* SpecialScope.Module */ : 1 /* SpecialScope.Global */;
+}
+var SpecialScope;
+(function (SpecialScope) {
+    SpecialScope[SpecialScope["Module"] = 0] = "Module";
+    SpecialScope[SpecialScope["Global"] = 1] = "Global";
+})(SpecialScope || (SpecialScope = {}));
+/**
+ * Result of 'extractRange' operation for a specific scope.
+ * Stores either a list of changes that should be applied to extract a range or a list of errors
+ */
+function extractFunctionInScope(node, scope, { usages: usagesInScope, typeParameterUsages, substitutions }, exposedVariableDeclarations, range, context) {
+    const checker = context.program.getTypeChecker();
+    // O alvo da configuração fixa (CK-24).
+    const scriptTarget = ScriptTarget.ES2020;
+    const importAdder = codefix.createImportAdder(context.file, context.program, context.preferences, context.host);
+    // Make a unique name for the extracted function. Na tag, o nome era outro para um método (CK-02).
+    const file = scope.getSourceFile();
+    const functionNameText = getUniqueName("newFunction", file);
+    const functionName = createIdentifier(functionNameText);
+    let returnType;
+    const parameters = [];
+    const callArguments = [];
+    let writes;
+    // Na tag, o arquivo JavaScript não anotava os tipos (CK-03).
+    usagesInScope.forEach((usage, name) => {
+        let type = checker.getTypeOfSymbolAtLocation(usage.symbol, usage.node);
+        // Widen the type so we don't emit nonsense annotations like "function fn(x: 3) {"
+        type = checker.getBaseTypeOfLiteralType(type);
+        const typeNode = codefix.typeToAutoImportableTypeNode(checker, importAdder, type, scope, scriptTarget, NodeBuilderFlags.NoTruncation);
+        const paramDecl = createParameter(
+        /*modifiers*/ undefined, 
+        /*dotDotDotToken*/ undefined, 
+        /*name*/ name, 
+        /*questionToken*/ undefined, typeNode);
+        parameters.push(paramDecl);
+        if (usage.usage === 2 /* Usage.Write */) {
+            (writes || (writes = [])).push(usage);
+        }
+        callArguments.push(createIdentifier(name));
+    });
+    const typeParametersAndDeclarations = arrayFrom(typeParameterUsages.values()).map(type => ({ type, declaration: getFirstDeclaration(type) }));
+    const sortedTypeParametersAndDeclarations = typeParametersAndDeclarations.sort(compareTypesByDeclarationOrder);
+    const typeParameters = sortedTypeParametersAndDeclarations.length === 0
+        ? undefined
+        : sortedTypeParametersAndDeclarations.map(t => t.declaration);
+    // Strictly speaking, we should check whether each name actually binds to the appropriate type
+    // parameter.  In cases of shadowing, they may not.
+    const callTypeArguments = typeParameters !== undefined
+        ? typeParameters.map(decl => createTypeReferenceNode(decl.name, /*typeArguments*/ undefined))
+        : undefined;
+    // Provide explicit return types for contextually-typed functions
+    // to avoid problems when there are literal types present
+    if (isExpression(node)) {
+        const contextualType = checker.getContextualType(node);
+        returnType = checker.typeToTypeNode(contextualType, scope, NodeBuilderFlags.NoTruncation);
+    }
+    const { body, returnValueProperty } = transformFunctionBody(node, exposedVariableDeclarations, writes, substitutions, !!(range.facts & RangeFacts.HasReturn));
+    suppressLeadingAndTrailingTrivia(body);
+    // A função da Linguagem é um `const` com uma arrow (CK-69). Na tag, uma `function` declarada, ou, numa classe, um
+    // método privado, estático na região estática (CK-02); e a estrela do generator (CK-02).
+    const newFunction = createVariableStatement(
+    /*modifiers*/ undefined, createVariableDeclarationList([createVariableDeclaration(functionName, 
+        /*type*/ undefined, createArrowFunction(range.facts & RangeFacts.IsAsyncFunction ? [createToken(SyntaxKind.AsyncKeyword)] : undefined, typeParameters, parameters, returnType, 
+        /*equalsGreaterThanToken*/ undefined, body))], NodeFlags.Const));
+    // O `const` não é içado como a `function`: ele entra antes do statement que o usa, onde a extração para uma constante
+    // o põe, e não depois do trecho, no fim do escopo, como a `function` da tag (CK-69).
+    const changeTracker = textChanges.ChangeTracker.fromContext(context);
+    const nodeToInsertBefore = getNodeToInsertConstantBefore(isReadonlyArray(range.range) ? first(range.range) : range.range, scope);
+    if (nodeToInsertBefore.pos === 0) {
+        changeTracker.insertNodeAtTopOfFile(context.file, newFunction, /*blankLineBetween*/ true);
+    }
+    else {
+        changeTracker.insertNodeBefore(context.file, nodeToInsertBefore, newFunction, /*blankLineBetween*/ true);
+    }
+    importAdder.writeFixes(changeTracker);
+    const newNodes = [];
+    // replace range with function call. Na tag, o método de uma classe se chamava pelo `this` ou pelo nome dela (CK-02).
+    const called = createIdentifier(functionNameText);
+    let call = createCall(called, callTypeArguments, // Note that no attempt is made to take advantage of type argument inference
+    callArguments);
+    if (range.facts & RangeFacts.IsAsyncFunction) {
+        call = createAwait(call);
+    }
+    if (exposedVariableDeclarations.length && !writes) {
+        // No need to mix declarations and writes.
+        // How could any variables be exposed if there's a return statement?
+        Debug.assert(!returnValueProperty, "Expected no returnValueProperty");
+        Debug.assert(!(range.facts & RangeFacts.HasReturn), "Expected RangeFacts.HasReturn flag to be unset");
+        if (exposedVariableDeclarations.length === 1) {
+            // Declaring exactly one variable: let x = newFunction();
+            const variableDeclaration = exposedVariableDeclarations[0];
+            newNodes.push(createVariableStatement(
+            /*modifiers*/ undefined, createVariableDeclarationList([createVariableDeclaration(getSynthesizedDeepClone(variableDeclaration.name), /*type*/ getSynthesizedDeepClone(variableDeclaration.type), /*initializer*/ call)], // TODO (acasey): test binding patterns
+            variableDeclaration.parent.flags)));
+        }
+        else {
+            // Declaring multiple variables / return properties:
+            //   let {x, y} = newFunction();
+            const bindingElements = [];
+            const typeElements = [];
+            let commonNodeFlags = exposedVariableDeclarations[0].parent.flags;
+            let sawExplicitType = false;
+            for (const variableDeclaration of exposedVariableDeclarations) {
+                bindingElements.push(createBindingElement(
+                /*dotDotDotToken*/ undefined, 
+                /*propertyName*/ undefined, 
+                /*name*/ getSynthesizedDeepClone(variableDeclaration.name)));
+                // Being returned through an object literal will have widened the type.
+                const variableType = checker.typeToTypeNode(checker.getBaseTypeOfLiteralType(checker.getTypeAtLocation(variableDeclaration)), scope, NodeBuilderFlags.NoTruncation);
+                typeElements.push(createPropertySignature(
+                /*modifiers*/ undefined, 
+                /*name*/ variableDeclaration.symbol.name, 
+                /*questionToken*/ undefined, 
+                /*type*/ variableType, 
+                /*initializer*/ undefined));
+                sawExplicitType = sawExplicitType || variableDeclaration.type !== undefined;
+                commonNodeFlags = commonNodeFlags & variableDeclaration.parent.flags;
+            }
+            const typeLiteral = sawExplicitType ? createTypeLiteralNode(typeElements) : undefined;
+            if (typeLiteral) {
+                setEmitFlags(typeLiteral, EmitFlags.SingleLine);
+            }
+            newNodes.push(createVariableStatement(
+            /*modifiers*/ undefined, createVariableDeclarationList([createVariableDeclaration(createObjectBindingPattern(bindingElements), 
+                /*type*/ typeLiteral, 
+                /*initializer*/ call)], commonNodeFlags)));
+        }
+    }
+    else if (exposedVariableDeclarations.length || writes) {
+        if (exposedVariableDeclarations.length) {
+            // CONSIDER: we're going to create one statement per variable, but we could actually preserve their original grouping.
+            for (const variableDeclaration of exposedVariableDeclarations) {
+                let flags = variableDeclaration.parent.flags;
+                if (flags & NodeFlags.Const) {
+                    flags = (flags & ~NodeFlags.Const) | NodeFlags.Let;
+                }
+                newNodes.push(createVariableStatement(
+                /*modifiers*/ undefined, createVariableDeclarationList([createVariableDeclaration(variableDeclaration.symbol.name, getTypeDeepCloneUnionUndefined(variableDeclaration.type))], flags)));
+            }
+        }
+        if (returnValueProperty) {
+            // has both writes and return, need to create variable declaration to hold return value;
+            newNodes.push(createVariableStatement(
+            /*modifiers*/ undefined, createVariableDeclarationList([createVariableDeclaration(returnValueProperty, getTypeDeepCloneUnionUndefined(returnType))], NodeFlags.Let)));
+        }
+        const assignments = getPropertyAssignmentsForWritesAndVariableDeclarations(exposedVariableDeclarations, writes);
+        if (returnValueProperty) {
+            assignments.unshift(createShorthandPropertyAssignment(returnValueProperty));
+        }
+        // propagate writes back
+        if (assignments.length === 1) {
+            // We would only have introduced a return value property if there had been
+            // other assignments to make.
+            Debug.assert(!returnValueProperty, "Shouldn't have returnValueProperty here");
+            newNodes.push(createStatement(createAssignment(assignments[0].name, call)));
+            if (range.facts & RangeFacts.HasReturn) {
+                newNodes.push(createReturn());
+            }
+        }
+        else {
+            // emit e.g.
+            //   { a, b, __return } = newFunction(a, b);
+            //   return __return;
+            newNodes.push(createStatement(createAssignment(createObjectLiteral(assignments), call)));
+            if (returnValueProperty) {
+                newNodes.push(createReturn(createIdentifier(returnValueProperty)));
+            }
+        }
+    }
+    else {
+        if (range.facts & RangeFacts.HasReturn) {
+            newNodes.push(createReturn(call));
+        }
+        else if (isReadonlyArray(range.range)) {
+            newNodes.push(createStatement(call));
+        }
+        else {
+            newNodes.push(call);
+        }
+    }
+    if (isReadonlyArray(range.range)) {
+        changeTracker.replaceNodeRangeWithNodes(context.file, first(range.range), last(range.range), newNodes);
+    }
+    else {
+        changeTracker.replaceNodeWithNodes(context.file, range.range, newNodes);
+    }
+    const edits = changeTracker.getChanges();
+    const renameRange = isReadonlyArray(range.range) ? first(range.range) : range.range;
+    // A declaração vem antes do uso, como a da constante (CK-69): o rename começa na última ocorrência, que é a chamada.
+    const renameFilename = renameRange.getSourceFile().fileName;
+    const renameLocation = getRenameLocation(edits, renameFilename, functionNameText, /*isDeclaredBeforeUse*/ true);
+    return { renameFilename, renameLocation, edits };
+    function getTypeDeepCloneUnionUndefined(typeNode) {
+        if (typeNode === undefined) {
+            return undefined;
+        }
+        const clone = getSynthesizedDeepClone(typeNode);
+        let withoutParens = clone;
+        while (isParenthesizedTypeNode(withoutParens)) {
+            withoutParens = withoutParens.type;
+        }
+        return isUnionTypeNode(withoutParens) && find(withoutParens.types, t => t.kind === SyntaxKind.UndefinedKeyword)
+            ? clone
+            : createUnionTypeNode([clone, createKeywordTypeNode(SyntaxKind.UndefinedKeyword)]);
+    }
+}
+/**
+ * Result of 'extractRange' operation for a specific scope.
+ * Stores either a list of changes that should be applied to extract a range or a list of errors
+ */
+function extractConstantInScope(node, scope, { substitutions }, context) {
+    const checker = context.program.getTypeChecker();
+    // Make a unique name for the extracted variable. Na tag, o nome era outro para uma propriedade de classe (CK-02).
+    const file = scope.getSourceFile();
+    const localNameText = getUniqueName("newLocal", file);
+    // Na tag, o arquivo JavaScript não anotava o tipo (CK-03).
+    let variableType = !checker.isContextSensitive(node)
+        ? undefined
+        : checker.typeToTypeNode(checker.getContextualType(node), scope, NodeBuilderFlags.NoTruncation);
+    let initializer = transformConstantInitializer(node, substitutions);
+    ({ variableType, initializer } = transformFunctionInitializerAndType(variableType, initializer));
+    suppressLeadingAndTrailingTrivia(initializer);
+    const changeTracker = textChanges.ChangeTracker.fromContext(context);
+    // Na tag, numa classe, a constante era uma propriedade `readonly` privada, estática na região estática (CK-02).
+    const newVariableDeclaration = createVariableDeclaration(localNameText, variableType, initializer);
+    // If the node is part of an initializer in a list of variable declarations, insert a new
+    // variable declaration into the list (in case it depends on earlier ones).
+    // CONSIDER: If the declaration list isn't const, we might want to split it into multiple
+    // lists so that the newly extracted one can be const.
+    const oldVariableDeclaration = getContainingVariableDeclarationIfInList(node, scope);
+    if (oldVariableDeclaration) {
+        // Declare
+        // CONSIDER: could detect that each is on a separate line (See `extractConstant_VariableList_MultipleLines` in `extractConstants.ts`)
+        changeTracker.insertNodeBefore(context.file, oldVariableDeclaration, newVariableDeclaration);
+        // Consume
+        const localReference = createIdentifier(localNameText);
+        changeTracker.replaceNode(context.file, node, localReference);
+    }
+    else if (node.parent.kind === SyntaxKind.ExpressionStatement && scope === findAncestor(node, isScope)) {
+        // If the parent is an expression statement and the target scope is the immediately enclosing one,
+        // replace the statement with the declaration.
+        const newVariableStatement = createVariableStatement(
+        /*modifiers*/ undefined, createVariableDeclarationList([newVariableDeclaration], NodeFlags.Const));
+        changeTracker.replaceNode(context.file, node.parent, newVariableStatement);
+    }
+    else {
+        const newVariableStatement = createVariableStatement(
+        /*modifiers*/ undefined, createVariableDeclarationList([newVariableDeclaration], NodeFlags.Const));
+        // Declare
+        const nodeToInsertBefore = getNodeToInsertConstantBefore(node, scope);
+        if (nodeToInsertBefore.pos === 0) {
+            changeTracker.insertNodeAtTopOfFile(context.file, newVariableStatement, /*blankLineBetween*/ false);
+        }
+        else {
+            changeTracker.insertNodeBefore(context.file, nodeToInsertBefore, newVariableStatement, /*blankLineBetween*/ false);
+        }
+        // Consume
+        if (node.parent.kind === SyntaxKind.ExpressionStatement) {
+            // If the parent is an expression statement, delete it.
+            changeTracker.delete(context.file, node.parent);
+        }
+        else {
+            const localReference = createIdentifier(localNameText);
+            changeTracker.replaceNode(context.file, node, localReference);
+        }
+    }
+    const edits = changeTracker.getChanges();
+    const renameFilename = node.getSourceFile().fileName;
+    const renameLocation = getRenameLocation(edits, renameFilename, localNameText, /*isDeclaredBeforeUse*/ true);
+    return { renameFilename, renameLocation, edits };
+    function transformFunctionInitializerAndType(variableType, initializer) {
+        // If no contextual type exists there is nothing to transfer to the function signature
+        if (variableType === undefined)
+            return { variableType, initializer };
+        // Only do this for arrow functions that are not generic. Na tag, também a function expression (CK-02).
+        if (!isArrowFunction(initializer) || !!initializer.typeParameters)
+            return { variableType, initializer };
+        const functionType = checker.getTypeAtLocation(node);
+        const functionSignature = singleOrUndefined(checker.getSignaturesOfType(functionType));
+        // If no function signature, maybe there was an error, do nothing
+        if (!functionSignature)
+            return { variableType, initializer };
+        // If the function signature has generic type parameters we don't attempt to move the parameters
+        if (!!functionSignature.getTypeParameters())
+            return { variableType, initializer };
+        // We add parameter types if needed
+        const parameters = [];
+        let hasAny = false;
+        for (const p of initializer.parameters) {
+            if (p.type) {
+                parameters.push(p);
+            }
+            else {
+                const paramType = checker.getTypeAtLocation(p);
+                if (paramType === checker.getAnyType())
+                    hasAny = true;
+                parameters.push(updateParameter(p, p.modifiers, p.dotDotDotToken, p.name, p.questionToken, p.type || checker.typeToTypeNode(paramType, scope, NodeBuilderFlags.NoTruncation), p.initializer));
+            }
+        }
+        // If a parameter was inferred as any we skip adding function parameters at all.
+        // Turning an implicit any (which under common settings is a error) to an explicit
+        // is probably actually a worse refactor outcome.
+        if (hasAny)
+            return { variableType, initializer };
+        variableType = undefined;
+        // Na tag, a function expression ganhava também o parâmetro `this` da assinatura (CK-02).
+        initializer = updateArrowFunction(initializer, node.modifiers, initializer.typeParameters, parameters, initializer.type || checker.typeToTypeNode(functionSignature.getReturnType(), scope, NodeBuilderFlags.NoTruncation), initializer.equalsGreaterThanToken, initializer.body);
+        return { variableType, initializer };
+    }
+}
+function getContainingVariableDeclarationIfInList(node, scope) {
+    let prevNode;
+    while (node !== undefined && node !== scope) {
+        if (isVariableDeclaration(node) &&
+            node.initializer === prevNode &&
+            isVariableDeclarationList(node.parent) &&
+            node.parent.declarations.length > 1) {
+            return node;
+        }
+        prevNode = node;
+        node = node.parent;
+    }
+}
+function getFirstDeclaration(type) {
+    let firstDeclaration;
+    const symbol = type.symbol;
+    if (symbol && symbol.declarations) {
+        for (const declaration of symbol.declarations) {
+            if (firstDeclaration === undefined || declaration.pos < firstDeclaration.pos) {
+                firstDeclaration = declaration;
+            }
+        }
+    }
+    return firstDeclaration;
+}
+function compareTypesByDeclarationOrder({ type: type1, declaration: declaration1 }, { type: type2, declaration: declaration2 }) {
+    return compareProperties(declaration1, declaration2, "pos", compareValues)
+        || compareStringsCaseSensitive(type1.symbol ? type1.symbol.getName() : "", type2.symbol ? type2.symbol.getName() : "")
+        || compareValues(type1.id, type2.id);
+}
+function transformFunctionBody(body, exposedVariableDeclarations, writes, substitutions, hasReturn) {
+    const hasWritesOrVariableDeclarations = writes !== undefined || exposedVariableDeclarations.length > 0;
+    if (isBlock(body) && !hasWritesOrVariableDeclarations && substitutions.size === 0) {
+        // already block, no declarations or writes to propagate back, no substitutions - can use node as is
+        return { body: createBlock(body.statements, /*multLine*/ true), returnValueProperty: undefined };
+    }
+    let returnValueProperty;
+    let ignoreReturns = false;
+    const statements = createNodeArray(isBlock(body) ? body.statements.slice(0) : [isStatement(body) ? body : createReturn(body)]);
+    // rewrite body if either there are writes that should be propagated back via return statements or there are substitutions
+    if (hasWritesOrVariableDeclarations || substitutions.size) {
+        const rewrittenStatements = visitNodes(statements, visitor).slice();
+        if (hasWritesOrVariableDeclarations && !hasReturn && isStatement(body)) {
+            // add return at the end to propagate writes back in case if control flow falls out of the function body
+            // it is ok to know that range has at least one return since it we only allow unconditional returns
+            const assignments = getPropertyAssignmentsForWritesAndVariableDeclarations(exposedVariableDeclarations, writes);
+            if (assignments.length === 1) {
+                rewrittenStatements.push(createReturn(assignments[0].name));
+            }
+            else {
+                rewrittenStatements.push(createReturn(createObjectLiteral(assignments)));
+            }
+        }
+        return { body: createBlock(rewrittenStatements, /*multiLine*/ true), returnValueProperty };
+    }
+    else {
+        return { body: createBlock(statements, /*multiLine*/ true), returnValueProperty: undefined };
+    }
+    function visitor(node) {
+        if (!ignoreReturns && node.kind === SyntaxKind.ReturnStatement && hasWritesOrVariableDeclarations) {
+            const assignments = getPropertyAssignmentsForWritesAndVariableDeclarations(exposedVariableDeclarations, writes);
+            if (node.expression) {
+                if (!returnValueProperty) {
+                    returnValueProperty = "__return";
+                }
+                assignments.unshift(createPropertyAssignment(returnValueProperty, visitNode(node.expression, visitor)));
+            }
+            if (assignments.length === 1) {
+                return createReturn(assignments[0].name);
+            }
+            else {
+                return createReturn(createObjectLiteral(assignments));
+            }
+        }
+        else {
+            const oldIgnoreReturns = ignoreReturns;
+            ignoreReturns = ignoreReturns || isFunctionLikeDeclaration(node);
+            const substitution = substitutions.get(getNodeId(node).toString());
+            const result = substitution ? getSynthesizedDeepClone(substitution) : visitEachChild(node, visitor, nullTransformationContext);
+            ignoreReturns = oldIgnoreReturns;
+            return result;
+        }
+    }
+}
+function transformConstantInitializer(initializer, substitutions) {
+    return substitutions.size
+        ? visitor(initializer)
+        : initializer;
+    function visitor(node) {
+        const substitution = substitutions.get(getNodeId(node).toString());
+        return substitution ? getSynthesizedDeepClone(substitution) : visitEachChild(node, visitor, nullTransformationContext);
+    }
+}
+// Na tag, também onde entrava a `function` extraída (o `getNodeToInsertFunctionBefore`, depois do trecho, antes da
+// função seguinte do escopo, com o `getStatementsOrClassElements`), que agora entra como a constante (CK-69), e onde
+// entrava a propriedade de uma classe (CK-02).
+function getNodeToInsertConstantBefore(node, scope) {
+    let prevScope;
+    for (let curr = node; curr !== scope; curr = curr.parent) {
+        if (isScope(curr)) {
+            prevScope = curr;
+        }
+    }
+    for (let curr = (prevScope || node).parent;; curr = curr.parent) {
+        if (isBlockLike(curr)) {
+            let prevStatement;
+            for (const statement of curr.statements) {
+                if (statement.pos > node.pos) {
+                    break;
+                }
+                prevStatement = statement;
+            }
+            if (!prevStatement && isCaseClause(curr)) {
+                // We must have been in the expression of the case clause.
+                Debug.assert(isSwitchStatement(curr.parent.parent), "Grandparent isn't a switch statement");
+                return curr.parent.parent;
+            }
+            // There must be at least one statement since we started in one.
+            return Debug.checkDefined(prevStatement, "prevStatement failed to get set");
+        }
+        Debug.assert(curr !== scope, "Didn't encounter a block-like before encountering scope");
+    }
+}
+function getPropertyAssignmentsForWritesAndVariableDeclarations(exposedVariableDeclarations, writes) {
+    const variableAssignments = map(exposedVariableDeclarations, v => createShorthandPropertyAssignment(v.symbol.name));
+    const writeAssignments = map(writes, w => createShorthandPropertyAssignment(w.symbol.name));
+    // TODO: GH#18217 `variableAssignments` not possibly undefined!
+    return variableAssignments === undefined
+        ? writeAssignments
+        : writeAssignments === undefined
+            ? variableAssignments
+            : variableAssignments.concat(writeAssignments);
+}
+function isReadonlyArray(v) {
+    return isArray(v);
+}
+/**
+ * Produces a range that spans the entirety of nodes, given a selection
+ * that might start/end in the middle of nodes.
+ *
+ * For example, when the user makes a selection like this
+ *                     v---v
+ *   var someThing = foo + bar;
+ *  this returns     ^-------^
+ */
+function getEnclosingTextRange(targetRange, sourceFile) {
+    return isReadonlyArray(targetRange.range)
+        ? { pos: first(targetRange.range).getStart(sourceFile), end: last(targetRange.range).getEnd() }
+        : targetRange.range;
+}
+var Usage;
+(function (Usage) {
+    // value should be passed to extracted method
+    Usage[Usage["Read"] = 1] = "Read";
+    // value should be passed to extracted method and propagated back
+    Usage[Usage["Write"] = 2] = "Write";
+})(Usage || (Usage = {}));
+function collectReadsAndWrites(targetRange, scopes, enclosingTextRange, sourceFile, checker, cancellationToken) {
+    const allTypeParameterUsages = createMap(); // Key is type ID
+    const usagesPerScope = [];
+    const substitutionsPerScope = [];
+    const functionErrorsPerScope = [];
+    const constantErrorsPerScope = [];
+    const visibleDeclarationsInExtractedRange = [];
+    const exposedVariableSymbolSet = createMap(); // Key is symbol ID
+    const exposedVariableDeclarations = [];
+    let firstExposedNonVariableDeclaration;
+    const expression = !isReadonlyArray(targetRange.range)
+        ? targetRange.range
+        : targetRange.range.length === 1 && isExpressionStatement(targetRange.range[0])
+            ? targetRange.range[0].expression
+            : undefined;
+    let expressionDiagnostic;
+    if (expression === undefined) {
+        const statements = targetRange.range;
+        const start = first(statements).getStart();
+        const end = last(statements).end;
+        expressionDiagnostic = createFileDiagnostic(sourceFile, start, end - start, Messages.expressionExpected);
+    }
+    else if (checker.getTypeAtLocation(expression).flags & (TypeFlags.Void | TypeFlags.Never)) {
+        expressionDiagnostic = createDiagnosticForNode(expression, Messages.uselessConstantType);
+    }
+    // initialize results
+    for (const scope of scopes) {
+        usagesPerScope.push({ usages: createMap(), typeParameterUsages: createMap(), substitutions: createMap() });
+        substitutionsPerScope.push(createMap());
+        // Na tag, a função se extraía para dentro de uma `function` declarada, e não de outra função; a arrow é a função
+        // que fica, e a extração para dentro dela continua recusada (CK-02).
+        functionErrorsPerScope.push(isFunctionLikeDeclaration(scope)
+            ? [createDiagnosticForNode(scope, Messages.cannotExtractToOtherFunctionLike)]
+            : []);
+        // Na tag, também a classe de um arquivo JavaScript (CK-02, CK-03).
+        const constantErrors = [];
+        if (expressionDiagnostic) {
+            constantErrors.push(expressionDiagnostic);
+        }
+        if (isArrowFunction(scope) && !isBlock(scope.body)) {
+            constantErrors.push(createDiagnosticForNode(scope, Messages.cannotExtractToExpressionArrowFunction));
+        }
+        constantErrorsPerScope.push(constantErrors);
+    }
+    const seenUsages = createMap();
+    const target = isReadonlyArray(targetRange.range) ? createBlock(targetRange.range) : targetRange.range;
+    const unmodifiedNode = isReadonlyArray(targetRange.range) ? first(targetRange.range) : targetRange.range;
+    const inGenericContext = isInGenericContext(unmodifiedNode);
+    collectUsages(target);
+    // Unfortunately, this code takes advantage of the knowledge that the generated method
+    // will use the contextual type of an expression as the return type of the extracted
+    // method (and will therefore "use" all the types involved).
+    if (inGenericContext && !isReadonlyArray(targetRange.range)) {
+        const contextualType = checker.getContextualType(targetRange.range); // TODO: GH#18217
+        recordTypeParameterUsages(contextualType);
+    }
+    if (allTypeParameterUsages.size > 0) {
+        const seenTypeParameterUsages = createMap(); // Key is type ID
+        let i = 0;
+        for (let curr = unmodifiedNode; curr !== undefined && i < scopes.length; curr = curr.parent) {
+            if (curr === scopes[i]) {
+                // Copy current contents of seenTypeParameterUsages into scope.
+                seenTypeParameterUsages.forEach((typeParameter, id) => {
+                    usagesPerScope[i].typeParameterUsages.set(id, typeParameter);
+                });
+                i++;
+            }
+            // Note that we add the current node's type parameters *after* updating the corresponding scope.
+            if (isDeclarationWithTypeParameters(curr)) {
+                for (const typeParameterDecl of getEffectiveTypeParameterDeclarations(curr)) {
+                    const typeParameter = checker.getTypeAtLocation(typeParameterDecl);
+                    if (allTypeParameterUsages.has(typeParameter.id.toString())) {
+                        seenTypeParameterUsages.set(typeParameter.id.toString(), typeParameter);
+                    }
+                }
+            }
+        }
+        // If we didn't get through all the scopes, then there were some that weren't in our
+        // parent chain (impossible at time of writing).  A conservative solution would be to
+        // copy allTypeParameterUsages into all remaining scopes.
+        Debug.assert(i === scopes.length, "Should have iterated all scopes");
+    }
+    // If there are any declarations in the extracted block that are used in the same enclosing
+    // lexical scope, we can't move the extraction "up" as those declarations will become unreachable
+    if (visibleDeclarationsInExtractedRange.length) {
+        const containingLexicalScopeOfExtraction = isBlockScope(scopes[0], scopes[0].parent)
+            ? scopes[0]
+            : getEnclosingBlockScopeContainer(scopes[0]);
+        forEachChild(containingLexicalScopeOfExtraction, checkForUsedDeclarations);
+    }
+    for (let i = 0; i < scopes.length; i++) {
+        const scopeUsages = usagesPerScope[i];
+        // Special case: in the innermost scope, all usages are available.
+        // (The computed value reflects the value at the top-level of the scope, but the
+        // local will actually be declared at the same level as the extracted expression).
+        if (i > 0 && (scopeUsages.usages.size > 0 || scopeUsages.typeParameterUsages.size > 0)) {
+            const errorNode = isReadonlyArray(targetRange.range) ? targetRange.range[0] : targetRange.range;
+            constantErrorsPerScope[i].push(createDiagnosticForNode(errorNode, Messages.cannotAccessVariablesFromNestedScopes));
+        }
+        // Na tag, também a escrita numa propriedade `readonly` de uma classe, que só o construtor inicializa (CK-02).
+        let hasWrite = false;
+        usagesPerScope[i].usages.forEach(value => {
+            if (value.usage === 2 /* Usage.Write */) {
+                hasWrite = true;
+            }
+        });
+        // If an expression was extracted, then there shouldn't have been any variable declarations.
+        Debug.assert(isReadonlyArray(targetRange.range) || exposedVariableDeclarations.length === 0, "No variable declarations expected if something was extracted");
+        if (hasWrite && !isReadonlyArray(targetRange.range)) {
+            const diag = createDiagnosticForNode(targetRange.range, Messages.cannotWriteInExpression);
+            functionErrorsPerScope[i].push(diag);
+            constantErrorsPerScope[i].push(diag);
+        }
+        else if (firstExposedNonVariableDeclaration) {
+            const diag = createDiagnosticForNode(firstExposedNonVariableDeclaration, Messages.cannotExtractExportedEntity);
+            functionErrorsPerScope[i].push(diag);
+            constantErrorsPerScope[i].push(diag);
+        }
+    }
+    return { target, usagesPerScope, functionErrorsPerScope, constantErrorsPerScope, exposedVariableDeclarations };
+    function isInGenericContext(node) {
+        return !!findAncestor(node, n => isDeclarationWithTypeParameters(n) && getEffectiveTypeParameterDeclarations(n).length !== 0);
+    }
+    function recordTypeParameterUsages(type) {
+        // PERF: This is potentially very expensive.  `type` could be a library type with
+        // a lot of properties, each of which the walker will visit.  Unfortunately, the
+        // solution isn't as trivial as filtering to user types because of (e.g.) Array.
+        const symbolWalker = checker.getSymbolWalker(() => (cancellationToken.throwIfCancellationRequested(), true));
+        const { visitedTypes } = symbolWalker.walkType(type);
+        for (const visitedType of visitedTypes) {
+            if (visitedType.isTypeParameter()) {
+                allTypeParameterUsages.set(visitedType.id.toString(), visitedType);
+            }
+        }
+    }
+    function collectUsages(node, valueUsage = 1 /* Usage.Read */) {
+        if (inGenericContext) {
+            const type = checker.getTypeAtLocation(node);
+            recordTypeParameterUsages(type);
+        }
+        if (isDeclaration(node) && node.symbol) {
+            visibleDeclarationsInExtractedRange.push(node);
+        }
+        if (isAssignmentExpression(node)) {
+            // use 'write' as default usage for values
+            collectUsages(node.left, 2 /* Usage.Write */);
+            collectUsages(node.right);
+        }
+        else if (isUnaryExpressionWithWrite(node)) {
+            collectUsages(node.operand, 2 /* Usage.Write */);
+        }
+        else if (isPropertyAccessExpression(node) || isElementAccessExpression(node)) {
+            // use 'write' as default usage for values
+            forEachChild(node, collectUsages);
+        }
+        else if (isIdentifier(node)) {
+            if (!node.parent) {
+                return;
+            }
+            if (isQualifiedName(node.parent) && node !== node.parent.left) {
+                return;
+            }
+            if (isPropertyAccessExpression(node.parent) && node !== node.parent.expression) {
+                return;
+            }
+            recordUsage(node, valueUsage, /*isTypeNode*/ isPartOfTypeNode(node));
+        }
+        else {
+            forEachChild(node, collectUsages);
+        }
+    }
+    function recordUsage(n, usage, isTypeNode) {
+        const symbolId = recordUsagebySymbol(n, usage, isTypeNode);
+        if (symbolId) {
+            for (let i = 0; i < scopes.length; i++) {
+                // push substitution from map<symbolId, subst> to map<nodeId, subst> to simplify rewriting
+                const substitution = substitutionsPerScope[i].get(symbolId);
+                if (substitution) {
+                    usagesPerScope[i].substitutions.set(getNodeId(n).toString(), substitution);
+                }
+            }
+        }
+    }
+    function recordUsagebySymbol(identifier, usage, isTypeName) {
+        const symbol = getSymbolReferencedByIdentifier(identifier);
+        if (!symbol) {
+            // cannot find symbol - do nothing
+            return undefined;
+        }
+        const symbolId = getSymbolId(symbol).toString();
+        const lastUsage = seenUsages.get(symbolId);
+        // there are two kinds of value usages
+        // - reads - if range contains a read from the value located outside of the range then value should be passed as a parameter
+        // - writes - if range contains a write to a value located outside the range the value should be passed as a parameter and
+        //   returned as a return value
+        // 'write' case is a superset of 'read' so if we already have processed 'write' of some symbol there is not need to handle 'read'
+        // since all information is already recorded
+        if (lastUsage && lastUsage >= usage) {
+            return symbolId;
+        }
+        seenUsages.set(symbolId, usage);
+        if (lastUsage) {
+            // if we get here this means that we are trying to handle 'write' and 'read' was already processed
+            // walk scopes and update existing records.
+            for (const perScope of usagesPerScope) {
+                const prevEntry = perScope.usages.get(identifier.text);
+                if (prevEntry) {
+                    perScope.usages.set(identifier.text, { usage, symbol, node: identifier });
+                }
+            }
+            return symbolId;
+        }
+        // find first declaration in this file
+        const decls = symbol.getDeclarations();
+        const declInFile = decls && find(decls, d => d.getSourceFile() === sourceFile);
+        if (!declInFile) {
+            return undefined;
+        }
+        if (rangeContainsStartEnd(enclosingTextRange, declInFile.getStart(), declInFile.end)) {
+            // declaration is located in range to be extracted - do nothing
+            return undefined;
+        }
+        // Na tag, a escrita numa referência de fora, num trecho extraído para um generator, era recusada (CK-02).
+        for (let i = 0; i < scopes.length; i++) {
+            const scope = scopes[i];
+            const resolvedSymbol = checker.resolveName(symbol.name, scope, symbol.flags, /*excludeGlobals*/ false);
+            if (resolvedSymbol === symbol) {
+                continue;
+            }
+            if (!substitutionsPerScope[i].has(symbolId)) {
+                const substitution = tryReplaceWithQualifiedNameOrPropertyAccess(symbol.exportSymbol || symbol, scope, isTypeName);
+                if (substitution) {
+                    substitutionsPerScope[i].set(symbolId, substitution);
+                }
+                else if (isTypeName) {
+                    // If the symbol is a type parameter that won't be in scope, we'll pass it as a type argument
+                    // so there's no problem.
+                    if (!(symbol.flags & SymbolFlags.TypeParameter)) {
+                        const diag = createDiagnosticForNode(identifier, Messages.typeWillNotBeVisibleInTheNewScope);
+                        functionErrorsPerScope[i].push(diag);
+                        constantErrorsPerScope[i].push(diag);
+                    }
+                }
+                else {
+                    usagesPerScope[i].usages.set(identifier.text, { usage, symbol, node: identifier });
+                }
+            }
+        }
+        return symbolId;
+    }
+    function checkForUsedDeclarations(node) {
+        // If this node is entirely within the original extraction range, we don't need to do anything.
+        if (node === targetRange.range || (isReadonlyArray(targetRange.range) && targetRange.range.indexOf(node) >= 0)) {
+            return;
+        }
+        // Otherwise check and recurse.
+        const sym = isIdentifier(node)
+            ? getSymbolReferencedByIdentifier(node)
+            : checker.getSymbolAtLocation(node);
+        if (sym) {
+            const decl = find(visibleDeclarationsInExtractedRange, d => d.symbol === sym);
+            if (decl) {
+                if (isVariableDeclaration(decl)) {
+                    const idString = decl.symbol.id.toString();
+                    if (!exposedVariableSymbolSet.has(idString)) {
+                        exposedVariableDeclarations.push(decl);
+                        exposedVariableSymbolSet.set(idString, true);
+                    }
+                }
+                else {
+                    // CONSIDER: this includes binding elements, which we could
+                    // expose in the same way as variables.
+                    firstExposedNonVariableDeclaration = firstExposedNonVariableDeclaration || decl;
+                }
+            }
+        }
+        forEachChild(node, checkForUsedDeclarations);
+    }
+    /**
+     * Return the symbol referenced by an identifier (even if it declares a different symbol).
+     */
+    function getSymbolReferencedByIdentifier(identifier) {
+        // If the identifier is both a property name and its value, we're only interested in its value
+        // (since the name is a declaration and will be included in the extracted range).
+        return identifier.parent && isShorthandPropertyAssignment(identifier.parent) && identifier.parent.name === identifier
+            ? checker.getShorthandAssignmentValueSymbol(identifier.parent)
+            : checker.getSymbolAtLocation(identifier);
+    }
+    function tryReplaceWithQualifiedNameOrPropertyAccess(symbol, scopeDecl, isTypeNode) {
+        if (!symbol) {
+            return undefined;
+        }
+        const decls = symbol.getDeclarations();
+        if (decls && decls.some(d => d.parent === scopeDecl)) {
+            return createIdentifier(symbol.name);
+        }
+        const prefix = tryReplaceWithQualifiedNameOrPropertyAccess(symbol.parent, scopeDecl, isTypeNode);
+        if (prefix === undefined) {
+            return undefined;
+        }
+        return isTypeNode
+            ? createQualifiedName(prefix, createIdentifier(symbol.name))
+            : createPropertyAccess(prefix, symbol.name);
+    }
+}
+/**
+ * Computes whether or not a node represents an expression in a position where it could
+ * be extracted.
+ * The isExpression() in utilities.ts returns some false positives we need to handle,
+ * such as `import x from 'y'` -- the 'y' is a StringLiteral but is *not* an expression
+ * in the sense of something that you could extract on
+ */
+function isExtractableExpression(node) {
+    const { parent } = node;
+    // Na tag, o valor de um membro de enum não se extraía (CK-02).
+    switch (node.kind) {
+        case SyntaxKind.StringLiteral:
+            return parent.kind !== SyntaxKind.ImportDeclaration &&
+                parent.kind !== SyntaxKind.ImportSpecifier;
+        case SyntaxKind.SpreadElement:
+        case SyntaxKind.ObjectBindingPattern:
+        case SyntaxKind.BindingElement:
+            return false;
+        case SyntaxKind.Identifier:
+            return parent.kind !== SyntaxKind.BindingElement &&
+                parent.kind !== SyntaxKind.ImportSpecifier &&
+                parent.kind !== SyntaxKind.ExportSpecifier;
+    }
+    return true;
+}
+function isBlockLike(node) {
+    switch (node.kind) {
+        case SyntaxKind.Block:
+        case SyntaxKind.SourceFile:
+        case SyntaxKind.ModuleBlock:
+        case SyntaxKind.CaseClause:
+            return true;
+        default:
+            return false;
+    }
+}