diff --git a/rascal-lsp/src/main/java/org/rascalmpl/vscode/lsp/rascal/RascalLanguageServices.java b/rascal-lsp/src/main/java/org/rascalmpl/vscode/lsp/rascal/RascalLanguageServices.java
index 5e5271277..d46144ef6 100644
--- a/rascal-lsp/src/main/java/org/rascalmpl/vscode/lsp/rascal/RascalLanguageServices.java
+++ b/rascal-lsp/src/main/java/org/rascalmpl/vscode/lsp/rascal/RascalLanguageServices.java
@@ -213,7 +213,7 @@ public InterruptibleFuture<ITuple> getRename(ITree module, Position cursor, Set<
         return runEvaluator("Rascal rename", semanticEvaluator, eval -> {
             try {
                 IFunction rascalGetPathConfig = eval.getFunctionValueFactory().function(getPathConfigType, (t, u) -> addResources(getPathConfig.apply((ISourceLocation) t[0])));
-                return (ITuple) eval.call("rascalRenameSymbol", cursorTree, VF.set(workspaceFolders.toArray(ISourceLocation[]::new)), VF.string(newName), rascalGetPathConfig);
+                return (ITuple) eval.call("rascalRenameSymbol", cursorTree, VF.string(newName), VF.set(workspaceFolders.toArray(ISourceLocation[]::new)), rascalGetPathConfig);
             } catch (Throw e) {
                 if (e.getException() instanceof IConstructor) {
                     var exception = (IConstructor)e.getException();
diff --git a/rascal-lsp/src/main/rascal/lang/rascal/lsp/refactor/Rename.rsc b/rascal-lsp/src/main/rascal/lang/rascal/lsp/refactor/Rename.rsc
index b7e11922b..eb53446d6 100644
--- a/rascal-lsp/src/main/rascal/lang/rascal/lsp/refactor/Rename.rsc
+++ b/rascal-lsp/src/main/rascal/lang/rascal/lsp/refactor/Rename.rsc
@@ -50,21 +50,17 @@ import lang::rascal::\syntax::Rascal;
 
 import lang::rascalcore::check::Checker;
 
-extend lang::rascal::lsp::refactor::Exception;
-import lang::rascal::lsp::refactor::Util;
-import lang::rascal::lsp::refactor::WorkspaceInfo;
+extend util::refactor::Exception;
+extend util::refactor::Rename;
+import util::refactor::TextEdits;
+import util::Util;
 
-import lang::rascal::lsp::refactor::TextEdits;
+import lang::rascal::lsp::refactor::WorkspaceInfo;
 
 import util::FileSystem;
 import util::Maybe;
-import util::Monitor;
 import util::Reflective;
 
-alias Edits = tuple[list[DocumentEdit], map[ChangeAnnotationId, ChangeAnnotation]];
-
-private str MANDATORY_CHANGE_DESCRIPTION = "These changes are required for a correct renaming. They can be previewed here, but it is not advised to disable them.";
-
 // Rascal compiler-specific extension
 void throwAnyErrors(list[ModuleMessages] mmsgs) {
     for (mmsg <- mmsgs) {
@@ -77,9 +73,9 @@ void throwAnyErrors(program(_, msgs)) {
     throwAnyErrors(msgs);
 }
 
-private set[IllegalRenameReason] rascalCheckLegalName(str name, set[IdRole] roles) {
+private set[IllegalRenameReason] rascalCheckLegalNameByRoles(str name, set[IdRole] roles) {
     escName = rascalEscapeName(name);
-    tuple[type[&T <: Tree] as, str desc] asType = <#Name, "identifier">;
+    tuple[type[Tree] as, str desc] asType = <#Name, "identifier">;
     if ({moduleId(), *_} := roles) asType = <#QualifiedName, "module name">;
     if ({constructorId(), *_} := roles) asType = <#NonterminalLabel, "constructor name">;
     if ({fieldId(), *_} := roles) asType = <#NonterminalLabel, "constructor field name">;
@@ -89,12 +85,13 @@ private set[IllegalRenameReason] rascalCheckLegalName(str name, set[IdRole] role
     return {};
 }
 
-private void rascalCheckLegalName(str name, Symbol sym) {
+set[IllegalRenameReason] rascalCheckLegalNameByType(str name, Symbol sym) {
     escName = rascalEscapeName(name);
     g = grammar(#start[Module]);
-    if (tryParseAs(type(sym, g.rules), escName) is nothing) {
-        throw illegalRename("\'<escName>\' is not a valid name at this position", {invalidName(escName, "<sym>")});
+    if (type[Tree] t := type(sym, g.rules), tryParseAs(t, escName) is nothing) {
+        return {invalidName(escName, "<sym>")};
     }
+    return {};
 }
 
 private set[IllegalRenameReason] rascalCheckDefinitionsOutsideWorkspace(TModel ws, set[loc] defs) =
@@ -174,17 +171,18 @@ private set[IllegalRenameReason] rascalCollectIllegalRenames(TModel ws, start[Mo
     set[Define] newNameDefs = {def | Define def:<_, newName, _, _, _, _> <- ws.defines};
 
     return
-        rascalCheckLegalName(newName, definitionsRel(ws)[currentDefs].idRole)
+        rascalCheckLegalNameByRoles(newName, definitionsRel(ws)[currentDefs].idRole)
       + rascalCheckDefinitionsOutsideWorkspace(ws, currentDefs)
       + rascalCheckCausesDoubleDeclarations(ws, currentDefs, newNameDefs, newName)
       + rascalCheckCausesCaptures(ws, m, currentDefs, currentUses, newNameDefs)
     ;
 }
 
-private str rascalEscapeName(str name) = name in getRascalReservedIdentifiers() ? "\\<name>" : name;
+str rascalEscapeName(str name) = name in getRascalReservedIdentifiers() ? "\\<name>" : name;
 
 // Find the smallest trees of defined non-terminal type with a source location in `useDefs`
-private rel[loc, loc] rascalFindNamesInUseDefs(start[Module] m, set[loc] useDefs) {
+rel[loc, loc] rascalFindNamesInUseDefs(loc l, set[loc] useDefs) {
+    start[Module] m = parseModuleWithSpacesCached(l);
     rel[loc, loc] nameOfUseDef = {};
     useDefsToDo = useDefs;
     visit(m.top) {
@@ -197,7 +195,7 @@ private rel[loc, loc] rascalFindNamesInUseDefs(start[Module] m, set[loc] useDefs
     }
 
     if (useDefsToDo != {}) {
-        throw unsupportedRename("Rename unsupported", issues={<l, "Cannot find the name for this definition in <m.src.top>."> | l <- useDefsToDo});
+        throw unsupportedRename("Rename unsupported", issues={<ud, "Cannot find the name for this definition in <m.src.top>."> | ud <- useDefsToDo});
     }
 
     return nameOfUseDef;
@@ -221,33 +219,6 @@ Maybe[loc] rascalLocationOfName(Nonterminal nt) = just(nt.src);
 Maybe[loc] rascalLocationOfName(NonterminalLabel l) = just(l.src);
 default Maybe[loc] rascalLocationOfName(Tree t) = nothing();
 
-private tuple[set[IllegalRenameReason] reasons, list[TextEdit] edits] computeTextEdits(TModel ws, start[Module] m, set[RenameLocation] defs, set[RenameLocation] uses, str name, ChangeAnnotationRegister registerChangeAnnotation) {
-    if (reasons := rascalCollectIllegalRenames(ws, m, defs.l, uses.l, name), reasons != {}) {
-        return <reasons, []>;
-    }
-
-    replaceName = rascalEscapeName(name);
-
-    rel[loc l, Maybe[ChangeAnnotationId] ann, bool isDef] renames =
-        {<l, a, true>  | <l, a> <- defs}
-      + {<l, a, false> | <l, a> <- uses};
-    rel[loc name, loc useDef] nameOfUseDef = rascalFindNamesInUseDefs(m, renames.l);
-
-    ChangeAnnotationId defAnno = registerChangeAnnotation("Definitions", MANDATORY_CHANGE_DESCRIPTION, false);
-    ChangeAnnotationId useAnno = registerChangeAnnotation("References", MANDATORY_CHANGE_DESCRIPTION, false);
-
-    // Note: if the implementer of the rename logic has attached annotations to multiple rename suggestions that have the same
-    // name location, one will be arbitrarily chosen here. This could mean that a `needsConfirmation` annotation is thrown away.
-    return <{}, [{just(annotation), *_} := renameOpts.ann
-                 ? replace(l, replaceName, annotation = annotation)
-                 : replace(l, replaceName, annotation = any(b <- renameOpts.isDef) ? defAnno : useAnno)
-                 | l <- nameOfUseDef.name
-                 , rel[Maybe[ChangeAnnotationId] ann, bool isDef] renameOpts := renames[nameOfUseDef[l]]]>;
-}
-
-private tuple[set[IllegalRenameReason] reasons, list[TextEdit] edits] computeTextEdits(TModel ws, loc moduleLoc, set[RenameLocation] defs, set[RenameLocation] uses, str name, ChangeAnnotationRegister registerChangeAnnotation) =
-    computeTextEdits(ws, parseModuleWithSpacesCached(moduleLoc), defs, uses, name, registerChangeAnnotation);
-
 private bool rascalIsFunctionLocalDefs(TModel ws, set[loc] defs) {
     for (d <- defs) {
         if (Define fun: <_, _, _, _, _, defType(afunc(_, _, _))> <- ws.defines
@@ -384,7 +355,7 @@ private CursorKind rascalGetCursorKind(TModel ws, loc cursorLoc, str cursorName,
     throw unsupportedRename("Could not retrieve information for \'<cursorName>\' at <cursorLoc>.");
 }
 
-private Cursor rascalGetCursor(TModel ws, Tree cursorT) {
+Cursor rascalGetCursor(TModel ws, Tree cursorT) {
     loc cursorLoc = cursorT.src;
     str cursorName = "<cursorT>";
 
@@ -438,7 +409,7 @@ private Cursor rascalGetCursor(TModel ws, Tree cursorT) {
 
 private set[Tree] rascalNameToEquivalentNames(str name) {
     set[Tree] equivs = {t
-        | T <- {#Name, #Nonterminal, #NonterminalLabel}
+        | type[Tree] T <- {#Name, #Nonterminal, #NonterminalLabel}
         , just(Tree t) := tryParseAs(T, name)
     };
 
@@ -455,21 +426,21 @@ private bool rascalContainsName(loc l, str name) {
     return false;
 }
 
-private set[TModel] rascalTModels(set[loc] fs, PathConfig pcfg) {
-    RascalCompilerConfig ccfg = rascalCompilerConfig(pcfg)[verbose = false]
-                                                          [logPathConfig = false];
+set[TModel] rascalTModels(set[loc] fs, PathConfig pcfg) {
+    RascalCompilerConfig ccfg = rascalCompilerConfig(pcfg)[verbose=false][logPathConfig=false];
     ms = rascalTModelForLocs(toList(fs), ccfg, dummy_compile1);
 
     set[TModel] tmodels = {};
     for (modName <- ms.moduleLocs) {
         <found, tm, ms> = getTModelForModule(modName, ms);
         if (!found) throw unexpectedFailure("Cannot read TModel for module \'<modName>\'\n<toString(ms.messages)>");
-        tmodels += convertTModel2PhysicalLocs(tm);
+        tmodels += tm;
     }
     return tmodels;
 }
 
-ProjectFiles preloadFiles(set[loc] workspaceFolders, loc cursorLoc) {
+ProjectFiles rascalPreloadFiles(Tree cursorT, set[loc] workspaceFolders, PathConfig(loc) _) {
+    loc cursorLoc = cursorT.src;
     return { <
         max([f | f <- workspaceFolders, isPrefixOf(f, cursorLoc)]),
         true,
@@ -477,21 +448,18 @@ ProjectFiles preloadFiles(set[loc] workspaceFolders, loc cursorLoc) {
     > };
 }
 
-ProjectFiles allWorkspaceFiles(set[loc] workspaceFolders, str cursorName, bool(loc, str) containsName, PathConfig(loc) getPathConfig) {
-    return {
+ProjectFiles rascalAllWorkspaceFiles(TModel tm, Cursor cur, set[loc] workspaceFolders, PathConfig(loc) getPathConfig) =
+    rascalIsFunctionLocal(tm, cur) ? {}
+    : {
         // If we do not find any occurrences of the name under the cursor in a module,
         // we are not interested in loading the model, but we still want to inform the
         // renaming framework about the existence of the file.
-        <folder, containsName(file, cursorName), file>
+        <folder, rascalContainsName(file, cur.name), file>
         | folder <- workspaceFolders
         , PathConfig pcfg := getPathConfig(folder)
         , srcFolder <- pcfg.srcs
         , file <- find(srcFolder, "rsc")
     };
-}
-
-set[TModel] tmodelsForProjectFiles(ProjectFiles projectFiles, set[TModel](set[loc], PathConfig) tmodelsForFiles, PathConfig(loc) getPathConfig) =
-    ({} | it + tmodelsForFiles(projectFiles[pf, true], pcfg) | pf <- projectFiles.projectFolder, pcfg := getPathConfig(pf));
 
 @synopsis{
     Rename the Rascal symbol under the cursor. Renames all related (overloaded) definitions and uses of those definitions.
@@ -560,67 +528,23 @@ set[TModel] tmodelsForProjectFiles(ProjectFiles projectFiles, set[TModel](set[lo
     2. It does not change the semantics of the application.
     3. It does not change definitions outside of the current workspace.
 }
-Edits rascalRenameSymbol(Tree cursorT, set[loc] workspaceFolders, str newName, PathConfig(loc) getPathConfig)
-    = job("renaming <cursorT> to <newName>", Edits(void(str, int) step) {
-
-    step("checking validity of new name", 1);
-    loc cursorLoc = cursorT.src;
-    str cursorName = "<cursorT>";
-
-    rascalCheckLegalName(newName, typeOf(cursorT));
-
-    step("preloading minimal workspace information", 1);
-    set[TModel] localTmodelsForFiles(ProjectFiles projectFiles) = tmodelsForProjectFiles(projectFiles, rascalTModels, getPathConfig);
-
-    TModel ws = loadLocs(tmodel(), preloadFiles(workspaceFolders, cursorLoc), localTmodelsForFiles);
-
-    step("analyzing name at cursor", 1);
-    cur = rascalGetCursor(ws, cursorT);
-
-    step("loading required type information", 1);
-    if (!rascalIsFunctionLocal(ws, cur)) {
-        ws = loadLocs(ws, allWorkspaceFiles(workspaceFolders, cursorName, rascalContainsName, getPathConfig), localTmodelsForFiles);
+public RenameSymbolF rascalRenameSymbol = renameSymbolFramework(
+    CheckResult(Tree c, str nn, set[loc] _, PathConfig(loc) _) { return rascalCheckLegalNameByType(nn, typeOf(c)); }
+    , CheckResult(TModel tm, loc moduleLoc, str nn, set[RenameLocation] defs, set[RenameLocation] uses) {
+        start[Module] m = parseModuleWithSpacesCached(moduleLoc);
+        return rascalCollectIllegalRenames(tm, m, defs.l, uses.l, nn);
     }
-
-    step("collecting uses of \'<cursorName>\'", 1);
-
-    map[ChangeAnnotationId, ChangeAnnotation] changeAnnotations = ();
-    ChangeAnnotationRegister registerChangeAnnotation = ChangeAnnotationId(str label, str description, bool needsConfirmation) {
-        ChangeAnnotationId makeKey(str label, int suffix) = "<label>_<suffix>";
-
-        int suffix = 1;
-        while (makeKey(label, suffix) in changeAnnotations) {
-            suffix += 1;
-        }
-
-        ChangeAnnotationId id = makeKey(label, suffix);
-        changeAnnotations[id] = changeAnnotation(label, description, needsConfirmation);
-
-        return id;
-    };
-
-    <defs, uses, getRenames> = rascalGetDefsUses(ws, cur, rascalMayOverloadSameName, registerChangeAnnotation, getPathConfig);
-
-    rel[loc file, RenameLocation defines] defsPerFile = {<d.l.top, d> | d <- defs};
-    rel[loc file, RenameLocation uses] usesPerFile = {<u.l.top, u> | u <- uses};
-
-    set[loc] \files = defsPerFile.file + usesPerFile.file;
-
-    step("checking rename validity", 1);
-
-    map[loc, tuple[set[IllegalRenameReason] reasons, list[TextEdit] edits]] moduleResults =
-        (file: <reasons, edits> | file <- \files, <reasons, edits> := computeTextEdits(ws, file, defsPerFile[file], usesPerFile[file], newName, registerChangeAnnotation));
-
-    if (reasons := union({moduleResults[file].reasons | file <- moduleResults}), reasons != {}) {
-        list[str] reasonDescs = toList({describe(r) | r <- reasons});
-        throw illegalRename("Rename is not valid, because:\n - <intercalate("\n - ", reasonDescs)>", reasons);
+    , rascalPreloadFiles
+    , rascalAllWorkspaceFiles
+    , rascalTModels
+    , rascalEscapeName
+    , rascalGetCursor
+    , DefsUsesRenames(TModel tm, Cursor cur, ChangeAnnotationRegister regChangeAnno, PathConfigF gpcfg) {
+        return rascalGetDefsUses(tm, cur, rascalMayOverloadSameName, regChangeAnno, gpcfg);
     }
+    , rascalFindNamesInUseDefs
+);
 
-    list[DocumentEdit] changes = [changed(file, moduleResults[file].edits) | file <- moduleResults];
-    list[DocumentEdit] renames = [renamed(from, to) | <from, to> <- getRenames(newName)];
-
-    return <changes + renames, changeAnnotations>;
-}, totalWork = 6);
 
 //// WORKAROUNDS
 
diff --git a/rascal-lsp/src/main/rascal/lang/rascal/lsp/refactor/WorkspaceInfo.rsc b/rascal-lsp/src/main/rascal/lang/rascal/lsp/refactor/WorkspaceInfo.rsc
index 025957d7e..aecdf42a8 100644
--- a/rascal-lsp/src/main/rascal/lang/rascal/lsp/refactor/WorkspaceInfo.rsc
+++ b/rascal-lsp/src/main/rascal/lang/rascal/lsp/refactor/WorkspaceInfo.rsc
@@ -31,18 +31,21 @@ import Relation;
 
 import analysis::typepal::TModel;
 
-import lang::rascalcore::check::ATypeUtils;
-import lang::rascalcore::check::Checker;
+import lang::rascalcore::check::ATypeBase;
+import lang::rascalcore::check::BasicRascalConfig;
+import lang::rascalcore::check::RascalConfig;
 
 import lang::rascal::\syntax::Rascal;
 
 import util::Maybe;
 import util::Reflective;
 
-import lang::rascal::lsp::refactor::Exception;
-import lang::rascal::lsp::refactor::TextEdits;
-import lang::rascal::lsp::refactor::Util;
+import util::refactor::Exception;
+import util::refactor::TextEdits;
+import util::refactor::WorkspaceInfo;
+import util::Util;
 
+import IO;
 import List;
 import Location;
 import Map;
@@ -68,70 +71,15 @@ data Cursor
     ;
 
 alias MayOverloadFun = bool(set[loc] defs, map[loc, Define] defines);
-alias FileRenamesF = rel[loc old, loc new](str newName);
-alias RenameLocation = tuple[loc l, Maybe[ChangeAnnotationId] annotation];
-alias DefsUsesRenames = tuple[set[RenameLocation] defs, set[RenameLocation] uses, FileRenamesF renames];
-alias ProjectFiles = rel[loc projectFolder, bool loadModel, loc file];
-
-// Extend the TModel to include some workspace information.
-data TModel (
-    set[loc] projects = {},
-    set[loc] sourceFiles = {}
-);
-
-set[RenameLocation] annotateLocs(set[loc] locs, Maybe[ChangeAnnotationId] annotationId = nothing()) = {<l, annotationId> | l <- locs};
-
-TModel loadLocs(TModel wsTM, ProjectFiles projectFiles, set[TModel](ProjectFiles projectFiles) tmodelsForFiles) {
-    for (modTM <- tmodelsForFiles(projectFiles)) {
-        wsTM = appendTModel(wsTM, modTM);
-    }
-
-    // In addition to data from the TModel, we keep track of which projects/modules we loaded.
-    wsTM.sourceFiles += projectFiles.file;
-    wsTM.projects += projectFiles.projectFolder;
 
-    return wsTM;
+@synopsis{
+    A cached wrapper for the Rascal whole-module parse function.
 }
-
-TModel appendTModel(TModel to, TModel from) {
-    try {
-        throwAnyErrors(from);
-    } catch set[Message] errors: {
-        throw unsupportedRename("Cannot rename: some files in workspace have errors.\n<toString(errors)>", issues={<(error.at ? |unknown:///|), error.msg> | error <- errors});
-    }
-
-    to.useDef      += from.useDef;
-    to.defines     += from.defines;
-    to.definitions += from.definitions;
-    to.facts       += from.facts;
-    to.scopes      += from.scopes;
-    to.paths       += from.paths;
-
-    return to;
-}
-
-loc getProjectFolder(TModel ws, loc l) {
-    if (project <- ws.projects, isPrefixOf(project, l)) {
-        return project;
-    }
-
-    throw "Could not find project containing <l>";
+start[Module] parseModuleWithSpacesCached(loc l) {
+    @memo{expireAfter(minutes=5)} start[Module] parseModuleWithSpacesCached(loc l, datetime _) = parseModuleWithSpaces(l);
+    return parseModuleWithSpacesCached(l, lastModified(l));
 }
 
-@memo{maximumSize(1), expireAfter(minutes=5)}
-rel[loc, loc] defUse(TModel ws) = invert(ws.useDef);
-
-@memo{maximumSize(1), expireAfter(minutes=5)}
-map[AType, set[loc]] factsInvert(TModel ws) = invert(ws.facts);
-
-set[loc] getUses(TModel ws, loc def) = defUse(ws)[def];
-
-set[loc] getUses(TModel ws, set[loc] defs) = defUse(ws)[defs];
-
-set[loc] getDefs(TModel ws, loc use) = ws.useDef[use];
-
-Maybe[AType] getFact(TModel ws, loc l) = l in ws.facts ? just(ws.facts[l]) : nothing();
-
 @memo{maximumSize(1), expireAfter(minutes=5)}
 set[loc] getModuleScopes(TModel ws) = invert(ws.scopes)[|global-scope:///|];
 
@@ -168,9 +116,6 @@ set[loc] rascalReachableModules(TModel ws, set[loc] froms) {
     return {s.top | s <- reachable.modScope};
 }
 
-@memo{maximumSize(1), expireAfter(minutes=5)}
-rel[loc, Define] definitionsRel(TModel ws) = toRel(ws.definitions);
-
 set[Define] rascalReachableDefs(TModel ws, set[loc] defs) {
     rel[loc from, loc to] modulePaths = rascalGetTransitiveReflexiveModulePaths(ws);
     rel[loc from, loc to] scopes = rascalGetTransitiveReflexiveScopes(ws);
@@ -300,10 +245,8 @@ bool rascalMayOverloadSameName(set[loc] defs, map[loc, Define] definitions) {
     set[Define] defines = {definitions[d] | d <- defs};
 
     if (size(defines.id) > 1) return false;
-    if ({IdRole role} := defines.idRole) {
-        return rascalMayOverload(defs, definitions);
-    }
-    return false;
+    if (size(defines) == 0) return false;
+    return rascalMayOverload(defs, definitions);
 }
 
 set[Define] rascalGetADTDefinitions(TModel ws, loc lhs) {
@@ -405,7 +348,7 @@ private set[RenameLocation] rascalGetExceptUses(TModel ws, set[loc] defs) {
     })];
 
     set[RenameLocation] uses = {};
-    for (Define d: <_, consName, _, constructorId(), _, defType(acons(aadt(_, _, _), _, _))> <- constructorDefs) {
+    for (Define _: <_, consName, _, constructorId(), _, defType(acons(aadt(_, _, _), _, _))> <- constructorDefs) {
         // Find all neighbouring pairs of facts where an except for `cursorName` exists only in the latter
         for (
             [ *_
@@ -422,7 +365,7 @@ private set[RenameLocation] rascalGetExceptUses(TModel ws, set[loc] defs) {
     return uses;
 }
 
-DefsUsesRenames rascalGetDefsUses(TModel ws, cursor(use(), l, cursorName), MayOverloadFun mayOverloadF, ChangeAnnotationRegister registerChangeAnnotation, PathConfig(loc) getPathConfig) {
+DefsUsesRenames rascalGetDefsUses(TModel ws, cursor(use(), l, cursorName), MayOverloadFun mayOverloadF, ChangeAnnotationRegister registerChangeAnnotation, PathConfig(loc) _) {
     set[loc] defs = rascalGetOverloadedDefs(ws, getDefs(ws, l), mayOverloadF);
     set[RenameLocation] uses = annotateLocs(getUses(ws, defs));
 
@@ -430,7 +373,7 @@ DefsUsesRenames rascalGetDefsUses(TModel ws, cursor(use(), l, cursorName), MayOv
     if (keywordFormalId() in roles) {
         uses += rascalGetKeywordFormalUses(ws, defs, cursorName);
         uses += rascalGetKeywordFieldUses(ws, defs, cursorName);
-        uses += rascalGetHasUses(ws, defs, cursorName, registerChangeAnnotation, getPathConfig);
+        uses += rascalGetHasUses(ws, defs, cursorName, registerChangeAnnotation);
     } else if (constructorId() in roles) {
         uses += rascalGetExceptUses(ws, defs);
     }
@@ -438,7 +381,7 @@ DefsUsesRenames rascalGetDefsUses(TModel ws, cursor(use(), l, cursorName), MayOv
     return <annotateLocs(defs), uses, NO_RENAMES>;
 }
 
-DefsUsesRenames rascalGetDefsUses(TModel ws, cursor(def(), l, cursorName), MayOverloadFun mayOverloadF, ChangeAnnotationRegister registerChangeAnnotation, PathConfig(loc) getPathConfig) {
+DefsUsesRenames rascalGetDefsUses(TModel ws, cursor(def(), l, cursorName), MayOverloadFun mayOverloadF, ChangeAnnotationRegister registerChangeAnnotation, PathConfig(loc) _) {
     set[loc] initialUses = getUses(ws, l);
     set[loc] initialDefs = {l} + {*ds | u <- initialUses, ds := getDefs(ws, u)};
     set[loc] defs = rascalGetOverloadedDefs(ws, initialDefs, mayOverloadF);
@@ -448,7 +391,7 @@ DefsUsesRenames rascalGetDefsUses(TModel ws, cursor(def(), l, cursorName), MayOv
     if (roles & {keywordFormalId(), fieldId()} != {}) {
         uses += rascalGetKeywordFormalUses(ws, defs, cursorName);
         uses += rascalGetKeywordFieldUses(ws, defs, cursorName);
-        uses += rascalGetHasUses(ws, defs, cursorName, registerChangeAnnotation, getPathConfig);
+        uses += rascalGetHasUses(ws, defs, cursorName, registerChangeAnnotation);
     } else if (constructorId() in roles) {
         uses += rascalGetExceptUses(ws, defs);
     }
@@ -469,7 +412,7 @@ DefsUsesRenames rascalGetDefsUses(TModel ws, cursor(exceptConstructor(), l, curs
     return <{}, {}, NO_RENAMES>;
 }
 
-DefsUsesRenames rascalGetDefsUses(TModel ws, cursor(typeParam(), cursorLoc, cursorName), MayOverloadFun _, ChangeAnnotationRegister _, PathConfig(loc) getPathConfig) {
+DefsUsesRenames rascalGetDefsUses(TModel ws, cursor(typeParam(), cursorLoc, cursorName), MayOverloadFun _, ChangeAnnotationRegister _, PathConfig(loc) _) {
     set[loc] getFormals(afunc(_, _, _), rel[loc, AType] facts) = {l | <l, f> <- facts, f.alabel != ""};
     set[loc] getFormals(aadt(_, _, _), rel[loc, AType] facts) {
         perName = {<name, l> | <l, f: aparameter(name, _)> <- facts, f.alabel == ""};
@@ -525,7 +468,7 @@ Maybe[tuple[loc, set[loc]]] rascalGetHasLocs(str fieldName, (Expression) `<Expre
 
 default Maybe[tuple[loc, set[loc]]] rascalGetHasLocs(str _, Tree _) = nothing();
 
-set[RenameLocation] rascalGetHasUses(TModel ws, set[loc] defs, str cursorName, ChangeAnnotationRegister registerChangeAnnotation, PathConfig(loc) _) {
+set[RenameLocation] rascalGetHasUses(TModel ws, set[loc] defs, str cursorName, ChangeAnnotationRegister registerChangeAnnotation) {
     return {
         <field, just(registerChangeAnnotation("Use of `has <cursorName>` on value of <describeFact(getFact(ws, lhs))>", "Due to the dynamic nature of these names, please review these suggested changes.", true))>
         | loc l <- rascalReachableModules(ws, defs)
@@ -534,7 +477,7 @@ set[RenameLocation] rascalGetHasUses(TModel ws, set[loc] defs, str cursorName, C
     };
 }
 
-DefsUsesRenames rascalGetDefsUses(TModel ws, cursor(dataField(loc adtLoc, AType fieldType), cursorLoc, cursorName), MayOverloadFun mayOverloadF, ChangeAnnotationRegister registerChangeAnnotation, PathConfig(loc) getPathConfig) {
+DefsUsesRenames rascalGetDefsUses(TModel ws, cursor(dataField(loc adtLoc, AType fieldType), cursorLoc, cursorName), MayOverloadFun mayOverloadF, ChangeAnnotationRegister registerChangeAnnotation, PathConfig(loc) _) {
     set[loc] initialDefs = {};
     if (cursorLoc in ws.useDef<0>) {
         initialDefs = getDefs(ws, cursorLoc);
@@ -555,14 +498,14 @@ DefsUsesRenames rascalGetDefsUses(TModel ws, cursor(dataField(loc adtLoc, AType
 
     set[loc] defs = rascalGetOverloadedDefs(ws, initialDefs, mayOverloadF);
     set[RenameLocation] uses = annotateLocs(getUses(ws, defs)) + rascalGetKeywordFieldUses(ws, defs, cursorName);
-    set[RenameLocation] hasUses = rascalGetHasUses(ws, defs, cursorName, registerChangeAnnotation, getPathConfig);
+    set[RenameLocation] hasUses = rascalGetHasUses(ws, defs, cursorName, registerChangeAnnotation);
 
     return <annotateLocs(defs), uses + hasUses, NO_RENAMES>;
 }
 
 bool debug = false;
 
-DefsUsesRenames rascalGetDefsUses(TModel ws, cursor(cursorKind, cursorLoc, cursorName), MayOverloadFun mayOverloadF, ChangeAnnotationRegister registerChangeAnnotation, PathConfig(loc) getPathConfig) {
+DefsUsesRenames rascalGetDefsUses(TModel ws, cursor(cursorKind, cursorLoc, cursorName), MayOverloadFun mayOverloadF, ChangeAnnotationRegister registerChangeAnnotation, PathConfig(loc) _) {
     if (cursorKind is dataKeywordField || cursorKind is dataCommonKeywordField) {
         set[RenameLocation] defs = {};
         set[RenameLocation] uses = {};
@@ -583,7 +526,7 @@ DefsUsesRenames rascalGetDefsUses(TModel ws, cursor(cursorKind, cursorLoc, curso
             uses += us;
         }
 
-        uses += rascalGetHasUses(ws, adtDefs, cursorName, registerChangeAnnotation, getPathConfig);
+        uses += rascalGetHasUses(ws, adtDefs, cursorName, registerChangeAnnotation);
 
         return <defs, uses, NO_RENAMES>;
     }
@@ -591,7 +534,7 @@ DefsUsesRenames rascalGetDefsUses(TModel ws, cursor(cursorKind, cursorLoc, curso
     fail;
 }
 
-DefsUsesRenames rascalGetDefsUses(TModel ws, cursor(collectionField(), cursorLoc, cursorName), MayOverloadFun _, ChangeAnnotationRegister _, PathConfig(loc) getPathConfig) {
+DefsUsesRenames rascalGetDefsUses(TModel ws, cursor(collectionField(), cursorLoc, cursorName), MayOverloadFun _, ChangeAnnotationRegister _, PathConfig(loc) _) {
     bool isTupleField(AType fieldType) = fieldType.alabel == "";
 
     lrel[loc, AType] factsBySize = sort(toRel(ws.facts), isShorterTuple);
diff --git a/rascal-lsp/src/main/rascal/lang/rascal/tests/rename/Annotations.rsc b/rascal-lsp/src/main/rascal/lang/rascal/tests/rename/Annotations.rsc
index e64f9a32f..99cfdbf7b 100644
--- a/rascal-lsp/src/main/rascal/lang/rascal/tests/rename/Annotations.rsc
+++ b/rascal-lsp/src/main/rascal/lang/rascal/tests/rename/Annotations.rsc
@@ -24,10 +24,11 @@ CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 POSSIBILITY OF SUCH DAMAGE.
 }
+@bootstrapParser
 module lang::rascal::tests::rename::Annotations
 
 import lang::rascal::tests::rename::TestUtils;
-import lang::rascal::lsp::refactor::Exception;
+import util::refactor::Exception;
 
 test bool userDefinedAnno() = testRenameOccurrences({0, 1, 2}, "
     'x = d();
diff --git a/rascal-lsp/src/main/rascal/lang/rascal/tests/rename/Constructors.rsc b/rascal-lsp/src/main/rascal/lang/rascal/tests/rename/Constructors.rsc
index b81eab7a1..c6852ae6a 100644
--- a/rascal-lsp/src/main/rascal/lang/rascal/tests/rename/Constructors.rsc
+++ b/rascal-lsp/src/main/rascal/lang/rascal/tests/rename/Constructors.rsc
@@ -24,6 +24,7 @@ CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 POSSIBILITY OF SUCH DAMAGE.
 }
+@bootstrapParser
 module lang::rascal::tests::rename::Constructors
 
 import lang::rascal::tests::rename::TestUtils;
diff --git a/rascal-lsp/src/main/rascal/lang/rascal/tests/rename/Fields.rsc b/rascal-lsp/src/main/rascal/lang/rascal/tests/rename/Fields.rsc
index eff44aefc..6d7dfcf52 100644
--- a/rascal-lsp/src/main/rascal/lang/rascal/tests/rename/Fields.rsc
+++ b/rascal-lsp/src/main/rascal/lang/rascal/tests/rename/Fields.rsc
@@ -24,10 +24,11 @@ CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 POSSIBILITY OF SUCH DAMAGE.
 }
+@bootstrapParser
 module lang::rascal::tests::rename::Fields
 
 import lang::rascal::tests::rename::TestUtils;
-import lang::rascal::lsp::refactor::Exception;
+import util::refactor::Exception;
 
 test bool constructorField() = testRenameOccurrences({0, 1, 2}, "
     'D oneTwo = d(1, 2);
diff --git a/rascal-lsp/src/main/rascal/lang/rascal/tests/rename/FormalParameters.rsc b/rascal-lsp/src/main/rascal/lang/rascal/tests/rename/FormalParameters.rsc
index f6daf01d7..95ef32159 100644
--- a/rascal-lsp/src/main/rascal/lang/rascal/tests/rename/FormalParameters.rsc
+++ b/rascal-lsp/src/main/rascal/lang/rascal/tests/rename/FormalParameters.rsc
@@ -24,10 +24,11 @@ CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 POSSIBILITY OF SUCH DAMAGE.
 }
+@bootstrapParser
 module lang::rascal::tests::rename::FormalParameters
 
 import lang::rascal::tests::rename::TestUtils;
-import lang::rascal::lsp::refactor::Exception;
+import util::refactor::Exception;
 
 test bool outerNestedFunctionParameter() = testRenameOccurrences({0, 3}, "
     'int f(int foo) {
diff --git a/rascal-lsp/src/main/rascal/lang/rascal/tests/rename/Functions.rsc b/rascal-lsp/src/main/rascal/lang/rascal/tests/rename/Functions.rsc
index 2c92ca3d3..0f04beafa 100644
--- a/rascal-lsp/src/main/rascal/lang/rascal/tests/rename/Functions.rsc
+++ b/rascal-lsp/src/main/rascal/lang/rascal/tests/rename/Functions.rsc
@@ -24,10 +24,11 @@ CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 POSSIBILITY OF SUCH DAMAGE.
 }
+@bootstrapParser
 module lang::rascal::tests::rename::Functions
 
 import lang::rascal::tests::rename::TestUtils;
-import lang::rascal::lsp::refactor::Exception;
+import util::refactor::Exception;
 
 test bool nestedFunctionParameter() = testRenameOccurrences({0, 1}, "
     'int f(int foo, int baz) {
diff --git a/rascal-lsp/src/main/rascal/lang/rascal/tests/rename/Grammars.rsc b/rascal-lsp/src/main/rascal/lang/rascal/tests/rename/Grammars.rsc
index ead403554..4409ae471 100644
--- a/rascal-lsp/src/main/rascal/lang/rascal/tests/rename/Grammars.rsc
+++ b/rascal-lsp/src/main/rascal/lang/rascal/tests/rename/Grammars.rsc
@@ -24,6 +24,7 @@ CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 POSSIBILITY OF SUCH DAMAGE.
 }
+@bootstrapParser
 module lang::rascal::tests::rename::Grammars
 
 import lang::rascal::tests::rename::TestUtils;
diff --git a/rascal-lsp/src/main/rascal/lang/rascal/tests/rename/Modules.rsc b/rascal-lsp/src/main/rascal/lang/rascal/tests/rename/Modules.rsc
index 9b0299864..b8faade7c 100644
--- a/rascal-lsp/src/main/rascal/lang/rascal/tests/rename/Modules.rsc
+++ b/rascal-lsp/src/main/rascal/lang/rascal/tests/rename/Modules.rsc
@@ -24,6 +24,7 @@ CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 POSSIBILITY OF SUCH DAMAGE.
 }
+@bootstrapParser
 module lang::rascal::tests::rename::Modules
 
 import lang::rascal::tests::rename::TestUtils;
diff --git a/rascal-lsp/src/main/rascal/lang/rascal/tests/rename/Performance.rsc b/rascal-lsp/src/main/rascal/lang/rascal/tests/rename/Performance.rsc
index edc0f75db..4efafecb9 100644
--- a/rascal-lsp/src/main/rascal/lang/rascal/tests/rename/Performance.rsc
+++ b/rascal-lsp/src/main/rascal/lang/rascal/tests/rename/Performance.rsc
@@ -24,10 +24,11 @@ CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 POSSIBILITY OF SUCH DAMAGE.
 }
+@bootstrapParser
 module lang::rascal::tests::rename::Performance
 
 import lang::rascal::tests::rename::TestUtils;
-import lang::rascal::lsp::refactor::Exception;
+import util::refactor::Exception;
 
 import List;
 
diff --git a/rascal-lsp/src/main/rascal/lang/rascal/tests/rename/ProjectOnDisk.rsc b/rascal-lsp/src/main/rascal/lang/rascal/tests/rename/ProjectOnDisk.rsc
index 9db612cf2..7891886e2 100644
--- a/rascal-lsp/src/main/rascal/lang/rascal/tests/rename/ProjectOnDisk.rsc
+++ b/rascal-lsp/src/main/rascal/lang/rascal/tests/rename/ProjectOnDisk.rsc
@@ -24,6 +24,7 @@ CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 POSSIBILITY OF SUCH DAMAGE.
 }
+@bootstrapParser
 module lang::rascal::tests::rename::ProjectOnDisk
 
 import lang::rascal::lsp::refactor::Rename;
diff --git a/rascal-lsp/src/main/rascal/lang/rascal/tests/rename/TestUtils.rsc b/rascal-lsp/src/main/rascal/lang/rascal/tests/rename/TestUtils.rsc
index 188a56dfd..df91949f2 100644
--- a/rascal-lsp/src/main/rascal/lang/rascal/tests/rename/TestUtils.rsc
+++ b/rascal-lsp/src/main/rascal/lang/rascal/tests/rename/TestUtils.rsc
@@ -29,7 +29,8 @@ module lang::rascal::tests::rename::TestUtils
 
 import lang::rascal::lsp::refactor::Rename; // Module under test
 
-import lang::rascal::lsp::refactor::Util;
+import util::Util;
+import util::refactor::TextEdits;
 
 import IO;
 import List;
@@ -46,7 +47,6 @@ import lang::rascalcore::check::RascalConfig;
 import lang::rascalcore::compile::util::Names;
 
 import analysis::diff::edits::ExecuteTextEdits;
-import lang::rascal::lsp::refactor::TextEdits;
 
 import util::FileSystem;
 import util::Math;
@@ -116,7 +116,7 @@ bool testRenameOccurrences(set[TestModule] modules, str oldName = "foo", str new
         cursorT = findCursor([m.file | m <- modulesByLocation, getModuleName(m.file, pcfg) == mm.name][0], oldName, cursorOcc);
 
         println("Renaming \'<oldName>\' from <cursorT.src>");
-        edits = rascalRenameSymbol(cursorT, toSet(pcfg.srcs), newName, PathConfig(loc _) { return pcfg; });
+        edits = rascalRenameSymbol(cursorT, newName, toSet(pcfg.srcs), PathConfig(loc _) { return pcfg; });
 
         renamesPerModule = (
             beforeRename: afterRename
@@ -225,7 +225,7 @@ PathConfig getPathConfig(loc project) {
 
 Edits getEdits(loc singleModule, set[loc] projectDirs, int cursorAtOldNameOccurrence, str oldName, str newName, PathConfig(loc) getPathConfig) {
     Tree cursor = findCursor(singleModule, oldName, cursorAtOldNameOccurrence);
-    return rascalRenameSymbol(cursor, projectDirs, newName, getPathConfig);
+    return rascalRenameSymbol(cursor, newName, projectDirs, getPathConfig);
 }
 
 tuple[Edits, set[int]] getEditsAndOccurrences(loc singleModule, loc projectDir, int cursorAtOldNameOccurrence, str oldName, str newName, PathConfig pcfg = getTestPathConfig(projectDir)) {
diff --git a/rascal-lsp/src/main/rascal/lang/rascal/tests/rename/Types.rsc b/rascal-lsp/src/main/rascal/lang/rascal/tests/rename/Types.rsc
index 7e980e53a..45ada11fe 100644
--- a/rascal-lsp/src/main/rascal/lang/rascal/tests/rename/Types.rsc
+++ b/rascal-lsp/src/main/rascal/lang/rascal/tests/rename/Types.rsc
@@ -24,6 +24,7 @@ CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 POSSIBILITY OF SUCH DAMAGE.
 }
+@bootstrapParser
 module lang::rascal::tests::rename::Types
 
 import lang::rascal::tests::rename::TestUtils;
diff --git a/rascal-lsp/src/main/rascal/lang/rascal/tests/rename/ValidNames.rsc b/rascal-lsp/src/main/rascal/lang/rascal/tests/rename/ValidNames.rsc
index 545e1bf84..ae71b2d83 100644
--- a/rascal-lsp/src/main/rascal/lang/rascal/tests/rename/ValidNames.rsc
+++ b/rascal-lsp/src/main/rascal/lang/rascal/tests/rename/ValidNames.rsc
@@ -24,10 +24,11 @@ CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 POSSIBILITY OF SUCH DAMAGE.
 }
+@bootstrapParser
 module lang::rascal::tests::rename::ValidNames
 
 import lang::rascal::tests::rename::TestUtils;
-import lang::rascal::lsp::refactor::Exception;
+import util::refactor::Exception;
 
 import analysis::diff::edits::TextEdits;
 
diff --git a/rascal-lsp/src/main/rascal/lang/rascal/tests/rename/Variables.rsc b/rascal-lsp/src/main/rascal/lang/rascal/tests/rename/Variables.rsc
index ed1408305..7bd6b295a 100644
--- a/rascal-lsp/src/main/rascal/lang/rascal/tests/rename/Variables.rsc
+++ b/rascal-lsp/src/main/rascal/lang/rascal/tests/rename/Variables.rsc
@@ -24,10 +24,11 @@ CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 POSSIBILITY OF SUCH DAMAGE.
 }
+@bootstrapParser
 module lang::rascal::tests::rename::Variables
 
 import lang::rascal::tests::rename::TestUtils;
-import lang::rascal::lsp::refactor::Exception;
+import util::refactor::Exception;
 
 
 //// Local
diff --git a/rascal-lsp/src/main/rascal/lang/rascal/lsp/refactor/Util.rsc b/rascal-lsp/src/main/rascal/util/Util.rsc
similarity index 85%
rename from rascal-lsp/src/main/rascal/lang/rascal/lsp/refactor/Util.rsc
rename to rascal-lsp/src/main/rascal/util/Util.rsc
index 4569b6ffa..916ffaacc 100644
--- a/rascal-lsp/src/main/rascal/lang/rascal/lsp/refactor/Util.rsc
+++ b/rascal-lsp/src/main/rascal/util/Util.rsc
@@ -24,9 +24,9 @@ CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 POSSIBILITY OF SUCH DAMAGE.
 }
-module lang::rascal::lsp::refactor::Util
+@bootstrapParser
+module util::Util
 
-import IO;
 import List;
 import Location;
 import Message;
@@ -34,9 +34,6 @@ import ParseTree;
 import String;
 
 import util::Maybe;
-import util::Reflective;
-
-import lang::rascal::\syntax::Rascal;
 
 @synopsis{
     Finds the smallest location in `wrappers` than contains `l`. If none contains `l`, returns `nothing().`
@@ -72,14 +69,6 @@ bool isPrefixOf(loc prefix, loc l) = l.scheme == prefix.scheme
                                   && l.authority == prefix.authority
                                   && startsWith(l.path, endsWith(prefix.path, "/") ? prefix.path : prefix.path + "/");
 
-@synopsis{
-    A cached wrapper for the Rascal whole-module parse function.
-}
-start[Module] parseModuleWithSpacesCached(loc l) {
-    @memo{expireAfter(minutes=5)} start[Module] parseModuleWithSpacesCached(loc l, datetime _) = parseModuleWithSpaces(l);
-    return parseModuleWithSpacesCached(l, lastModified(l));
-}
-
 @synopsis{
     Try to parse string `name` as reified type `begin` and return whether this succeeded.
 }
@@ -114,17 +103,3 @@ rel[&K, &V] groupBy(set[&V] s, &K(&V) pred) =
 bool isShorter(loc l1, loc l2) = l1.length < l2.length;
 
 bool isShorterTuple(tuple[loc, &T] t1, tuple[loc, &T] t2) = isShorter(t1[0], t2[0]);
-
-@synopsis{
-    Predicate to sort locations by offset.
-}
-bool byOffset(loc l1, loc l2) = l1.offset < l2.offset;
-
-@synopsis{
-    Predicate to reverse a sort order.
-}
-bool(&T, &T) desc(bool(&T, &T) f) {
-    return bool(&T t1, &T t2) {
-        return f(t2, t1);
-    };
-}
diff --git a/rascal-lsp/src/main/rascal/lang/rascal/lsp/refactor/Exception.rsc b/rascal-lsp/src/main/rascal/util/refactor/Exception.rsc
similarity index 98%
rename from rascal-lsp/src/main/rascal/lang/rascal/lsp/refactor/Exception.rsc
rename to rascal-lsp/src/main/rascal/util/refactor/Exception.rsc
index c51d72d4b..01b541cae 100644
--- a/rascal-lsp/src/main/rascal/lang/rascal/lsp/refactor/Exception.rsc
+++ b/rascal-lsp/src/main/rascal/util/refactor/Exception.rsc
@@ -24,7 +24,8 @@ CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 POSSIBILITY OF SUCH DAMAGE.
 }
-module lang::rascal::lsp::refactor::Exception
+@bootstrapParser
+module util::refactor::Exception
 
 import analysis::typepal::TModel;
 
diff --git a/rascal-lsp/src/main/rascal/util/refactor/Rename.rsc b/rascal-lsp/src/main/rascal/util/refactor/Rename.rsc
new file mode 100644
index 000000000..f915a91c5
--- /dev/null
+++ b/rascal-lsp/src/main/rascal/util/refactor/Rename.rsc
@@ -0,0 +1,193 @@
+@license{
+Copyright (c) 2018-2023, NWO-I CWI and Swat.engineering
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice,
+this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+this list of conditions and the following disclaimer in the documentation
+and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.
+}
+@bootstrapParser
+module util::refactor::Rename
+
+import ParseTree;
+import Set;
+import util::Maybe;
+import util::Monitor;
+import util::Reflective;
+
+import IO;
+
+import util::refactor::Exception;
+import util::refactor::TextEdits;
+extend util::refactor::WorkspaceInfo;
+
+import analysis::typepal::TModel;
+
+@synopsis{ To be extended by implementations. }
+data Cursor;
+
+@synopsis{ Return type for rename refactoring. }
+alias Edits = tuple[list[DocumentEdit], map[ChangeAnnotationId, ChangeAnnotation]];
+@synopsis{ Return type for rename validity checks. }
+alias CheckResult = set[IllegalRenameReason];
+@synopsis {Get a path config for a project folder. }
+alias PathConfigF = PathConfig(loc);
+@synopsis { A rename validity check that does not require type check information. }
+alias PreCheckF = CheckResult(Tree cursorT, str newName, set[loc] workspaceFolders, PathConfigF getPathConfig);
+@synopsis{ A function that checks whether the produced rename candidates are valid. }
+alias PostCheckF = CheckResult(TModel tm, loc moduleLoc, str newName, set[RenameLocation] defs, set[RenameLocation] uses);
+@synopsis{ A function that selects project files to load. }
+alias PreFilesF = ProjectFiles(Tree cursorT, set[loc] workspaceFolders, PathConfigF getPathConfig);
+alias AllFilesF = ProjectFiles(TModel tm, Cursor cur, set[loc] workspaceFolders, PathConfigF getPathConfig);
+@synopsis{ A function that, given a set of file locs and a path config, returns a set of TModels. }
+alias TModelsF = set[TModel](set[loc] fs, PathConfig pcfg);
+@synopsis{ A function that, given a TModel and the Tree under the cursor, returns a Cursor. }
+alias CursorF = Cursor(TModel tm, Tree cursorT);
+@synopsis{ A function that determines rename candidates. }
+alias DefsUsesF = DefsUsesRenames(TModel tm, Cursor cur, ChangeAnnotationRegister registerChangeAnnotation, PathConfigF getPathConfig);
+@synopsis{ A function that finds the location of names in candidates. }
+alias FindNamesF = rel[loc, loc](loc l, set[loc] candidates);
+@synopsis{ Escape a name. }
+alias EscapeNameF = str(str name);
+@synopsis{ The type of the rename function, as expected by the language server. }
+alias RenameSymbolF = Edits(Tree cursorT, str newName, set[loc] workspaceFolders, PathConfigF getPathConfig);
+
+// TODO Make parameter
+str MANDATORY_CHANGE_DESCRIPTION = "These changes are required for a correct renaming. They can be previewed here, but it is not advised to disable them.";
+
+RenameSymbolF renameSymbolFramework(
+    PreCheckF preCheck
+  , PostCheckF postCheck
+  , PreFilesF preFiles
+  , AllFilesF allFiles
+  , TModelsF getTModels
+  , EscapeNameF escapeName
+  , CursorF getCursor
+  , DefsUsesF getDefsUses
+  , FindNamesF findNames
+) {
+    return Edits(Tree cursorT, str newName, set[loc] workspaceFolders, PathConfigF getPathConfig) {
+        return job("renaming \'<"<cursorT>">\' to \'<newName>\'", Edits(void(str, int) step) {
+            step("pre-checking rename validity", 1);
+            str cursorName = "<cursorT>";
+            checkResult(preCheck(cursorT, newName, workspaceFolders, getPathConfig));
+
+            step("preloading minimal workspace information", 1);
+            ProjectFiles preloadFiles = preFiles(cursorT, workspaceFolders, getPathConfig);
+            TModel tm = loadLocs(tmodel(), preloadFiles, getTModels, getPathConfig);
+
+            step("analyzing name at cursor", 1);
+            Cursor cur = getCursor(tm, cursorT);
+
+            step("loading required type information", 1);
+            ProjectFiles allLoadFiles = allFiles(tm, cur, workspaceFolders, getPathConfig);
+            tm = loadLocs(tm, allLoadFiles, getTModels, getPathConfig);
+
+            step("collecting definitions and uses of \'<cursorName>\'", 1);
+            map[ChangeAnnotationId, ChangeAnnotation] changeAnnotations = ();
+            ChangeAnnotationRegister registerChangeAnnotation = ChangeAnnotationId(str label, str description, bool needsConfirmation) {
+                ChangeAnnotationId makeKey(str label, int suffix) = "<label>_<suffix>";
+
+                int suffix = 1;
+                while (makeKey(label, suffix) in changeAnnotations) {
+                    suffix += 1;
+                }
+
+                ChangeAnnotationId id = makeKey(label, suffix);
+                changeAnnotations[id] = changeAnnotation(label, description, needsConfirmation);
+
+                return id;
+            };
+
+            <defs, uses, getRenames> = getDefsUses(tm, cur, registerChangeAnnotation, getPathConfig);
+
+            rel[loc file, RenameLocation defines] defsPerFile = {<d.l.top, d> | d <- defs};
+            rel[loc file, RenameLocation uses] usesPerFile = {<u.l.top, u> | u <- uses};
+            set[loc] \files = defsPerFile.file + usesPerFile.file;
+
+            step("checking rename validity", 1);
+            map[loc, tuple[set[IllegalRenameReason] reasons, list[TextEdit] edits]] fileResults =
+                (file: <reasons, edits> | file <- \files, <reasons, edits> :=
+                    computeTextEdits(
+                        tm
+                    , file
+                    , defsPerFile[file]
+                    , usesPerFile[file]
+                    , newName
+                    , registerChangeAnnotation
+                    , postCheck
+                    , escapeName
+                    , findNames
+                    )
+                );
+
+            if (reasons := union({fileResults[file].reasons | file <- fileResults}), reasons != {}) {
+                list[str] reasonDescs = toList({describe(r) | r <- reasons});
+                throw illegalRename("Rename is not valid, because:\n - <intercalate("\n - ", reasonDescs)>", reasons);
+            }
+
+            list[DocumentEdit] changes = [changed(file, fileResults[file].edits) | file <- fileResults];
+            list[DocumentEdit] renames = [renamed(from, to) | <from, to> <- getRenames(newName)];
+
+            return <changes + renames, changeAnnotations>;
+        }, totalWork = 6);
+    };
+}
+
+private void checkResult(CheckResult r, str msg = "Check failed") {
+    if (size(r) > 0) {
+        throw illegalRename(msg, r);
+    }
+}
+
+private tuple[set[IllegalRenameReason] reasons, list[TextEdit] edits] computeTextEdits(
+    TModel ws
+  , loc moduleLoc
+  , set[RenameLocation] defs
+  , set[RenameLocation] uses
+  , str name
+  , ChangeAnnotationRegister registerChangeAnnotation
+  , PostCheckF postCheck
+  , EscapeNameF escapeName
+  , FindNamesF findNames
+) {
+    if (reasons := postCheck(ws, moduleLoc, name, defs, uses), reasons != {}) {
+        return <reasons, []>;
+    }
+
+    replaceName = escapeName(name);
+
+    rel[loc l, Maybe[ChangeAnnotationId] ann, bool isDef] renames =
+        {<l, a, true>  | <l, a> <- defs}
+      + {<l, a, false> | <l, a> <- uses};
+    rel[loc name, loc useDef] nameOfUseDef = findNames(moduleLoc, renames.l);
+
+    ChangeAnnotationId defAnno = registerChangeAnnotation("Definitions", MANDATORY_CHANGE_DESCRIPTION, false);
+    ChangeAnnotationId useAnno = registerChangeAnnotation("References", MANDATORY_CHANGE_DESCRIPTION, false);
+
+    // Note: if the implementer of the rename logic has attached annotations to multiple rename suggestions that have the same
+    // name location, one will be arbitrarily chosen here. This could mean that a `needsConfirmation` annotation is thrown away.
+    return <{}, [{just(annotation), *_} := renameOpts.ann
+                 ? replace(l, replaceName, annotation = annotation)
+                 : replace(l, replaceName, annotation = true in renameOpts.isDef ? defAnno : useAnno)
+                 | l <- nameOfUseDef.name
+                 , rel[Maybe[ChangeAnnotationId] ann, bool isDef] renameOpts := renames[nameOfUseDef[l]]]>;
+}
diff --git a/rascal-lsp/src/main/rascal/lang/rascal/lsp/refactor/TextEdits.rsc b/rascal-lsp/src/main/rascal/util/refactor/TextEdits.rsc
similarity index 97%
rename from rascal-lsp/src/main/rascal/lang/rascal/lsp/refactor/TextEdits.rsc
rename to rascal-lsp/src/main/rascal/util/refactor/TextEdits.rsc
index e8d153e3c..0836b9e9b 100644
--- a/rascal-lsp/src/main/rascal/lang/rascal/lsp/refactor/TextEdits.rsc
+++ b/rascal-lsp/src/main/rascal/util/refactor/TextEdits.rsc
@@ -24,7 +24,8 @@ CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 POSSIBILITY OF SUCH DAMAGE.
 }
-module lang::rascal::lsp::refactor::TextEdits
+@bootstrapParser
+module util::refactor::TextEdits
 
 extend analysis::diff::edits::TextEdits;
 
diff --git a/rascal-lsp/src/main/rascal/util/refactor/WorkspaceInfo.rsc b/rascal-lsp/src/main/rascal/util/refactor/WorkspaceInfo.rsc
new file mode 100644
index 000000000..b16224ab4
--- /dev/null
+++ b/rascal-lsp/src/main/rascal/util/refactor/WorkspaceInfo.rsc
@@ -0,0 +1,109 @@
+@license{
+Copyright (c) 2018-2023, NWO-I CWI and Swat.engineering
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice,
+this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+this list of conditions and the following disclaimer in the documentation
+and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.
+}
+@bootstrapParser
+module util::refactor::WorkspaceInfo
+
+import Map;
+import Message;
+import Relation;
+import util::Maybe;
+
+import util::refactor::Exception;
+import util::refactor::TextEdits;
+import util::Util;
+
+import analysis::typepal::TModel;
+
+alias FileRenamesF = rel[loc old, loc new](str newName);
+alias RenameLocation = tuple[loc l, Maybe[ChangeAnnotationId] annotation];
+alias DefsUsesRenames = tuple[set[RenameLocation] defs, set[RenameLocation] uses, FileRenamesF renames];
+alias ProjectFiles = rel[loc projectFolder, bool loadModel, loc file];
+
+data PathConfig; // util::Reflective
+
+// Extend the TModel to include some workspace information.
+data TModel (
+    set[loc] projects = {},
+    set[loc] sourceFiles = {}
+);
+
+set[TModel] tmodelsForProjectFiles(ProjectFiles projectFiles, set[TModel](set[loc], PathConfig) tmodelsForFiles, PathConfig(loc) getPathConfig) =
+    ({} | it + tmodelsForFiles(projectFiles[pf, true], pcfg) | pf <- projectFiles.projectFolder, pcfg := getPathConfig(pf));
+
+TModel loadLocs(TModel wsTM, ProjectFiles projectFiles, set[TModel](set[loc], PathConfig) tmodelsForFiles, PathConfig(loc) getPathConfig) {
+    wsTM = (wsTM | appendTModel(it, modTM) | modTM <- tmodelsForProjectFiles(projectFiles, tmodelsForFiles, getPathConfig));
+
+    // In addition to data from the loaded TModel, we keep track of which projects/modules we loaded.
+    wsTM.sourceFiles += projectFiles.file;
+    wsTM.projects += projectFiles.projectFolder;
+
+    return wsTM;
+}
+
+TModel appendTModel(TModel to, TModel from) {
+    try {
+        throwAnyErrors(from);
+    } catch set[Message] errors: {
+        throw unsupportedRename("Cannot rename: some files in workspace have errors.\n<toString(errors)>", issues={<(error.at ? |unknown:///|), error.msg> | error <- errors});
+    }
+
+    to.useDef      += from.useDef;
+    to.defines     += from.defines;
+    to.definitions += from.definitions;
+    to.facts       += from.facts;
+    to.scopes      += from.scopes;
+    to.paths       += from.paths;
+
+    return to;
+}
+
+loc getProjectFolder(TModel ws, loc l) {
+    if (project <- ws.projects, isPrefixOf(project, l)) {
+        return project;
+    }
+
+    throw "Could not find project containing <l>";
+}
+
+@memo{maximumSize(1), expireAfter(minutes=5)}
+rel[loc, loc] defUse(TModel ws) = invert(ws.useDef);
+
+@memo{maximumSize(1), expireAfter(minutes=5)}
+map[AType, set[loc]] factsInvert(TModel ws) = invert(ws.facts);
+
+set[loc] getUses(TModel ws, loc def) = defUse(ws)[def];
+
+set[loc] getUses(TModel ws, set[loc] defs) = defUse(ws)[defs];
+
+set[loc] getDefs(TModel ws, loc use) = ws.useDef[use];
+
+Maybe[AType] getFact(TModel ws, loc l) = l in ws.facts ? just(ws.facts[l]) : nothing();
+
+@memo{maximumSize(1), expireAfter(minutes=5)}
+rel[loc, Define] definitionsRel(TModel ws) = toRel(ws.definitions);
+
+set[RenameLocation] annotateLocs(set[loc] locs, Maybe[ChangeAnnotationId] annotationId = nothing()) = {<l, annotationId> | l <- locs};