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 f80d26194..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
@@ -72,6 +72,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.exceptions.FactTypeUseException;
@@ -204,7 +205,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 moduleLocation = TreeAdapter.getLocation(module);
         Position pos = Locations.toRascalPosition(moduleLocation, cursor, columns);
         var cursorTree = TreeAdapter.locateLexical(module, pos.getLine(), pos.getCharacter());
@@ -212,7 +213,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();
@@ -231,7 +232,7 @@ public InterruptibleFuture<IList> getRename(ITree module, Position cursor, Set<I
                 }
                 throw e;
             }
-        }, VF.list(), exec, false, client);
+        }, VF.tuple(VF.list(), VF.map()), 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 000dfc0fa..14e4eb71a 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;
@@ -117,6 +114,7 @@
 import org.rascalmpl.vscode.lsp.util.locations.impl.TreeSearch;
 
 import io.usethesource.vallang.IList;
+import io.usethesource.vallang.IMap;
 import io.usethesource.vallang.ISourceLocation;
 import io.usethesource.vallang.IValue;
 
@@ -301,8 +299,12 @@ 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(t -> {
+                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..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
@@ -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,10 +46,13 @@
 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.ITuple;
 import io.usethesource.vallang.IValue;
 
 /**
@@ -89,8 +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 -> 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());
     }
 
@@ -102,4 +113,19 @@ 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(ITuple.class::cast)
+            .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(annoId, 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 d40dc2859..aa0205eea 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) {
@@ -190,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) {
@@ -206,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);
@@ -227,16 +229,24 @@ 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) {
+    if (reasons := rascalCollectIllegalRenames(ws, m, defs.l, uses.l, name), reasons != {}) {
         return <reasons, []>;
     }
 
     replaceName = rascalEscapeName(name);
-    return <{}, [replace(l, replaceName) | l <- rascalFindNamesInUseDefs(m, defs + uses)]>;
+
+    set[RenameLocation] renames = defs + uses;
+    set[loc] renameLocs = renames.l;
+    map[loc, loc] namesAt = rascalFindNamesInUseDefs(m, renameLocs);
+
+    return <{}, [{just(annotation), *_} := renames[l]
+                 ? replace(namesAt[l], replaceName, annotation = annotation)
+                 : replace(namesAt[l], replaceName)
+                 | l <- renameLocs]>;
 }
 
-private tuple[set[IllegalRenameReason] reasons, list[TextEdit] edits] computeTextEdits(WorkspaceInfo ws, loc moduleLoc, set[loc] defs, set[loc] uses, str name) =
+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) {
@@ -382,7 +392,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
     };
 
@@ -508,8 +518,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>";
 
@@ -572,14 +582,34 @@ list[DocumentEdit] rascalRenameSymbol(Tree cursorT, set[loc] workspaceFolders, s
     }
 
     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};
+    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;
+    };
+
+    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);
+
+    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;
 
     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));
 
@@ -591,7 +621,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..e8d153e3c
--- /dev/null
+++ b/rascal-lsp/src/main/rascal/lang/rascal/lsp/refactor/TextEdits.rsc
@@ -0,0 +1,40 @@
+@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;
+
+alias ChangeAnnotationId = str;
+
+data ChangeAnnotation
+    = changeAnnotation(str label, str description, bool needsConfirmation)
+    ;
+
+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 ef29ebd6f..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
@@ -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;
@@ -39,11 +40,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 +69,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];
+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];
 
 /**
@@ -91,6 +95,8 @@ data WorkspaceInfo (
     set[TModel](ProjectFiles) tmodelsForLocs
 );
 
+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)) {
         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)
             };
         }
     }
@@ -353,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
@@ -363,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};
     }
@@ -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 = annotateLocs(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)
@@ -413,7 +419,7 @@ set[loc] rascalGetKeywordFieldUses(WorkspaceInfo ws, set[loc] defs, str cursorNa
     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 {};
 
@@ -423,70 +429,72 @@ 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 (
-            [ _*
-            , <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
-            uses += trim(l2, removePrefix = l2.length - size(consName));
+            uses += <trim(l2, removePrefix = l2.length - size(consName)), nothing()>;
         }
     }
 
     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 registerChangeAnnotation) {
+    set[loc] defs = rascalGetOverloadedDefs(ws, getDefs(ws, l), mayOverloadF);
+    set[RenameLocation] uses = annotateLocs(getUses(ws, defs));
 
     set[IdRole] roles = {ws.definitions[d].idRole | d <- defs};
     if (keywordFormalId() in roles) {
         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 <defs, uses, NO_RENAMES>;
+    return <annotateLocs(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 = annotateLocs(getUses(ws, defs));
 
     set[IdRole] roles = {ws.definitions[d].idRole | d <- defs};
-    if (keywordFormalId() in roles) {
+    if (roles & {keywordFormalId(), fieldId()} != {}) {
         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 <defs, uses, NO_RENAMES>;
+    return <annotateLocs(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 +539,27 @@ DefsUsesRenames rascalGetDefsUses(WorkspaceInfo ws, cursor(typeParam(), cursorLo
         };
     }
 
-    return <defs, useDefs - defs, NO_RENAMES>;
+    return <annotateLocs(defs), annotateLocs(useDefs - defs), NO_RENAMES>;
 }
 
-DefsUsesRenames rascalGetDefsUses(WorkspaceInfo ws, cursor(dataField(loc adtLoc, AType fieldType), cursorLoc, cursorName), MayOverloadFun mayOverloadF) {
+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 {
+        <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)
+    };
+}
+
+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 +568,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 = annotateLocs(getUses(ws, defs)) + rascalGetKeywordFieldUses(ws, defs, cursorName);
+    set[RenameLocation] hasUses = rascalGetHasUses(ws, defs, cursorName, registerChangeAnnotation);
 
-    return <defs, uses, NO_RENAMES>;
+    return <annotateLocs(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 registerChangeAnnotation) {
     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);
@@ -576,18 +603,20 @@ 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;
         }
 
+        uses += rascalGetHasUses(ws, adtDefs, cursorName, registerChangeAnnotation);
+
         return <defs, uses, NO_RENAMES>;
     }
 
     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);
@@ -686,10 +715,10 @@ private DefsUsesRenames rascalGetFieldDefsUses(WorkspaceInfo ws, set[loc] reacha
         }
     }
 
-    return <defs, uses, NO_RENAMES>;
+    return <annotateLocs(defs), annotateLocs(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 +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 <defs, uses, getRenames>;
+    return <annotateLocs(defs), annotateLocs(uses), getRenames>;
 }
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 6823b4c12..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
@@ -116,9 +116,18 @@ 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 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\"+;
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..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, changed(_, replaces) := e
-                     , r <- replaces, replace(_, name) := r};
+    newNames = {name | e <- edits<0>
+                     , r <- e.edits
+                     , name := r.replacement};
 
     return newNames == {"\\int"};
 }