Making Move To File Action appear less often

src/compiler/types.ts

@@ -3305,6 +3305,10 @@ export type BlockLike =
     | ModuleBlock
     | CaseOrDefaultClause;
 
+export type RootNode =
+    | SourceFile
+    | Bundle;
+
 export interface Block extends Statement, LocalsContainer {
     readonly kind: SyntaxKind.Block;
     readonly statements: NodeArray<Statement>;

src/harness/fourslashImpl.ts

@@ -3979,8 +3979,8 @@ export class TestState {
         };
     }
 
-    public verifyRefactorAvailable(negative: boolean, triggerReason: ts.RefactorTriggerReason, name: string, actionName?: string, actionDescription?: string) {
-        let refactors = this.getApplicableRefactorsAtSelection(triggerReason);
+    public verifyRefactorAvailable(negative: boolean, triggerReason: ts.RefactorTriggerReason, name: string, actionName?: string, actionDescription?: string, kind?: string, preferences = ts.emptyOptions, includeInteractiveActions?: boolean) {
+        let refactors = this.getApplicableRefactorsAtSelection(triggerReason, kind, preferences, includeInteractiveActions);
         refactors = refactors.filter(r => r.name === name);
 
         if (actionName !== undefined) {
@@ -4445,8 +4445,8 @@ export class TestState {
         test(renameKeys(newFileContents, key => pathUpdater(key) || key), "with file moved");
     }
 
-    private getApplicableRefactorsAtSelection(triggerReason: ts.RefactorTriggerReason = "implicit", kind?: string, preferences = ts.emptyOptions) {
-        return this.getApplicableRefactorsWorker(this.getSelection(), this.activeFile.fileName, preferences, triggerReason, kind);
+    private getApplicableRefactorsAtSelection(triggerReason: ts.RefactorTriggerReason = "implicit", kind?: string, preferences = ts.emptyOptions, includeInteractiveActions?: boolean) {
+        return this.getApplicableRefactorsWorker(this.getSelection(), this.activeFile.fileName, preferences, triggerReason, kind, includeInteractiveActions);
     }
     private getApplicableRefactors(rangeOrMarker: Range | Marker, preferences = ts.emptyOptions, triggerReason: ts.RefactorTriggerReason = "implicit", kind?: string, includeInteractiveActions?: boolean): readonly ts.ApplicableRefactorInfo[] {
         return this.getApplicableRefactorsWorker("position" in rangeOrMarker ? rangeOrMarker.position : rangeOrMarker, rangeOrMarker.fileName, preferences, triggerReason, kind, includeInteractiveActions); // eslint-disable-line local/no-in-operator

src/harness/fourslashInterfaceImpl.ts

@@ -212,12 +212,12 @@ export class VerifyNegatable {
         this.state.verifyRefactorsAvailable(names);
     }
 
-    public refactorAvailable(name: string, actionName?: string, actionDescription?: string) {
-        this.state.verifyRefactorAvailable(this.negative, "implicit", name, actionName, actionDescription);
+    public refactorAvailable(name: string, actionName?: string, actionDescription?: string, kind?: string, preferences = ts.emptyOptions, includeInteractiveActions?: boolean) {
+        this.state.verifyRefactorAvailable(this.negative, "implicit", name, actionName, actionDescription, kind, preferences, includeInteractiveActions);
     }
 
-    public refactorAvailableForTriggerReason(triggerReason: ts.RefactorTriggerReason, name: string, actionName?: string) {
-        this.state.verifyRefactorAvailable(this.negative, triggerReason, name, actionName);
+    public refactorAvailableForTriggerReason(triggerReason: ts.RefactorTriggerReason, name: string, actionName?: string, actionDescription?: string, kind?: string, preferences = ts.emptyOptions, includeInteractiveActions?: boolean) {
+        this.state.verifyRefactorAvailable(this.negative, triggerReason, name, actionName, actionDescription, kind, preferences, includeInteractiveActions);
     }
 
     public refactorKindAvailable(kind: string, expected: string[], preferences = ts.emptyOptions) {

src/services/refactors/extractSymbol.ts

@@ -6,7 +6,6 @@ import {
     assertType,
     BindingElement,
     Block,
-    BlockLike,
     BreakStatement,
     CancellationToken,
     canHaveModifiers,
@@ -67,6 +66,7 @@ import {
     isAssignmentExpression,
     isBinaryExpression,
     isBlock,
+    isBlockLike,
     isBlockScope,
     isCaseClause,
     isClassLike,
@@ -2221,18 +2221,6 @@ function isExtractableExpression(node: Node): boolean {
     return true;
 }
 
-function isBlockLike(node: Node): node is BlockLike {
-    switch (node.kind) {
-        case SyntaxKind.Block:
-        case SyntaxKind.SourceFile:
-        case SyntaxKind.ModuleBlock:
-        case SyntaxKind.CaseClause:
-            return true;
-        default:
-            return false;
-    }
-}
-
 function isInJSXContent(node: Node) {
     return isStringLiteralJsxAttribute(node) ||
         (isJsxElement(node) || isJsxSelfClosingElement(node) || isJsxFragment(node)) && (isJsxElement(node.parent) || isJsxFragment(node.parent));

src/services/refactors/moveToFile.ts

@@ -11,6 +11,7 @@ import {
     BinaryExpression,
     BindingElement,
     BindingName,
+    BlockLike,
     CallExpression,
     canHaveDecorators,
     canHaveModifiers,
@@ -60,6 +61,7 @@ import {
     getRelativePathFromFile,
     getSourceFileOfNode,
     getSynthesizedDeepClone,
+    getTokenAtPosition,
     getUniqueName,
     hasJSFileExtension,
     hasSyntacticModifier,
@@ -75,6 +77,7 @@ import {
     isArrayLiteralExpression,
     isBinaryExpression,
     isBindingElement,
+    isBlockLike,
     isDeclarationName,
     isExportDeclaration,
     isExportSpecifier,
@@ -93,6 +96,7 @@ import {
     isPropertyAccessExpression,
     isPropertyAssignment,
     isRequireCall,
+    isRootNode,
     isSourceFile,
     isStatement,
     isStringLiteral,
@@ -126,6 +130,7 @@ import {
     RequireOrImportCall,
     RequireVariableStatement,
     resolvePath,
+    RootNode,
     ScriptTarget,
     skipAlias,
     some,
@@ -167,6 +172,17 @@ registerRefactor(refactorNameForMoveToFile, {
         if (!interactiveRefactorArguments) {
             return emptyArray;
         }
+        const endPosition = context.endPosition;
+        if (endPosition !== undefined) {
+            const file = context.file;
+            const startNode = getTokenAtPosition(file, context.startPosition);
+            const endNode = getTokenAtPosition(file, endPosition);
+            const startNodeAncestor = getBlockLikeAncestorOrRootNode(startNode);
+            const endNodeAncestor = getBlockLikeAncestorOrRootNode(endNode);
+            if (!isRootNode(startNodeAncestor) && !isRootNode(endNodeAncestor)) {
+                return emptyArray;
+            }
+        }
         if (context.preferences.allowTextChangesInNewFiles && statements) {
             return [{ name: refactorNameForMoveToFile, description, actions: [moveToFileAction] }];
         }
@@ -274,6 +290,17 @@ function getNewStatementsAndRemoveFromOldFile(
     ];
 }
 
+function getBlockLikeAncestorOrRootNode(node: Node): BlockLike | RootNode {
+    let currentNode = node;
+    while (!isRootNode(currentNode)) {
+        if (isBlockLike(currentNode)) {
+            break;
+        }
+        currentNode = currentNode.parent;
+    }
+    return currentNode;
+}
+
 function getTargetFileImportsAndAddExportInOldFile(
     oldFile: SourceFile,
     targetFile: string,

src/services/utilities.ts

@@ -9,6 +9,7 @@ import {
     BinaryExpression,
     binarySearchKey,
     BindingElement,
+    BlockLike,
     BreakOrContinueStatement,
     CallExpression,
     canHaveModifiers,
@@ -310,6 +311,7 @@ import {
     pseudoBigIntToString,
     QualifiedName,
     RefactorContext,
+    RootNode,
     Scanner,
     ScriptElementKind,
     ScriptElementKindModifier,
@@ -4274,3 +4276,27 @@ export function fileShouldUseJavaScriptRequire(file: SourceFile | string, progra
     }
     return preferRequire;
 }
+
+/** @internal */
+export function isBlockLike(node: Node): node is BlockLike {
+    switch (node.kind) {
+        case SyntaxKind.Block:
+        case SyntaxKind.SourceFile:
+        case SyntaxKind.ModuleBlock:
+        case SyntaxKind.CaseClause:
+            return true;
+        default:
+            return false;
+    }
+}
+
+/** @internal */
+export function isRootNode(node: Node): node is RootNode {
+    switch (node.kind) {
+        case SyntaxKind.SourceFile:
+        case SyntaxKind.Bundle:
+            return true;
+        default:
+            return false;
+    }
+}

tests/baselines/reference/api/typescript.d.ts

@@ -5789,6 +5789,7 @@ declare namespace ts {
         readonly name?: Identifier;
     }
     type BlockLike = SourceFile | Block | ModuleBlock | CaseOrDefaultClause;
+    type RootNode = SourceFile | Bundle;
     interface Block extends Statement, LocalsContainer {
         readonly kind: SyntaxKind.Block;
         readonly statements: NodeArray<Statement>;

tests/cases/fourslash/fourslash.ts

@@ -281,8 +281,8 @@ declare namespace FourSlashInterface {
         codeFixDiagnosticsAvailableAtMarkers(markerNames: string[], diagnosticCode?: number): void;
         applicableRefactorAvailableForRange(): void;
 
-        refactorAvailable(name: string, actionName?: string, actionDescription?: string): void;
-        refactorAvailableForTriggerReason(triggerReason: RefactorTriggerReason, name: string, action?: string): void;
+        refactorAvailable(name: string, actionName?: string, actionDescription?: string, kind?: string, preferences?: {}, includeInteractiveActions?: boolean): void;
+        refactorAvailableForTriggerReason(triggerReason: RefactorTriggerReason, name: string, action?: string, actionDescription?: string, kind?: string, preferences?: {}, includeInteractiveActions?: boolean): void;
         refactorKindAvailable(refactorKind: string, expected: string[], preferences?: {}): void;
     }
     class verify extends verifyNegatable {

tests/cases/fourslash/refactorMoveToFile1.ts

@@ -0,0 +1,18 @@
+/// <reference path='fourslash.ts' />
+
+////namespace ns {
+////    /*a*/export function fn() {
+////    }
+////    fn();
+////    /*b*/
+////}
+
+goTo.select("a", "b");
+verify.not.refactorAvailable("Move to file",
+undefined,
+undefined,
+undefined,
+{
+    allowTextChangesInNewFiles : true
+},
+true);

tests/cases/fourslash/refactorMoveToFile2.ts

@@ -0,0 +1,20 @@
+/// <reference path='fourslash.ts' />
+
+/////*a*/
+////namespace ns {
+////    export function fn() {
+////    }
+////    fn();
+////}
+/////*b*/
+
+goTo.select("a", "b");
+verify.refactorAvailable("Move to file",
+undefined,
+undefined,
+undefined,
+{
+    allowTextChangesInNewFiles : true
+},
+true);
+