diff --git a/compiler/rustc_typeck/src/variance/constraints.rs b/compiler/rustc_typeck/src/variance/constraints.rs
index a8fbdfb7c6514..339eb5f9afc74 100644
--- a/compiler/rustc_typeck/src/variance/constraints.rs
+++ b/compiler/rustc_typeck/src/variance/constraints.rs
@@ -207,27 +207,13 @@ impl<'a, 'tcx> ConstraintContext<'a, 'tcx> {
         }
     }
 
-    fn add_constraints_from_trait_ref(
-        &mut self,
-        current: &CurrentItem,
-        trait_ref: ty::TraitRef<'tcx>,
-        variance: VarianceTermPtr<'a>,
-    ) {
-        debug!("add_constraints_from_trait_ref: trait_ref={:?} variance={:?}", trait_ref, variance);
-        self.add_constraints_from_invariant_substs(current, trait_ref.substs, variance);
-    }
-
+    #[instrument(skip(self, current))]
     fn add_constraints_from_invariant_substs(
         &mut self,
         current: &CurrentItem,
         substs: SubstsRef<'tcx>,
         variance: VarianceTermPtr<'a>,
     ) {
-        debug!(
-            "add_constraints_from_invariant_substs: substs={:?} variance={:?}",
-            substs, variance
-        );
-
         // Trait are always invariant so we can take advantage of that.
         let variance_i = self.invariant(variance);
 
@@ -300,8 +286,7 @@ impl<'a, 'tcx> ConstraintContext<'a, 'tcx> {
             }
 
             ty::Projection(ref data) => {
-                let tcx = self.tcx();
-                self.add_constraints_from_trait_ref(current, data.trait_ref(tcx), variance);
+                self.add_constraints_from_invariant_substs(current, data.substs, variance);
             }
 
             ty::Opaque(_, substs) => {
diff --git a/src/test/ui/generic-associated-types/variance_constraints.rs b/src/test/ui/generic-associated-types/variance_constraints.rs
new file mode 100644
index 0000000000000..36db80706b499
--- /dev/null
+++ b/src/test/ui/generic-associated-types/variance_constraints.rs
@@ -0,0 +1,24 @@
+// check-pass
+// issue #69184
+#![feature(generic_associated_types)]
+#![allow(incomplete_features)]
+
+trait A {
+    type B<'a>;
+
+    fn make_b<'a>(&'a self) -> Self::B<'a>;
+}
+
+struct S {}
+impl A for S {
+    type B<'a> = &'a S;
+    fn make_b<'a>(&'a self) -> &'a Self {
+        self
+    }
+}
+
+enum E<'a> {
+    S(<S as A>::B<'a>),
+}
+
+fn main() {}