const statements = getStatementsToMove(context);

if (context.preferences.allowTextChangesInNewFiles && statements) {

return [{ name: refactorName, description, actions: [moveToNewFileAction] }];

}

if (context.preferences.provideRefactorNotApplicableReason) {

return [{ name: refactorName, description, actions:

[{ ...moveToNewFileAction, notApplicableReason: getLocaleSpecificMessage(Diagnostics.Selection_is_not_a_valid_statement_or_statements) }]

}];

}

return emptyArray;

Debug.assert(actionName === refactorName, "Wrong refactor invoked");

const statements = Debug.checkDefined(getStatementsToMove(context));

const edits = textChanges.ChangeTracker.with(context, t => doChange(context.file, context.program, statements, t, context.host, context.preferences));

return { edits, renameFilename: undefined, renameLocation: undefined };

const { file } = context;

const range = createTextRangeFromSpan(getRefactorContextSpan(context));

const { statements } = file;

const startNodeIndex = findIndex(statements, s => s.end > range.pos);

if (startNodeIndex === -1) return undefined;

const startStatement = statements[startNodeIndex];

if (isNamedDeclaration(startStatement) && startStatement.name && rangeContainsRange(startStatement.name, range)) {

return { toMove: [statements[startNodeIndex]], afterLast: statements[startNodeIndex + 1] };

}

// Can't only partially include the start node or be partially into the next node

if (range.pos > startStatement.getStart(file)) return undefined;

const afterEndNodeIndex = findIndex(statements, s => s.end > range.end, startNodeIndex);

// Can't be partially into the next node

if (afterEndNodeIndex !== -1 && (afterEndNodeIndex === 0 || statements[afterEndNodeIndex].getStart(file) < range.end)) return undefined;

return {

toMove: statements.slice(startNodeIndex, afterEndNodeIndex === -1 ? statements.length : afterEndNodeIndex),

afterLast: afterEndNodeIndex === -1 ? undefined : statements[afterEndNodeIndex],

};

const checker = program.getTypeChecker();

const usage = getUsageInfo(oldFile, toMove.all, checker);

const currentDirectory = getDirectoryPath(oldFile.fileName);

const extension = extensionFromPath(oldFile.fileName);

const newModuleName = makeUniqueModuleName(getNewModuleName(usage.movedSymbols), extension, currentDirectory, host);

const newFileNameWithExtension = newModuleName + extension;

// If previous file was global, this is easy.

changes.createNewFile(oldFile, combinePaths(currentDirectory, newFileNameWithExtension), getNewStatementsAndRemoveFromOldFile(oldFile, usage, changes, toMove, program, newModuleName, preferences));

addNewFileToTsconfig(program, changes, oldFile.fileName, newFileNameWithExtension, hostGetCanonicalFileName(host));

const rangeToMove = getRangeToMove(context);

if (rangeToMove === undefined) return undefined;

const all: Statement[] = [];

const ranges: StatementRange[] = [];

const { toMove, afterLast } = rangeToMove;

getRangesWhere(toMove, isAllowedStatementToMove, (start, afterEndIndex) => {

for (let i = start; i < afterEndIndex; i++) all.push(toMove[i]);

ranges.push({ first: toMove[start], afterLast });

});

return all.length === 0 ? undefined : { all, ranges };

// Filters imports and prologue directives out of the range of statements to move.

// Imports will be copied to the new file anyway, and may still be needed in the old file.

// Prologue directives will be copied to the new file and should be left in the old file.

return !isPureImport(statement) && !isPrologueDirective(statement);;

switch (node.kind) {

case SyntaxKind.ImportDeclaration:

return true;

case SyntaxKind.ImportEqualsDeclaration:

return !hasSyntacticModifier(node, ModifierFlags.Export);

case SyntaxKind.VariableStatement:

return (node as VariableStatement).declarationList.declarations.every(d => !!d.initializer && isRequireCall(d.initializer, /*checkArgumentIsStringLiteralLike*/ true));

default:

return false;

}

const cfg = program.getCompilerOptions().configFile;

if (!cfg) return;

const newFileAbsolutePath = normalizePath(combinePaths(oldFileName, "..", newFileNameWithExtension));

const newFilePath = getRelativePathFromFile(cfg.fileName, newFileAbsolutePath, getCanonicalFileName);

const cfgObject = cfg.statements[0] && tryCast(cfg.statements[0].expression, isObjectLiteralExpression);

const filesProp = cfgObject && find(cfgObject.properties, (prop): prop is PropertyAssignment =>

isPropertyAssignment(prop) && isStringLiteral(prop.name) && prop.name.text === "files");

if (filesProp && isArrayLiteralExpression(filesProp.initializer)) {

changes.insertNodeInListAfter(cfg, last(filesProp.initializer.elements), factory.createStringLiteral(newFilePath), filesProp.initializer.elements);

}

oldFile: SourceFile, usage: UsageInfo, changes: textChanges.ChangeTracker, toMove: ToMove, program: Program, newModuleName: string, preferences: UserPreferences,

) {

const checker = program.getTypeChecker();

const prologueDirectives = takeWhile(oldFile.statements, isPrologueDirective);

if (!oldFile.externalModuleIndicator && !oldFile.commonJsModuleIndicator) {

deleteMovedStatements(oldFile, toMove.ranges, changes);

return [...prologueDirectives, ...toMove.all];

}

const useEsModuleSyntax = !!oldFile.externalModuleIndicator;

const quotePreference = getQuotePreference(oldFile, preferences);

const importsFromNewFile = createOldFileImportsFromNewFile(usage.oldFileImportsFromNewFile, newModuleName, useEsModuleSyntax, quotePreference);

if (importsFromNewFile) {

insertImports(changes, oldFile, importsFromNewFile, /*blankLineBetween*/ true);

}

deleteUnusedOldImports(oldFile, toMove.all, changes, usage.unusedImportsFromOldFile, checker);

deleteMovedStatements(oldFile, toMove.ranges, changes);

updateImportsInOtherFiles(changes, program, oldFile, usage.movedSymbols, newModuleName);

const imports = getNewFileImportsAndAddExportInOldFile(oldFile, usage.oldImportsNeededByNewFile, usage.newFileImportsFromOldFile, changes, checker, useEsModuleSyntax, quotePreference);

const body = addExports(oldFile, toMove.all, usage.oldFileImportsFromNewFile, useEsModuleSyntax);

if (imports.length && body.length) {

return [

...prologueDirectives,

...imports,

SyntaxKind.NewLineTrivia as const,

...body

];

}

return [

...prologueDirectives,

...imports,

...body,

];

for (const { first, afterLast } of moved) {

changes.deleteNodeRangeExcludingEnd(sourceFile, first, afterLast);

}

for (const statement of oldFile.statements) {

if (contains(toMove, statement)) continue;

forEachImportInStatement(statement, i => deleteUnusedImports(oldFile, i, changes, name => toDelete.has(checker.getSymbolAtLocation(name)!)));

}

const checker = program.getTypeChecker();

for (const sourceFile of program.getSourceFiles()) {

if (sourceFile === oldFile) continue;

for (const statement of sourceFile.statements) {

forEachImportInStatement(statement, importNode => {

if (checker.getSymbolAtLocation(moduleSpecifierFromImport(importNode)) !== oldFile.symbol) return;

const shouldMove = (name: Identifier): boolean => {

const symbol = isBindingElement(name.parent)

? getPropertySymbolFromBindingElement(checker, name.parent as ObjectBindingElementWithoutPropertyName)

: skipAlias(checker.getSymbolAtLocation(name)!, checker); // TODO: GH#18217

return !!symbol && movedSymbols.has(symbol);

};

deleteUnusedImports(sourceFile, importNode, changes, shouldMove); // These will be changed to imports from the new file

const newModuleSpecifier = combinePaths(getDirectoryPath(moduleSpecifierFromImport(importNode).text), newModuleName);

const newImportDeclaration = filterImport(importNode, factory.createStringLiteral(newModuleSpecifier), shouldMove);

if (newImportDeclaration) changes.insertNodeAfter(sourceFile, statement, newImportDeclaration);

const ns = getNamespaceLikeImport(importNode);

if (ns) updateNamespaceLikeImport(changes, sourceFile, checker, movedSymbols, newModuleName, newModuleSpecifier, ns, importNode);

});

}

}

switch (node.kind) {

case SyntaxKind.ImportDeclaration:

return node.importClause && node.importClause.namedBindings && node.importClause.namedBindings.kind === SyntaxKind.NamespaceImport ?

node.importClause.namedBindings.name : undefined;

case SyntaxKind.ImportEqualsDeclaration:

return node.name;

case SyntaxKind.VariableDeclaration:

return tryCast(node.name, isIdentifier);

default:

return Debug.assertNever(node, `Unexpected node kind ${(node as SupportedImport).kind}`);

}

changes: textChanges.ChangeTracker,

sourceFile: SourceFile,

checker: TypeChecker,

movedSymbols: ReadonlySymbolSet,

newModuleName: string,

newModuleSpecifier: string,

oldImportId: Identifier,

oldImportNode: SupportedImport,

): void {

const preferredNewNamespaceName = codefix.moduleSpecifierToValidIdentifier(newModuleName, ScriptTarget.ESNext);

let needUniqueName = false;

const toChange: Identifier[] = [];

FindAllReferences.Core.eachSymbolReferenceInFile(oldImportId, checker, sourceFile, ref => {

if (!isPropertyAccessExpression(ref.parent)) return;

needUniqueName = needUniqueName || !!checker.resolveName(preferredNewNamespaceName, ref, SymbolFlags.All, /*excludeGlobals*/ true);

if (movedSymbols.has(checker.getSymbolAtLocation(ref.parent.name)!)) {

toChange.push(ref);

}

});

if (toChange.length) {

const newNamespaceName = needUniqueName ? getUniqueName(preferredNewNamespaceName, sourceFile) : preferredNewNamespaceName;

for (const ref of toChange) {

changes.replaceNode(sourceFile, ref, factory.createIdentifier(newNamespaceName));

}

changes.insertNodeAfter(sourceFile, oldImportNode, updateNamespaceLikeImportNode(oldImportNode, newModuleName, newModuleSpecifier));

}

const newNamespaceId = factory.createIdentifier(newNamespaceName);

const newModuleString = factory.createStringLiteral(newModuleSpecifier);

switch (node.kind) {

case SyntaxKind.ImportDeclaration:

return factory.createImportDeclaration(

/*decorators*/ undefined, /*modifiers*/ undefined,

factory.createImportClause(/*isTypeOnly*/ false, /*name*/ undefined, factory.createNamespaceImport(newNamespaceId)),

newModuleString,

/*assertClause*/ undefined);

case SyntaxKind.ImportEqualsDeclaration:

return factory.createImportEqualsDeclaration(/*decorators*/ undefined, /*modifiers*/ undefined, /*isTypeOnly*/ false, newNamespaceId, factory.createExternalModuleReference(newModuleString));

case SyntaxKind.VariableDeclaration:

return factory.createVariableDeclaration(newNamespaceId, /*exclamationToken*/ undefined, /*type*/ undefined, createRequireCall(newModuleString));

default:

return Debug.assertNever(node, `Unexpected node kind ${(node as SupportedImport).kind}`);

}

return (i.kind === SyntaxKind.ImportDeclaration ? i.moduleSpecifier

: i.kind === SyntaxKind.ImportEqualsDeclaration ? i.moduleReference.expression

: i.initializer.arguments[0]);

if (isImportDeclaration(statement)) {

if (isStringLiteral(statement.moduleSpecifier)) cb(statement as SupportedImport);

}

else if (isImportEqualsDeclaration(statement)) {

if (isExternalModuleReference(statement.moduleReference) && isStringLiteralLike(statement.moduleReference.expression)) {

cb(statement as SupportedImport);

}

}

else if (isVariableStatement(statement)) {

for (const decl of statement.declarationList.declarations) {

if (decl.initializer && isRequireCall(decl.initializer, /*checkArgumentIsStringLiteralLike*/ true)) {

cb(decl as SupportedImport);

}

}

}

let defaultImport: Identifier | undefined;

const imports: string[] = [];

newFileNeedExport.forEach(symbol => {

if (symbol.escapedName === InternalSymbolName.Default) {

defaultImport = factory.createIdentifier(symbolNameNoDefault(symbol)!); // TODO: GH#18217

}

else {

imports.push(symbol.name);

}

});

return makeImportOrRequire(defaultImport, imports, newFileNameWithExtension, useEs6Imports, quotePreference);

path = ensurePathIsNonModuleName(path);

if (useEs6Imports) {

const specifiers = imports.map(i => factory.createImportSpecifier(/*isTypeOnly*/ false, /*propertyName*/ undefined, factory.createIdentifier(i)));

return makeImportIfNecessary(defaultImport, specifiers, path, quotePreference);

}

else {

Debug.assert(!defaultImport, "No default import should exist"); // If there's a default export, it should have been an es6 module.

const bindingElements = imports.map(i => factory.createBindingElement(/*dotDotDotToken*/ undefined, /*propertyName*/ undefined, i));

return bindingElements.length

? makeVariableStatement(factory.createObjectBindingPattern(bindingElements), /*type*/ undefined, createRequireCall(factory.createStringLiteral(path))) as RequireVariableStatement

: undefined;

}

return flatMap(toMove, statement => {

if (isTopLevelDeclarationStatement(statement) &&

!isExported(sourceFile, statement, useEs6Exports) &&

forEachTopLevelDeclaration(statement, d => needExport.has(Debug.checkDefined(d.symbol)))) {

const exports = addExport(statement, useEs6Exports);

if (exports) return exports;

}

return statement;

});

switch (importDecl.kind) {

case SyntaxKind.ImportDeclaration:

deleteUnusedImportsInDeclaration(sourceFile, importDecl, changes, isUnused);

break;

case SyntaxKind.ImportEqualsDeclaration:

if (isUnused(importDecl.name)) {

changes.delete(sourceFile, importDecl);

}

break;

case SyntaxKind.VariableDeclaration:

deleteUnusedImportsInVariableDeclaration(sourceFile, importDecl, changes, isUnused);

break;

default:

Debug.assertNever(importDecl, `Unexpected import decl kind ${(importDecl as SupportedImport).kind}`);

}

if (!importDecl.importClause) return;

const { name, namedBindings } = importDecl.importClause;

const defaultUnused = !name || isUnused(name);

const namedBindingsUnused = !namedBindings ||

(namedBindings.kind === SyntaxKind.NamespaceImport ? isUnused(namedBindings.name) : namedBindings.elements.length !== 0 && namedBindings.elements.every(e => isUnused(e.name)));

if (defaultUnused && namedBindingsUnused) {

changes.delete(sourceFile, importDecl);

}

else {

if (name && defaultUnused) {

changes.delete(sourceFile, name);

}

if (namedBindings) {

if (namedBindingsUnused) {

changes.replaceNode(

sourceFile,

importDecl.importClause,

factory.updateImportClause(importDecl.importClause, importDecl.importClause.isTypeOnly, name, /*namedBindings*/ undefined)

);

}

else if (namedBindings.kind === SyntaxKind.NamedImports) {

for (const element of namedBindings.elements) {

if (isUnused(element.name)) changes.delete(sourceFile, element);

}

}

}

}

const { name } = varDecl;

switch (name.kind) {

case SyntaxKind.Identifier:

if (isUnused(name)) {

changes.delete(sourceFile, name);

}

break;

case SyntaxKind.ArrayBindingPattern:

break;

case SyntaxKind.ObjectBindingPattern:

if (name.elements.every(e => isIdentifier(e.name) && isUnused(e.name))) {

changes.delete(sourceFile,

isVariableDeclarationList(varDecl.parent) && varDecl.parent.declarations.length === 1 ? varDecl.parent.parent : varDecl);

}

else {

for (const element of name.elements) {

if (isIdentifier(element.name) && isUnused(element.name)) {

changes.delete(sourceFile, element.name);

}

}

}

break;

}

oldFile: SourceFile,

importsToCopy: ReadonlySymbolSet,

newFileImportsFromOldFile: ReadonlySymbolSet,

changes: textChanges.ChangeTracker,

checker: TypeChecker,

useEsModuleSyntax: boolean,

quotePreference: QuotePreference,

): readonly SupportedImportStatement[] {

const copiedOldImports: SupportedImportStatement[] = [];

for (const oldStatement of oldFile.statements) {

forEachImportInStatement(oldStatement, i => {

append(copiedOldImports, filterImport(i, moduleSpecifierFromImport(i), name => importsToCopy.has(checker.getSymbolAtLocation(name)!)));

});

}

// Also, import things used from the old file, and insert 'export' modifiers as necessary in the old file.

let oldFileDefault: Identifier | undefined;

const oldFileNamedImports: string[] = [];

const markSeenTop = nodeSeenTracker(); // Needed because multiple declarations may appear in `const x = 0, y = 1;`.

newFileImportsFromOldFile.forEach(symbol => {

if (!symbol.declarations) {

return;

}

for (const decl of symbol.declarations) {

if (!isTopLevelDeclaration(decl)) continue;

const name = nameOfTopLevelDeclaration(decl);

if (!name) continue;

const top = getTopLevelDeclarationStatement(decl);

if (markSeenTop(top)) {

addExportToChanges(oldFile, top, name, changes, useEsModuleSyntax);

}

if (hasSyntacticModifier(decl, ModifierFlags.Default)) {

oldFileDefault = name;

}

else {

oldFileNamedImports.push(name.text);

}

}

});

append(copiedOldImports, makeImportOrRequire(oldFileDefault, oldFileNamedImports, removeFileExtension(getBaseFileName(oldFile.fileName)), useEsModuleSyntax, quotePreference));

return copiedOldImports;

let newModuleName = moduleName;

for (let i = 1; ; i++) {

const name = combinePaths(inDirectory, newModuleName + extension);

if (!host.fileExists!(name)) return newModuleName; // TODO: GH#18217

newModuleName = `${moduleName}.${i}`;

}

// Symbols whose declarations are moved from the old file to the new file.

readonly movedSymbols: ReadonlySymbolSet;

// Symbols declared in the old file that must be imported by the new file. (May not already be exported.)

readonly newFileImportsFromOldFile: ReadonlySymbolSet;

// Subset of movedSymbols that are still used elsewhere in the old file and must be imported back.

readonly oldFileImportsFromNewFile: ReadonlySymbolSet;

readonly oldImportsNeededByNewFile: ReadonlySymbolSet;

// Subset of oldImportsNeededByNewFile that are will no longer be used in the old file.

readonly unusedImportsFromOldFile: ReadonlySymbolSet;

const movedSymbols = new SymbolSet();

const oldImportsNeededByNewFile = new SymbolSet();

const newFileImportsFromOldFile = new SymbolSet();

const containsJsx = find(toMove, statement => !!(statement.transformFlags & TransformFlags.ContainsJsx));

const jsxNamespaceSymbol = getJsxNamespaceSymbol(containsJsx);

if (jsxNamespaceSymbol) { // Might not exist (e.g. in non-compiling code)

oldImportsNeededByNewFile.add(jsxNamespaceSymbol);

}

for (const statement of toMove) {

forEachTopLevelDeclaration(statement, decl => {

movedSymbols.add(Debug.checkDefined(isExpressionStatement(decl) ? checker.getSymbolAtLocation(decl.expression.left) : decl.symbol, "Need a symbol here"));

});

}

for (const statement of toMove) {

forEachReference(statement, checker, symbol => {

if (!symbol.declarations) return;

for (const decl of symbol.declarations) {

if (isInImport(decl)) {

oldImportsNeededByNewFile.add(symbol);

}

else if (isTopLevelDeclaration(decl) && sourceFileOfTopLevelDeclaration(decl) === oldFile && !movedSymbols.has(symbol)) {

newFileImportsFromOldFile.add(symbol);

}

}

});

}

const unusedImportsFromOldFile = oldImportsNeededByNewFile.clone();

const oldFileImportsFromNewFile = new SymbolSet();

for (const statement of oldFile.statements) {

if (contains(toMove, statement)) continue;

// jsxNamespaceSymbol will only be set iff it is in oldImportsNeededByNewFile.

if (jsxNamespaceSymbol && !!(statement.transformFlags & TransformFlags.ContainsJsx)) {

unusedImportsFromOldFile.delete(jsxNamespaceSymbol);

}

forEachReference(statement, checker, symbol => {

if (movedSymbols.has(symbol)) oldFileImportsFromNewFile.add(symbol);

unusedImportsFromOldFile.delete(symbol);

});

}

return { movedSymbols, newFileImportsFromOldFile, oldFileImportsFromNewFile, oldImportsNeededByNewFile, unusedImportsFromOldFile };

function getJsxNamespaceSymbol(containsJsx: Node | undefined) {

if (containsJsx === undefined) {

return undefined;

}

const jsxNamespace = checker.getJsxNamespace(containsJsx);

// Strictly speaking, this could resolve to a symbol other than the JSX namespace.

// This will produce erroneous output (probably, an incorrectly copied import) but

// is expected to be very rare and easily reversible.

const jsxNamespaceSymbol = checker.resolveName(jsxNamespace, containsJsx, SymbolFlags.Namespace, /*excludeGlobals*/ true);

return !!jsxNamespaceSymbol && some(jsxNamespaceSymbol.declarations, isInImport)

? jsxNamespaceSymbol

: undefined;

}

switch (decl.kind) {

case SyntaxKind.ImportEqualsDeclaration:

case SyntaxKind.ImportSpecifier:

case SyntaxKind.ImportClause:

case SyntaxKind.NamespaceImport:

return true;

case SyntaxKind.VariableDeclaration:

return isVariableDeclarationInImport(decl as VariableDeclaration);

case SyntaxKind.BindingElement:

return isVariableDeclaration(decl.parent.parent) && isVariableDeclarationInImport(decl.parent.parent);

default:

return false;

}

switch (i.kind) {

case SyntaxKind.ImportDeclaration: {

const clause = i.importClause;

if (!clause) return undefined;

const defaultImport = clause.name && keep(clause.name) ? clause.name : undefined;

const namedBindings = clause.namedBindings && filterNamedBindings(clause.namedBindings, keep);

return defaultImport || namedBindings

? factory.createImportDeclaration(/*decorators*/ undefined, /*modifiers*/ undefined, factory.createImportClause(/*isTypeOnly*/ false, defaultImport, namedBindings), moduleSpecifier, /*assertClause*/ undefined)

: undefined;

}

case SyntaxKind.ImportEqualsDeclaration:

return keep(i.name) ? i : undefined;

case SyntaxKind.VariableDeclaration: {

const name = filterBindingName(i.name, keep);

return name ? makeVariableStatement(name, i.type, createRequireCall(moduleSpecifier), i.parent.flags) : undefined;

}

default:

return Debug.assertNever(i, `Unexpected import kind ${(i as SupportedImport).kind}`);

}

if (namedBindings.kind === SyntaxKind.NamespaceImport) {

return keep(namedBindings.name) ? namedBindings : undefined;

}

else {

const newElements = namedBindings.elements.filter(e => keep(e.name));

return newElements.length ? factory.createNamedImports(newElements) : undefined;

}

switch (name.kind) {

case SyntaxKind.Identifier:

return keep(name) ? name : undefined;

case SyntaxKind.ArrayBindingPattern:

return name;

case SyntaxKind.ObjectBindingPattern: {

// We can't handle nested destructurings or property names well here, so just copy them all.

const newElements = name.elements.filter(prop => prop.propertyName || !isIdentifier(prop.name) || keep(prop.name));

return newElements.length ? factory.createObjectBindingPattern(newElements) : undefined;

}

}

node.forEachChild(function cb(node) {

if (isIdentifier(node) && !isDeclarationName(node)) {

const sym = checker.getSymbolAtLocation(node);

if (sym) onReference(sym);

}

else {

node.forEachChild(cb);

}

});

has(symbol: Symbol): boolean;

forEach(cb: (symbol: Symbol) => void): void;

forEachEntry<T>(cb: (symbol: Symbol) => T | undefined): T | undefined;

private map = new Map<string, Symbol>();

add(symbol: Symbol): void {

this.map.set(String(getSymbolId(symbol)), symbol);

}

has(symbol: Symbol): boolean {

return this.map.has(String(getSymbolId(symbol)));

}

delete(symbol: Symbol): void {

this.map.delete(String(getSymbolId(symbol)));

}

forEach(cb: (symbol: Symbol) => void): void {