Rollup merge of #154918 - fmease:fix-enum-var-lt, r=jackh726

Fix elided lifetime resolution & trait object lifetime defaulting for enum variant paths

Context: #129543 (comment).
Fixes #108224.

I consider this to be a minor bug fix that doesn't demand a (T-types) FCP.

r? @lcnr or reassign

Author: JonathanBrouwer

compiler/rustc_hir_analysis/src/collect/resolve_bound_vars.rs

@@ -1693,7 +1693,9 @@ impl<'a, 'tcx> BoundVarContext<'a, 'tcx> {
         // which requires object lifetime defaults.
         let type_def_id = match res {
             Res::Def(DefKind::AssocTy, def_id) if depth == 1 => Some(self.tcx.parent(def_id)),
-            Res::Def(DefKind::Variant, def_id) if depth == 0 => Some(self.tcx.parent(def_id)),
+            Res::Def(DefKind::Variant, def_id) if depth == 0 || depth == 1 => {
+                Some(self.tcx.parent(def_id))
+            }
             Res::Def(
                 DefKind::Struct
                 | DefKind::Union

compiler/rustc_resolve/src/late.rs

@@ -2177,7 +2177,15 @@ impl<'a, 'ast, 'ra, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
                 Res::Def(DefKind::AssocTy, def_id) if i + 2 == proj_start => {
                     self.r.tcx.parent(def_id)
                 }
-                Res::Def(DefKind::Variant, def_id) if i + 1 == proj_start => {
+                Res::Def(DefKind::Variant, def_id)
+                    if i + 2 == proj_start && segment.has_generic_args =>
+                {
+                    self.r.tcx.parent(def_id)
+                }
+                Res::Def(DefKind::Variant, def_id)
+                    if i + 1 == proj_start
+                        && !i.checked_sub(1).is_some_and(|i| path[i].has_generic_args) =>
+                {
                     self.r.tcx.parent(def_id)
                 }
                 Res::Def(DefKind::Struct, def_id)

compiler/rustc_resolve/src/lib.rs

@@ -353,8 +353,7 @@ enum VisResolutionError {
 struct Segment {
     ident: Ident,
     id: Option<NodeId>,
-    /// Signals whether this `PathSegment` has generic arguments. Used to avoid providing
-    /// nonsensical suggestions.
+    /// Signals whether this `PathSegment` has generic arguments.
     has_generic_args: bool,
     /// Signals whether this `PathSegment` has lifetime arguments.
     has_lifetime_args: bool,

tests/ui/lifetimes/no-lt-elision-in-variant-path-seg-as-enum-path-seg-has-gen-args.rs

@@ -0,0 +1,37 @@
+// Given an enum `Enum` with lifetime parameters, we used to lower `Enum::<…>::Variant {}` to
+// `Enum::<…>::Variant::<'_, …> {}`, i.e., synthesize `'_` lifetime args for enum variants
+// even if generic args were already passed to the enum itself.
+// Obviously, these conflicting generic arg lists were then rejected later on (by HIR ty lowering).
+//
+// Now we no longer do. Why do we synthesize these lifetimes for struct variant paths in the first
+// place while we don't do it for unit & tuple variants? Well, we later HIR-ty-lower the former in
+// "type mode" while we lower the latter in "value mode". In "type mode", we won't infer
+// elided lifetimes if the generic arg lists contains non-lifetime args which is undesirable here.
+//
+// issue: <https://github.com/rust-lang/rust/issues/108224>
+//@ check-pass
+
+fn scope<'any>() {
+    enum Ty0<'a> {
+        Unit,
+        Tuple,
+        Struct {},
+
+        Carry(&'a ()),
+    }
+
+    enum Ty1<'a, T: ?Sized> {
+        Variant,
+
+        Carry(&'a T),
+    }
+
+    let _ = Ty0::<'_>::Unit {};
+    let _ = Ty0::<'static>::Tuple {};
+    let _ = Ty0::<'any>::Struct {};
+
+    let _ = Ty1::</*'_, */()>::Variant {};
+    let _ = Ty1::<'any, ()>::Variant {};
+}
+
+fn main() {}

tests/ui/object-lifetime/object-lifetime-default-enum-variant.rs

@@ -0,0 +1,24 @@
+//@ check-pass
+
+enum Enum<'a, T: 'a + AbideBy<'a> + ?Sized> {
+    Variant,
+
+    Carry(&'a T),
+}
+
+fn scope<'any>() {
+    // We elaborate `dyn Trait` to `dyn Trait + 'any` due to bound `'a` on `T`.
+    let _ = Enum::Variant::<'any, dyn Trait> {};
+
+    // Similarly here.
+    let _ = Enum::<'any, dyn Trait>::Variant {};
+}
+
+trait Trait {}
+
+// We use this to test that a given trait object lifetime bound is
+// *exactly equal* to a given lifetime (not longer, not shorter).
+trait AbideBy<'a> {}
+impl<'a> AbideBy<'a> for dyn Trait + 'a {}
+
+fn main() {}