diff --git a/src/change.c b/src/change.c
index c0b8785..0ea424f 100644
--- a/src/change.c
+++ b/src/change.c
@@ -656,22 +656,20 @@
 		set_topline(wp, wp->w_topline);
 #endif
 	    // If lines have been added or removed, relative numbering always
-	    // requires a redraw.
+	    // requires an update even if cursor didn't move.
 	    if (wp->w_p_rnu && xtra != 0)
-	    {
 		wp->w_last_cursor_lnum_rnu = 0;
-		redraw_win_later(wp, UPD_VALID);
-	    }
+
 #ifdef FEAT_SYN_HL
-	    // Cursor line highlighting probably need to be updated with
-	    // "UPD_VALID" if it's below the change.
-	    // If the cursor line is inside the change we need to redraw more.
-	    if (wp->w_p_cul)
+	    if (wp->w_p_cul && wp->w_last_cursorline >= lnum)
 	    {
-		if (xtra == 0)
-		    redraw_win_later(wp, UPD_VALID);
-		else if (lnum <= wp->w_last_cursorline)
-		    redraw_win_later(wp, UPD_SOME_VALID);
+		if (wp->w_last_cursorline < lnume)
+		    // If 'cursorline' was inside the change, it has already
+		    // been invalidated in w_lines[] by the loop above.
+		    wp->w_last_cursorline = 0;
+		else
+		    // If 'cursorline' was below the change, adjust its lnum.
+		    wp->w_last_cursorline += xtra;
 	    }
 #endif
 	}
