From 026331cc1bae8094c3a3a457fc7241ae8c39f766 Mon Sep 17 00:00:00 2001
From: Toine Hartman <toine.hartman@swat.engineering>
Date: Tue, 15 Oct 2024 15:25:13 +0200
Subject: [PATCH 01/16] Add annotated changes to rename framework.

---
 .../lsp/rascal/RascalTextDocumentService.java | 12 +++++--
 .../vscode/lsp/util/DocumentChanges.java      | 23 ++++++++++++-
 .../lang/rascal/lsp/refactor/Rename.rsc       | 26 +++++++++++---
 .../lang/rascal/lsp/refactor/TextEdits.rsc    | 16 +++++++++
 .../lang/rascal/tests/rename/TestUtils.rsc    | 34 +++++++++----------
 .../lang/rascal/tests/rename/ValidNames.rsc   |  2 +-
 6 files changed, 87 insertions(+), 26 deletions(-)
 create mode 100644 rascal-lsp/src/main/rascal/lang/rascal/lsp/refactor/TextEdits.rsc

diff --git a/rascal-lsp/src/main/java/org/rascalmpl/vscode/lsp/rascal/RascalTextDocumentService.java b/rascal-lsp/src/main/java/org/rascalmpl/vscode/lsp/rascal/RascalTextDocumentService.java
index 6de9d8b44..6eb067746 100644
--- a/rascal-lsp/src/main/java/org/rascalmpl/vscode/lsp/rascal/RascalTextDocumentService.java
+++ b/rascal-lsp/src/main/java/org/rascalmpl/vscode/lsp/rascal/RascalTextDocumentService.java
@@ -105,7 +105,10 @@
 import org.rascalmpl.vscode.lsp.util.locations.LineColumnOffsetMap;
 import org.rascalmpl.vscode.lsp.util.locations.Locations;
 
+import io.usethesource.vallang.IList;
+import io.usethesource.vallang.IMap;
 import io.usethesource.vallang.ISourceLocation;
+import io.usethesource.vallang.ITuple;
 import io.usethesource.vallang.IValue;
 
 public class RascalTextDocumentService implements IBaseTextDocumentService, LanguageClientAware {
@@ -287,8 +290,13 @@ public CompletableFuture<WorkspaceEdit> rename(RenameParams params) {
             .thenApply(Versioned::get)
             .handle((t, r) -> (t == null ? (file.getMostRecentTree().get()) : t))
             .thenCompose(tr -> rascalServices.getRename(tr, params.getPosition(), workspaceFolders, facts::getPathConfig, params.getNewName(), columns).get())
-            .thenApply(c -> new WorkspaceEdit(DocumentChanges.translateDocumentChanges(this, c)))
-            ;
+            .thenApply(c -> {
+                ITuple t = (ITuple) c;
+                WorkspaceEdit wsEdit = new WorkspaceEdit();
+                wsEdit.setDocumentChanges(DocumentChanges.translateDocumentChanges(this, (IList) t.get(0)));
+                wsEdit.setChangeAnnotations(DocumentChanges.translateChangeAnnotations((IMap) t.get(1)));
+                return wsEdit;
+            });
     }
 
     @Override
diff --git a/rascal-lsp/src/main/java/org/rascalmpl/vscode/lsp/util/DocumentChanges.java b/rascal-lsp/src/main/java/org/rascalmpl/vscode/lsp/util/DocumentChanges.java
index d931eed21..515551f7b 100644
--- a/rascal-lsp/src/main/java/org/rascalmpl/vscode/lsp/util/DocumentChanges.java
+++ b/rascal-lsp/src/main/java/org/rascalmpl/vscode/lsp/util/DocumentChanges.java
@@ -28,8 +28,11 @@
 
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Map;
 import java.util.stream.Collectors;
 
+import org.eclipse.lsp4j.AnnotatedTextEdit;
+import org.eclipse.lsp4j.ChangeAnnotation;
 import org.eclipse.lsp4j.CreateFile;
 import org.eclipse.lsp4j.DeleteFile;
 import org.eclipse.lsp4j.Range;
@@ -43,8 +46,10 @@
 import org.rascalmpl.vscode.lsp.util.locations.LineColumnOffsetMap;
 import org.rascalmpl.vscode.lsp.util.locations.Locations;
 
+import io.usethesource.vallang.IBool;
 import io.usethesource.vallang.IConstructor;
 import io.usethesource.vallang.IList;
+import io.usethesource.vallang.IMap;
 import io.usethesource.vallang.ISourceLocation;
 import io.usethesource.vallang.IString;
 import io.usethesource.vallang.IValue;
@@ -90,7 +95,9 @@ public static List<Either<TextDocumentEdit, ResourceOperation>> translateDocumen
     private static List<TextEdit> translateTextEdits(final IBaseTextDocumentService docService, IList edits) {
         return edits.stream()
             .map(e -> (IConstructor) e)
-            .map(c -> new TextEdit(locationToRange(docService, (ISourceLocation) c.get("range")), ((IString) c.get("replacement")).getValue()))
+            .map(c -> (c.has("annotation")
+                ? new AnnotatedTextEdit(locationToRange(docService, (ISourceLocation) c.get("range")), ((IString) c.get("replacement")).getValue(), ((IString) c.get("annotation")).getValue())
+                : new TextEdit(locationToRange(docService, (ISourceLocation) c.get("range")), ((IString) c.get("replacement")).getValue())))
             .collect(Collectors.toList());
     }
 
@@ -102,4 +109,18 @@ private static Range locationToRange(final IBaseTextDocumentService docService,
     private static String getFileURI(IConstructor edit, String label) {
         return ((ISourceLocation) edit.get(label)).getURI().toString();
     }
+
+    public static Map<String, ChangeAnnotation> translateChangeAnnotations(IMap annos) {
+        return annos.stream()
+            .map(id -> (IString) id)
+            .map(id -> {
+                IConstructor c = (IConstructor) annos.get(id);
+                ChangeAnnotation anno = new ChangeAnnotation();
+                anno.setLabel(((IString) c.get("label")).getValue());
+                anno.setDescription(((IString) c.get("description")).getValue());
+                anno.setNeedsConfirmation(((IBool) c.get("needsConfirmation")).getValue());
+                return Map.entry(id.getValue(), anno);
+            })
+            .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
+    }
 }
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 e50b9f164..76fb4d8ca 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
@@ -53,13 +53,15 @@ extend lang::rascal::lsp::refactor::Exception;
 import lang::rascal::lsp::refactor::Util;
 import lang::rascal::lsp::refactor::WorkspaceInfo;
 
-import analysis::diff::edits::TextEdits;
+import lang::rascal::lsp::refactor::TextEdits;
 
 import util::FileSystem;
 import util::Maybe;
 import util::Monitor;
 import util::Reflective;
 
+alias Edits = tuple[list[DocumentEdit], map[ChangeAnnotationId, ChangeAnnotation]];
+
 // Rascal compiler-specific extension
 void throwAnyErrors(list[ModuleMessages] mmsgs) {
     for (mmsg <- mmsgs) {
@@ -508,8 +510,8 @@ private bool rascalContainsName(loc l, str name) {
     2. It does not change the semantics of the application.
     3. It does not change definitions outside of the current workspace.
 }
-list[DocumentEdit] rascalRenameSymbol(Tree cursorT, set[loc] workspaceFolders, str newName, PathConfig(loc) getPathConfig)
-    = job("renaming <cursorT> to <newName>", list[DocumentEdit](void(str, int) step) {
+Edits rascalRenameSymbol(Tree cursorT, set[loc] workspaceFolders, str newName, PathConfig(loc) getPathConfig)
+    = job("renaming <cursorT> to <newName>", Edits(void(str, int) step) {
     loc cursorLoc = cursorT.src;
     str cursorName = "<cursorT>";
 
@@ -576,6 +578,22 @@ list[DocumentEdit] rascalRenameSymbol(Tree cursorT, set[loc] workspaceFolders, s
     set[loc] \files = defsPerFile.file + usesPerFile.file;
 
     step("checking rename validity", 1);
+
+    map[ChangeAnnotationId, ChangeAnnotation] changeAnnotations = ();
+    ChangeAnnotationId registerChangeAnnotation(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;
+    }
+
     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));
 
@@ -587,7 +605,7 @@ list[DocumentEdit] rascalRenameSymbol(Tree cursorT, set[loc] workspaceFolders, s
     list[DocumentEdit] changes = [changed(file, moduleResults[file].edits) | file <- moduleResults];
     list[DocumentEdit] renames = [renamed(from, to) | <from, to> <- getRenames(newName)];
 
-    return changes + renames;
+    return <changes + renames, changeAnnotations>;
 }, totalWork = 6);
 
 //// WORKAROUNDS
diff --git a/rascal-lsp/src/main/rascal/lang/rascal/lsp/refactor/TextEdits.rsc b/rascal-lsp/src/main/rascal/lang/rascal/lsp/refactor/TextEdits.rsc
new file mode 100644
index 000000000..7d2eb01af
--- /dev/null
+++ b/rascal-lsp/src/main/rascal/lang/rascal/lsp/refactor/TextEdits.rsc
@@ -0,0 +1,16 @@
+module lang::rascal::lsp::refactor::TextEdits
+
+extend analysis::diff::edits::TextEdits;
+
+alias ChangeAnnotationId = str;
+
+data ChangeAnnotation
+    = changeAnnotation(str label, str description, bool needsConfirmation)
+    ;
+
+data TextEdit
+    = replace(loc range, str replacement, ChangeAnnotationId annotation)
+    ;
+
+alias ChangeAnnotationRegister =
+    ChangeAnnotationId(str label, str description, bool needsConfirmation);
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 b81f1add8..7baf7ebe6 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
@@ -46,6 +46,7 @@ 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;
@@ -63,8 +64,8 @@ private DocumentEdit sortChanges(changed(loc l, list[TextEdit] edits)) = changed
 }));
 private default DocumentEdit sortChanges(DocumentEdit e) = e;
 
-private void verifyTypeCorrectRenaming(loc root, list[DocumentEdit] edits, PathConfig pcfg) {
-    executeDocumentEdits(sortEdits(edits));
+private void verifyTypeCorrectRenaming(loc root, Edits edits, PathConfig pcfg) {
+    executeDocumentEdits(sortEdits(edits<0>));
     remove(pcfg.resources);
     RascalCompilerConfig ccfg = rascalCompilerConfig(pcfg)[forceCompilationTopModule = true][verbose = false][logPathConfig = false];
     throwAnyErrors(checkAll(root, ccfg));
@@ -117,16 +118,16 @@ bool testRenameOccurrences(set[TestModule] modules, str oldName = "foo", str new
 
         renamesPerModule = (
             beforeRename: afterRename
-            | renamed(oldLoc, newLoc) <- edits
+            | renamed(oldLoc, newLoc) <- edits<0>
             , beforeRename := getModuleName(oldLoc, pcfg)
             , afterRename := getModuleName(newLoc, pcfg)
         );
 
         replacesPerModule = (
             name: occs
-            | changed(file, changes) <- edits
+            | changed(file, changes) <- edits<0>
             , name := getModuleName(file, pcfg)
-            , locs := {l | replace(l, _) <- changes}
+            , locs := {c.range | c <- changes}
             , occs := locsToOccs(parseModuleWithSpaces(file), oldName, locs)
         );
 
@@ -224,7 +225,7 @@ PathConfig getPathConfig(loc project) {
     return resolveLocations(pcfg);
 }
 
-list[DocumentEdit] testRascalCore(loc rascalCoreDir, loc typepalDir) {
+Edits testRascalCore(loc rascalCoreDir, loc typepalDir) {
     registerLocations("project", "", (
         |project://rascal-core/target/test-classes|: rascalCoreDir + "target/test-classes",
         |project://rascal-core/target/generated-test-sources|: rascalCoreDir + "target/generated-test-sources",
@@ -235,13 +236,13 @@ list[DocumentEdit] testRascalCore(loc rascalCoreDir, loc typepalDir) {
     return getEdits(rascalCoreDir + "src/org/rascalmpl/core/library/lang/rascalcore/check/ATypeBase.rsc", {resolveLocation(rascalCoreDir), resolveLocation(typepalDir)}, 0, "arat", "arational", getPathConfig);
 }
 
-list[DocumentEdit] getEdits(loc singleModule, set[loc] projectDirs, int cursorAtOldNameOccurrence, str oldName, str newName, PathConfig(loc) getPathConfig) {
+Edits getEdits(loc singleModule, set[loc] projectDirs, int cursorAtOldNameOccurrence, str oldName, str newName, PathConfig(loc) getPathConfig) {
     loc f = resolveLocation(singleModule);
     Tree cursor = findCursor(singleModule, oldName, cursorAtOldNameOccurrence);
     return rascalRenameSymbol(cursor, projectDirs, newName, getPathConfig);
 }
 
-tuple[list[DocumentEdit], set[int]] getEditsAndOccurrences(loc singleModule, loc projectDir, int cursorAtOldNameOccurrence, str oldName, str newName, PathConfig pcfg = getTestPathConfig(projectDir)) {
+tuple[Edits, set[int]] getEditsAndOccurrences(loc singleModule, loc projectDir, int cursorAtOldNameOccurrence, str oldName, str newName, PathConfig pcfg = getTestPathConfig(projectDir)) {
     edits = getEdits(singleModule, {projectDir}, cursorAtOldNameOccurrence, oldName, newName, PathConfig(loc _) { return pcfg; });
     occs = extractRenameOccurrences(singleModule, edits, oldName);
 
@@ -252,12 +253,12 @@ tuple[list[DocumentEdit], set[int]] getEditsAndOccurrences(loc singleModule, loc
     return <edits, occs>;
 }
 
-list[DocumentEdit] getEdits(str stmtsStr, int cursorAtOldNameOccurrence, str oldName, str newName, str decls, str imports) {
+Edits getEdits(str stmtsStr, int cursorAtOldNameOccurrence, str oldName, str newName, str decls, str imports) {
     <edits, _> = getEditsAndModule(stmtsStr, cursorAtOldNameOccurrence, oldName, newName, decls, imports);
     return edits;
 }
 
-private tuple[list[DocumentEdit], set[int]] getEditsAndModule(str stmtsStr, int cursorAtOldNameOccurrence, str oldName, str newName, str decls, str imports, str moduleName = "TestModule") {
+private tuple[Edits, set[int]] getEditsAndModule(str stmtsStr, int cursorAtOldNameOccurrence, str oldName, str newName, str decls, str imports, str moduleName = "TestModule") {
     str moduleStr =
     "module <moduleName>
     '<trim(imports)>
@@ -292,21 +293,18 @@ private list[Tree] collectNameTrees(start[Module] m, str name) {
     return names;
 }
 
-private set[int] extractRenameOccurrences(loc moduleFileName, list[DocumentEdit] edits, str name) {
+private set[int] extractRenameOccurrences(loc moduleFileName, Edits edits, str name) {
     start[Module] m = parseModuleWithSpaces(moduleFileName);
     list[loc] oldNameOccurrences = [n.src | n <- collectNameTrees(m, name)];
 
-    // print("All locations of \'<name>\': ");
-    // iprintln(sort(oldNameOccurrences, byOffset));
-
-    if ([changed(_, replaces)] := edits) {
+    if ([changed(_, replaces)] := edits<0>) {
         set[int] occs = {};
         set[loc] nonOldNameLocs = {};
-        for (replace(l, _) <- replaces) {
-            if (idx := indexOf(oldNameOccurrences, l), idx >= 0) {
+        for (r <- replaces) {
+            if (idx := indexOf(oldNameOccurrences, r.range), idx >= 0) {
                 occs += idx;
             } else {
-                nonOldNameLocs += l;
+                nonOldNameLocs += r.range;
             }
         }
 
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 b342ce294..a5ef93ca1 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
@@ -33,7 +33,7 @@ import analysis::diff::edits::TextEdits;
 
 test bool renameToReservedName() {
     edits = getEdits("int foo = 8;", 0, "foo", "int", "", "");
-    newNames = {name | e <- edits, changed(_, replaces) := e
+    newNames = {name | e <- edits<0>, changed(_, replaces) := e
                      , r <- replaces, replace(_, name) := r};
 
     return newNames == {"\\int"};

From 5bce79e1c291a719bbb70bf70902d8a62ae1f1ee Mon Sep 17 00:00:00 2001
From: Toine Hartman <toine.hartman@swat.engineering>
Date: Thu, 17 Oct 2024 14:34:13 +0200
Subject: [PATCH 02/16] Semantic & static fixes.

---
 .../src/main/rascal/lang/rascal/lsp/refactor/WorkspaceInfo.rsc  | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

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 ef29ebd6f..3b4f3dbe8 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
@@ -576,7 +576,7 @@ DefsUsesRenames rascalGetDefsUses(WorkspaceInfo ws, cursor(cursorKind, cursorLoc
         }
         for (Define _:<_, _, _, IdRole idRole, _, defType(acons(AType dataType, _, _))> <- reachableDefs
            , idRole != dataId()) {
-            <ds, us, _> += rascalGetFieldDefsUses(ws, reachableModules, dataType, cursorKind.fieldType, cursorName);
+            <ds, us, _> = rascalGetFieldDefsUses(ws, reachableModules, dataType, cursorKind.fieldType, cursorName);
             defs += ds;
             uses += us;
         }

From 9e67aee41b8689837cae1d102c8d58208bf65fc3 Mon Sep 17 00:00:00 2001
From: Toine Hartman <toine.hartman@swat.engineering>
Date: Thu, 17 Oct 2024 14:54:41 +0200
Subject: [PATCH 03/16] Implement user-confirmed rename of fields in
 has-expression.

---
 .../lang/rascal/lsp/refactor/Rename.rsc       |  41 ++++---
 .../rascal/lsp/refactor/WorkspaceInfo.rsc     | 110 +++++++++++-------
 .../lang/rascal/tests/rename/Grammars.rsc     |   5 +-
 3 files changed, 92 insertions(+), 64 deletions(-)

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 76fb4d8ca..19aa3e164 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
@@ -192,7 +192,7 @@ private set[IllegalRenameReason] rascalCollectIllegalRenames(WorkspaceInfo ws, s
 private 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 set[loc] rascalFindNamesInUseDefs(start[Module] m, set[loc] useDefs) {
+private map[loc, loc] rascalFindNamesInUseDefs(start[Module] m, set[loc] useDefs) {
     map[loc, loc] useDefNameAt = ();
     useDefsToDo = useDefs;
     visit(m.top) {
@@ -208,7 +208,7 @@ private set[loc] rascalFindNamesInUseDefs(start[Module] m, set[loc] useDefs) {
         throw unsupportedRename("Rename unsupported", issues={<l, "Cannot find the name for this definition in <m.src.top>."> | l <- useDefsToDo});
     }
 
-    return range(useDefNameAt);
+    return useDefNameAt;
 }
 
 Maybe[loc] rascalLocationOfName(Name n) = just(n.src);
@@ -229,17 +229,21 @@ 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(WorkspaceInfo ws, start[Module] m, set[loc] defs, set[loc] uses, str name) {
-    if (reasons := rascalCollectIllegalRenames(ws, m, defs, uses, name), reasons != {}) {
+private tuple[set[IllegalRenameReason] reasons, list[TextEdit] edits] computeTextEdits(WorkspaceInfo ws, start[Module] m, set[RenameLocation] defs, set[RenameLocation] uses, str name, ChangeAnnotationRegister registerChangeAnnotation) {
+    if (reasons := rascalCollectIllegalRenames(ws, m, toLocs(defs), toLocs(uses), name), reasons != {}) {
         return <reasons, []>;
     }
 
     replaceName = rascalEscapeName(name);
-    return <{}, [replace(l, replaceName) | l <- rascalFindNamesInUseDefs(m, defs + uses)]>;
+    map[loc, loc] namesAt = rascalFindNamesInUseDefs(m, {ud.l | ud <- defs + uses});
+    return <{}, [r.annotation is nothing
+                 ? replace(namesAt[r.l], replaceName)
+                 : replace(namesAt[r.l], replaceName, r.annotation.val)
+                 | r <- defs + uses]>;
 }
 
-private tuple[set[IllegalRenameReason] reasons, list[TextEdit] edits] computeTextEdits(WorkspaceInfo ws, loc moduleLoc, set[loc] defs, set[loc] uses, str name) =
-    computeTextEdits(ws, parseModuleWithSpacesCached(moduleLoc), defs, uses, name);
+private tuple[set[IllegalRenameReason] reasons, list[TextEdit] edits] computeTextEdits(WorkspaceInfo ws, loc moduleLoc, set[RenameLocation] defs, set[RenameLocation] uses, str name, ChangeAnnotationRegister registerChangeAnnotation) =
+    computeTextEdits(ws, parseModuleWithSpacesCached(moduleLoc), defs, uses, name, registerChangeAnnotation);
 
 private bool rascalIsFunctionLocalDefs(WorkspaceInfo ws, set[loc] defs) {
     for (d <- defs) {
@@ -570,17 +574,9 @@ Edits rascalRenameSymbol(Tree cursorT, set[loc] workspaceFolders, str newName, P
     }
 
     step("collecting uses of \'<cursorName>\'", 1);
-    <defs, uses, getRenames> = rascalGetDefsUses(ws, cur, rascalMayOverloadSameName);
-
-    rel[loc file, loc defines] defsPerFile = {<d.top, d> | d <- defs};
-    rel[loc file, loc uses] usesPerFile = {<u.top, u> | u <- uses};
-
-    set[loc] \files = defsPerFile.file + usesPerFile.file;
-
-    step("checking rename validity", 1);
 
     map[ChangeAnnotationId, ChangeAnnotation] changeAnnotations = ();
-    ChangeAnnotationId registerChangeAnnotation(str label, str description, bool needsConfirmation) {
+    ChangeAnnotationRegister registerChangeAnnotation = ChangeAnnotationId(str label, str description, bool needsConfirmation) {
         ChangeAnnotationId makeKey(str label, int suffix) = "<label>_<suffix>";
 
         int suffix = 1;
@@ -592,10 +588,19 @@ Edits rascalRenameSymbol(Tree cursorT, set[loc] workspaceFolders, str newName, P
         changeAnnotations[id] = changeAnnotation(label, description, needsConfirmation);
 
         return id;
-    }
+    };
+
+    <defs, uses, getRenames> = rascalGetDefsUses(ws, cur, rascalMayOverloadSameName, registerChangeAnnotation);
+
+    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));
+        (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});
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 3b4f3dbe8..28c09fbbf 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
@@ -39,11 +39,13 @@ 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 List;
 import Location;
 import Map;
+import ParseTree;
 import Set;
 import String;
 
@@ -66,7 +68,8 @@ data Cursor
 
 alias MayOverloadFun = bool(set[loc] defs, map[loc, Define] defines);
 alias FileRenamesF = rel[loc old, loc new](str newName);
-alias DefsUsesRenames = tuple[set[loc] defs, set[loc] uses, FileRenamesF renames];
+data RenameLocation = rl(loc l, Maybe[ChangeAnnotationId] annotation = nothing());
+alias DefsUsesRenames = tuple[set[RenameLocation] defs, set[RenameLocation] uses, FileRenamesF renames];
 alias ProjectFiles = rel[loc projectFolder, loc file, bool loadModel];
 
 /**
@@ -91,6 +94,9 @@ data WorkspaceInfo (
     set[TModel](ProjectFiles) tmodelsForLocs
 );
 
+set[loc] toLocs(set[RenameLocation] rls) = {r.l | RenameLocation r <- rls};
+set[RenameLocation] fromLocs(set[loc] locs) = {rl(l) | l <- locs};
+
 WorkspaceInfo loadLocs(WorkspaceInfo ws, ProjectFiles projectFiles) {
     for (tm <- ws.tmodelsForLocs(projectFiles)) {
         ws = loadTModel(ws, tm);
@@ -199,9 +205,8 @@ set[Define] rascalReachableDefs(WorkspaceInfo ws, set[loc] defs) {
          (scopes                                                // All scopes surrounding defs
         o modulePaths                                           // Transitive-reflexive paths from scope to reachable modules
         ) + (                                                   // In ADT and syntax definitions, search inwards to find field scopes
-          (ws.defines<idRole, scope, defined>)[dataId()]
-        + (ws.defines<idRole, scope, defined>)[nonterminalId()]
-        + (ws.defines<idRole, scope, defined>)[lexicalId()]
+            (ws.defines<idRole, scope, defined>)[{dataId(), nonterminalId(), lexicalId()}]
+          + ws.defines<scope, scope>
         )
       )
       o ws.defines<scope, defined>                              // Definitions in these scopes
@@ -310,6 +315,11 @@ bool rascalIsCollectionType(AType at) = at is arel || at is alrel || at is atupl
 bool rascalIsConstructorType(AType at) = at is acons;
 bool rascalIsDataType(AType at) = at is aadt;
 
+bool rascalIsDataTypeLike(dataId()) = true;
+bool rascalIsDataTypeLike(nonterminalId()) = true;
+bool rascalIsDataTypeLike(lexicalId()) = true;
+default bool rascalIsDataTypeLike(IdRole _) = false;
+
 bool rascalMayOverloadSameName(set[loc] defs, map[loc, Define] definitions) {
     if (l <- defs, !definitions[l]?) return false;
     set[Define] defines = {definitions[d] | d <- defs};
@@ -322,11 +332,6 @@ bool rascalMayOverloadSameName(set[loc] defs, map[loc, Define] definitions) {
 }
 
 set[Define] rascalGetADTDefinitions(WorkspaceInfo ws, loc lhs) {
-    bool isDataTypeLike(dataId()) = true;
-    bool isDataTypeLike(nonterminalId()) = true;
-    bool isDataTypeLike(lexicalId()) = true;
-    default bool isDataTypeLike(IdRole _) = false;
-
     set[loc] fromDefs = (ws.definitions[lhs]? || lhs in ws.useDef<1>)
         ? {lhs}
         : getDefs(ws, lhs)
@@ -339,13 +344,13 @@ set[Define] rascalGetADTDefinitions(WorkspaceInfo ws, loc lhs) {
                 , Define cons: <_, _, _, constructorId(), _, _> := ws.definitions[cD]
                 , AType consAdtType := cons.defInfo.atype.adt
                 , Define adt: <_, _, _, _, _, defType(consAdtType)> <- rascalReachableDefs(ws, {cons.defined})
-                , isDataTypeLike(adt.idRole)
+                , rascalIsDataTypeLike(adt.idRole)
             };
         } else if (rascalIsDataType(lhsType)) {
             return {adt
                 | set[loc] overloads := rascalGetOverloadedDefs(ws, fromDefs, rascalMayOverloadSameName)
                 , Define adt: <_, _, _, _, _, defType(lhsType)> <- rascalReachableDefs(ws, overloads)
-                , isDataTypeLike(adt.idRole)
+                , rascalIsDataTypeLike(adt.idRole)
             };
         }
     }
@@ -390,13 +395,14 @@ set[loc] rascalGetKeywordArgs(\default(_, {KeywordArgument[Pattern] ","}+ keywor
     | kwArg <- keywordArgs
     , "<kwArg.name>" == cursorName};
 
-set[loc] rascalGetKeywordFieldUses(WorkspaceInfo ws, set[loc] defs, str cursorName) {
-    set[loc] uses = getUses(ws, defs);
+set[RenameLocation] rascalGetKeywordFieldUses(WorkspaceInfo ws, set[loc] defs, str cursorName) {
+    set[RenameLocation] uses = fromLocs(getUses(ws, defs));
 
     set[Define] reachableDefs = rascalReachableDefs(ws, defs);
 
     for (d <- defs
-       , Define dataDef: <_, _, _, dataId(), _, _> <- reachableDefs
+       , Define dataDef <- reachableDefs
+       , rascalIsDataTypeLike(dataDef.idRole)
        , isStrictlyContainedIn(d, dataDef.defined)
        , Define consDef: <_, _, _, constructorId(), _, _> <- reachableDefs
        , isStrictlyContainedIn(consDef.defined, dataDef.defined)
@@ -441,52 +447,53 @@ private set[loc] rascalGetExceptUses(WorkspaceInfo ws, set[loc] defs) {
     return uses;
 }
 
-DefsUsesRenames rascalGetDefsUses(WorkspaceInfo ws, cursor(use(), l, cursorName), MayOverloadFun mayOverloadF) {
-    defs = rascalGetOverloadedDefs(ws, getDefs(ws, l), mayOverloadF);
-    uses = getUses(ws, defs);
+DefsUsesRenames rascalGetDefsUses(WorkspaceInfo ws, cursor(use(), l, cursorName), MayOverloadFun mayOverloadF, ChangeAnnotationRegister _) {
+    set[loc] defs = rascalGetOverloadedDefs(ws, getDefs(ws, l), mayOverloadF);
+    set[RenameLocation] uses = fromLocs(getUses(ws, defs));
 
     set[IdRole] roles = {ws.definitions[d].idRole | d <- defs};
     if (keywordFormalId() in roles) {
-        uses += rascalGetKeywordFormalUses(ws, defs, cursorName);
+        uses += fromLocs(rascalGetKeywordFormalUses(ws, defs, cursorName));
         uses += rascalGetKeywordFieldUses(ws, defs, cursorName);
     } else if (constructorId() in roles) {
         uses += rascalGetExceptUses(ws, defs);
     }
 
-    return <defs, uses, NO_RENAMES>;
+    return <fromLocs(defs), uses, NO_RENAMES>;
 }
 
-DefsUsesRenames rascalGetDefsUses(WorkspaceInfo ws, cursor(def(), l, cursorName), MayOverloadFun mayOverloadF) {
+DefsUsesRenames rascalGetDefsUses(WorkspaceInfo ws, cursor(def(), l, cursorName), MayOverloadFun mayOverloadF, ChangeAnnotationRegister registerChangeAnnotation) {
     set[loc] initialUses = getUses(ws, l);
     set[loc] initialDefs = {l} + {*ds | u <- initialUses, ds := getDefs(ws, u)};
-    defs = rascalGetOverloadedDefs(ws, initialDefs, mayOverloadF);
-    uses = getUses(ws, defs);
+    set[loc] defs = rascalGetOverloadedDefs(ws, initialDefs, mayOverloadF);
+    set[RenameLocation] uses = fromLocs(getUses(ws, defs));
 
     set[IdRole] roles = {ws.definitions[d].idRole | d <- defs};
-    if (keywordFormalId() in roles) {
-        uses += rascalGetKeywordFormalUses(ws, defs, cursorName);
+    if (roles & {keywordFormalId(), fieldId()} != {}) {
+        uses += fromLocs(rascalGetKeywordFormalUses(ws, defs, cursorName));
         uses += rascalGetKeywordFieldUses(ws, defs, cursorName);
+        uses += rascalGetHasUses(ws, defs, cursorName, registerChangeAnnotation);
     } else if (constructorId() in roles) {
-        uses += rascalGetExceptUses(ws, defs);
+        uses += fromLocs(rascalGetExceptUses(ws, defs));
     }
 
-    return <defs, uses, NO_RENAMES>;
+    return <fromLocs(defs), uses, NO_RENAMES>;
 }
 
-DefsUsesRenames rascalGetDefsUses(WorkspaceInfo ws, cursor(exceptConstructor(), l, cursorName), MayOverloadFun mayOverloadF) {
+DefsUsesRenames rascalGetDefsUses(WorkspaceInfo ws, cursor(exceptConstructor(), l, cursorName), MayOverloadFun mayOverloadF, ChangeAnnotationRegister registerChangeAnnotation) {
     if (f <- ws.facts
        , isContainedIn(l, f)
        , aprod(prod(_, [*_, conditional(AType nontermType, /\a-except(cursorName)) ,*_])) := ws.facts[f]
        , Define currentCons:<_, _, _, constructorId(), _, _> <- ws.defines
        , isContainedIn(currentCons.defined, f)
        , Define exceptCons:<_, cursorName, _, constructorId(), _, defType(acons(nontermType, _, _))> <- rascalReachableDefs(ws, {currentCons.defined})) {
-        return rascalGetDefsUses(ws, cursor(def(), exceptCons.defined, cursorName), mayOverloadF);
+        return rascalGetDefsUses(ws, cursor(def(), exceptCons.defined, cursorName), mayOverloadF, registerChangeAnnotation);
     }
 
     return <{}, {}, NO_RENAMES>;
 }
 
-DefsUsesRenames rascalGetDefsUses(WorkspaceInfo ws, cursor(typeParam(), cursorLoc, cursorName), MayOverloadFun _) {
+DefsUsesRenames rascalGetDefsUses(WorkspaceInfo ws, cursor(typeParam(), cursorLoc, cursorName), MayOverloadFun _, ChangeAnnotationRegister _) {
     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 == ""};
@@ -531,10 +538,20 @@ DefsUsesRenames rascalGetDefsUses(WorkspaceInfo ws, cursor(typeParam(), cursorLo
         };
     }
 
-    return <defs, useDefs - defs, NO_RENAMES>;
+    return <fromLocs(defs), fromLocs(useDefs - defs), NO_RENAMES>;
 }
 
-DefsUsesRenames rascalGetDefsUses(WorkspaceInfo ws, cursor(dataField(loc adtLoc, AType fieldType), cursorLoc, cursorName), MayOverloadFun mayOverloadF) {
+set[RenameLocation] rascalGetHasUses(WorkspaceInfo ws, set[loc] defs, str cursorName, ChangeAnnotationRegister registerChangeAnnotation) {
+    return {
+        rl(name.src, annotation = just(registerChangeAnnotation("dynamic field name", "", true)))
+        | loc l <- rascalReachableModules(ws, defs)
+        , start[Module] m := parseModuleWithSpacesCached(l)
+        , /(Expression) `<Expression _> has <Name name>` := m
+        , "<name>" == cursorName
+    };
+}
+
+DefsUsesRenames rascalGetDefsUses(WorkspaceInfo ws, cursor(dataField(loc adtLoc, AType fieldType), cursorLoc, cursorName), MayOverloadFun mayOverloadF, ChangeAnnotationRegister registerChangeAnnotation) {
     set[loc] initialDefs = {};
     if (cursorLoc in ws.useDef<0>) {
         initialDefs = getDefs(ws, cursorLoc);
@@ -543,27 +560,29 @@ DefsUsesRenames rascalGetDefsUses(WorkspaceInfo ws, cursor(dataField(loc adtLoc,
     } else if (just(AType adtType) := getFact(ws, adtLoc)) {
         set[Define] reachableDefs = rascalReachableDefs(ws, {adtLoc});
         initialDefs = {
-            kwDef.defined
-            | Define dataDef: <_, _, _, dataId(), _, defType(adtType)> <- rascalGetADTDefinitions(ws, cursorLoc)
-            , Define kwDef: <_, _, cursorName, keywordFormalId(), _, _> <- reachableDefs
-            , isStrictlyContainedIn(kwDef.defined, dataDef.defined)
+            fieldDef.defined
+            | Define dataDef: <_, _, _, _, _, defType(adtType)> <- rascalGetADTDefinitions(ws, adtLoc)
+            , Define fieldDef: <_, _, cursorName, _, _, _> <- reachableDefs
+            , fieldDef.idRole in {keywordFormalId(), fieldId()}
+            , isStrictlyContainedIn(fieldDef.defined, dataDef.defined)
         };
     } else {
         throw unsupportedRename("Cannot rename data field \'<cursorName>\' from <cursorLoc>");
     }
 
     set[loc] defs = rascalGetOverloadedDefs(ws, initialDefs, mayOverloadF);
-    set[loc] uses = getUses(ws, defs) + rascalGetKeywordFieldUses(ws, defs, cursorName);
+    set[RenameLocation] uses = fromLocs(getUses(ws, defs)) + rascalGetKeywordFieldUses(ws, defs, cursorName);
+    set[RenameLocation] hasUses = rascalGetHasUses(ws, defs, cursorName, registerChangeAnnotation);
 
-    return <defs, uses, NO_RENAMES>;
+    return <fromLocs(defs), uses + hasUses, NO_RENAMES>;
 }
 
 bool debug = false;
 
-DefsUsesRenames rascalGetDefsUses(WorkspaceInfo ws, cursor(cursorKind, cursorLoc, cursorName), MayOverloadFun mayOverloadF) {
+DefsUsesRenames rascalGetDefsUses(WorkspaceInfo ws, cursor(cursorKind, cursorLoc, cursorName), MayOverloadFun mayOverloadF, ChangeAnnotationRegister _) {
     if (cursorKind is dataKeywordField || cursorKind is dataCommonKeywordField) {
-        set[loc] defs = {};
-        set[loc] uses = {};
+        set[RenameLocation] defs = {};
+        set[RenameLocation] uses = {};
 
         set[loc] adtDefs = rascalGetOverloadedDefs(ws, {cursorKind.dataTypeDef}, mayOverloadF);
         set[Define] reachableDefs = rascalReachableDefs(ws, adtDefs);
@@ -587,7 +606,7 @@ DefsUsesRenames rascalGetDefsUses(WorkspaceInfo ws, cursor(cursorKind, cursorLoc
     fail;
 }
 
-DefsUsesRenames rascalGetDefsUses(WorkspaceInfo ws, cursor(collectionField(), cursorLoc, cursorName), MayOverloadFun _) {
+DefsUsesRenames rascalGetDefsUses(WorkspaceInfo ws, cursor(collectionField(), cursorLoc, cursorName), MayOverloadFun _, ChangeAnnotationRegister _) {
     bool isTupleField(AType fieldType) = fieldType.alabel == "";
 
     lrel[loc, AType] factsBySize = sort(toRel(ws.facts), isShorterTuple);
@@ -637,6 +656,9 @@ Maybe[tuple[loc, set[loc], bool]] rascalGetFieldLocs(str fieldName, (Expression)
 Maybe[tuple[loc, set[loc], bool]] rascalGetFieldLocs(str fieldName, (Expression) `<Expression e>[<Name field> = <Expression _>]`) =
     just(<e.src, {field.src}, false>) when fieldName == "<field>";
 
+Maybe[tuple[loc, set[loc], bool]] rascalGetFieldLocs(str fieldName, (Expression) `<Expression e> has <Name field>`) =
+    just(<e.src, {field.src}, false>) when fieldName == "<field>";
+
 Maybe[tuple[loc, set[loc], bool]] rascalGetFieldLocs(str fieldName, (StructuredType) `<BasicType tp>[<{TypeArg ","}+ args>]`) {
     fieldLocs = {name.src | (TypeArg) `<Type _> <Name name>` <- args, fieldName == "<name>"};
     return fieldLocs != {} ? just(<tp.src, fieldLocs, true>) : nothing();
@@ -686,10 +708,10 @@ private DefsUsesRenames rascalGetFieldDefsUses(WorkspaceInfo ws, set[loc] reacha
         }
     }
 
-    return <defs, uses, NO_RENAMES>;
+    return <fromLocs(defs), fromLocs(uses), NO_RENAMES>;
 }
 
-DefsUsesRenames rascalGetDefsUses(WorkspaceInfo ws, cursor(moduleName(), cursorLoc, cursorName), MayOverloadFun _) {
+DefsUsesRenames rascalGetDefsUses(WorkspaceInfo ws, cursor(moduleName(), cursorLoc, cursorName), MayOverloadFun _, ChangeAnnotationRegister registerChangeAnnotation) {
     loc moduleFile = |unknown:///|;
     if (d <- ws.useDef[cursorLoc], amodule(_) := ws.facts[d]) {
         // Cursor is at an import
@@ -728,5 +750,5 @@ DefsUsesRenames rascalGetDefsUses(WorkspaceInfo ws, cursor(moduleName(), cursorL
 
     rel[loc, loc] getRenames(str newName) = {<file, file[file = "<newName>.rsc"]> | d <- defs, file := d.top};
 
-    return <defs, uses, getRenames>;
+    return <fromLocs(defs), fromLocs(uses), getRenames>;
 }
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 6823b4c12..d21b8c026 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
@@ -116,9 +116,10 @@ test bool exceptedDuplicateConstructorAtStart() = testRenameOccurrences({0, 1},
     'syntax T = foo: \"Tfoo\";
 ");
 
-test bool syntaxConstructorField() = testRenameOccurrences({0, 1}, "
+test bool syntaxConstructorField() = testRenameOccurrences({0, 1, 2}, "
     'S getChild(S x) = x.foo;
-", decls = "syntax S = S foo;");
+    'bool h(S x) = x has foo;
+", decls = "syntax S = s: S foo;");
 
 test bool referencedConstructor() = testRenameOccurrences({0, 1}, "", decls = "
     'lexical L = \"l\"+;

From 2bef0bce8ff53fa333d6664e5d8c61c5e3e2ffb1 Mon Sep 17 00:00:00 2001
From: Toine Hartman <toine.hartman@swat.engineering>
Date: Tue, 29 Oct 2024 14:02:38 +0100
Subject: [PATCH 04/16] Add use of `has` to data field tests.

---
 .../lang/rascal/tests/rename/Fields.rsc       | 28 +++++++++++++------
 .../lang/rascal/tests/rename/Grammars.rsc     |  8 ++++++
 2 files changed, 28 insertions(+), 8 deletions(-)

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 9cbe05dce..eff44aefc 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
@@ -29,27 +29,31 @@ module lang::rascal::tests::rename::Fields
 import lang::rascal::tests::rename::TestUtils;
 import lang::rascal::lsp::refactor::Exception;
 
-test bool constructorField() = testRenameOccurrences({0, 1}, "
+test bool constructorField() = testRenameOccurrences({0, 1, 2}, "
     'D oneTwo = d(1, 2);
     'x = oneTwo.foo;
+    'b = oneTwo has foo;
     ", decls = "data D = d(int foo, int baz);"
 );
 
-test bool constructorKeywordField() = testRenameOccurrences({0, 1, 2}, "
+test bool constructorKeywordField() = testRenameOccurrences({0, 1, 2, 3}, "
     'D dd = d(foo=1, baz=2);
     'x = dd.foo;
+    'b = dd has foo;
     ", decls="data D = d(int foo = 0, int baz = 0);"
 );
 
-test bool commonKeywordField() = testRenameOccurrences({0, 1, 2}, "
+test bool commonKeywordField() = testRenameOccurrences({0, 1, 2, 3}, "
     'D oneTwo = d(foo=1, baz=2);
     'x = oneTwo.foo;
+    'b = oneTwo has foo;
     ", decls = "data D(int foo = 0, int baz = 0) = d();"
 );
 
-test bool multipleConstructorField() = testRenameOccurrences({0, 1, 2}, "
+test bool multipleConstructorField() = testRenameOccurrences({0, 1, 2, 3}, "
     'x = d(1, 2);
     'y = x.foo;
+    'b = x has foo;
     ", decls = "data D = d(int foo) | d(int foo, int baz);"
 );
 
@@ -79,21 +83,28 @@ test bool commonKeywordFieldsSameType() = testRenameOccurrences({0, 1},
     decls = "data D (set[loc] foo = {}, set[loc] baz = {})= d();"
 );
 
-test bool sameNameFields() = testRenameOccurrences({0, 2}, "
+test bool sameNameFields() = testRenameOccurrences({0, 2, 3}, "
     'D x = d(8);
     'int i = x.foo;
+    'bool b = x has foo;
 ", decls = "
     'data D = d(int foo);
     'data E = e(int foo);
 ");
 
 test bool sameNameADTFields() = testRenameOccurrences({
-    byText("Definer", "data D = d(int foo);", {0})
+    byText("Definer", "
+        'data D = d(int foo);
+        'bool hasFoo(D dd) = dd has foo;
+        ", {0, 1})
   , byText("Unrelated", "data D = d(int foo);", {})
 });
 
 test bool sameNameFieldsDisconnectedModules() = testRenameOccurrences({
-    byText("A", "data D = d(int foo);", {0})
+    byText("A", "
+        'data D = d(int foo);
+        'bool hasFoo(D dd) = dd has foo;
+        ", {0, 1})
   , byText("B", "data E = e(int foo);", {})
 });
 
@@ -145,7 +156,8 @@ test bool extendedConstructorField() = testRenameOccurrences({
     byText("Scratch2", "
         'extend Scratch1;
         'data Foo = g(int foo);
-        ", {0})
+        'bool hasFoo(Foo ff) = ff has foo;
+        ", {0, 1})
 });
 
 test bool dataTypeReusedName() = testRenameOccurrences({
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 d21b8c026..ead403554 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
@@ -121,6 +121,14 @@ test bool syntaxConstructorField() = testRenameOccurrences({0, 1, 2}, "
     'bool h(S x) = x has foo;
 ", decls = "syntax S = s: S foo;");
 
+test bool hasConstructorFields() = testRenameOccurrences({0, 2}, "
+    D x = d(8);
+    bool b = x has foo;
+", decls = "
+    'data D = d(int foo);
+    'data E = e(int foo);
+");
+
 test bool referencedConstructor() = testRenameOccurrences({0, 1}, "", decls = "
     'lexical L = \"l\"+;
     'syntax S = foo: L l;

From 2a1ec505b4c4f4bc62d28dc5115a0e0fe1c31cea Mon Sep 17 00:00:00 2001
From: Toine Hartman <toine.hartman@swat.engineering>
Date: Wed, 30 Oct 2024 11:46:06 +0100
Subject: [PATCH 05/16] Add license to new file.

---
 .../lang/rascal/lsp/refactor/TextEdits.rsc    | 26 +++++++++++++++++++
 1 file changed, 26 insertions(+)

diff --git a/rascal-lsp/src/main/rascal/lang/rascal/lsp/refactor/TextEdits.rsc b/rascal-lsp/src/main/rascal/lang/rascal/lsp/refactor/TextEdits.rsc
index 7d2eb01af..7ec0eab60 100644
--- a/rascal-lsp/src/main/rascal/lang/rascal/lsp/refactor/TextEdits.rsc
+++ b/rascal-lsp/src/main/rascal/lang/rascal/lsp/refactor/TextEdits.rsc
@@ -1,3 +1,29 @@
+@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.
+}
 module lang::rascal::lsp::refactor::TextEdits
 
 extend analysis::diff::edits::TextEdits;

From 318a614d023254e2a78f8b1ca3b84fb5927c07ed Mon Sep 17 00:00:00 2001
From: Toine Hartman <toine.hartman@swat.engineering>
Date: Wed, 30 Oct 2024 13:41:28 +0100
Subject: [PATCH 06/16] Fix Rascal->Java translation of change annotations.

---
 .../vscode/lsp/rascal/RascalLanguageServices.java      |  7 ++++---
 .../vscode/lsp/rascal/RascalTextDocumentService.java   |  4 +---
 .../org/rascalmpl/vscode/lsp/util/DocumentChanges.java | 10 ++++++----
 3 files changed, 11 insertions(+), 10 deletions(-)

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 eed62f975..b0d4723ac 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
@@ -68,6 +68,7 @@
 import io.usethesource.vallang.ISet;
 import io.usethesource.vallang.ISourceLocation;
 import io.usethesource.vallang.IString;
+import io.usethesource.vallang.ITuple;
 import io.usethesource.vallang.IValue;
 import io.usethesource.vallang.IValueFactory;
 import io.usethesource.vallang.type.Type;
@@ -193,7 +194,7 @@ public InterruptibleFuture<IList> getDocumentSymbols(IConstructor module) {
     }
 
 
-    public InterruptibleFuture<IList> getRename(ITree module, Position cursor, Set<ISourceLocation> workspaceFolders, Function<ISourceLocation, PathConfig> getPathConfig, String newName, ColumnMaps columns) {
+    public InterruptibleFuture<ITuple> getRename(ITree module, Position cursor, Set<ISourceLocation> workspaceFolders, Function<ISourceLocation, PathConfig> getPathConfig, String newName, ColumnMaps columns) {
         var line = cursor.getLine() + 1;
         var moduleLocation = TreeAdapter.getLocation(module);
         var translatedOffset = columns.get(moduleLocation).translateInverseColumn(line, cursor.getCharacter(), false);
@@ -202,7 +203,7 @@ public InterruptibleFuture<IList> getRename(ITree module, Position cursor, Set<I
         return runEvaluator("Rascal rename", semanticEvaluator, eval -> {
             try {
                 IFunction rascalGetPathConfig = eval.getFunctionValueFactory().function(getPathConfigType, (t, u) -> addResources(getPathConfig.apply((ISourceLocation) t[0])));
-                return (IList) eval.call("rascalRenameSymbol", cursorTree, VF.set(workspaceFolders.toArray(ISourceLocation[]::new)), VF.string(newName), rascalGetPathConfig);
+                return (ITuple) eval.call("rascalRenameSymbol", cursorTree, VF.set(workspaceFolders.toArray(ISourceLocation[]::new)), VF.string(newName), rascalGetPathConfig);
             } catch (Throw e) {
                 if (e.getException() instanceof IConstructor) {
                     var exception = (IConstructor)e.getException();
@@ -221,7 +222,7 @@ public InterruptibleFuture<IList> getRename(ITree module, Position cursor, Set<I
                 }
                 throw e;
             }
-        }, VF.list(), exec, false, client);
+        }, VF.tuple(), exec, false, client);
     }
 
 
diff --git a/rascal-lsp/src/main/java/org/rascalmpl/vscode/lsp/rascal/RascalTextDocumentService.java b/rascal-lsp/src/main/java/org/rascalmpl/vscode/lsp/rascal/RascalTextDocumentService.java
index 6eb067746..4d2d705eb 100644
--- a/rascal-lsp/src/main/java/org/rascalmpl/vscode/lsp/rascal/RascalTextDocumentService.java
+++ b/rascal-lsp/src/main/java/org/rascalmpl/vscode/lsp/rascal/RascalTextDocumentService.java
@@ -108,7 +108,6 @@
 import io.usethesource.vallang.IList;
 import io.usethesource.vallang.IMap;
 import io.usethesource.vallang.ISourceLocation;
-import io.usethesource.vallang.ITuple;
 import io.usethesource.vallang.IValue;
 
 public class RascalTextDocumentService implements IBaseTextDocumentService, LanguageClientAware {
@@ -290,8 +289,7 @@ public CompletableFuture<WorkspaceEdit> rename(RenameParams params) {
             .thenApply(Versioned::get)
             .handle((t, r) -> (t == null ? (file.getMostRecentTree().get()) : t))
             .thenCompose(tr -> rascalServices.getRename(tr, params.getPosition(), workspaceFolders, facts::getPathConfig, params.getNewName(), columns).get())
-            .thenApply(c -> {
-                ITuple t = (ITuple) c;
+            .thenApply(t -> {
                 WorkspaceEdit wsEdit = new WorkspaceEdit();
                 wsEdit.setDocumentChanges(DocumentChanges.translateDocumentChanges(this, (IList) t.get(0)));
                 wsEdit.setChangeAnnotations(DocumentChanges.translateChangeAnnotations((IMap) t.get(1)));
diff --git a/rascal-lsp/src/main/java/org/rascalmpl/vscode/lsp/util/DocumentChanges.java b/rascal-lsp/src/main/java/org/rascalmpl/vscode/lsp/util/DocumentChanges.java
index 515551f7b..30ff2f87e 100644
--- a/rascal-lsp/src/main/java/org/rascalmpl/vscode/lsp/util/DocumentChanges.java
+++ b/rascal-lsp/src/main/java/org/rascalmpl/vscode/lsp/util/DocumentChanges.java
@@ -52,6 +52,7 @@
 import io.usethesource.vallang.IMap;
 import io.usethesource.vallang.ISourceLocation;
 import io.usethesource.vallang.IString;
+import io.usethesource.vallang.ITuple;
 import io.usethesource.vallang.IValue;
 
 /**
@@ -112,14 +113,15 @@ private static String getFileURI(IConstructor edit, String label) {
 
     public static Map<String, ChangeAnnotation> translateChangeAnnotations(IMap annos) {
         return annos.stream()
-            .map(id -> (IString) id)
-            .map(id -> {
-                IConstructor c = (IConstructor) annos.get(id);
+            .map(entry -> (ITuple) entry)
+            .map(entry -> {
+                String annoId = ((IString) entry.get(0)).getValue();
                 ChangeAnnotation anno = new ChangeAnnotation();
+                IConstructor c = (IConstructor) entry.get(1);
                 anno.setLabel(((IString) c.get("label")).getValue());
                 anno.setDescription(((IString) c.get("description")).getValue());
                 anno.setNeedsConfirmation(((IBool) c.get("needsConfirmation")).getValue());
-                return Map.entry(id.getValue(), anno);
+                return Map.entry(annoId, anno);
             })
             .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
     }

From 40c90a14325cfca155e81cdaeabf44f6f5f10716 Mon Sep 17 00:00:00 2001
From: Toine Hartman <toine.hartman@swat.engineering>
Date: Wed, 30 Oct 2024 15:33:30 +0100
Subject: [PATCH 07/16] Renames with annotations take precendence over forced
 ones.

---
 .../rascal/lang/rascal/lsp/refactor/Rename.rsc    | 15 ++++++++++-----
 1 file changed, 10 insertions(+), 5 deletions(-)

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 19aa3e164..6cf4f1903 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
@@ -235,11 +235,16 @@ private tuple[set[IllegalRenameReason] reasons, list[TextEdit] edits] computeTex
     }
 
     replaceName = rascalEscapeName(name);
-    map[loc, loc] namesAt = rascalFindNamesInUseDefs(m, {ud.l | ud <- defs + uses});
-    return <{}, [r.annotation is nothing
-                 ? replace(namesAt[r.l], replaceName)
-                 : replace(namesAt[r.l], replaceName, r.annotation.val)
-                 | r <- defs + uses]>;
+
+    set[RenameLocation] renames = defs + uses;
+    set[loc] renameLocs = toLocs(renames);
+    map[loc, loc] namesAt = rascalFindNamesInUseDefs(m, renameLocs);
+    rel[loc, Maybe[ChangeAnnotationId]] annosAt = {<r.l, r.annotation> | r <- renames};
+
+    return <{}, [{just(annotation), *_} := annosAt[l]
+                 ? replace(namesAt[l], replaceName, annotation)
+                 : replace(namesAt[l], replaceName)
+                 | l <- renameLocs]>;
 }
 
 private tuple[set[IllegalRenameReason] reasons, list[TextEdit] edits] computeTextEdits(WorkspaceInfo ws, loc moduleLoc, set[RenameLocation] defs, set[RenameLocation] uses, str name, ChangeAnnotationRegister registerChangeAnnotation) =

From e28c7c6d469d5e63a8ec94ea5d86d9d320dd78bf Mon Sep 17 00:00:00 2001
From: Toine Hartman <toine.hartman@swat.engineering>
Date: Thu, 31 Oct 2024 11:34:12 +0100
Subject: [PATCH 08/16] Remove unused parameter.

---
 .../src/main/rascal/lang/rascal/lsp/refactor/Rename.rsc   | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

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 6cf4f1903..8a5054fab 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
@@ -229,7 +229,7 @@ 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(WorkspaceInfo ws, start[Module] m, set[RenameLocation] defs, set[RenameLocation] uses, str name, ChangeAnnotationRegister registerChangeAnnotation) {
+private tuple[set[IllegalRenameReason] reasons, list[TextEdit] edits] computeTextEdits(WorkspaceInfo ws, start[Module] m, set[RenameLocation] defs, set[RenameLocation] uses, str name) {
     if (reasons := rascalCollectIllegalRenames(ws, m, toLocs(defs), toLocs(uses), name), reasons != {}) {
         return <reasons, []>;
     }
@@ -247,8 +247,8 @@ private tuple[set[IllegalRenameReason] reasons, list[TextEdit] edits] computeTex
                  | l <- renameLocs]>;
 }
 
-private tuple[set[IllegalRenameReason] reasons, list[TextEdit] edits] computeTextEdits(WorkspaceInfo ws, loc moduleLoc, set[RenameLocation] defs, set[RenameLocation] uses, str name, ChangeAnnotationRegister registerChangeAnnotation) =
-    computeTextEdits(ws, parseModuleWithSpacesCached(moduleLoc), defs, uses, name, registerChangeAnnotation);
+private tuple[set[IllegalRenameReason] reasons, list[TextEdit] edits] computeTextEdits(WorkspaceInfo ws, loc moduleLoc, set[RenameLocation] defs, set[RenameLocation] uses, str name) =
+    computeTextEdits(ws, parseModuleWithSpacesCached(moduleLoc), defs, uses, name);
 
 private bool rascalIsFunctionLocalDefs(WorkspaceInfo ws, set[loc] defs) {
     for (d <- defs) {
@@ -605,7 +605,7 @@ Edits rascalRenameSymbol(Tree cursorT, set[loc] workspaceFolders, str newName, P
     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));
+        (file: <reasons, edits> | file <- \files, <reasons, edits> := computeTextEdits(ws, file, defsPerFile[file], usesPerFile[file], newName));
 
     if (reasons := union({moduleResults[file].reasons | file <- moduleResults}), reasons != {}) {
         list[str] reasonDescs = toList({describe(r) | r <- reasons});

From f9c659eafcb19c5a07a1a95efc9e9f6ca222ba43 Mon Sep 17 00:00:00 2001
From: Toine Hartman <toine.hartman@swat.engineering>
Date: Thu, 31 Oct 2024 11:38:18 +0100
Subject: [PATCH 09/16] Organize imports.

---
 .../vscode/lsp/rascal/RascalTextDocumentService.java         | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/rascal-lsp/src/main/java/org/rascalmpl/vscode/lsp/rascal/RascalTextDocumentService.java b/rascal-lsp/src/main/java/org/rascalmpl/vscode/lsp/rascal/RascalTextDocumentService.java
index 15b3db487..5a18c7e28 100644
--- a/rascal-lsp/src/main/java/org/rascalmpl/vscode/lsp/rascal/RascalTextDocumentService.java
+++ b/rascal-lsp/src/main/java/org/rascalmpl/vscode/lsp/rascal/RascalTextDocumentService.java
@@ -41,7 +41,6 @@
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
-import org.apache.logging.log4j.Level;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import org.checkerframework.checker.nullness.qual.MonotonicNonNull;
@@ -83,7 +82,6 @@
 import org.eclipse.lsp4j.TextDocumentSyncKind;
 import org.eclipse.lsp4j.VersionedTextDocumentIdentifier;
 import org.eclipse.lsp4j.WorkspaceEdit;
-import org.eclipse.lsp4j.jsonrpc.CompletableFutures;
 import org.eclipse.lsp4j.jsonrpc.ResponseErrorException;
 import org.eclipse.lsp4j.jsonrpc.messages.Either;
 import org.eclipse.lsp4j.jsonrpc.messages.ResponseError;
@@ -94,7 +92,6 @@
 import org.rascalmpl.library.util.PathConfig;
 import org.rascalmpl.parser.gtd.exception.ParseError;
 import org.rascalmpl.uri.URIResolverRegistry;
-import org.rascalmpl.values.IRascalValueFactory;
 import org.rascalmpl.values.parsetrees.ITree;
 import org.rascalmpl.vscode.lsp.BaseWorkspaceService;
 import org.rascalmpl.vscode.lsp.IBaseLanguageClient;
@@ -107,8 +104,8 @@
 import org.rascalmpl.vscode.lsp.util.CodeActions;
 import org.rascalmpl.vscode.lsp.util.Diagnostics;
 import org.rascalmpl.vscode.lsp.util.DocumentChanges;
-import org.rascalmpl.vscode.lsp.util.FoldingRanges;
 import org.rascalmpl.vscode.lsp.util.DocumentSymbols;
+import org.rascalmpl.vscode.lsp.util.FoldingRanges;
 import org.rascalmpl.vscode.lsp.util.SemanticTokenizer;
 import org.rascalmpl.vscode.lsp.util.Versioned;
 import org.rascalmpl.vscode.lsp.util.locations.ColumnMaps;

From ebdf1f759a76e5e661aa818cd86d94b4f81b1d46 Mon Sep 17 00:00:00 2001
From: Toine Hartman <toine.hartman@swat.engineering>
Date: Wed, 6 Nov 2024 15:20:58 +0100
Subject: [PATCH 10/16] Improved descriptions in refactor preview.

---
 .../rascal/lang/rascal/lsp/refactor/Rename.rsc   | 16 ++++++++++++++--
 .../lang/rascal/lsp/refactor/WorkspaceInfo.rsc   |  8 ++++++--
 .../lang/rascal/tests/rename/TestUtils.rsc       |  5 ++++-
 .../lang/rascal/tests/rename/ValidNames.rsc      |  5 +++--
 4 files changed, 27 insertions(+), 7 deletions(-)

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 8a5054fab..dae831c9c 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
@@ -595,10 +595,22 @@ Edits rascalRenameSymbol(Tree cursorT, set[loc] workspaceFolders, str newName, P
         return id;
     };
 
+    set[RenameLocation] registerChangeAnnotations(set[RenameLocation] locs, str label, str description = "These changes are required for a correct renaming. They can be previewed here, but it is not advised to disable them.", bool needsConfirmation = false) {
+        set[RenameLocation] modifiedLocs = {};
+        for (rl <- locs) {
+            if (nothing() := rl.annotation) {
+                modifiedLocs += rl[annotation = just(registerChangeAnnotation(label, description, needsConfirmation))];
+            } else {
+                modifiedLocs += rl;
+            }
+        }
+        return modifiedLocs;
+    }
+
     <defs, uses, getRenames> = rascalGetDefsUses(ws, cur, rascalMayOverloadSameName, registerChangeAnnotation);
 
-    rel[loc file, RenameLocation defines] defsPerFile = {<d.l.top, d> | d <- defs};
-    rel[loc file, RenameLocation uses] usesPerFile = {<u.l.top, u> | u <- uses};
+    rel[loc file, RenameLocation defines] defsPerFile = {<d.l.top, d> | d <- registerChangeAnnotations(defs, "Definitions")};
+    rel[loc file, RenameLocation uses] usesPerFile = {<u.l.top, u> | u <- registerChangeAnnotations(uses, "References")};
 
     set[loc] \files = defsPerFile.file + usesPerFile.file;
 
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 28c09fbbf..4ee511b10 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,6 +31,7 @@ import Relation;
 
 import analysis::typepal::TModel;
 
+import lang::rascalcore::check::ATypeUtils;
 import lang::rascalcore::check::Checker;
 
 import lang::rascal::\syntax::Rascal;
@@ -541,12 +542,15 @@ DefsUsesRenames rascalGetDefsUses(WorkspaceInfo ws, cursor(typeParam(), cursorLo
     return <fromLocs(defs), fromLocs(useDefs - defs), NO_RENAMES>;
 }
 
+private str describeFact(just(AType tp)) = "type \'<prettyAType(tp)>\'";
+private str describeFact(nothing()) = "unknown type";
+
 set[RenameLocation] rascalGetHasUses(WorkspaceInfo ws, set[loc] defs, str cursorName, ChangeAnnotationRegister registerChangeAnnotation) {
     return {
-        rl(name.src, annotation = just(registerChangeAnnotation("dynamic field name", "", true)))
+        rl(name.src, annotation = just(registerChangeAnnotation("Use of `has <cursorName>` on value of <describeFact(getFact(ws, e.src))>", "Due to the dynamic nature of these names, it cannot be ensured that they need to be renamed. Please review these suggested changes.", true)))
         | loc l <- rascalReachableModules(ws, defs)
         , start[Module] m := parseModuleWithSpacesCached(l)
-        , /(Expression) `<Expression _> has <Name name>` := m
+        , /(Expression) `<Expression e> has <Name name>` := m
         , "<name>" == cursorName
     };
 }
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 7baf7ebe6..910a95d69 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
@@ -64,8 +64,11 @@ private DocumentEdit sortChanges(changed(loc l, list[TextEdit] edits)) = changed
 }));
 private default DocumentEdit sortChanges(DocumentEdit e) = e;
 
+private list[DocumentEdit] stripAnnotations(list[DocumentEdit] edits) =
+    visit (edits) { case replace(range, replacement, _) => replace(range, replacement) };
+
 private void verifyTypeCorrectRenaming(loc root, Edits edits, PathConfig pcfg) {
-    executeDocumentEdits(sortEdits(edits<0>));
+    executeDocumentEdits(sortEdits(stripAnnotations(edits<0>)));
     remove(pcfg.resources);
     RascalCompilerConfig ccfg = rascalCompilerConfig(pcfg)[forceCompilationTopModule = true][verbose = false][logPathConfig = false];
     throwAnyErrors(checkAll(root, ccfg));
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 a5ef93ca1..76ab56160 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
@@ -33,8 +33,9 @@ import analysis::diff::edits::TextEdits;
 
 test bool renameToReservedName() {
     edits = getEdits("int foo = 8;", 0, "foo", "int", "", "");
-    newNames = {name | e <- edits<0>, changed(_, replaces) := e
-                     , r <- replaces, replace(_, name) := r};
+    newNames = {name | e <- edits<0>
+                     , r <- e.edits
+                     , name := r.replacement};
 
     return newNames == {"\\int"};
 }

From adfd046fd12cf8b247a66f0babe5291a52341d13 Mon Sep 17 00:00:00 2001
From: Toine Hartman <toine.hartman@swat.engineering>
Date: Wed, 6 Nov 2024 17:00:02 +0100
Subject: [PATCH 11/16] Use correctly typed default for rename evaluator call.

---
 .../org/rascalmpl/vscode/lsp/rascal/RascalLanguageServices.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

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 6926059ef..5e5271277 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
@@ -232,7 +232,7 @@ public InterruptibleFuture<ITuple> getRename(ITree module, Position cursor, Set<
                 }
                 throw e;
             }
-        }, VF.tuple(), exec, false, client);
+        }, VF.tuple(VF.list(), VF.map()), exec, false, client);
     }
 
 

From e606290b04002fbd0d91e264062691a850221bed Mon Sep 17 00:00:00 2001
From: Toine Hartman <toine.hartman@swat.engineering>
Date: Thu, 7 Nov 2024 09:41:00 +0100
Subject: [PATCH 12/16] Reword `has` annotation

---
 .../src/main/rascal/lang/rascal/lsp/refactor/WorkspaceInfo.rsc  | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

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 4ee511b10..96a1d50de 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
@@ -547,7 +547,7 @@ private str describeFact(nothing()) = "unknown type";
 
 set[RenameLocation] rascalGetHasUses(WorkspaceInfo ws, set[loc] defs, str cursorName, ChangeAnnotationRegister registerChangeAnnotation) {
     return {
-        rl(name.src, annotation = just(registerChangeAnnotation("Use of `has <cursorName>` on value of <describeFact(getFact(ws, e.src))>", "Due to the dynamic nature of these names, it cannot be ensured that they need to be renamed. Please review these suggested changes.", true)))
+        rl(name.src, annotation = just(registerChangeAnnotation("Use of `has <cursorName>` on value of <describeFact(getFact(ws, e.src))>", "Due to the dynamic nature of these names, please review these suggested changes.", true)))
         | loc l <- rascalReachableModules(ws, defs)
         , start[Module] m := parseModuleWithSpacesCached(l)
         , /(Expression) `<Expression e> has <Name name>` := m

From 75dd87c9462cb16c99db67d08e429638072459ac Mon Sep 17 00:00:00 2001
From: Toine Hartman <toine.hartman@swat.engineering>
Date: Thu, 7 Nov 2024 14:01:06 +0100
Subject: [PATCH 13/16] Fix warnings.

---
 .../main/rascal/lang/rascal/lsp/refactor/WorkspaceInfo.rsc  | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

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 96a1d50de..88dcb1065 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
@@ -434,10 +434,10 @@ private set[loc] rascalGetExceptUses(WorkspaceInfo ws, set[loc] defs) {
     for (Define d: <_, consName, _, constructorId(), _, defType(acons(aadt(_, _, _), _, _))> <- constructorDefs) {
         // Find all neighbouring pairs of facts where an except for `cursorName` exists only in the latter
         for (
-            [ _*
-            , <l1, at1: !/\a-except(consName)>
+            [ *_
+            , <_, _: !/\a-except(consName)>
             , <l2, at2:  /\a-except(consName)>
-            , _*] := sortedFacts
+            , *_] := sortedFacts
             , aprod(choice(_, _)) !:= at2
         ) {
             // There might be whitespace before (but not after) the `cursorName`, so we correct the location length

From b3aeec757f8de3e6f04eeaa5aae93361350e7719 Mon Sep 17 00:00:00 2001
From: Toine Hartman <toine.hartman@swat.engineering>
Date: Fri, 8 Nov 2024 10:19:39 +0100
Subject: [PATCH 14/16] Fix use of has triggering refactor preview.

---
 .../lang/rascal/lsp/refactor/Rename.rsc       |  2 +-
 .../rascal/lsp/refactor/WorkspaceInfo.rsc     | 22 +++++++++++--------
 2 files changed, 14 insertions(+), 10 deletions(-)

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 dae831c9c..5589e61aa 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
@@ -393,7 +393,7 @@ private Cursor rascalGetCursor(WorkspaceInfo ws, Tree cursorT) {
 
     rel[loc field, loc container] fields = {<fieldLoc, containerLoc>
         | /Tree t := parseModuleWithSpacesCached(cursorLoc.top)
-        , just(<containerLoc, fieldLocs, _>) := rascalGetFieldLocs(cursorName, t)
+        , just(<containerLoc, fieldLocs, _>) := rascalGetFieldLocs(cursorName, t) || just(<containerLoc, fieldLocs>) := rascalGetHasLocs(cursorName, t)
         , loc fieldLoc <- fieldLocs
     };
 
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 88dcb1065..86c2b1262 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
@@ -448,7 +448,7 @@ private set[loc] rascalGetExceptUses(WorkspaceInfo ws, set[loc] defs) {
     return uses;
 }
 
-DefsUsesRenames rascalGetDefsUses(WorkspaceInfo ws, cursor(use(), l, cursorName), MayOverloadFun mayOverloadF, ChangeAnnotationRegister _) {
+DefsUsesRenames rascalGetDefsUses(WorkspaceInfo ws, cursor(use(), l, cursorName), MayOverloadFun mayOverloadF, ChangeAnnotationRegister registerChangeAnnotation) {
     set[loc] defs = rascalGetOverloadedDefs(ws, getDefs(ws, l), mayOverloadF);
     set[RenameLocation] uses = fromLocs(getUses(ws, defs));
 
@@ -456,6 +456,7 @@ DefsUsesRenames rascalGetDefsUses(WorkspaceInfo ws, cursor(use(), l, cursorName)
     if (keywordFormalId() in roles) {
         uses += fromLocs(rascalGetKeywordFormalUses(ws, defs, cursorName));
         uses += rascalGetKeywordFieldUses(ws, defs, cursorName);
+        uses += rascalGetHasUses(ws, defs, cursorName, registerChangeAnnotation);
     } else if (constructorId() in roles) {
         uses += rascalGetExceptUses(ws, defs);
     }
@@ -545,13 +546,17 @@ DefsUsesRenames rascalGetDefsUses(WorkspaceInfo ws, cursor(typeParam(), cursorLo
 private str describeFact(just(AType tp)) = "type \'<prettyAType(tp)>\'";
 private str describeFact(nothing()) = "unknown type";
 
+Maybe[tuple[loc, set[loc]]] rascalGetHasLocs(str fieldName, (Expression) `<Expression e> has <Name field>`) =
+    just(<e.src, {field.src}>) when fieldName == "<field>";
+
+default Maybe[tuple[loc, set[loc]]] rascalGetHasLocs(str _, Tree _) = nothing();
+
 set[RenameLocation] rascalGetHasUses(WorkspaceInfo ws, set[loc] defs, str cursorName, ChangeAnnotationRegister registerChangeAnnotation) {
     return {
-        rl(name.src, annotation = just(registerChangeAnnotation("Use of `has <cursorName>` on value of <describeFact(getFact(ws, e.src))>", "Due to the dynamic nature of these names, please review these suggested changes.", true)))
+        rl(field, annotation = 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)
-        , start[Module] m := parseModuleWithSpacesCached(l)
-        , /(Expression) `<Expression e> has <Name name>` := m
-        , "<name>" == cursorName
+        , /Tree t := parseModuleWithSpacesCached(l)
+        , just(<lhs, {field}>) := rascalGetHasLocs(cursorName, t)
     };
 }
 
@@ -583,7 +588,7 @@ DefsUsesRenames rascalGetDefsUses(WorkspaceInfo ws, cursor(dataField(loc adtLoc,
 
 bool debug = false;
 
-DefsUsesRenames rascalGetDefsUses(WorkspaceInfo ws, cursor(cursorKind, cursorLoc, cursorName), MayOverloadFun mayOverloadF, ChangeAnnotationRegister _) {
+DefsUsesRenames rascalGetDefsUses(WorkspaceInfo ws, cursor(cursorKind, cursorLoc, cursorName), MayOverloadFun mayOverloadF, ChangeAnnotationRegister registerChangeAnnotation) {
     if (cursorKind is dataKeywordField || cursorKind is dataCommonKeywordField) {
         set[RenameLocation] defs = {};
         set[RenameLocation] uses = {};
@@ -604,6 +609,8 @@ DefsUsesRenames rascalGetDefsUses(WorkspaceInfo ws, cursor(cursorKind, cursorLoc
             uses += us;
         }
 
+        uses += rascalGetHasUses(ws, adtDefs, cursorName, registerChangeAnnotation);
+
         return <defs, uses, NO_RENAMES>;
     }
 
@@ -660,9 +667,6 @@ Maybe[tuple[loc, set[loc], bool]] rascalGetFieldLocs(str fieldName, (Expression)
 Maybe[tuple[loc, set[loc], bool]] rascalGetFieldLocs(str fieldName, (Expression) `<Expression e>[<Name field> = <Expression _>]`) =
     just(<e.src, {field.src}, false>) when fieldName == "<field>";
 
-Maybe[tuple[loc, set[loc], bool]] rascalGetFieldLocs(str fieldName, (Expression) `<Expression e> has <Name field>`) =
-    just(<e.src, {field.src}, false>) when fieldName == "<field>";
-
 Maybe[tuple[loc, set[loc], bool]] rascalGetFieldLocs(str fieldName, (StructuredType) `<BasicType tp>[<{TypeArg ","}+ args>]`) {
     fieldLocs = {name.src | (TypeArg) `<Type _> <Name name>` <- args, fieldName == "<name>"};
     return fieldLocs != {} ? just(<tp.src, fieldLocs, true>) : nothing();

From 8b7ceb13e0cacfb174ec538f2a9494019876024f Mon Sep 17 00:00:00 2001
From: Toine Hartman <toine.hartman@swat.engineering>
Date: Fri, 8 Nov 2024 10:35:19 +0100
Subject: [PATCH 15/16] Simplify TextEdit extension and use relations for
 annotation tracking.

---
 .../vscode/lsp/util/DocumentChanges.java      | 13 +++---
 .../lang/rascal/lsp/refactor/Rename.rsc       | 22 +++------
 .../lang/rascal/lsp/refactor/TextEdits.rsc    |  4 +-
 .../rascal/lsp/refactor/WorkspaceInfo.rsc     | 45 +++++++++----------
 .../lang/rascal/tests/rename/TestUtils.rsc    |  5 +--
 5 files changed, 38 insertions(+), 51 deletions(-)

diff --git a/rascal-lsp/src/main/java/org/rascalmpl/vscode/lsp/util/DocumentChanges.java b/rascal-lsp/src/main/java/org/rascalmpl/vscode/lsp/util/DocumentChanges.java
index 30ff2f87e..040ed2dcf 100644
--- a/rascal-lsp/src/main/java/org/rascalmpl/vscode/lsp/util/DocumentChanges.java
+++ b/rascal-lsp/src/main/java/org/rascalmpl/vscode/lsp/util/DocumentChanges.java
@@ -95,10 +95,13 @@ public static List<Either<TextDocumentEdit, ResourceOperation>> translateDocumen
 
     private static List<TextEdit> translateTextEdits(final IBaseTextDocumentService docService, IList edits) {
         return edits.stream()
-            .map(e -> (IConstructor) e)
-            .map(c -> (c.has("annotation")
-                ? new AnnotatedTextEdit(locationToRange(docService, (ISourceLocation) c.get("range")), ((IString) c.get("replacement")).getValue(), ((IString) c.get("annotation")).getValue())
-                : new TextEdit(locationToRange(docService, (ISourceLocation) c.get("range")), ((IString) c.get("replacement")).getValue())))
+            .map(IConstructor.class::cast)
+            .map(c -> {
+                var kw = c.asWithKeywordParameters();
+                return kw.hasParameter("annotation")
+                    ? new AnnotatedTextEdit(locationToRange(docService, (ISourceLocation) c.get("range")), ((IString) c.get("replacement")).getValue(), ((IString) kw.getParameter("annotation")).getValue())
+                    : new TextEdit(locationToRange(docService, (ISourceLocation) c.get("range")), ((IString) c.get("replacement")).getValue());
+            })
             .collect(Collectors.toList());
     }
 
@@ -113,7 +116,7 @@ private static String getFileURI(IConstructor edit, String label) {
 
     public static Map<String, ChangeAnnotation> translateChangeAnnotations(IMap annos) {
         return annos.stream()
-            .map(entry -> (ITuple) entry)
+            .map(ITuple.class::cast)
             .map(entry -> {
                 String annoId = ((IString) entry.get(0)).getValue();
                 ChangeAnnotation anno = new ChangeAnnotation();
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 5589e61aa..de178aa83 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
@@ -230,19 +230,18 @@ Maybe[loc] rascalLocationOfName(NonterminalLabel l) = just(l.src);
 default Maybe[loc] rascalLocationOfName(Tree t) = nothing();
 
 private tuple[set[IllegalRenameReason] reasons, list[TextEdit] edits] computeTextEdits(WorkspaceInfo ws, start[Module] m, set[RenameLocation] defs, set[RenameLocation] uses, str name) {
-    if (reasons := rascalCollectIllegalRenames(ws, m, toLocs(defs), toLocs(uses), name), reasons != {}) {
+    if (reasons := rascalCollectIllegalRenames(ws, m, defs.l, uses.l, name), reasons != {}) {
         return <reasons, []>;
     }
 
     replaceName = rascalEscapeName(name);
 
     set[RenameLocation] renames = defs + uses;
-    set[loc] renameLocs = toLocs(renames);
+    set[loc] renameLocs = renames.l;
     map[loc, loc] namesAt = rascalFindNamesInUseDefs(m, renameLocs);
-    rel[loc, Maybe[ChangeAnnotationId]] annosAt = {<r.l, r.annotation> | r <- renames};
 
-    return <{}, [{just(annotation), *_} := annosAt[l]
-                 ? replace(namesAt[l], replaceName, annotation)
+    return <{}, [{just(annotation), *_} := renames[l]
+                 ? replace(namesAt[l], replaceName, annotation = annotation)
                  : replace(namesAt[l], replaceName)
                  | l <- renameLocs]>;
 }
@@ -595,17 +594,8 @@ Edits rascalRenameSymbol(Tree cursorT, set[loc] workspaceFolders, str newName, P
         return id;
     };
 
-    set[RenameLocation] registerChangeAnnotations(set[RenameLocation] locs, str label, str description = "These changes are required for a correct renaming. They can be previewed here, but it is not advised to disable them.", bool needsConfirmation = false) {
-        set[RenameLocation] modifiedLocs = {};
-        for (rl <- locs) {
-            if (nothing() := rl.annotation) {
-                modifiedLocs += rl[annotation = just(registerChangeAnnotation(label, description, needsConfirmation))];
-            } else {
-                modifiedLocs += rl;
-            }
-        }
-        return modifiedLocs;
-    }
+    set[RenameLocation] registerChangeAnnotations(set[RenameLocation] locs, str label, str description = "These changes are required for a correct renaming. They can be previewed here, but it is not advised to disable them.", bool needsConfirmation = false) =
+        {<r, nothing() := maybeAnn ? just(registerChangeAnnotation(label, description, needsConfirmation)) : maybeAnn> | <r, maybeAnn> <- locs};
 
     <defs, uses, getRenames> = rascalGetDefsUses(ws, cur, rascalMayOverloadSameName, registerChangeAnnotation);
 
diff --git a/rascal-lsp/src/main/rascal/lang/rascal/lsp/refactor/TextEdits.rsc b/rascal-lsp/src/main/rascal/lang/rascal/lsp/refactor/TextEdits.rsc
index 7ec0eab60..e8d153e3c 100644
--- a/rascal-lsp/src/main/rascal/lang/rascal/lsp/refactor/TextEdits.rsc
+++ b/rascal-lsp/src/main/rascal/lang/rascal/lsp/refactor/TextEdits.rsc
@@ -34,9 +34,7 @@ data ChangeAnnotation
     = changeAnnotation(str label, str description, bool needsConfirmation)
     ;
 
-data TextEdit
-    = replace(loc range, str replacement, ChangeAnnotationId annotation)
-    ;
+data TextEdit(ChangeAnnotationId annotation = "");
 
 alias ChangeAnnotationRegister =
     ChangeAnnotationId(str label, str description, bool needsConfirmation);
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 86c2b1262..c95f07820 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
@@ -69,7 +69,7 @@ data Cursor
 
 alias MayOverloadFun = bool(set[loc] defs, map[loc, Define] defines);
 alias FileRenamesF = rel[loc old, loc new](str newName);
-data RenameLocation = rl(loc l, Maybe[ChangeAnnotationId] annotation = nothing());
+alias RenameLocation = tuple[loc l, Maybe[ChangeAnnotationId] annotation];
 alias DefsUsesRenames = tuple[set[RenameLocation] defs, set[RenameLocation] uses, FileRenamesF renames];
 alias ProjectFiles = rel[loc projectFolder, loc file, bool loadModel];
 
@@ -95,8 +95,7 @@ data WorkspaceInfo (
     set[TModel](ProjectFiles) tmodelsForLocs
 );
 
-set[loc] toLocs(set[RenameLocation] rls) = {r.l | RenameLocation r <- rls};
-set[RenameLocation] fromLocs(set[loc] locs) = {rl(l) | l <- locs};
+set[RenameLocation] annotateLocs(set[loc] locs, Maybe[ChangeAnnotationId] annotationId = nothing()) = {<l, annotationId> | l <- locs};
 
 WorkspaceInfo loadLocs(WorkspaceInfo ws, ProjectFiles projectFiles) {
     for (tm <- ws.tmodelsForLocs(projectFiles)) {
@@ -359,8 +358,8 @@ set[Define] rascalGetADTDefinitions(WorkspaceInfo ws, loc lhs) {
     return {};
 }
 
-set[loc] rascalGetKeywordFormalUses(WorkspaceInfo ws, set[loc] defs, str cursorName) {
-    set[loc] uses = {};
+set[RenameLocation] rascalGetKeywordFormalUses(WorkspaceInfo ws, set[loc] defs, str cursorName) {
+    set[RenameLocation] uses = {};
 
     for (d <- defs
        , f <- ws.facts
@@ -369,7 +368,7 @@ set[loc] rascalGetKeywordFormalUses(WorkspaceInfo ws, set[loc] defs, str cursorN
        , funcName <- getUses(ws, f)
        ) {
         loc funcCall = min({l | l <- factsInvert(ws)[retType], l.offset == funcName.offset});
-        uses += {name.src | /Name name := parseModuleWithSpacesCached(funcCall.top)
+        uses += {<name.src, nothing()> | /Name name := parseModuleWithSpacesCached(funcCall.top)
                           , isStrictlyContainedIn(name.src, funcCall)
                           , "<name>" == kwAType.alabel};
     }
@@ -397,7 +396,7 @@ set[loc] rascalGetKeywordArgs(\default(_, {KeywordArgument[Pattern] ","}+ keywor
     , "<kwArg.name>" == cursorName};
 
 set[RenameLocation] rascalGetKeywordFieldUses(WorkspaceInfo ws, set[loc] defs, str cursorName) {
-    set[RenameLocation] uses = fromLocs(getUses(ws, defs));
+    set[RenameLocation] uses = annotateLocs(getUses(ws, defs));
 
     set[Define] reachableDefs = rascalReachableDefs(ws, defs);
 
@@ -420,7 +419,7 @@ set[RenameLocation] rascalGetKeywordFieldUses(WorkspaceInfo ws, set[loc] defs, s
     return uses;
 }
 
-private set[loc] rascalGetExceptUses(WorkspaceInfo ws, set[loc] defs) {
+private set[RenameLocation] rascalGetExceptUses(WorkspaceInfo ws, set[loc] defs) {
     constructorDefs = {d | l <- defs, Define d: <_, _, _, constructorId(), _, _> := ws.definitions[l]};
     if (constructorDefs == {}) return {};
 
@@ -430,7 +429,7 @@ private set[loc] rascalGetExceptUses(WorkspaceInfo ws, set[loc] defs) {
         return l1.end != l2.end ? l1.end < l2.end : l1.length < l2.length;
     })];
 
-    set[loc] uses = {};
+    set[RenameLocation] uses = {};
     for (Define d: <_, consName, _, constructorId(), _, defType(acons(aadt(_, _, _), _, _))> <- constructorDefs) {
         // Find all neighbouring pairs of facts where an except for `cursorName` exists only in the latter
         for (
@@ -441,7 +440,7 @@ private set[loc] rascalGetExceptUses(WorkspaceInfo ws, set[loc] defs) {
             , aprod(choice(_, _)) !:= at2
         ) {
             // There might be whitespace before (but not after) the `cursorName`, so we correct the location length
-            uses += trim(l2, removePrefix = l2.length - size(consName));
+            uses += <trim(l2, removePrefix = l2.length - size(consName)), nothing()>;
         }
     }
 
@@ -450,36 +449,36 @@ private set[loc] rascalGetExceptUses(WorkspaceInfo ws, set[loc] defs) {
 
 DefsUsesRenames rascalGetDefsUses(WorkspaceInfo ws, cursor(use(), l, cursorName), MayOverloadFun mayOverloadF, ChangeAnnotationRegister registerChangeAnnotation) {
     set[loc] defs = rascalGetOverloadedDefs(ws, getDefs(ws, l), mayOverloadF);
-    set[RenameLocation] uses = fromLocs(getUses(ws, defs));
+    set[RenameLocation] uses = annotateLocs(getUses(ws, defs));
 
     set[IdRole] roles = {ws.definitions[d].idRole | d <- defs};
     if (keywordFormalId() in roles) {
-        uses += fromLocs(rascalGetKeywordFormalUses(ws, defs, cursorName));
+        uses += rascalGetKeywordFormalUses(ws, defs, cursorName);
         uses += rascalGetKeywordFieldUses(ws, defs, cursorName);
         uses += rascalGetHasUses(ws, defs, cursorName, registerChangeAnnotation);
     } else if (constructorId() in roles) {
         uses += rascalGetExceptUses(ws, defs);
     }
 
-    return <fromLocs(defs), uses, NO_RENAMES>;
+    return <annotateLocs(defs), uses, NO_RENAMES>;
 }
 
 DefsUsesRenames rascalGetDefsUses(WorkspaceInfo ws, cursor(def(), l, cursorName), MayOverloadFun mayOverloadF, ChangeAnnotationRegister registerChangeAnnotation) {
     set[loc] initialUses = getUses(ws, l);
     set[loc] initialDefs = {l} + {*ds | u <- initialUses, ds := getDefs(ws, u)};
     set[loc] defs = rascalGetOverloadedDefs(ws, initialDefs, mayOverloadF);
-    set[RenameLocation] uses = fromLocs(getUses(ws, defs));
+    set[RenameLocation] uses = annotateLocs(getUses(ws, defs));
 
     set[IdRole] roles = {ws.definitions[d].idRole | d <- defs};
     if (roles & {keywordFormalId(), fieldId()} != {}) {
-        uses += fromLocs(rascalGetKeywordFormalUses(ws, defs, cursorName));
+        uses += rascalGetKeywordFormalUses(ws, defs, cursorName);
         uses += rascalGetKeywordFieldUses(ws, defs, cursorName);
         uses += rascalGetHasUses(ws, defs, cursorName, registerChangeAnnotation);
     } else if (constructorId() in roles) {
-        uses += fromLocs(rascalGetExceptUses(ws, defs));
+        uses += rascalGetExceptUses(ws, defs);
     }
 
-    return <fromLocs(defs), uses, NO_RENAMES>;
+    return <annotateLocs(defs), uses, NO_RENAMES>;
 }
 
 DefsUsesRenames rascalGetDefsUses(WorkspaceInfo ws, cursor(exceptConstructor(), l, cursorName), MayOverloadFun mayOverloadF, ChangeAnnotationRegister registerChangeAnnotation) {
@@ -540,7 +539,7 @@ DefsUsesRenames rascalGetDefsUses(WorkspaceInfo ws, cursor(typeParam(), cursorLo
         };
     }
 
-    return <fromLocs(defs), fromLocs(useDefs - defs), NO_RENAMES>;
+    return <annotateLocs(defs), annotateLocs(useDefs - defs), NO_RENAMES>;
 }
 
 private str describeFact(just(AType tp)) = "type \'<prettyAType(tp)>\'";
@@ -553,7 +552,7 @@ default Maybe[tuple[loc, set[loc]]] rascalGetHasLocs(str _, Tree _) = nothing();
 
 set[RenameLocation] rascalGetHasUses(WorkspaceInfo ws, set[loc] defs, str cursorName, ChangeAnnotationRegister registerChangeAnnotation) {
     return {
-        rl(field, annotation = 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)))
+        <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)
         , /Tree t := parseModuleWithSpacesCached(l)
         , just(<lhs, {field}>) := rascalGetHasLocs(cursorName, t)
@@ -580,10 +579,10 @@ DefsUsesRenames rascalGetDefsUses(WorkspaceInfo ws, cursor(dataField(loc adtLoc,
     }
 
     set[loc] defs = rascalGetOverloadedDefs(ws, initialDefs, mayOverloadF);
-    set[RenameLocation] uses = fromLocs(getUses(ws, defs)) + rascalGetKeywordFieldUses(ws, defs, cursorName);
+    set[RenameLocation] uses = annotateLocs(getUses(ws, defs)) + rascalGetKeywordFieldUses(ws, defs, cursorName);
     set[RenameLocation] hasUses = rascalGetHasUses(ws, defs, cursorName, registerChangeAnnotation);
 
-    return <fromLocs(defs), uses + hasUses, NO_RENAMES>;
+    return <annotateLocs(defs), uses + hasUses, NO_RENAMES>;
 }
 
 bool debug = false;
@@ -716,7 +715,7 @@ private DefsUsesRenames rascalGetFieldDefsUses(WorkspaceInfo ws, set[loc] reacha
         }
     }
 
-    return <fromLocs(defs), fromLocs(uses), NO_RENAMES>;
+    return <annotateLocs(defs), annotateLocs(uses), NO_RENAMES>;
 }
 
 DefsUsesRenames rascalGetDefsUses(WorkspaceInfo ws, cursor(moduleName(), cursorLoc, cursorName), MayOverloadFun _, ChangeAnnotationRegister registerChangeAnnotation) {
@@ -758,5 +757,5 @@ DefsUsesRenames rascalGetDefsUses(WorkspaceInfo ws, cursor(moduleName(), cursorL
 
     rel[loc, loc] getRenames(str newName) = {<file, file[file = "<newName>.rsc"]> | d <- defs, file := d.top};
 
-    return <fromLocs(defs), fromLocs(uses), getRenames>;
+    return <annotateLocs(defs), annotateLocs(uses), getRenames>;
 }
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 910a95d69..7baf7ebe6 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
@@ -64,11 +64,8 @@ private DocumentEdit sortChanges(changed(loc l, list[TextEdit] edits)) = changed
 }));
 private default DocumentEdit sortChanges(DocumentEdit e) = e;
 
-private list[DocumentEdit] stripAnnotations(list[DocumentEdit] edits) =
-    visit (edits) { case replace(range, replacement, _) => replace(range, replacement) };
-
 private void verifyTypeCorrectRenaming(loc root, Edits edits, PathConfig pcfg) {
-    executeDocumentEdits(sortEdits(stripAnnotations(edits<0>)));
+    executeDocumentEdits(sortEdits(edits<0>));
     remove(pcfg.resources);
     RascalCompilerConfig ccfg = rascalCompilerConfig(pcfg)[forceCompilationTopModule = true][verbose = false][logPathConfig = false];
     throwAnyErrors(checkAll(root, ccfg));

From ce74879d2d38a83b681a5cca13ce1ec39f18a2cf Mon Sep 17 00:00:00 2001
From: Toine Hartman <toine.hartman@swat.engineering>
Date: Fri, 8 Nov 2024 13:57:06 +0100
Subject: [PATCH 16/16] Remove name wildcard.

---
 .../src/main/rascal/lang/rascal/lsp/refactor/WorkspaceInfo.rsc  | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

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 c95f07820..dd305717e 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
@@ -434,7 +434,7 @@ private set[RenameLocation] rascalGetExceptUses(WorkspaceInfo ws, set[loc] defs)
         // Find all neighbouring pairs of facts where an except for `cursorName` exists only in the latter
         for (
             [ *_
-            , <_, _: !/\a-except(consName)>
+            , <_, !/\a-except(consName)>
             , <l2, at2:  /\a-except(consName)>
             , *_] := sortedFacts
             , aprod(choice(_, _)) !:= at2