[5.2.x] Fixed #36198 -- Implemented unresolved transform expression replacement.

This allows the proper resolving of F("field__transform") when
performing constraint validation.

Thanks Tom Hall for the report and Sarah for the test.

Prerequisite for #36518.

Backport of fc303551077c3e023fe4f9d01fc1b3026c816fa4 from main.

1 files changed, 18 insertions, 1 deletions

diff --git a/django/db/models/expressions.py b/django/db/models/expressions.py
index b214be7fa5..3e1bcdbd2b 100644
--- a/django/db/models/expressions.py
+++ b/django/db/models/expressions.py
@@ -902,7 +902,24 @@ class F(Combinable):
         return query.resolve_ref(self.name, allow_joins, reuse, summarize)
 
     def replace_expressions(self, replacements):
-        return replacements.get(self, self)
+        if (replacement := replacements.get(self)) is not None:
+            return replacement
+        field_name, *transforms = self.name.split(LOOKUP_SEP)
+        # Avoid unnecessarily looking up replacements with field_name again as
+        # in the vast majority of cases F instances won't be composed of any
+        # lookups.
+        if not transforms:
+            return self
+        if (
+            replacement := replacements.get(F(field_name))
+        ) is None or replacement._output_field_or_none is None:
+            return self
+        for transform in transforms:
+            transform_class = replacement.get_transform(transform)
+            if transform_class is None:
+                return self
+            replacement = transform_class(replacement)
+        return replacement
 
     def asc(self, **kwargs):
         return OrderBy(self, **kwargs)