Fixup bsaed on review comments

synapse/events/utils.py

@@ -368,9 +368,7 @@ def serialize_event(self, event, time_now, **kwargs):
 
             edit = None
             if event.type == EventTypes.Message:
-                edit = yield self.store.get_applicable_edit(
-                    event.event_id, event.type, event.sender,
-                )
+                edit = yield self.store.get_applicable_edit(event_id)
 
             if edit:
                 # If there is an edit replace the content, preserving existing

synapse/replication/slave/storage/events.py

@@ -143,4 +143,4 @@ def invalidate_caches_for_event(self, stream_ordering, event_id, room_id,
         if relates_to:
             self.get_relations_for_event.invalidate_many((relates_to,))
             self.get_aggregation_groups_for_event.invalidate_many((relates_to,))
-            self.get_applicable_edit.invalidate_many((relates_to,))
+            self.get_applicable_edit.invalidate((relates_to,))

synapse/storage/relations.py

@@ -19,7 +19,7 @@
 
 from twisted.internet import defer
 
-from synapse.api.constants import EventTypes, RelationTypes
+from synapse.api.constants import RelationTypes
 from synapse.api.errors import SynapseError
 from synapse.storage._base import SQLBaseStore
 from synapse.storage.stream import generate_pagination_where_clause
@@ -314,44 +314,44 @@ def _get_aggregation_groups_for_event_txn(txn):
             "get_aggregation_groups_for_event", _get_aggregation_groups_for_event_txn
         )
 
-    @cachedInlineCallbacks(tree=True)
-    def get_applicable_edit(self, event_id, event_type, sender):
+    @cachedInlineCallbacks()
+    def get_applicable_edit(self, event_id):
         """Get the most recent edit (if any) that has happened for the given
         event.
 
         Correctly handles checking whether edits were allowed to happen.
 
         Args:
             event_id (str): The original event ID
-            event_type (str): The original event type
-            sender (str): The original event sender
 
         Returns:
             Deferred[EventBase|None]: Returns the most recent edit, if any.
         """
 
         # We only allow edits for `m.room.message` events that have the same sender
         # and event type. We can't assert these things during regular event auth so
-        # we have to do the post hoc.
-
-        if event_type != EventTypes.Message:
-            return
+        # we have to do the checks post hoc.
 
+        # Fetches latest edit that has the same type and sender as the
+        # original, and is an `m.room.message`.
         sql = """
-            SELECT event_id, origin_server_ts FROM events
+            SELECT edit.event_id FROM events AS edit
             INNER JOIN event_relations USING (event_id)
+            INNER JOIN events AS original ON
+                original.event_id = relates_to_id
+                AND edit.type = original.type
+                AND edit.sender = original.sender
             WHERE
                 relates_to_id = ?
                 AND relation_type = ?
-                AND type = ?
-                AND sender = ?
-            ORDER by origin_server_ts DESC, event_id DESC
+                AND edit.type = 'm.room.message'
+            ORDER by edit.origin_server_ts DESC, edit.event_id DESC
             LIMIT 1
         """
 
         def _get_applicable_edit_txn(txn):
             txn.execute(
-                sql, (event_id, RelationTypes.REPLACES, event_type, sender)
+                sql, (event_id, RelationTypes.REPLACES,)
             )
             row = txn.fetchone()
             if row:
@@ -412,4 +412,6 @@ def _handle_event_relations(self, txn, event):
         txn.call_after(
             self.get_aggregation_groups_for_event.invalidate_many, (parent_id,)
         )
-        txn.call_after(self.get_applicable_edit.invalidate_many, (parent_id,))
+
+        if rel_type == RelationTypes.REPLACES:
+            txn.call_after(self.get_applicable_edit.invalidate, (parent_id,))