More robust module renames

rascal-lsp/src/main/rascal/lsp/lang/rascal/lsp/refactor/rename/Modules.rsc

@@ -184,31 +184,55 @@ list[TextEdit] getChanges(loc f, PathConfig wsProject, lrel[str oldName, str new
     return [];
 }
 
-set[tuple[str, str, PathConfig]] getQualifiedNameChanges(loc old, loc new, PathConfig(loc) getPathConfig) {
+set[tuple[str, str, PathConfig]] getQualifiedNameChanges(loc old, loc new, PathConfig(loc) getPathConfig, void(Message) msg) {
     PathConfig oldPcfg = getPathConfig(old);
     PathConfig newPcfg = getPathConfig(new);
-    if (isFile(new) && endsWith(new.file, ".rsc")) {
-        return {<safeRelativeModuleName(old, oldPcfg), safeRelativeModuleName(new, newPcfg), newPcfg>};
+    // Moved a single file
+    if (isFile(new)) {
+        if(new.extension == "rsc") {
+            // Moved a single Rascal module
+            try {
+                return {<safeRelativeModuleName(old, oldPcfg), safeRelativeModuleName(new, newPcfg), newPcfg>};
+            } catch PathNotFound(loc f): {
+                msg(error("Cannot rename references to this file, since it was moved outside of the project\'s source directories.", f));
+                return {};
+            }
+        } else {
+            // Renamed from .rsc to a non-Rascal extension
+            str reason = new.extension == ""
+                ? "its extension was removed"
+                : "it was renamed to the non-Rascal extension \'<new.extension>\'"
+                ;
+
+            msg(error("Cannot rename references to thie file, since <reason>.", new));
+            return {};
+        }
+    }
+
+    // Moved directories
+    set[tuple[str, str, PathConfig]] moves = {};
+    for (loc newFile <- find(new, "rsc")
+       , loc relFilePath := relativize(new, newFile)
+       , loc oldFile := old + relFilePath.path) {
+        try {
+            moves += <safeRelativeModuleName(oldFile, oldPcfg), safeRelativeModuleName(newFile, newPcfg), newPcfg>;
+        } catch PathNotFound(loc f): {
+            msg(error("Cannot rename references to this file, since it was moved outside of the project\'s source directories.", f));
+        }
     }
 
-    return {
-        <safeRelativeModuleName(oldFile, oldPcfg), safeRelativeModuleName(newFile, newPcfg), newPcfg>
-        | loc newFile <- find(new, "rsc")
-        , loc relFilePath := relativize(new, newFile)
-        , loc oldFile := old + relFilePath.path
-    };
+    return moves;
 }
 
 tuple[list[DocumentEdit], set[Message]] propagateModuleRenames(lrel[loc old, loc new] renames, set[loc] workspaceFolders, PathConfig(loc) getPathConfig) {
+    set[Message] messages = {};
+    void registerMessage(Message msg) { messages += msg; }
     lrel[str oldName, str newName, PathConfig pcfg] qualifiedNameChanges = [
         rename
         | <oldLoc, newLoc> <- renames
-        , tuple[str, str, PathConfig] rename <- getQualifiedNameChanges(oldLoc, newLoc, getPathConfig)
+        , tuple[str, str, PathConfig] rename <- getQualifiedNameChanges(oldLoc, newLoc, getPathConfig, registerMessage)
     ];
 
-    set[Message] messages = {};
-    void registerMessage(Message msg) { messages += msg; }
-
     list[PathConfig] projectWithRenamedModule = qualifiedNameChanges.pcfg;
     set[DocumentEdit] edits = flatMap(workspaceFolders, set[DocumentEdit](loc wsFolder) {
         PathConfig wsFolderPcfg = getPathConfig(wsFolder);

rascal-lsp/src/main/rascal/lsp/lang/rascal/tests/rename/Modules.rsc

@@ -27,7 +27,13 @@ POSSIBILITY OF SUCH DAMAGE.
 @bootstrapParser
 module lang::rascal::tests::rename::Modules
 
+import IO;
+import List;
+import Set;
+
+import lang::rascal::lsp::refactor::Rename;
 import lang::rascal::tests::rename::TestUtils;
+import lang::rascalcore::check::Checker;
 
 test bool deepModule() = testRenameOccurrences({
     byText("some::path::to::Foo", "
@@ -157,3 +163,53 @@ test bool moduleExists() = testRenameOccurrences({
     byText("Foo", "", {0}),
     byText("foo::Foo", "", {})
 }, oldName = "Foo", newName = "foo::Foo");
+
+test bool moduleRenameProducesEdits()
+    = testProject({byText("Foo", "", {})},
+        "moduleRenameProducesEdits",
+        bool({TestModule foo}, loc testDir, PathConfig pcfg) {
+            loc oldLoc = foo.file;
+            loc newLoc = |<oldLoc.scheme>:///<oldLoc.parent.path>/nested/<oldLoc.file>|;
+
+            // VS Code moves first, and informs us afterwards
+            move(foo.file, newLoc);
+
+            <edits, msgs> = rascalRenameModule([<foo.file, newLoc>], toSet(pcfg.srcs), PathConfig(loc _) { return pcfg; });
+            throwMessagesIfError(msgs);
+            return [changed(newLoc, [replace(_, "nested::Foo")])] := edits;
+        }
+    );
+
+@expected{illegalRename}
+test bool moduleRenameWithoutExtension()
+    = testProject({byText("Foo", "", {})},
+        "moduleRenameWithoutExtension",
+        bool({TestModule foo}, loc testDir, PathConfig pcfg) {
+            loc oldLoc = foo.file;
+            loc newLoc = |<oldLoc.scheme>:///<oldLoc.path[..-4]>|; // remove .rsc extension
+
+            // VS Code moves first, and informs us afterwards
+            move(foo.file, newLoc);
+
+            <edits, msgs> = rascalRenameModule([<foo.file, newLoc>], toSet(pcfg.srcs), PathConfig(loc _) { return pcfg; });
+            throwMessagesIfError(msgs);
+            return [] := edits;
+        }
+    );
+
+@expected{illegalRename}
+test bool moduleRenameOutsideSources()
+    = testProject({byText("Foo", "", {})},
+        "moduleRenameOutsideSources",
+        bool({TestModule foo}, loc testDir, PathConfig pcfg) {
+            loc oldLoc = foo.file;
+            loc newLoc = |<oldLoc.scheme>:///<oldLoc.parent.parent.path>/<oldLoc.file>|;
+
+            // VS Code moves first, and informs us afterwards
+            move(foo.file, newLoc);
+
+            <edits, msgs> = rascalRenameModule([<foo.file, newLoc>], toSet(pcfg.srcs), PathConfig(loc _) { return pcfg; });
+            throwMessagesIfError(msgs);
+            return false;
+        }
+    );

rascal-lsp/src/main/rascal/lsp/lang/rascal/tests/rename/TestUtils.rsc

@@ -83,7 +83,7 @@ private void verifyTypeCorrectRenaming(loc root, list[DocumentEdit] edits, PathC
     list[ModuleMessages] checkBefore = checkAll(root, ccfg);
 
     // Back-up sources
-    loc backupLoc = |memory://tests/backup|;
+    loc backupLoc = |memory:///tests/backup|;
     remove(backupLoc, recursive = true);
     copy(root, backupLoc, recursive = true);
 
@@ -118,76 +118,82 @@ bool expectEq(&T expected, &T actual, str epilogue = "") {
     return true;
 }
 
-bool testRenameOccurrences(set[TestModule] modules, str oldName = "foo", str newName = "bar") {
-    bool success = true;
-
+bool testProject(set[TestModule] modules, str testName, bool(set[TestModule] mods, loc testDir, PathConfig pcfg) doCheck) {
+    loc testDir = |unknown:///|;
     bool moduleExistsOnDisk = any(mmm <- modules, mmm is byLoc);
-    for (mm <- modules, cursorOcc <- (mm.nameOccs - mm.skipCursors)) {
-        loc testDir = |unknown:///|;
-        if (moduleExistsOnDisk){
-            testDir = cover([m.file.parent | m <- modules, m is byLoc]).parent;
-        } else {
-            // If none of the modules refers to an existing file, clear the test directory before writing files.
-            str testName = "Test_<mm.name>_<cursorOcc>";
-            testDir = |memory://tests/rename/<testName>|;
-            remove(testDir);
-        }
+    if (moduleExistsOnDisk){
+        testDir = cover([m.file.parent | m <- modules, m is byLoc]).parent;
+    } else {
+        // If none of the modules refers to an existing file, clear the test directory before writing files.
+        testDir = |memory:///tests/rename/<testName>|;
+        remove(testDir);
+    }
 
-        pcfg = getTestPathConfig(testDir);
-        modulesByLocation = {mByLoc | m <- modules, mByLoc := (m is byLoc ? m : byLoc(m.name, storeTestModule(testDir, m.name, m.body), m.nameOccs, newName = m.newName, skipCursors = m.skipCursors))};
+    pcfg = getTestPathConfig(testDir);
+    modulesByLocation = {mByLoc | m <- modules, mByLoc := (m is byLoc ? m : byLoc(m.name, storeTestModule(testDir, m.name, m.body), m.nameOccs, newName = m.newName, skipCursors = m.skipCursors))};
 
-        for (m <- modulesByLocation) {
-            try {
-                parse(#start[Module], m.file);
-            } catch ParseError(l): {
-                throw "Parse error in test module <m.file>: <l>";
-            }
+    for (m <- modulesByLocation) {
+        try {
+            parse(#start[Module], m.file);
+        } catch ParseError(l): {
+            throw "Parse error in test module <m.file>: <l>";
         }
+    }
 
-        <cursor, focus> = findCursor([m.file | m <- modulesByLocation, m.name == mm.name][0], oldName, cursorOcc);
+    // Do the actual work here
+    bool result = doCheck(modulesByLocation, testDir, pcfg);
 
-        println("Renaming \'<oldName>\' from <focus[0].src>");
-        <edits, msgs> = rascalRenameSymbol(cursor, focus, newName, toSet(pcfg.srcs), PathConfig(loc _) { return pcfg; });
+    if (!moduleExistsOnDisk) {
+        remove(testDir);
+    }
 
-        throwMessagesIfError(msgs);
+    return result;
+}
 
-        renamesPerModule = (
-            beforeRename: afterRename
-            | renamed(oldLoc, newLoc) <- edits
-            , beforeRename := safeRelativeModuleName(oldLoc, pcfg)
-            , afterRename := safeRelativeModuleName(newLoc, pcfg)
-        );
+bool testRenameOccurrences(set[TestModule] modules, str oldName = "foo", str newName = "bar") {
+    bool success = true;
+    for (mm <- modules, cursorOcc <- (mm.nameOccs - mm.skipCursors)) {
+        success = success && testProject(modules, "Test_<mm.name>_<cursorOcc>", bool(set[TestModule] modulesByLocation, loc testDir, PathConfig pcfg) {
+            <cursor, focus> = findCursor([m.file | m <- modulesByLocation, m.name == mm.name][0], oldName, cursorOcc);
+
+            println("Renaming \'<oldName>\' from <focus[0].src>");
+            <edits, msgs> = rascalRenameSymbol(cursor, focus, newName, toSet(pcfg.srcs), PathConfig(loc _) { return pcfg; });
+
+            throwMessagesIfError(msgs);
+
+            renamesPerModule = (
+                beforeRename: afterRename
+                | renamed(oldLoc, newLoc) <- edits
+                , beforeRename := safeRelativeModuleName(oldLoc, pcfg)
+                , afterRename := safeRelativeModuleName(newLoc, pcfg)
+            );
+
+            replacesPerModule = toMap({
+                <name, occ>
+                | changed(file, changes) <- edits
+                , name := safeRelativeModuleName(file, pcfg)
+                , locs := {c.range | c <- changes}
+                , occ <- locsToOccs(parseModuleWithSpaces(file), oldName, locs)
+            });
+
+            editsPerModule = (
+                name : <occs, nameAfterRename>
+                | srcDir <- pcfg.srcs
+                , file <- find(srcDir, "rsc")
+                , name := safeRelativeModuleName(file, pcfg)
+                , occs := replacesPerModule[name] ? {}
+                , nameAfterRename := renamesPerModule[name] ? name
+            );
+
+            expectedEditsPerModule = (name: <m.nameOccs, m.newName> | m <- modulesByLocation, name := safeRelativeModuleName(m.file, pcfg));
+
+            if (expectEq(expectedEditsPerModule, editsPerModule, epilogue = "Rename from cursor <focus[0].src> failed:")) {
+                verifyTypeCorrectRenaming(testDir, edits, pcfg);
+                return true;
+            }
 
-        replacesPerModule = toMap({
-            <name, occ>
-            | changed(file, changes) <- edits
-            , name := safeRelativeModuleName(file, pcfg)
-            , locs := {c.range | c <- changes}
-            , occ <- locsToOccs(parseModuleWithSpaces(file), oldName, locs)
+            return false;
         });
-
-        editsPerModule = (
-            name : <occs, nameAfterRename>
-            | srcDir <- pcfg.srcs
-            , file <- find(srcDir, "rsc")
-            , name := safeRelativeModuleName(file, pcfg)
-            , occs := replacesPerModule[name] ? {}
-            , nameAfterRename := renamesPerModule[name] ? name
-        );
-
-        expectedEditsPerModule = (name: <m.nameOccs, m.newName> | m <- modulesByLocation, name := safeRelativeModuleName(m.file, pcfg));
-
-        if (!expectEq(expectedEditsPerModule, editsPerModule, epilogue = "Rename from cursor <focus[0].src> failed:")) {
-            success = false;
-        }
-
-        if (success) {
-            verifyTypeCorrectRenaming(testDir, edits, pcfg);
-        }
-
-        if (!moduleExistsOnDisk) {
-            remove(testDir);
-        }
     }
 
     return success;
@@ -308,7 +314,7 @@ private tuple[Edits, set[int]] getEditsAndModule(str stmtsStr, int cursorAtOldNa
     '}";
 
     // Write the file to disk (and clean up later) to easily emulate typical editor behaviour
-    loc testDir = |memory://tests/rename/<moduleName>|;
+    loc testDir = |memory:///tests/rename/<moduleName>|;
     remove(testDir);
     loc moduleFileName = testDir + "rascal" + "<moduleName>.rsc";
     writeFile(moduleFileName, moduleStr);