copy prologue directives to new file (#40306)

Author: a-tarasyuk

src/compiler/core.ts

@@ -2272,4 +2272,14 @@ namespace ts {
     export function padRight(s: string, length: number, padString: " " = " ") {
         return length <= s.length ? s : s + padString.repeat(length - s.length);
     }
+
+    export function takeWhile<T, U extends T>(array: readonly T[], predicate: (element: T) => element is U): U[];
+    export function takeWhile<T>(array: readonly T[], predicate: (element: T) => boolean): T[] {
+        const len = array.length;
+        let index = 0;
+        while (index < len && predicate(array[index])) {
+            index++;
+        }
+        return array.slice(0, index);
+    }
 }

src/services/refactors/moveToNewFile.ts

@@ -65,20 +65,26 @@ namespace ts.refactor {
         readonly ranges: readonly StatementRange[];
     }
 
-    // Filters imports 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.
     function getStatementsToMove(context: RefactorContext): ToMove | undefined {
         const rangeToMove = getRangeToMove(context);
         if (rangeToMove === undefined) return undefined;
         const all: Statement[] = [];
         const ranges: StatementRange[] = [];
         const { toMove, afterLast } = rangeToMove;
-        getRangesWhere(toMove, s => !isPureImport(s), (start, afterEndIndex) => {
+        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 };
     }
 
+    function isAllowedStatementToMove(statement: Statement): boolean {
+        // 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);;
+    }
+
     function isPureImport(node: Node): boolean {
         switch (node.kind) {
             case SyntaxKind.ImportDeclaration:
@@ -111,10 +117,10 @@ namespace ts.refactor {
         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 toMove.all;
+            return [...prologueDirectives, ...toMove.all];
         }
 
         const useEs6ModuleSyntax = !!oldFile.externalModuleIndicator;
@@ -126,20 +132,21 @@ namespace ts.refactor {
 
         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, useEs6ModuleSyntax, quotePreference);
         const body = addExports(oldFile, toMove.all, usage.oldFileImportsFromNewFile, useEs6ModuleSyntax);
         if (imports.length && body.length) {
             return [
+                ...prologueDirectives,
                 ...imports,
                 SyntaxKind.NewLineTrivia as const,
                 ...body
             ];
         }
 
         return [
+            ...prologueDirectives,
             ...imports,
             ...body,
         ];

tests/cases/fourslash/moveToNewFile_prologueDirectives1.ts

@@ -0,0 +1,23 @@
+/// <reference path='fourslash.ts' />
+
+// @Filename: /a.ts
+////"use strict";
+////[|function b() {
+////    return this;
+////}|]
+////b();
+
+verify.moveToNewFile({
+    newFileContents: {
+        "/a.ts":
+`"use strict";
+b();`,
+
+        "/b.ts":
+`"use strict";
+function b() {
+    return this;
+}
+`,
+    },
+});

tests/cases/fourslash/moveToNewFile_prologueDirectives2.ts

@@ -0,0 +1,33 @@
+/// <reference path='fourslash.ts' />
+
+// @module: commonjs
+// @allowJs: true
+
+// @Filename: /foo.js
+////exports.foo = function () {};
+
+// @Filename: /a.js
+////"use strict";
+////const foo = require("./foo");
+////[|function b() {
+////    return this;
+////}|]
+////b();
+
+verify.moveToNewFile({
+    newFileContents: {
+        "/a.js":
+`"use strict";
+const { b } = require("./b");
+const foo = require("./foo");
+b();`,
+
+        "/b.js":
+`"use strict";
+function b() {
+    return this;
+}
+exports.b = b;
+`,
+    },
+});

tests/cases/fourslash/moveToNewFile_prologueDirectives3.ts

@@ -0,0 +1,6 @@
+/// <reference path='fourslash.ts' />
+
+// @Filename: /a.ts
+////[|"use strict";|]
+
+verify.noMoveToNewFile();

tests/cases/fourslash/moveToNewFile_prologueDirectives4.ts

@@ -0,0 +1,8 @@
+/// <reference path='fourslash.ts' />
+
+// @Filename: /a.ts
+////function foo() {
+////    [|"use strict";|]
+////}
+
+verify.noMoveToNewFile();

tests/cases/fourslash/moveToNewFile_prologueDirectives5.ts

@@ -0,0 +1,32 @@
+/// <reference path='fourslash.ts' />
+
+// @module: esnext
+
+// @Filename: /foo.ts
+////export default function () {}
+
+// @Filename: /a.ts
+////"use strict";
+////import foo from "./foo";
+////[|function b() {
+////    return foo;
+////}|]
+////b();
+
+verify.moveToNewFile({
+    newFileContents: {
+        "/a.ts":
+`"use strict";
+import { b } from "./b";
+b();`,
+
+        "/b.ts":
+`"use strict";
+import foo from "./foo";
+
+export function b() {
+    return foo;
+}
+`,
+    },
+});

tests/cases/fourslash/moveToNewFile_prologueDirectives6.ts

@@ -0,0 +1,38 @@
+/// <reference path='fourslash.ts' />
+
+// @module: esnext
+
+// @Filename: /foo.ts
+////export default function () {}
+
+// @Filename: /a.ts
+////"use strict";
+////"use foo";
+////"use bar";
+////import foo from "./foo";
+////[|function b() {
+////    return foo;
+////}|]
+////b();
+
+verify.moveToNewFile({
+    newFileContents: {
+        "/a.ts":
+`"use strict";
+"use foo";
+"use bar";
+import { b } from "./b";
+b();`,
+
+        "/b.ts":
+`"use strict";
+"use foo";
+"use bar";
+import foo from "./foo";
+
+export function b() {
+    return foo;
+}
+`,
+    },
+});

tests/cases/fourslash/moveToNewFile_prologueDirectives7.ts

@@ -0,0 +1,25 @@
+/// <reference path='fourslash.ts' />
+
+// @Filename: /a.ts
+////"use strict";
+////[|function b() {
+////    return this;
+////}|]
+////"prologue directive like statement";
+////b();
+
+verify.moveToNewFile({
+    newFileContents: {
+        "/a.ts":
+`"use strict";
+"prologue directive like statement";
+b();`,
+
+        "/b.ts":
+`"use strict";
+function b() {
+    return this;
+}
+`,
+    },
+});