this is really messy I'm so sorry

Author: addie.sh

compiler/rustc_hir/src/hir.rs

@@ -830,6 +830,7 @@ pub enum GenericParamKind<'hir> {
     /// A lifetime definition (e.g., `'a: 'b + 'c + 'd`).
     Lifetime {
         kind: LifetimeParamKind,
+        // FIXME(addiesh): add late_bound: bool,
     },
     Type {
         default: Option<&'hir Ty<'hir>>,

compiler/rustc_hir_analysis/src/collect/generics_of.rs

@@ -60,9 +60,10 @@ pub(super) fn generics_of(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::Generics {
             parent: Some(trait_def_id),
             parent_count,
             own_params,
+            own_all_params: opaque_ty_generics.own_all_params.clone(),
             param_def_id_to_index,
             has_self: opaque_ty_generics.has_self,
-            has_late_bound_regions: opaque_ty_generics.has_late_bound_regions,
+            own_late_bound_regions: opaque_ty_generics.own_late_bound_regions.clone(),
         };
     }
 
@@ -154,9 +155,10 @@ pub(super) fn generics_of(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::Generics {
                         parent: generics.parent,
                         parent_count: generics.parent_count,
                         own_params,
+                        own_all_params: generics.own_all_params.clone(),
                         param_def_id_to_index,
                         has_self: generics.has_self,
-                        has_late_bound_regions: generics.has_late_bound_regions,
+                        own_late_bound_regions: generics.own_late_bound_regions.clone(),
                     };
                 }
                 ty::AnonConstKind::GCE => Some(parent_did),
@@ -268,6 +270,22 @@ pub(super) fn generics_of(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::Generics {
         own_params.push(opt_self);
     }
 
+    let all_lifetimes = hir_generics
+        .params
+        .iter()
+        .enumerate()
+        .filter_map(|(i, param)| match param.kind {
+            GenericParamKind::Lifetime { .. } => Some(ty::GenericParamDef {
+                name: param.name.ident().name,
+                index: own_start + i as u32,
+                def_id: param.def_id.to_def_id(),
+                pure_wrt_drop: param.pure_wrt_drop,
+                kind: ty::GenericParamDefKind::Lifetime,
+            }),
+            _ => None,
+        })
+        .collect::<Vec<_>>();
+
     let early_lifetimes = super::early_bound_lifetimes_from_generics(tcx, hir_generics);
     own_params.extend(early_lifetimes.enumerate().map(|(i, param)| ty::GenericParamDef {
         name: param.name.ident().name,
@@ -393,9 +411,10 @@ pub(super) fn generics_of(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::Generics {
         parent: parent_def_id.map(LocalDefId::to_def_id),
         parent_count,
         own_params,
+        own_all_params: all_lifetimes,
         param_def_id_to_index,
         has_self: has_self || parent_has_self,
-        has_late_bound_regions: has_late_bound_regions(tcx, node),
+        own_late_bound_regions: late_bound_regions(tcx, node),
     }
 }
 
@@ -441,7 +460,7 @@ fn param_default_policy(node: Node<'_>) -> Option<ParamDefaultPolicy> {
     })
 }
 
-fn has_late_bound_regions<'tcx>(tcx: TyCtxt<'tcx>, node: Node<'tcx>) -> Option<Span> {
+fn late_bound_regions<'tcx>(tcx: TyCtxt<'tcx>, node: Node<'tcx>) -> Vec<Span> {
     struct LateBoundRegionsDetector<'tcx> {
         tcx: TyCtxt<'tcx>,
         outer_index: ty::DebruijnIndex,
@@ -494,25 +513,37 @@ fn has_late_bound_regions<'tcx>(tcx: TyCtxt<'tcx>, node: Node<'tcx>) -> Option<S
         }
     }
 
-    fn has_late_bound_regions<'tcx>(
+    fn late_bound_regions<'tcx>(
         tcx: TyCtxt<'tcx>,
         generics: &'tcx hir::Generics<'tcx>,
         decl: &'tcx hir::FnDecl<'tcx>,
-    ) -> Option<Span> {
+    ) -> Vec<Span> {
         let mut visitor = LateBoundRegionsDetector { tcx, outer_index: ty::INNERMOST };
-        for param in generics.params {
-            if let GenericParamKind::Lifetime { .. } = param.kind {
-                if tcx.is_late_bound(param.hir_id) {
-                    return Some(param.span);
+
+        let spans = generics
+            .params
+            .iter()
+            .flat_map(|param| {
+                if let GenericParamKind::Lifetime { .. } = param.kind
+                    && tcx.is_late_bound(param.hir_id)
+                {
+                    Some(param.span)
+                } else {
+                    None
                 }
-            }
+            })
+            .collect::<Vec<_>>();
+
+        if !spans.is_empty() {
+            spans
+        } else {
+            visitor.visit_fn_decl(decl).break_value().map_or_default(|val| vec![val])
         }
-        visitor.visit_fn_decl(decl).break_value()
     }
 
-    let decl = node.fn_decl()?;
-    let generics = node.generics()?;
-    has_late_bound_regions(tcx, generics, decl)
+    let Some(decl) = node.fn_decl() else { return vec![] };
+    let Some(generics) = node.generics() else { return vec![] };
+    late_bound_regions(tcx, generics, decl)
 }
 
 struct AnonConstInParamTyDetector {

compiler/rustc_hir_analysis/src/hir_ty_lowering/generics.rs

@@ -409,6 +409,8 @@ pub(crate) fn check_generic_arg_count(
     has_self: bool,
 ) -> GenericArgCountResult {
     let gen_args = seg.args();
+    let tcx = cx.tcx();
+    let kind = tcx.def_kind(def_id);
     let default_counts = gen_params.own_defaults();
     let param_counts = gen_params.own_counts();
 
@@ -430,14 +432,28 @@ pub(crate) fn check_generic_arg_count(
         prohibit_assoc_item_constraint(cx, c, None);
     }
 
-    let tcx = cx.tcx();
+    // this works!
+    // let hidden_early_bound = 0;
+    let hidden_early_bound = if matches!(gen_pos, GenericArgPosition::Value(_)) {
+        gen_params.own_params.iter().filter(|x| x.is_anonymous_lifetime()).count()
+    } else {
+        0
+    };
+
+    let hidden_lifetimes = if matches!(gen_pos, GenericArgPosition::Value(_)) {
+        gen_params.own_all_params.iter().filter(|x| x.is_anonymous_lifetime()).count()
+    } else {
+        0
+    };
+
+    let late_bound_lt_count = gen_params.own_late_bound_regions.len();
 
-    let kind = tcx.def_kind(def_id);
     if kind.is_fn_like() {
         tracing::info!("we are using fn-like {:?} ({gen_pos:?})", tcx.item_name(def_id));
     }
-    tracing::info!(?gen_args);
-    tracing::info!(?gen_params);
+    tracing::info!(?late_bound_lt_count);
+    tracing::info!("# gen_args = {}", gen_args.args.len());
+    tracing::info!("ALL gen_params={:?}", gen_params.own_all_params);
 
     // Suppress this warning for delegations as it is compiler generated and lifetimes are
     // propagated while late-bound lifetimes may be present.
@@ -448,56 +464,44 @@ pub(crate) fn check_generic_arg_count(
 
     let mut invalid_args = vec![];
 
-    let mut check_lifetime_args = |min_expected_args: usize,
-                                   max_expected_args: usize,
-                                   provided_args: usize,
-                                   late_bounds_ignore: bool| {
-        if (min_expected_args..=max_expected_args).contains(&provided_args) {
-            return Ok(());
-        }
-
-        if late_bounds_ignore {
-            return Ok(());
-        }
+    let mut check_lifetime_args =
+        |min_expected_args: usize, max_expected_args: usize, provided_args: usize| {
+            if (min_expected_args..=max_expected_args).contains(&provided_args) {
+                return Ok(());
+            }
 
-        invalid_args.extend(min_expected_args..provided_args);
+            invalid_args.extend(min_expected_args..provided_args);
 
-        let gen_args_info = if provided_args > min_expected_args {
-            let num_redundant_args = provided_args - min_expected_args;
-            GenericArgsInfo::ExcessLifetimes { num_redundant_args }
-        } else {
-            let num_missing_args = min_expected_args - provided_args;
-            GenericArgsInfo::MissingLifetimes { num_missing_args }
+            let gen_args_info = if provided_args > min_expected_args {
+                let num_redundant_args = provided_args - min_expected_args;
+                GenericArgsInfo::ExcessLifetimes { num_redundant_args }
+            } else {
+                let num_missing_args = min_expected_args - provided_args;
+                GenericArgsInfo::MissingLifetimes { num_missing_args }
+            };
+
+            let reported = cx.dcx().emit_err(WrongNumberOfGenericArgs::new(
+                tcx,
+                gen_args_info,
+                seg,
+                gen_params,
+                has_self as usize,
+                gen_args,
+                def_id,
+            ));
+
+            Err(reported)
         };
 
-        let reported = cx.dcx().emit_err(WrongNumberOfGenericArgs::new(
-            tcx,
-            gen_args_info,
-            seg,
-            gen_params,
-            has_self as usize,
-            gen_args,
-            def_id,
-        ));
-
-        Err(reported)
-    };
-
-    // this works!
-    let hidden_early_bound = 0;
-    // let hidden_early_bound = if matches!(gen_pos, GenericArgPosition::Value(_)) {
-    //     gen_params.own_params.iter().filter(|x| x.is_anonymous_lifetime()).count()
-    // } else {
-    //     0
-    // };
-
     let min_expected_lifetime_args =
         if infer_lifetimes { 0 } else { param_counts.lifetimes - hidden_early_bound };
-    let max_expected_lifetime_args = param_counts.lifetimes - hidden_early_bound;
+    let max_expected_lifetime_args =
+        param_counts.lifetimes - hidden_lifetimes + late_bound_lt_count;
     let num_provided_lifetime_args = gen_args.num_lifetime_args();
 
     tracing::info!(
         ?hidden_early_bound,
+        ?hidden_lifetimes,
         ?min_expected_lifetime_args,
         ?max_expected_lifetime_args,
         ?num_provided_lifetime_args,
@@ -507,7 +511,7 @@ pub(crate) fn check_generic_arg_count(
         min_expected_lifetime_args,
         max_expected_lifetime_args,
         num_provided_lifetime_args,
-        explicit_late_bound == ExplicitLateBound::Yes,
+        // explicit_late_bound == ExplicitLateBound::Yes,
     );
 
     let mut check_types_and_consts = |expected_min,
@@ -668,11 +672,12 @@ pub(crate) fn prohibit_explicit_late_bound_lifetimes(
 
     let param_counts = def.own_counts();
 
-    if let Some(span_late) = def.has_late_bound_regions
+    // FIXME(addiesh): just turning off the diagnostic is probably not enough to solve the problem. see:
+    //        https://rust-lang.zulipchat.com/#narrow/channel/600108-t-types.2Fearly-late-cleanup/topic/turbofishing.20elided.20lifetimes/near/607748866
+    if cx.tcx().features().late_bound_turbofishing() {
+        ExplicitLateBound::Yes
+    } else if let Some(span_late) = def.own_late_bound_regions.first().copied()
         && args.has_lifetime_args()
-        // FIXME(addiesh): just turning off the diagnostic is probably not enough to solve the problem. see:
-        //        https://rust-lang.zulipchat.com/#narrow/channel/600108-t-types.2Fearly-late-cleanup/topic/turbofishing.20elided.20lifetimes/near/607748866
-        && !cx.tcx().features().late_bound_turbofishing()
     {
         let gone_turbofishing = "this may change in the future; see issue #156581 <https://github.com/rust-lang/rust/issues/156581> for more information";
 

compiler/rustc_middle/src/ty/generics.rs

@@ -122,13 +122,14 @@ pub struct Generics {
     pub parent: Option<DefId>,
     pub parent_count: usize,
     pub own_params: Vec<GenericParamDef>,
+    pub own_all_params: Vec<GenericParamDef>,
 
     /// Reverse map to the `index` field of each `GenericParamDef`.
     #[stable_hash(ignore)]
     pub param_def_id_to_index: FxHashMap<DefId, u32>,
 
     pub has_self: bool,
-    pub has_late_bound_regions: Option<Span>,
+    pub own_late_bound_regions: Vec<Span>,
 }
 
 impl std::fmt::Debug for Generics {
@@ -143,7 +144,7 @@ impl std::fmt::Debug for Generics {
             .field("own_params", &self.own_params)
             .field("param_def_id_to_index", &stabilized_hashmap)
             .field("has_self", &self.has_self)
-            .field("has_late_bound_regions", &self.has_late_bound_regions)
+            .field("own_late_bound_regions", &self.own_late_bound_regions)
             .finish()
     }
 }

compiler/rustc_public/src/unstable/convert/stable/ty.rs

@@ -681,8 +681,10 @@ impl<'tcx> Stable<'tcx> for ty::Generics {
             params,
             param_def_id_to_index,
             has_self: self.has_self,
+            // FIXME: this type def has not been updated in rustc public
             has_late_bound_regions: self
-                .has_late_bound_regions
+                .own_late_bound_regions
+                .first()
                 .as_ref()
                 .map(|late_bound_regions| late_bound_regions.stable(tables, cx)),
         }

compiler/rustc_ty_utils/src/assoc.rs

@@ -356,9 +356,10 @@ fn associated_type_for_impl_trait_in_impl(
             parent: Some(impl_local_def_id.to_def_id()),
             parent_count,
             own_params,
+            own_all_params: trait_assoc_generics.own_all_params.clone(),
             param_def_id_to_index,
             has_self: false,
-            has_late_bound_regions: trait_assoc_generics.has_late_bound_regions,
+            own_late_bound_regions: trait_assoc_generics.own_late_bound_regions.clone(),
         }
     });
 

tests/ui/lifetimes/late-bound-turbofishing-basic.rs

@@ -0,0 +1,17 @@
+#![feature(late_bound_turbofishing)]
+
+fn foo_early<'a: 'a>(b: &'a u32) -> &'a u32 { b }
+fn foo_late<'a>(b: &'a u32) -> &'a u32 { b }
+fn foo_latest(_: &u32) {}
+
+fn require_static<T: 'static>(_: T) { }
+
+fn main() {
+    let f = foo_early::<'static>;
+    require_static(f);
+    let f = foo_late::<'static>;
+    require_static(f);
+    let f = foo_latest::<'static>;
+    //~^ ERROR: function takes 0 lifetime arguments but 1 lifetime argument was supplied [E0107]
+    require_static(f);
+}