diff --git a/crates/hir-def/src/hir/type_ref.rs b/crates/hir-def/src/hir/type_ref.rs
index 1fd878a..6b7f03e 100644
--- a/crates/hir-def/src/hir/type_ref.rs
+++ b/crates/hir-def/src/hir/type_ref.rs
@@ -106,6 +106,14 @@
     pub abi: Option<Symbol>,
 }
 
+impl FnType {
+    #[inline]
+    pub fn split_params_and_ret(&self) -> (&[(Option<Name>, TypeRefId)], TypeRefId) {
+        let (ret, params) = self.params.split_last().expect("should have at least return type");
+        (params, ret.1)
+    }
+}
+
 #[derive(Clone, PartialEq, Eq, Hash, Debug)]
 pub struct ArrayType {
     pub ty: TypeRefId,
diff --git a/crates/hir-ty/src/chalk_db.rs b/crates/hir-ty/src/chalk_db.rs
index bf16e08..2aa9401 100644
--- a/crates/hir-ty/src/chalk_db.rs
+++ b/crates/hir-ty/src/chalk_db.rs
@@ -27,6 +27,7 @@
     db::{HirDatabase, InternedCoroutine},
     from_assoc_type_id, from_chalk_trait_id, from_foreign_def_id,
     generics::generics,
+    lower::LifetimeElisionKind,
     make_binders, make_single_type_binders,
     mapping::{ToChalk, TypeAliasAsValue, from_chalk},
     method_resolution::{ALL_FLOAT_FPS, ALL_INT_FPS, TraitImpls, TyFingerprint},
@@ -632,9 +633,14 @@
     let type_alias_data = db.type_alias_signature(type_alias);
     let generic_params = generics(db, type_alias.into());
     let resolver = hir_def::resolver::HasResolver::resolver(type_alias, db);
-    let mut ctx =
-        crate::TyLoweringContext::new(db, &resolver, &type_alias_data.store, type_alias.into())
-            .with_type_param_mode(crate::lower::ParamLoweringMode::Variable);
+    let mut ctx = crate::TyLoweringContext::new(
+        db,
+        &resolver,
+        &type_alias_data.store,
+        type_alias.into(),
+        LifetimeElisionKind::AnonymousReportError,
+    )
+    .with_type_param_mode(crate::lower::ParamLoweringMode::Variable);
 
     let trait_subst = TyBuilder::subst_for_def(db, trait_, None)
         .fill_with_bound_vars(crate::DebruijnIndex::INNERMOST, 0)
diff --git a/crates/hir-ty/src/infer.rs b/crates/hir-ty/src/infer.rs
index cad2e3c..38807b6 100644
--- a/crates/hir-ty/src/infer.rs
+++ b/crates/hir-ty/src/infer.rs
@@ -34,8 +34,8 @@
 };
 use either::Either;
 use hir_def::{
-    AdtId, AssocItemId, DefWithBodyId, FieldId, FunctionId, GenericDefId, GenericParamId, ImplId,
-    ItemContainerId, Lookup, TraitId, TupleFieldId, TupleId, TypeAliasId, VariantId,
+    AdtId, AssocItemId, ConstId, DefWithBodyId, FieldId, FunctionId, GenericDefId, GenericParamId,
+    ImplId, ItemContainerId, Lookup, TraitId, TupleFieldId, TupleId, TypeAliasId, VariantId,
     builtin_type::{BuiltinInt, BuiltinType, BuiltinUint},
     expr_store::{Body, ExpressionStore, HygieneId, path::Path},
     hir::{BindingAnnotation, BindingId, ExprId, ExprOrPatId, LabelId, PatId},
@@ -67,9 +67,9 @@
         expr::ExprIsRead,
         unify::InferenceTable,
     },
-    lower::{GenericArgsPosition, ImplTraitLoweringMode, diagnostics::TyLoweringDiagnostic},
+    lower::{ImplTraitLoweringMode, LifetimeElisionKind, diagnostics::TyLoweringDiagnostic},
     mir::MirSpan,
-    to_assoc_type_id,
+    static_lifetime, to_assoc_type_id,
     traits::FnTrait,
     utils::UnevaluatedConstEvaluatorFolder,
 };
@@ -96,7 +96,7 @@
         DefWithBodyId::FunctionId(f) => {
             ctx.collect_fn(f);
         }
-        DefWithBodyId::ConstId(c) => ctx.collect_const(&db.const_signature(c)),
+        DefWithBodyId::ConstId(c) => ctx.collect_const(c, &db.const_signature(c)),
         DefWithBodyId::StaticId(s) => ctx.collect_static(&db.static_signature(s)),
         DefWithBodyId::VariantId(v) => {
             ctx.return_ty = TyBuilder::builtin(
@@ -899,9 +899,13 @@
         result
     }
 
-    fn collect_const(&mut self, data: &ConstSignature) {
-        let return_ty =
-            self.make_ty(data.type_ref, &data.store, InferenceTyDiagnosticSource::Signature);
+    fn collect_const(&mut self, id: ConstId, data: &ConstSignature) {
+        let return_ty = self.make_ty(
+            data.type_ref,
+            &data.store,
+            InferenceTyDiagnosticSource::Signature,
+            LifetimeElisionKind::for_const(id.loc(self.db).container),
+        );
 
         // Constants might be defining usage sites of TAITs.
         self.make_tait_coercion_table(iter::once(&return_ty));
@@ -910,8 +914,12 @@
     }
 
     fn collect_static(&mut self, data: &StaticSignature) {
-        let return_ty =
-            self.make_ty(data.type_ref, &data.store, InferenceTyDiagnosticSource::Signature);
+        let return_ty = self.make_ty(
+            data.type_ref,
+            &data.store,
+            InferenceTyDiagnosticSource::Signature,
+            LifetimeElisionKind::Elided(static_lifetime()),
+        );
 
         // Statics might be defining usage sites of TAITs.
         self.make_tait_coercion_table(iter::once(&return_ty));
@@ -921,12 +929,15 @@
 
     fn collect_fn(&mut self, func: FunctionId) {
         let data = self.db.function_signature(func);
-        let mut param_tys =
-            self.with_ty_lowering(&data.store, InferenceTyDiagnosticSource::Signature, |ctx| {
+        let mut param_tys = self.with_ty_lowering(
+            &data.store,
+            InferenceTyDiagnosticSource::Signature,
+            LifetimeElisionKind::for_fn_params(&data),
+            |ctx| {
                 ctx.type_param_mode(ParamLoweringMode::Placeholder);
-                ctx.in_fn_signature = true;
                 data.params.iter().map(|&type_ref| ctx.lower_ty(type_ref)).collect::<Vec<_>>()
-            });
+            },
+        );
 
         // Check if function contains a va_list, if it does then we append it to the parameter types
         // that are collected from the function data
@@ -967,10 +978,10 @@
                 let return_ty = self.with_ty_lowering(
                     &data.store,
                     InferenceTyDiagnosticSource::Signature,
+                    LifetimeElisionKind::for_fn_ret(),
                     |ctx| {
                         ctx.type_param_mode(ParamLoweringMode::Placeholder)
                             .impl_trait_mode(ImplTraitLoweringMode::Opaque);
-                        ctx.in_fn_signature = true;
                         ctx.lower_ty(return_ty)
                     },
                 );
@@ -1304,6 +1315,7 @@
         &mut self,
         store: &ExpressionStore,
         types_source: InferenceTyDiagnosticSource,
+        lifetime_elision: LifetimeElisionKind,
         f: impl FnOnce(&mut TyLoweringContext<'_>) -> R,
     ) -> R {
         let mut ctx = TyLoweringContext::new(
@@ -1313,12 +1325,18 @@
             &self.diagnostics,
             types_source,
             self.generic_def,
+            lifetime_elision,
         );
         f(&mut ctx)
     }
 
     fn with_body_ty_lowering<R>(&mut self, f: impl FnOnce(&mut TyLoweringContext<'_>) -> R) -> R {
-        self.with_ty_lowering(self.body, InferenceTyDiagnosticSource::Body, f)
+        self.with_ty_lowering(
+            self.body,
+            InferenceTyDiagnosticSource::Body,
+            LifetimeElisionKind::Infer,
+            f,
+        )
     }
 
     fn make_ty(
@@ -1326,29 +1344,46 @@
         type_ref: TypeRefId,
         store: &ExpressionStore,
         type_source: InferenceTyDiagnosticSource,
+        lifetime_elision: LifetimeElisionKind,
     ) -> Ty {
-        let ty = self.with_ty_lowering(store, type_source, |ctx| ctx.lower_ty(type_ref));
+        let ty = self
+            .with_ty_lowering(store, type_source, lifetime_elision, |ctx| ctx.lower_ty(type_ref));
         let ty = self.insert_type_vars(ty);
         self.normalize_associated_types_in(ty)
     }
 
     fn make_body_ty(&mut self, type_ref: TypeRefId) -> Ty {
-        self.make_ty(type_ref, self.body, InferenceTyDiagnosticSource::Body)
+        self.make_ty(
+            type_ref,
+            self.body,
+            InferenceTyDiagnosticSource::Body,
+            LifetimeElisionKind::Infer,
+        )
     }
 
     fn make_body_const(&mut self, const_ref: ConstRef, ty: Ty) -> Const {
-        let const_ = self.with_ty_lowering(self.body, InferenceTyDiagnosticSource::Body, |ctx| {
-            ctx.type_param_mode = ParamLoweringMode::Placeholder;
-            ctx.lower_const(&const_ref, ty)
-        });
+        let const_ = self.with_ty_lowering(
+            self.body,
+            InferenceTyDiagnosticSource::Body,
+            LifetimeElisionKind::Infer,
+            |ctx| {
+                ctx.type_param_mode = ParamLoweringMode::Placeholder;
+                ctx.lower_const(&const_ref, ty)
+            },
+        );
         self.insert_type_vars(const_)
     }
 
     fn make_path_as_body_const(&mut self, path: &Path, ty: Ty) -> Const {
-        let const_ = self.with_ty_lowering(self.body, InferenceTyDiagnosticSource::Body, |ctx| {
-            ctx.type_param_mode = ParamLoweringMode::Placeholder;
-            ctx.lower_path_as_const(path, ty)
-        });
+        let const_ = self.with_ty_lowering(
+            self.body,
+            InferenceTyDiagnosticSource::Body,
+            LifetimeElisionKind::Infer,
+            |ctx| {
+                ctx.type_param_mode = ParamLoweringMode::Placeholder;
+                ctx.lower_path_as_const(path, ty)
+            },
+        );
         self.insert_type_vars(const_)
     }
 
@@ -1357,9 +1392,12 @@
     }
 
     fn make_body_lifetime(&mut self, lifetime_ref: &LifetimeRef) -> Lifetime {
-        let lt = self.with_ty_lowering(self.body, InferenceTyDiagnosticSource::Body, |ctx| {
-            ctx.lower_lifetime(lifetime_ref)
-        });
+        let lt = self.with_ty_lowering(
+            self.body,
+            InferenceTyDiagnosticSource::Body,
+            LifetimeElisionKind::Infer,
+            |ctx| ctx.lower_lifetime(lifetime_ref),
+        );
         self.insert_type_vars(lt)
     }
 
@@ -1529,8 +1567,9 @@
             &self.diagnostics,
             InferenceTyDiagnosticSource::Body,
             self.generic_def,
+            LifetimeElisionKind::Infer,
         );
-        let mut path_ctx = ctx.at_path(path, node, GenericArgsPosition::Value);
+        let mut path_ctx = ctx.at_path(path, node);
         let (resolution, unresolved) = if value_ns {
             let Some(res) = path_ctx.resolve_path_in_value_ns(HygieneId::ROOT) else {
                 return (self.err_ty(), None);
@@ -1538,14 +1577,14 @@
             match res {
                 ResolveValueResult::ValueNs(value, _) => match value {
                     ValueNs::EnumVariantId(var) => {
-                        let substs = path_ctx.substs_from_path(var.into(), true);
+                        let substs = path_ctx.substs_from_path(var.into(), true, false);
                         drop(ctx);
                         let ty = self.db.ty(var.lookup(self.db).parent.into());
                         let ty = self.insert_type_vars(ty.substitute(Interner, &substs));
                         return (ty, Some(var.into()));
                     }
                     ValueNs::StructId(strukt) => {
-                        let substs = path_ctx.substs_from_path(strukt.into(), true);
+                        let substs = path_ctx.substs_from_path(strukt.into(), true, false);
                         drop(ctx);
                         let ty = self.db.ty(strukt.into());
                         let ty = self.insert_type_vars(ty.substitute(Interner, &substs));
@@ -1567,21 +1606,21 @@
         };
         return match resolution {
             TypeNs::AdtId(AdtId::StructId(strukt)) => {
-                let substs = path_ctx.substs_from_path(strukt.into(), true);
+                let substs = path_ctx.substs_from_path(strukt.into(), true, false);
                 drop(ctx);
                 let ty = self.db.ty(strukt.into());
                 let ty = self.insert_type_vars(ty.substitute(Interner, &substs));
                 forbid_unresolved_segments((ty, Some(strukt.into())), unresolved)
             }
             TypeNs::AdtId(AdtId::UnionId(u)) => {
-                let substs = path_ctx.substs_from_path(u.into(), true);
+                let substs = path_ctx.substs_from_path(u.into(), true, false);
                 drop(ctx);
                 let ty = self.db.ty(u.into());
                 let ty = self.insert_type_vars(ty.substitute(Interner, &substs));
                 forbid_unresolved_segments((ty, Some(u.into())), unresolved)
             }
             TypeNs::EnumVariantId(var) => {
-                let substs = path_ctx.substs_from_path(var.into(), true);
+                let substs = path_ctx.substs_from_path(var.into(), true, false);
                 drop(ctx);
                 let ty = self.db.ty(var.lookup(self.db).parent.into());
                 let ty = self.insert_type_vars(ty.substitute(Interner, &substs));
@@ -1665,7 +1704,7 @@
                     never!("resolver should always resolve lang item paths");
                     return (self.err_ty(), None);
                 };
-                let substs = path_ctx.substs_from_path_segment(it.into(), true, None);
+                let substs = path_ctx.substs_from_path_segment(it.into(), true, None, false);
                 drop(ctx);
                 let ty = self.db.ty(it.into());
                 let ty = self.insert_type_vars(ty.substitute(Interner, &substs));
diff --git a/crates/hir-ty/src/infer/closure.rs b/crates/hir-ty/src/infer/closure.rs
index 59ec3ad..e7b776a 100644
--- a/crates/hir-ty/src/infer/closure.rs
+++ b/crates/hir-ty/src/infer/closure.rs
@@ -440,6 +440,8 @@
         // collect explicitly written argument types
         for arg_type in arg_types.iter() {
             let arg_ty = match arg_type {
+                // FIXME: I think rustc actually lowers closure params with `LifetimeElisionKind::AnonymousCreateParameter`
+                // (but the return type with infer).
                 Some(type_ref) => self.make_body_ty(*type_ref),
                 None => self.table.new_type_var(),
             };
diff --git a/crates/hir-ty/src/infer/diagnostics.rs b/crates/hir-ty/src/infer/diagnostics.rs
index 2c633a0..e3c4f55 100644
--- a/crates/hir-ty/src/infer/diagnostics.rs
+++ b/crates/hir-ty/src/infer/diagnostics.rs
@@ -12,7 +12,7 @@
 use hir_def::{hir::ExprOrPatId, resolver::Resolver};
 use la_arena::{Idx, RawIdx};
 
-use crate::lower::GenericArgsPosition;
+use crate::lower::LifetimeElisionKind;
 use crate::{
     InferenceDiagnostic, InferenceTyDiagnosticSource, TyLoweringContext, TyLoweringDiagnostic,
     db::HirDatabase,
@@ -66,8 +66,13 @@
         diagnostics: &'a Diagnostics,
         source: InferenceTyDiagnosticSource,
         generic_def: GenericDefId,
+        lifetime_elision: LifetimeElisionKind,
     ) -> Self {
-        Self { ctx: TyLoweringContext::new(db, resolver, store, generic_def), diagnostics, source }
+        Self {
+            ctx: TyLoweringContext::new(db, resolver, store, generic_def, lifetime_elision),
+            diagnostics,
+            source,
+        }
     }
 
     #[inline]
@@ -75,7 +80,6 @@
         &'b mut self,
         path: &'b Path,
         node: ExprOrPatId,
-        position: GenericArgsPosition,
     ) -> PathLoweringContext<'b, 'a> {
         let on_diagnostic = PathDiagnosticCallback {
             data: Either::Right(PathDiagnosticCallbackData { diagnostics: self.diagnostics, node }),
@@ -85,14 +89,13 @@
                     .push(InferenceDiagnostic::PathDiagnostic { node: data.node, diag });
             },
         };
-        PathLoweringContext::new(&mut self.ctx, on_diagnostic, path, position)
+        PathLoweringContext::new(&mut self.ctx, on_diagnostic, path)
     }
 
     #[inline]
     pub(super) fn at_path_forget_diagnostics<'b>(
         &'b mut self,
         path: &'b Path,
-        position: GenericArgsPosition,
     ) -> PathLoweringContext<'b, 'a> {
         let on_diagnostic = PathDiagnosticCallback {
             data: Either::Right(PathDiagnosticCallbackData {
@@ -101,7 +104,7 @@
             }),
             callback: |_data, _, _diag| {},
         };
-        PathLoweringContext::new(&mut self.ctx, on_diagnostic, path, position)
+        PathLoweringContext::new(&mut self.ctx, on_diagnostic, path)
     }
 
     #[inline]
diff --git a/crates/hir-ty/src/infer/expr.rs b/crates/hir-ty/src/infer/expr.rs
index 2980549..643587e 100644
--- a/crates/hir-ty/src/infer/expr.rs
+++ b/crates/hir-ty/src/infer/expr.rs
@@ -37,7 +37,7 @@
     },
     lang_items::lang_items_for_bin_op,
     lower::{
-        GenericArgsPosition, ParamLoweringMode, lower_to_chalk_mutability,
+        LifetimeElisionKind, ParamLoweringMode, lower_to_chalk_mutability,
         path::{GenericArgsLowerer, TypeLikeConst, substs_from_args_and_bindings},
     },
     mapping::{ToChalk, from_chalk},
@@ -2162,6 +2162,23 @@
                     }
                 }
             }
+
+            fn report_elided_lifetimes_in_path(
+                &mut self,
+                _def: GenericDefId,
+                _expected_count: u32,
+                _hard_error: bool,
+            ) {
+                unreachable!("we set `LifetimeElisionKind::Infer`")
+            }
+
+            fn report_elision_failure(&mut self, _def: GenericDefId, _expected_count: u32) {
+                unreachable!("we set `LifetimeElisionKind::Infer`")
+            }
+
+            fn report_missing_lifetime(&mut self, _def: GenericDefId, _expected_count: u32) {
+                unreachable!("we set `LifetimeElisionKind::Infer`")
+            }
         }
 
         substs_from_args_and_bindings(
@@ -2170,7 +2187,8 @@
             generic_args,
             def,
             true,
-            GenericArgsPosition::MethodCall,
+            LifetimeElisionKind::Infer,
+            false,
             None,
             &mut LowererCtx { ctx: self, expr },
         )
diff --git a/crates/hir-ty/src/infer/path.rs b/crates/hir-ty/src/infer/path.rs
index 0e1d23b..bdaec61 100644
--- a/crates/hir-ty/src/infer/path.rs
+++ b/crates/hir-ty/src/infer/path.rs
@@ -16,7 +16,7 @@
     consteval, error_lifetime,
     generics::generics,
     infer::diagnostics::InferenceTyLoweringContext as TyLoweringContext,
-    lower::GenericArgsPosition,
+    lower::LifetimeElisionKind,
     method_resolution::{self, VisibleFromModule},
     to_chalk_trait_id,
 };
@@ -96,12 +96,12 @@
         };
 
         let substs = self.with_body_ty_lowering(|ctx| {
-            let mut path_ctx = ctx.at_path(path, id, GenericArgsPosition::Value);
+            let mut path_ctx = ctx.at_path(path, id);
             let last_segment = path.segments().len().checked_sub(1);
             if let Some(last_segment) = last_segment {
                 path_ctx.set_current_segment(last_segment)
             }
-            path_ctx.substs_from_path(value_def, true)
+            path_ctx.substs_from_path(value_def, true, false)
         });
         let substs = substs.as_slice(Interner);
 
@@ -162,11 +162,12 @@
             &self.diagnostics,
             InferenceTyDiagnosticSource::Body,
             self.generic_def,
+            LifetimeElisionKind::Infer,
         );
         let mut path_ctx = if no_diagnostics {
-            ctx.at_path_forget_diagnostics(path, GenericArgsPosition::Value)
+            ctx.at_path_forget_diagnostics(path)
         } else {
-            ctx.at_path(path, id, GenericArgsPosition::Value)
+            ctx.at_path(path, id)
         };
         let (value, self_subst) = if let Some(type_ref) = path.type_anchor() {
             let last = path.segments().last()?;
diff --git a/crates/hir-ty/src/lib.rs b/crates/hir-ty/src/lib.rs
index 2cb977b..128569d 100644
--- a/crates/hir-ty/src/lib.rs
+++ b/crates/hir-ty/src/lib.rs
@@ -94,8 +94,8 @@
 };
 pub use interner::Interner;
 pub use lower::{
-    ImplTraitLoweringMode, ParamLoweringMode, TyDefId, TyLoweringContext, ValueTyDefId,
-    associated_type_shorthand_candidates, diagnostics::*,
+    ImplTraitLoweringMode, LifetimeElisionKind, ParamLoweringMode, TyDefId, TyLoweringContext,
+    ValueTyDefId, associated_type_shorthand_candidates, diagnostics::*,
 };
 pub use mapping::{
     from_assoc_type_id, from_chalk_trait_id, from_foreign_def_id, from_placeholder_idx,
@@ -529,13 +529,13 @@
 
 impl CallableSig {
     pub fn from_params_and_return(
-        params: impl ExactSizeIterator<Item = Ty>,
+        params: impl Iterator<Item = Ty>,
         ret: Ty,
         is_varargs: bool,
         safety: Safety,
         abi: FnAbi,
     ) -> CallableSig {
-        let mut params_and_return = Vec::with_capacity(params.len() + 1);
+        let mut params_and_return = Vec::with_capacity(params.size_hint().0 + 1);
         params_and_return.extend(params);
         params_and_return.push(ret);
         CallableSig { params_and_return: params_and_return.into(), is_varargs, safety, abi }
diff --git a/crates/hir-ty/src/lower.rs b/crates/hir-ty/src/lower.rs
index 073a584..eecca32 100644
--- a/crates/hir-ty/src/lower.rs
+++ b/crates/hir-ty/src/lower.rs
@@ -25,8 +25,8 @@
 use either::Either;
 use hir_def::{
     AdtId, AssocItemId, CallableDefId, ConstId, ConstParamId, DefWithBodyId, EnumId, EnumVariantId,
-    FunctionId, GenericDefId, GenericParamId, HasModule, ImplId, LocalFieldId, Lookup, StaticId,
-    StructId, TypeAliasId, TypeOrConstParamId, UnionId, VariantId,
+    FunctionId, GenericDefId, GenericParamId, HasModule, ImplId, ItemContainerId, LocalFieldId,
+    Lookup, StaticId, StructId, TypeAliasId, TypeOrConstParamId, UnionId, VariantId,
     builtin_type::BuiltinType,
     expr_store::{ExpressionStore, path::Path},
     hir::generics::{
@@ -35,7 +35,7 @@
     item_tree::FieldsShape,
     lang_item::LangItem,
     resolver::{HasResolver, LifetimeNs, Resolver, TypeNs},
-    signatures::{TraitFlags, TypeAliasFlags},
+    signatures::{FunctionSignature, TraitFlags, TypeAliasFlags},
     type_ref::{
         ConstRef, LifetimeRef, LiteralConstRef, PathId, TraitBoundModifier,
         TraitRef as HirTraitRef, TypeBound, TypeRef, TypeRefId,
@@ -86,21 +86,70 @@
 
 pub(crate) struct PathDiagnosticCallbackData(TypeRefId);
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub(crate) enum GenericArgsPosition {
-    Type,
-    /// E.g. functions.
-    Value,
-    MethodCall,
-    // FIXME: This is a temporary variant we need to work around the lack of lifetime elision.
-    // The reason for its existence is that in `check_generic_args_len()`, without this, we will
-    // not infer elide lifetimes.
-    // They indeed should not be inferred - they should be elided - but we won't elide them either,
-    // emitting an error instead. rustc elides them in late resolve, and the generics it passes
-    // to lowering already include them. We probably can't do that, but we will still need to
-    // account for them when we properly implement lifetime elision.
-    FnSignature,
-    OtherSignature,
+#[derive(Debug, Clone)]
+pub enum LifetimeElisionKind {
+    /// Create a new anonymous lifetime parameter and reference it.
+    ///
+    /// If `report_in_path`, report an error when encountering lifetime elision in a path:
+    /// ```compile_fail
+    /// struct Foo<'a> { x: &'a () }
+    /// async fn foo(x: Foo) {}
+    /// ```
+    ///
+    /// Note: the error should not trigger when the elided lifetime is in a pattern or
+    /// expression-position path:
+    /// ```
+    /// struct Foo<'a> { x: &'a () }
+    /// async fn foo(Foo { x: _ }: Foo<'_>) {}
+    /// ```
+    AnonymousCreateParameter { report_in_path: bool },
+
+    /// Replace all anonymous lifetimes by provided lifetime.
+    Elided(Lifetime),
+
+    /// Give a hard error when either `&` or `'_` is written. Used to
+    /// rule out things like `where T: Foo<'_>`. Does not imply an
+    /// error on default object bounds (e.g., `Box<dyn Foo>`).
+    AnonymousReportError,
+
+    /// Resolves elided lifetimes to `'static` if there are no other lifetimes in scope,
+    /// otherwise give a warning that the previous behavior of introducing a new early-bound
+    /// lifetime is a bug and will be removed (if `only_lint` is enabled).
+    StaticIfNoLifetimeInScope { only_lint: bool },
+
+    /// Signal we cannot find which should be the anonymous lifetime.
+    ElisionFailure,
+
+    /// Infer all elided lifetimes.
+    Infer,
+}
+
+impl LifetimeElisionKind {
+    #[inline]
+    pub(crate) fn for_const(const_parent: ItemContainerId) -> LifetimeElisionKind {
+        match const_parent {
+            ItemContainerId::ExternBlockId(_) | ItemContainerId::ModuleId(_) => {
+                LifetimeElisionKind::Elided(static_lifetime())
+            }
+            ItemContainerId::ImplId(_) => {
+                LifetimeElisionKind::StaticIfNoLifetimeInScope { only_lint: true }
+            }
+            ItemContainerId::TraitId(_) => {
+                LifetimeElisionKind::StaticIfNoLifetimeInScope { only_lint: false }
+            }
+        }
+    }
+
+    #[inline]
+    pub(crate) fn for_fn_params(data: &FunctionSignature) -> LifetimeElisionKind {
+        LifetimeElisionKind::AnonymousCreateParameter { report_in_path: data.is_async() }
+    }
+
+    #[inline]
+    pub(crate) fn for_fn_ret() -> LifetimeElisionKind {
+        // FIXME: We should use the elided lifetime here, or `ElisionFailure`.
+        LifetimeElisionKind::Elided(error_lifetime())
+    }
 }
 
 #[derive(Debug)]
@@ -120,7 +169,7 @@
     /// Tracks types with explicit `?Sized` bounds.
     pub(crate) unsized_types: FxHashSet<Ty>,
     pub(crate) diagnostics: Vec<TyLoweringDiagnostic>,
-    pub(crate) in_fn_signature: bool,
+    lifetime_elision: LifetimeElisionKind,
 }
 
 impl<'a> TyLoweringContext<'a> {
@@ -129,6 +178,7 @@
         resolver: &'a Resolver,
         store: &'a ExpressionStore,
         def: GenericDefId,
+        lifetime_elision: LifetimeElisionKind,
     ) -> Self {
         let impl_trait_mode = ImplTraitLoweringState::new(ImplTraitLoweringMode::Disallowed);
         let type_param_mode = ParamLoweringMode::Placeholder;
@@ -144,7 +194,7 @@
             type_param_mode,
             unsized_types: FxHashSet::default(),
             diagnostics: Vec::new(),
-            in_fn_signature: false,
+            lifetime_elision,
         }
     }
 
@@ -167,6 +217,17 @@
         self.with_debruijn(self.in_binders.shifted_in_from(debruijn), f)
     }
 
+    fn with_lifetime_elision<T>(
+        &mut self,
+        lifetime_elision: LifetimeElisionKind,
+        f: impl FnOnce(&mut TyLoweringContext<'_>) -> T,
+    ) -> T {
+        let old_lifetime_elision = mem::replace(&mut self.lifetime_elision, lifetime_elision);
+        let result = f(self);
+        self.lifetime_elision = old_lifetime_elision;
+        result
+    }
+
     pub fn with_impl_trait_mode(self, impl_trait_mode: ImplTraitLoweringMode) -> Self {
         Self { impl_trait_mode: ImplTraitLoweringState::new(impl_trait_mode), ..self }
     }
@@ -318,10 +379,18 @@
             TypeRef::Placeholder => TyKind::Error.intern(Interner),
             TypeRef::Fn(fn_) => {
                 let substs = self.with_shifted_in(DebruijnIndex::ONE, |ctx| {
-                    Substitution::from_iter(
-                        Interner,
-                        fn_.params.iter().map(|&(_, tr)| ctx.lower_ty(tr)),
-                    )
+                    let (params, ret) = fn_.split_params_and_ret();
+                    let mut subst = Vec::with_capacity(fn_.params.len());
+                    ctx.with_lifetime_elision(
+                        LifetimeElisionKind::AnonymousCreateParameter { report_in_path: false },
+                        |ctx| {
+                            subst.extend(params.iter().map(|&(_, tr)| ctx.lower_ty(tr)));
+                        },
+                    );
+                    ctx.with_lifetime_elision(LifetimeElisionKind::for_fn_ret(), |ctx| {
+                        subst.push(ctx.lower_ty(ret));
+                    });
+                    Substitution::from_iter(Interner, subst)
                 });
                 TyKind::Function(FnPointer {
                     num_binders: 0, // FIXME lower `for<'a> fn()` correctly
@@ -431,11 +500,6 @@
             self,
             Self::on_path_diagnostic_callback(path_id.type_ref()),
             &self.store[path_id],
-            if self.in_fn_signature {
-                GenericArgsPosition::FnSignature
-            } else {
-                GenericArgsPosition::Type
-            },
         )
     }
 
@@ -855,8 +919,14 @@
     };
     let generics = generics(db, def);
     let mut res = ArenaMap::default();
-    let mut ctx = TyLoweringContext::new(db, &resolver, &var_data.store, def)
-        .with_type_param_mode(ParamLoweringMode::Variable);
+    let mut ctx = TyLoweringContext::new(
+        db,
+        &resolver,
+        &var_data.store,
+        def,
+        LifetimeElisionKind::AnonymousReportError,
+    )
+    .with_type_param_mode(ParamLoweringMode::Variable);
     for (field_id, field_data) in var_data.fields().iter() {
         res.insert(field_id, make_binders(db, &generics, ctx.lower_ty(field_data.type_ref)));
     }
@@ -879,8 +949,14 @@
 ) -> GenericPredicates {
     let generics = generics(db, def);
     let resolver = def.resolver(db);
-    let mut ctx = TyLoweringContext::new(db, &resolver, generics.store(), def)
-        .with_type_param_mode(ParamLoweringMode::Variable);
+    let mut ctx = TyLoweringContext::new(
+        db,
+        &resolver,
+        generics.store(),
+        def,
+        LifetimeElisionKind::AnonymousReportError,
+    )
+    .with_type_param_mode(ParamLoweringMode::Variable);
 
     // we have to filter out all other predicates *first*, before attempting to lower them
     let predicate = |pred: &_, generics: &Generics, ctx: &mut TyLoweringContext<'_>| match pred {
@@ -987,8 +1063,14 @@
 ) -> Arc<TraitEnvironment> {
     let generics = generics(db, def);
     let resolver = def.resolver(db);
-    let mut ctx = TyLoweringContext::new(db, &resolver, generics.store(), def)
-        .with_type_param_mode(ParamLoweringMode::Placeholder);
+    let mut ctx = TyLoweringContext::new(
+        db,
+        &resolver,
+        generics.store(),
+        def,
+        LifetimeElisionKind::AnonymousReportError,
+    )
+    .with_type_param_mode(ParamLoweringMode::Placeholder);
     let mut traits_in_scope = Vec::new();
     let mut clauses = Vec::new();
     for maybe_parent_generics in
@@ -1086,8 +1168,14 @@
 {
     let generics = generics(db, def);
     let resolver = def.resolver(db);
-    let mut ctx = TyLoweringContext::new(db, &resolver, generics.store(), def)
-        .with_type_param_mode(ParamLoweringMode::Variable);
+    let mut ctx = TyLoweringContext::new(
+        db,
+        &resolver,
+        generics.store(),
+        def,
+        LifetimeElisionKind::AnonymousReportError,
+    )
+    .with_type_param_mode(ParamLoweringMode::Variable);
 
     let mut predicates = Vec::new();
     for maybe_parent_generics in
@@ -1188,9 +1276,15 @@
     }
     let resolver = def.resolver(db);
 
-    let mut ctx = TyLoweringContext::new(db, &resolver, generic_params.store(), def)
-        .with_impl_trait_mode(ImplTraitLoweringMode::Disallowed)
-        .with_type_param_mode(ParamLoweringMode::Variable);
+    let mut ctx = TyLoweringContext::new(
+        db,
+        &resolver,
+        generic_params.store(),
+        def,
+        LifetimeElisionKind::AnonymousReportError,
+    )
+    .with_impl_trait_mode(ImplTraitLoweringMode::Disallowed)
+    .with_type_param_mode(ParamLoweringMode::Variable);
     let mut idx = 0;
     let mut has_any_default = false;
     let mut defaults = generic_params
@@ -1273,17 +1367,27 @@
 fn fn_sig_for_fn(db: &dyn HirDatabase, def: FunctionId) -> PolyFnSig {
     let data = db.function_signature(def);
     let resolver = def.resolver(db);
-    let mut ctx_params = TyLoweringContext::new(db, &resolver, &data.store, def.into())
-        .with_type_param_mode(ParamLoweringMode::Variable);
-    ctx_params.in_fn_signature = true;
+    let mut ctx_params = TyLoweringContext::new(
+        db,
+        &resolver,
+        &data.store,
+        def.into(),
+        LifetimeElisionKind::for_fn_params(&data),
+    )
+    .with_type_param_mode(ParamLoweringMode::Variable);
     let params = data.params.iter().map(|&tr| ctx_params.lower_ty(tr));
 
     let ret = match data.ret_type {
         Some(ret_type) => {
-            let mut ctx_ret = TyLoweringContext::new(db, &resolver, &data.store, def.into())
-                .with_impl_trait_mode(ImplTraitLoweringMode::Opaque)
-                .with_type_param_mode(ParamLoweringMode::Variable);
-            ctx_ret.in_fn_signature = true;
+            let mut ctx_ret = TyLoweringContext::new(
+                db,
+                &resolver,
+                &data.store,
+                def.into(),
+                LifetimeElisionKind::for_fn_ret(),
+            )
+            .with_impl_trait_mode(ImplTraitLoweringMode::Opaque)
+            .with_type_param_mode(ParamLoweringMode::Variable);
             ctx_ret.lower_ty(ret_type)
         }
         None => TyKind::Tuple(0, Substitution::empty(Interner)).intern(Interner),
@@ -1316,8 +1420,15 @@
     let data = db.const_signature(def);
     let generics = generics(db, def.into());
     let resolver = def.resolver(db);
-    let mut ctx = TyLoweringContext::new(db, &resolver, &data.store, def.into())
-        .with_type_param_mode(ParamLoweringMode::Variable);
+    let parent = def.loc(db).container;
+    let mut ctx = TyLoweringContext::new(
+        db,
+        &resolver,
+        &data.store,
+        def.into(),
+        LifetimeElisionKind::for_const(parent),
+    )
+    .with_type_param_mode(ParamLoweringMode::Variable);
 
     make_binders(db, &generics, ctx.lower_ty(data.type_ref))
 }
@@ -1326,18 +1437,20 @@
 fn type_for_static(db: &dyn HirDatabase, def: StaticId) -> Binders<Ty> {
     let data = db.static_signature(def);
     let resolver = def.resolver(db);
-    let mut ctx = TyLoweringContext::new(db, &resolver, &data.store, def.into());
+    let mut ctx = TyLoweringContext::new(
+        db,
+        &resolver,
+        &data.store,
+        def.into(),
+        LifetimeElisionKind::Elided(static_lifetime()),
+    );
 
     Binders::empty(Interner, ctx.lower_ty(data.type_ref))
 }
 
 fn fn_sig_for_struct_constructor(db: &dyn HirDatabase, def: StructId) -> PolyFnSig {
-    let struct_data = db.variant_fields(def.into());
-    let fields = struct_data.fields();
-    let resolver = def.resolver(db);
-    let mut ctx = TyLoweringContext::new(db, &resolver, &struct_data.store, def.into())
-        .with_type_param_mode(ParamLoweringMode::Variable);
-    let params = fields.iter().map(|(_, field)| ctx.lower_ty(field.type_ref));
+    let field_tys = db.field_types(def.into());
+    let params = field_tys.iter().map(|(_, ty)| ty.skip_binders().clone());
     let (ret, binders) = type_for_adt(db, def.into()).into_value_and_skipped_binders();
     Binders::new(
         binders,
@@ -1364,13 +1477,9 @@
 }
 
 fn fn_sig_for_enum_variant_constructor(db: &dyn HirDatabase, def: EnumVariantId) -> PolyFnSig {
-    let var_data = db.variant_fields(def.into());
-    let fields = var_data.fields();
-    let resolver = def.resolver(db);
+    let field_tys = db.field_types(def.into());
+    let params = field_tys.iter().map(|(_, ty)| ty.skip_binders().clone());
     let parent = def.lookup(db).parent;
-    let mut ctx = TyLoweringContext::new(db, &resolver, &var_data.store, parent.into())
-        .with_type_param_mode(ParamLoweringMode::Variable);
-    let params = fields.iter().map(|(_, field)| ctx.lower_ty(field.type_ref));
     let (ret, binders) = type_for_adt(db, parent.into()).into_value_and_skipped_binders();
     Binders::new(
         binders,
@@ -1429,9 +1538,15 @@
     } else {
         let resolver = t.resolver(db);
         let alias = db.type_alias_signature(t);
-        let mut ctx = TyLoweringContext::new(db, &resolver, &alias.store, t.into())
-            .with_impl_trait_mode(ImplTraitLoweringMode::Opaque)
-            .with_type_param_mode(ParamLoweringMode::Variable);
+        let mut ctx = TyLoweringContext::new(
+            db,
+            &resolver,
+            &alias.store,
+            t.into(),
+            LifetimeElisionKind::AnonymousReportError,
+        )
+        .with_impl_trait_mode(ImplTraitLoweringMode::Opaque)
+        .with_type_param_mode(ParamLoweringMode::Variable);
         let res = alias
             .ty
             .map(|type_ref| ctx.lower_ty(type_ref))
@@ -1517,8 +1632,14 @@
     let impl_data = db.impl_signature(impl_id);
     let resolver = impl_id.resolver(db);
     let generics = generics(db, impl_id.into());
-    let mut ctx = TyLoweringContext::new(db, &resolver, &impl_data.store, impl_id.into())
-        .with_type_param_mode(ParamLoweringMode::Variable);
+    let mut ctx = TyLoweringContext::new(
+        db,
+        &resolver,
+        &impl_data.store,
+        impl_id.into(),
+        LifetimeElisionKind::AnonymousCreateParameter { report_in_path: true },
+    )
+    .with_type_param_mode(ParamLoweringMode::Variable);
     (
         make_binders(db, &generics, ctx.lower_ty(impl_data.self_ty)),
         create_diagnostics(ctx.diagnostics),
@@ -1537,7 +1658,13 @@
     let (parent_data, store) = db.generic_params_and_store(def.parent());
     let data = &parent_data[def.local_id()];
     let resolver = def.parent().resolver(db);
-    let mut ctx = TyLoweringContext::new(db, &resolver, &store, def.parent());
+    let mut ctx = TyLoweringContext::new(
+        db,
+        &resolver,
+        &store,
+        def.parent(),
+        LifetimeElisionKind::AnonymousReportError,
+    );
     let ty = match data {
         TypeOrConstParamData::TypeParamData(_) => {
             never!();
@@ -1566,8 +1693,14 @@
 ) -> Option<(Binders<TraitRef>, Diagnostics)> {
     let impl_data = db.impl_signature(impl_id);
     let resolver = impl_id.resolver(db);
-    let mut ctx = TyLoweringContext::new(db, &resolver, &impl_data.store, impl_id.into())
-        .with_type_param_mode(ParamLoweringMode::Variable);
+    let mut ctx = TyLoweringContext::new(
+        db,
+        &resolver,
+        &impl_data.store,
+        impl_id.into(),
+        LifetimeElisionKind::AnonymousCreateParameter { report_in_path: true },
+    )
+    .with_type_param_mode(ParamLoweringMode::Variable);
     let (self_ty, binders) = db.impl_self_ty(impl_id).into_value_and_skipped_binders();
     let target_trait = impl_data.target_trait.as_ref()?;
     let trait_ref = Binders::new(binders, ctx.lower_trait_ref(target_trait, self_ty)?);
@@ -1581,9 +1714,10 @@
     // FIXME unify with fn_sig_for_fn instead of doing lowering twice, maybe
     let data = db.function_signature(def);
     let resolver = def.resolver(db);
-    let mut ctx_ret = TyLoweringContext::new(db, &resolver, &data.store, def.into())
-        .with_impl_trait_mode(ImplTraitLoweringMode::Opaque)
-        .with_type_param_mode(ParamLoweringMode::Variable);
+    let mut ctx_ret =
+        TyLoweringContext::new(db, &resolver, &data.store, def.into(), LifetimeElisionKind::Infer)
+            .with_impl_trait_mode(ImplTraitLoweringMode::Opaque)
+            .with_type_param_mode(ParamLoweringMode::Variable);
     if let Some(ret_type) = data.ret_type {
         let _ret = ctx_ret.lower_ty(ret_type);
     }
@@ -1603,9 +1737,15 @@
 ) -> Option<Arc<Binders<ImplTraits>>> {
     let data = db.type_alias_signature(def);
     let resolver = def.resolver(db);
-    let mut ctx = TyLoweringContext::new(db, &resolver, &data.store, def.into())
-        .with_impl_trait_mode(ImplTraitLoweringMode::Opaque)
-        .with_type_param_mode(ParamLoweringMode::Variable);
+    let mut ctx = TyLoweringContext::new(
+        db,
+        &resolver,
+        &data.store,
+        def.into(),
+        LifetimeElisionKind::AnonymousReportError,
+    )
+    .with_impl_trait_mode(ImplTraitLoweringMode::Opaque)
+    .with_type_param_mode(ParamLoweringMode::Variable);
     if let Some(type_ref) = data.ty {
         let _ty = ctx.lower_ty(type_ref);
     }
diff --git a/crates/hir-ty/src/lower/diagnostics.rs b/crates/hir-ty/src/lower/diagnostics.rs
index a5a13d6..009f047 100644
--- a/crates/hir-ty/src/lower/diagnostics.rs
+++ b/crates/hir-ty/src/lower/diagnostics.rs
@@ -63,6 +63,24 @@
         /// Whether the `GenericArgs` contains a `Self` arg.
         has_self_arg: bool,
     },
+    ElidedLifetimesInPath {
+        generics_source: PathGenericsSource,
+        def: GenericDefId,
+        expected_count: u32,
+        hard_error: bool,
+    },
+    /// An elided lifetimes was used (either implicitly, by not specifying lifetimes, or explicitly, by using `'_`),
+    /// but lifetime elision could not find a lifetime to replace it with.
+    ElisionFailure {
+        generics_source: PathGenericsSource,
+        def: GenericDefId,
+        expected_count: u32,
+    },
+    MissingLifetime {
+        generics_source: PathGenericsSource,
+        def: GenericDefId,
+        expected_count: u32,
+    },
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
diff --git a/crates/hir-ty/src/lower/path.rs b/crates/hir-ty/src/lower/path.rs
index c89aad8..d3ca438 100644
--- a/crates/hir-ty/src/lower/path.rs
+++ b/crates/hir-ty/src/lower/path.rs
@@ -27,8 +27,8 @@
     db::HirDatabase,
     error_lifetime,
     generics::{Generics, generics},
-    lower::{GenericArgsPosition, named_associated_type_shorthand_candidates},
-    to_assoc_type_id, to_chalk_trait_id, to_placeholder_idx,
+    lower::{LifetimeElisionKind, named_associated_type_shorthand_candidates},
+    static_lifetime, to_assoc_type_id, to_chalk_trait_id, to_placeholder_idx,
     utils::associated_type_by_name_including_super_traits,
 };
 
@@ -52,7 +52,6 @@
     current_segment_idx: usize,
     /// Contains the previous segment if `current_segment_idx == segments.len()`
     current_or_prev_segment: PathSegment<'a>,
-    position: GenericArgsPosition,
 }
 
 impl<'a, 'b> PathLoweringContext<'a, 'b> {
@@ -61,7 +60,6 @@
         ctx: &'a mut TyLoweringContext<'b>,
         on_diagnostic: PathDiagnosticCallback<'a>,
         path: &'a Path,
-        position: GenericArgsPosition,
     ) -> Self {
         let segments = path.segments();
         let first_segment = segments.first().unwrap_or(PathSegment::MISSING);
@@ -72,7 +70,6 @@
             segments,
             current_segment_idx: 0,
             current_or_prev_segment: first_segment,
-            position,
         }
     }
 
@@ -122,6 +119,19 @@
             .expect("invalid segment passed to PathLoweringContext::set_current_segment()");
     }
 
+    #[inline]
+    fn with_lifetime_elision<T>(
+        &mut self,
+        lifetime_elision: LifetimeElisionKind,
+        f: impl FnOnce(&mut PathLoweringContext<'_, '_>) -> T,
+    ) -> T {
+        let old_lifetime_elision =
+            std::mem::replace(&mut self.ctx.lifetime_elision, lifetime_elision);
+        let result = f(self);
+        self.ctx.lifetime_elision = old_lifetime_elision;
+        result
+    }
+
     pub(crate) fn lower_ty_relative_path(
         &mut self,
         ty: Ty,
@@ -141,22 +151,6 @@
         }
     }
 
-    fn prohibit_parenthesized_generic_args(&mut self) -> bool {
-        if let Some(generic_args) = self.current_or_prev_segment.args_and_bindings {
-            match generic_args.parenthesized {
-                GenericArgsParentheses::No => {}
-                GenericArgsParentheses::ReturnTypeNotation | GenericArgsParentheses::ParenSugar => {
-                    let segment = self.current_segment_u32();
-                    self.on_diagnostic(
-                        PathLoweringDiagnostic::ParenthesizedGenericArgsWithoutFnTrait { segment },
-                    );
-                    return true;
-                }
-            }
-        }
-        false
-    }
-
     // When calling this, the current segment is the resolved segment (we don't advance it yet).
     pub(crate) fn lower_partly_resolved_path(
         &mut self,
@@ -189,6 +183,7 @@
                                     associated_ty.into(),
                                     false,
                                     None,
+                                    true,
                                 );
                                 let substitution = Substitution::from_iter(
                                     Interner,
@@ -511,7 +506,7 @@
                 // generic params. It's inefficient to splice the `Substitution`s, so we may want
                 // that method to optionally take parent `Substitution` as we already know them at
                 // this point (`t.substitution`).
-                let substs = self.substs_from_path_segment(associated_ty.into(), false, None);
+                let substs = self.substs_from_path_segment(associated_ty.into(), false, None, true);
 
                 let substs = Substitution::from_iter(
                     Interner,
@@ -539,7 +534,7 @@
             TyDefId::AdtId(it) => it.into(),
             TyDefId::TypeAliasId(it) => it.into(),
         };
-        let substs = self.substs_from_path_segment(generic_def, infer_args, None);
+        let substs = self.substs_from_path_segment(generic_def, infer_args, None, false);
         self.ctx.db.ty(typeable).substitute(Interner, &substs)
     }
 
@@ -552,6 +547,7 @@
         // special-case enum variants
         resolved: ValueTyDefId,
         infer_args: bool,
+        lowering_assoc_type_generics: bool,
     ) -> Substitution {
         let prev_current_segment_idx = self.current_segment_idx;
         let prev_current_segment = self.current_or_prev_segment;
@@ -588,7 +584,12 @@
                 var.lookup(self.ctx.db).parent.into()
             }
         };
-        let result = self.substs_from_path_segment(generic_def, infer_args, None);
+        let result = self.substs_from_path_segment(
+            generic_def,
+            infer_args,
+            None,
+            lowering_assoc_type_generics,
+        );
         self.current_segment_idx = prev_current_segment_idx;
         self.current_or_prev_segment = prev_current_segment;
         result
@@ -599,26 +600,41 @@
         def: GenericDefId,
         infer_args: bool,
         explicit_self_ty: Option<Ty>,
+        lowering_assoc_type_generics: bool,
     ) -> Substitution {
-        let prohibit_parens = match def {
-            GenericDefId::TraitId(trait_) => {
-                // RTN is prohibited anyways if we got here.
-                let is_rtn =
-                    self.current_or_prev_segment.args_and_bindings.is_some_and(|generics| {
-                        generics.parenthesized == GenericArgsParentheses::ReturnTypeNotation
-                    });
-                let is_fn_trait = !self
-                    .ctx
-                    .db
-                    .trait_signature(trait_)
-                    .flags
-                    .contains(TraitFlags::RUSTC_PAREN_SUGAR);
-                is_rtn || is_fn_trait
+        let mut lifetime_elision = self.ctx.lifetime_elision.clone();
+
+        if let Some(args) = self.current_or_prev_segment.args_and_bindings {
+            if args.parenthesized != GenericArgsParentheses::No {
+                let prohibit_parens = match def {
+                    GenericDefId::TraitId(trait_) => {
+                        // RTN is prohibited anyways if we got here.
+                        let is_rtn =
+                            args.parenthesized == GenericArgsParentheses::ReturnTypeNotation;
+                        let is_fn_trait = self
+                            .ctx
+                            .db
+                            .trait_signature(trait_)
+                            .flags
+                            .contains(TraitFlags::RUSTC_PAREN_SUGAR);
+                        is_rtn || !is_fn_trait
+                    }
+                    _ => true,
+                };
+
+                if prohibit_parens {
+                    let segment = self.current_segment_u32();
+                    self.on_diagnostic(
+                        PathLoweringDiagnostic::ParenthesizedGenericArgsWithoutFnTrait { segment },
+                    );
+
+                    return TyBuilder::unknown_subst(self.ctx.db, def);
+                }
+
+                // `Fn()`-style generics are treated like functions for the purpose of lifetime elision.
+                lifetime_elision =
+                    LifetimeElisionKind::AnonymousCreateParameter { report_in_path: false };
             }
-            _ => true,
-        };
-        if prohibit_parens && self.prohibit_parenthesized_generic_args() {
-            return TyBuilder::unknown_subst(self.ctx.db, def);
         }
 
         self.substs_from_args_and_bindings(
@@ -627,6 +643,8 @@
             infer_args,
             explicit_self_ty,
             PathGenericsSource::Segment(self.current_segment_u32()),
+            lowering_assoc_type_generics,
+            lifetime_elision,
         )
     }
 
@@ -637,6 +655,8 @@
         infer_args: bool,
         explicit_self_ty: Option<Ty>,
         generics_source: PathGenericsSource,
+        lowering_assoc_type_generics: bool,
+        lifetime_elision: LifetimeElisionKind,
     ) -> Substitution {
         struct LowererCtx<'a, 'b, 'c> {
             ctx: &'a mut PathLoweringContext<'b, 'c>,
@@ -761,6 +781,36 @@
                     GenericParamId::LifetimeParamId(_) => error_lifetime().cast(Interner),
                 }
             }
+
+            fn report_elided_lifetimes_in_path(
+                &mut self,
+                def: GenericDefId,
+                expected_count: u32,
+                hard_error: bool,
+            ) {
+                self.ctx.on_diagnostic(PathLoweringDiagnostic::ElidedLifetimesInPath {
+                    generics_source: self.generics_source,
+                    def,
+                    expected_count,
+                    hard_error,
+                });
+            }
+
+            fn report_elision_failure(&mut self, def: GenericDefId, expected_count: u32) {
+                self.ctx.on_diagnostic(PathLoweringDiagnostic::ElisionFailure {
+                    generics_source: self.generics_source,
+                    def,
+                    expected_count,
+                });
+            }
+
+            fn report_missing_lifetime(&mut self, def: GenericDefId, expected_count: u32) {
+                self.ctx.on_diagnostic(PathLoweringDiagnostic::MissingLifetime {
+                    generics_source: self.generics_source,
+                    def,
+                    expected_count,
+                });
+            }
         }
 
         substs_from_args_and_bindings(
@@ -769,7 +819,8 @@
             args_and_bindings,
             def,
             infer_args,
-            self.position,
+            lifetime_elision,
+            lowering_assoc_type_generics,
             explicit_self_ty,
             &mut LowererCtx { ctx: self, generics_source },
         )
@@ -789,7 +840,7 @@
         resolved: TraitId,
         explicit_self_ty: Ty,
     ) -> Substitution {
-        self.substs_from_path_segment(resolved.into(), false, Some(explicit_self_ty))
+        self.substs_from_path_segment(resolved.into(), false, Some(explicit_self_ty), false)
     }
 
     pub(super) fn assoc_type_bindings_from_type_bound<'c>(
@@ -807,20 +858,25 @@
                     None => return SmallVec::new(),
                     Some(t) => t,
                 };
-                // FIXME: `substs_from_path_segment()` pushes `TyKind::Error` for every parent
-                // generic params. It's inefficient to splice the `Substitution`s, so we may want
-                // that method to optionally take parent `Substitution` as we already know them at
-                // this point (`super_trait_ref.substitution`).
-                let substitution = self.substs_from_args_and_bindings(
-                    binding.args.as_ref(),
-                    associated_ty.into(),
-                    false, // this is not relevant
-                    Some(super_trait_ref.self_type_parameter(Interner)),
-                    PathGenericsSource::AssocType {
-                        segment: self.current_segment_u32(),
-                        assoc_type: binding_idx as u32,
-                    },
-                );
+                let substitution =
+                    self.with_lifetime_elision(LifetimeElisionKind::AnonymousReportError, |this| {
+                        // FIXME: `substs_from_path_segment()` pushes `TyKind::Error` for every parent
+                        // generic params. It's inefficient to splice the `Substitution`s, so we may want
+                        // that method to optionally take parent `Substitution` as we already know them at
+                        // this point (`super_trait_ref.substitution`).
+                        this.substs_from_args_and_bindings(
+                            binding.args.as_ref(),
+                            associated_ty.into(),
+                            false, // this is not relevant
+                            Some(super_trait_ref.self_type_parameter(Interner)),
+                            PathGenericsSource::AssocType {
+                                segment: this.current_segment_u32(),
+                                assoc_type: binding_idx as u32,
+                            },
+                            false,
+                            this.ctx.lifetime_elision.clone(),
+                        )
+                    });
                 let substitution = Substitution::from_iter(
                     Interner,
                     super_trait_ref.substitution.iter(Interner).chain(
@@ -836,25 +892,48 @@
                 let mut predicates: SmallVec<[_; 1]> = SmallVec::with_capacity(
                     binding.type_ref.as_ref().map_or(0, |_| 1) + binding.bounds.len(),
                 );
+
                 if let Some(type_ref) = binding.type_ref {
-                    match (&self.ctx.store[type_ref], self.ctx.impl_trait_mode.mode) {
-                        (TypeRef::ImplTrait(_), ImplTraitLoweringMode::Disallowed) => (),
-                        (_, ImplTraitLoweringMode::Disallowed | ImplTraitLoweringMode::Opaque) => {
-                            let ty = self.ctx.lower_ty(type_ref);
-                            let alias_eq =
-                                AliasEq { alias: AliasTy::Projection(projection_ty.clone()), ty };
-                            predicates
-                                .push(crate::wrap_empty_binders(WhereClause::AliasEq(alias_eq)));
+                    let lifetime_elision =
+                        if args_and_bindings.parenthesized == GenericArgsParentheses::ParenSugar {
+                            // `Fn()`-style generics are elided like functions. This is `Output` (we lower to it in hir-def).
+                            LifetimeElisionKind::for_fn_ret()
+                        } else {
+                            self.ctx.lifetime_elision.clone()
+                        };
+                    self.with_lifetime_elision(lifetime_elision, |this| {
+                        match (&this.ctx.store[type_ref], this.ctx.impl_trait_mode.mode) {
+                            (TypeRef::ImplTrait(_), ImplTraitLoweringMode::Disallowed) => (),
+                            (
+                                _,
+                                ImplTraitLoweringMode::Disallowed | ImplTraitLoweringMode::Opaque,
+                            ) => {
+                                let ty = this.ctx.lower_ty(type_ref);
+                                let alias_eq = AliasEq {
+                                    alias: AliasTy::Projection(projection_ty.clone()),
+                                    ty,
+                                };
+                                predicates.push(crate::wrap_empty_binders(WhereClause::AliasEq(
+                                    alias_eq,
+                                )));
+                            }
                         }
+                    });
+                }
+
+                self.with_lifetime_elision(LifetimeElisionKind::AnonymousReportError, |this| {
+                    for bound in binding.bounds.iter() {
+                        predicates.extend(
+                            this.ctx.lower_type_bound(
+                                bound,
+                                TyKind::Alias(AliasTy::Projection(projection_ty.clone()))
+                                    .intern(Interner),
+                                false,
+                            ),
+                        );
                     }
-                }
-                for bound in binding.bounds.iter() {
-                    predicates.extend(self.ctx.lower_type_bound(
-                        bound,
-                        TyKind::Alias(AliasTy::Projection(projection_ty.clone())).intern(Interner),
-                        false,
-                    ));
-                }
+                });
+
                 predicates
             })
         })
@@ -868,6 +947,17 @@
 }
 
 pub(crate) trait GenericArgsLowerer {
+    fn report_elided_lifetimes_in_path(
+        &mut self,
+        def: GenericDefId,
+        expected_count: u32,
+        hard_error: bool,
+    );
+
+    fn report_elision_failure(&mut self, def: GenericDefId, expected_count: u32);
+
+    fn report_missing_lifetime(&mut self, def: GenericDefId, expected_count: u32);
+
     fn report_len_mismatch(
         &mut self,
         def: GenericDefId,
@@ -905,7 +995,8 @@
     def: GenericDefId,
     def_generics: &Generics,
     infer_args: bool,
-    position: GenericArgsPosition,
+    lifetime_elision: &LifetimeElisionKind,
+    lowering_assoc_type_generics: bool,
     ctx: &mut impl GenericArgsLowerer,
 ) -> bool {
     let mut had_error = false;
@@ -921,19 +1012,37 @@
         }
     }
 
-    // FIXME: Function signature lifetime elision has to be considered here once we have it
-    let infer_lifetimes =
-        position != GenericArgsPosition::OtherSignature && provided_lifetimes_count == 0;
-
-    let max_expected_lifetime_args = def_generics.len_lifetimes_self();
-    let min_expected_lifetime_args = if infer_lifetimes { 0 } else { max_expected_lifetime_args };
-    if provided_lifetimes_count < min_expected_lifetime_args
-        || max_expected_lifetime_args < provided_lifetimes_count
-    {
+    let lifetime_args_len = def_generics.len_lifetimes_self();
+    if provided_lifetimes_count == 0 && lifetime_args_len > 0 && !lowering_assoc_type_generics {
+        // In generic associated types, we never allow inferring the lifetimes.
+        match lifetime_elision {
+            &LifetimeElisionKind::AnonymousCreateParameter { report_in_path } => {
+                ctx.report_elided_lifetimes_in_path(def, lifetime_args_len as u32, report_in_path);
+                had_error |= report_in_path;
+            }
+            LifetimeElisionKind::AnonymousReportError => {
+                ctx.report_missing_lifetime(def, lifetime_args_len as u32);
+                had_error = true
+            }
+            LifetimeElisionKind::ElisionFailure => {
+                ctx.report_elision_failure(def, lifetime_args_len as u32);
+                had_error = true;
+            }
+            LifetimeElisionKind::StaticIfNoLifetimeInScope { only_lint: _ } => {
+                // FIXME: Check there are other lifetimes in scope, and error/lint.
+            }
+            LifetimeElisionKind::Elided(_) => {
+                ctx.report_elided_lifetimes_in_path(def, lifetime_args_len as u32, false);
+            }
+            LifetimeElisionKind::Infer => {
+                // Allow eliding lifetimes.
+            }
+        }
+    } else if lifetime_args_len != provided_lifetimes_count {
         ctx.report_len_mismatch(
             def,
             provided_lifetimes_count as u32,
-            max_expected_lifetime_args as u32,
+            lifetime_args_len as u32,
             IncorrectGenericsLenKind::Lifetimes,
         );
         had_error = true;
@@ -974,7 +1083,8 @@
     args_and_bindings: Option<&GenericArgs>,
     def: GenericDefId,
     mut infer_args: bool,
-    position: GenericArgsPosition,
+    lifetime_elision: LifetimeElisionKind,
+    lowering_assoc_type_generics: bool,
     explicit_self_ty: Option<Ty>,
     ctx: &mut impl GenericArgsLowerer,
 ) -> Substitution {
@@ -991,8 +1101,15 @@
         args_slice.iter().any(|arg| !matches!(arg, GenericArg::Lifetime(_)));
     infer_args &= !has_non_lifetime_args;
 
-    let had_count_error =
-        check_generic_args_len(args_and_bindings, def, &def_generics, infer_args, position, ctx);
+    let had_count_error = check_generic_args_len(
+        args_and_bindings,
+        def,
+        &def_generics,
+        infer_args,
+        &lifetime_elision,
+        lowering_assoc_type_generics,
+        ctx,
+    );
 
     let mut substs = Vec::with_capacity(def_generics.len());
 
@@ -1120,7 +1237,29 @@
 
             (None, Some(&(param_id, param))) => {
                 // If there are fewer arguments than parameters, it means we're inferring the remaining arguments.
-                substs.push(ctx.inferred_kind(def, param_id, param, infer_args, &substs));
+                let param = if let GenericParamId::LifetimeParamId(_) = param_id {
+                    match &lifetime_elision {
+                        LifetimeElisionKind::ElisionFailure
+                        | LifetimeElisionKind::AnonymousCreateParameter { report_in_path: true }
+                        | LifetimeElisionKind::AnonymousReportError => {
+                            assert!(had_count_error);
+                            ctx.inferred_kind(def, param_id, param, infer_args, &substs)
+                        }
+                        LifetimeElisionKind::StaticIfNoLifetimeInScope { only_lint: _ } => {
+                            static_lifetime().cast(Interner)
+                        }
+                        LifetimeElisionKind::Elided(lifetime) => lifetime.clone().cast(Interner),
+                        LifetimeElisionKind::AnonymousCreateParameter { report_in_path: false }
+                        | LifetimeElisionKind::Infer => {
+                            // FIXME: With `AnonymousCreateParameter`, we need to create a new lifetime parameter here
+                            // (but this will probably be done in hir-def lowering instead).
+                            ctx.inferred_kind(def, param_id, param, infer_args, &substs)
+                        }
+                    }
+                } else {
+                    ctx.inferred_kind(def, param_id, param, infer_args, &substs)
+                };
+                substs.push(param);
                 params.next();
             }
 
diff --git a/crates/hir/src/diagnostics.rs b/crates/hir/src/diagnostics.rs
index d8bcaa0..b6e3002 100644
--- a/crates/hir/src/diagnostics.rs
+++ b/crates/hir/src/diagnostics.rs
@@ -118,6 +118,8 @@
     BadRtn,
     IncorrectGenericsLen,
     IncorrectGenericsOrder,
+    MissingLifetime,
+    ElidedLifetimesInPath,
 ];
 
 #[derive(Debug)]
@@ -440,6 +442,23 @@
     pub def: GenericDef,
 }
 
+#[derive(Debug)]
+pub struct MissingLifetime {
+    /// Points at the name if there are no generics.
+    pub generics_or_segment: InFile<AstPtr<Either<ast::GenericArgList, ast::NameRef>>>,
+    pub expected: u32,
+    pub def: GenericDef,
+}
+
+#[derive(Debug)]
+pub struct ElidedLifetimesInPath {
+    /// Points at the name if there are no generics.
+    pub generics_or_segment: InFile<AstPtr<Either<ast::GenericArgList, ast::NameRef>>>,
+    pub expected: u32,
+    pub def: GenericDef,
+    pub hard_error: bool,
+}
+
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum GenericArgKind {
     Lifetime,
@@ -861,6 +880,31 @@
                 let expected_kind = GenericArgKind::from_id(param_id);
                 IncorrectGenericsOrder { provided_arg, expected_kind }.into()
             }
+            PathLoweringDiagnostic::MissingLifetime { generics_source, expected_count, def }
+            | PathLoweringDiagnostic::ElisionFailure { generics_source, expected_count, def } => {
+                let generics_or_segment =
+                    path_generics_source_to_ast(&path.value, generics_source)?;
+                let generics_or_segment = path.with_value(AstPtr::new(&generics_or_segment));
+                MissingLifetime { generics_or_segment, expected: expected_count, def: def.into() }
+                    .into()
+            }
+            PathLoweringDiagnostic::ElidedLifetimesInPath {
+                generics_source,
+                expected_count,
+                def,
+                hard_error,
+            } => {
+                let generics_or_segment =
+                    path_generics_source_to_ast(&path.value, generics_source)?;
+                let generics_or_segment = path.with_value(AstPtr::new(&generics_or_segment));
+                ElidedLifetimesInPath {
+                    generics_or_segment,
+                    expected: expected_count,
+                    def: def.into(),
+                    hard_error,
+                }
+                .into()
+            }
         })
     }
 
diff --git a/crates/hir/src/source_analyzer.rs b/crates/hir/src/source_analyzer.rs
index 108c8f0..00e67fb 100644
--- a/crates/hir/src/source_analyzer.rs
+++ b/crates/hir/src/source_analyzer.rs
@@ -34,8 +34,8 @@
     name::{AsName, Name},
 };
 use hir_ty::{
-    Adjustment, AliasTy, InferenceResult, Interner, ProjectionTy, Substitution, TraitEnvironment,
-    Ty, TyExt, TyKind, TyLoweringContext,
+    Adjustment, AliasTy, InferenceResult, Interner, LifetimeElisionKind, ProjectionTy,
+    Substitution, TraitEnvironment, Ty, TyExt, TyKind, TyLoweringContext,
     diagnostics::{
         InsideUnsafeBlock, record_literal_missing_fields, record_pattern_missing_fields,
         unsafe_operations,
@@ -261,11 +261,15 @@
 
     pub(crate) fn type_of_type(&self, db: &dyn HirDatabase, ty: &ast::Type) -> Option<Type> {
         let type_ref = self.type_id(ty)?;
-        let ty = hir_ty::TyLoweringContext::new(
+        let ty = TyLoweringContext::new(
             db,
             &self.resolver,
             self.store()?,
             self.resolver.generic_def()?,
+            // FIXME: Is this correct here? Anyway that should impact mostly diagnostics, which we don't emit here
+            // (this can impact the lifetimes generated, e.g. in `const` they won't be `'static`, but this seems like a
+            // small problem).
+            LifetimeElisionKind::Infer,
         )
         .lower_ty(type_ref);
         Some(Type::new_with_resolver(db, &self.resolver, ty))
@@ -1553,7 +1557,8 @@
         let (ty, unresolved) = match path.type_anchor() {
             Some(type_ref) => resolver.generic_def().and_then(|def| {
                 let (_, res) =
-                    TyLoweringContext::new(db, resolver, store?, def).lower_ty_ext(type_ref);
+                    TyLoweringContext::new(db, resolver, store?, def, LifetimeElisionKind::Infer)
+                        .lower_ty_ext(type_ref);
                 res.map(|ty_ns| (ty_ns, path.segments().first()))
             }),
             None => {
@@ -1681,7 +1686,8 @@
         let (ty, unresolved) = match path.type_anchor() {
             Some(type_ref) => resolver.generic_def().and_then(|def| {
                 let (_, res) =
-                    TyLoweringContext::new(db, resolver, store, def).lower_ty_ext(type_ref);
+                    TyLoweringContext::new(db, resolver, store, def, LifetimeElisionKind::Infer)
+                        .lower_ty_ext(type_ref);
                 res.map(|ty_ns| (ty_ns, path.segments().first()))
             }),
             None => {
diff --git a/crates/ide-diagnostics/src/handlers/elided_lifetimes_in_path.rs b/crates/ide-diagnostics/src/handlers/elided_lifetimes_in_path.rs
new file mode 100644
index 0000000..438dd2f
--- /dev/null
+++ b/crates/ide-diagnostics/src/handlers/elided_lifetimes_in_path.rs
@@ -0,0 +1,112 @@
+use crate::{Diagnostic, DiagnosticCode, DiagnosticsContext};
+
+// Diagnostic: elided-lifetimes-in-path
+//
+// This diagnostic is triggered when lifetimes are elided in paths. It is a lint only for some cases,
+// and a hard error for others.
+pub(crate) fn elided_lifetimes_in_path(
+    ctx: &DiagnosticsContext<'_>,
+    d: &hir::ElidedLifetimesInPath,
+) -> Diagnostic {
+    if d.hard_error {
+        Diagnostic::new_with_syntax_node_ptr(
+            ctx,
+            DiagnosticCode::RustcHardError("E0726"),
+            "implicit elided lifetime not allowed here",
+            d.generics_or_segment.map(Into::into),
+        )
+        .experimental()
+    } else {
+        Diagnostic::new_with_syntax_node_ptr(
+            ctx,
+            DiagnosticCode::RustcLint("elided_lifetimes_in_paths"),
+            "hidden lifetime parameters in types are deprecated",
+            d.generics_or_segment.map(Into::into),
+        )
+        .experimental()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::tests::check_diagnostics;
+
+    #[test]
+    fn fn_() {
+        check_diagnostics(
+            r#"
+#![warn(elided_lifetimes_in_paths)]
+
+struct Foo<'a>(&'a ());
+
+fn foo(_: Foo) {}
+       // ^^^ warn: hidden lifetime parameters in types are deprecated
+        "#,
+        );
+        check_diagnostics(
+            r#"
+#![warn(elided_lifetimes_in_paths)]
+
+struct Foo<'a>(&'a ());
+
+fn foo(_: Foo<'_>) -> Foo { loop {} }
+                   // ^^^ warn: hidden lifetime parameters in types are deprecated
+        "#,
+        );
+    }
+
+    #[test]
+    fn async_fn() {
+        check_diagnostics(
+            r#"
+struct Foo<'a>(&'a ());
+
+async fn foo(_: Foo) {}
+             // ^^^ error: implicit elided lifetime not allowed here
+        "#,
+        );
+        check_diagnostics(
+            r#"
+#![warn(elided_lifetimes_in_paths)]
+
+struct Foo<'a>(&'a ());
+
+fn foo(_: Foo<'_>) -> Foo { loop {} }
+                   // ^^^ warn: hidden lifetime parameters in types are deprecated
+        "#,
+        );
+    }
+
+    #[test]
+    fn no_error_when_explicitly_elided() {
+        check_diagnostics(
+            r#"
+#![warn(elided_lifetimes_in_paths)]
+
+struct Foo<'a>(&'a ());
+trait Trait<'a> {}
+
+fn foo(_: Foo<'_>) -> Foo<'_> { loop {} }
+async fn bar(_: Foo<'_>) -> Foo<'_> { loop {} }
+impl Foo<'_> {}
+impl Trait<'_> for Foo<'_> {}
+        "#,
+        );
+    }
+
+    #[test]
+    fn impl_() {
+        check_diagnostics(
+            r#"
+struct Foo<'a>(&'a ());
+trait Trait<'a> {}
+
+impl Foo {}
+  // ^^^ error: implicit elided lifetime not allowed here
+
+impl Trait for Foo<'_> {}
+  // ^^^^^ error: implicit elided lifetime not allowed here
+        "#,
+        );
+    }
+}
diff --git a/crates/ide-diagnostics/src/handlers/missing_lifetime.rs b/crates/ide-diagnostics/src/handlers/missing_lifetime.rs
new file mode 100644
index 0000000..8cdbb63
--- /dev/null
+++ b/crates/ide-diagnostics/src/handlers/missing_lifetime.rs
@@ -0,0 +1,92 @@
+use crate::{Diagnostic, DiagnosticCode, DiagnosticsContext};
+
+// Diagnostic: missing-lifetime
+//
+// This diagnostic is triggered when a lifetime argument is missing.
+pub(crate) fn missing_lifetime(
+    ctx: &DiagnosticsContext<'_>,
+    d: &hir::MissingLifetime,
+) -> Diagnostic {
+    Diagnostic::new_with_syntax_node_ptr(
+        ctx,
+        DiagnosticCode::RustcHardError("E0106"),
+        "missing lifetime specifier",
+        d.generics_or_segment.map(Into::into),
+    )
+    .experimental()
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::tests::check_diagnostics;
+
+    #[test]
+    fn in_fields() {
+        check_diagnostics(
+            r#"
+struct Foo<'a>(&'a ());
+struct Bar(Foo);
+        // ^^^ error: missing lifetime specifier
+        "#,
+        );
+    }
+
+    #[test]
+    fn bounds() {
+        check_diagnostics(
+            r#"
+struct Foo<'a, T>(&'a T);
+trait Trait<'a> {
+    type Assoc;
+}
+
+fn foo<'a, T: Trait>(
+           // ^^^^^ error: missing lifetime specifier
+    _: impl Trait<'a, Assoc: Trait>,
+                          // ^^^^^ error: missing lifetime specifier
+)
+where
+    Foo<T>: Trait<'a>,
+    // ^^^ error: missing lifetime specifier
+{
+}
+        "#,
+        );
+    }
+
+    #[test]
+    fn generic_defaults() {
+        check_diagnostics(
+            r#"
+struct Foo<'a>(&'a ());
+
+struct Bar<T = Foo>(T);
+            // ^^^ error: missing lifetime specifier
+        "#,
+        );
+    }
+
+    #[test]
+    fn type_alias_type() {
+        check_diagnostics(
+            r#"
+struct Foo<'a>(&'a ());
+
+type Bar = Foo;
+        // ^^^ error: missing lifetime specifier
+        "#,
+        );
+    }
+
+    #[test]
+    fn const_param_ty() {
+        check_diagnostics(
+            r#"
+struct Foo<'a>(&'a ());
+
+fn bar<const F: Foo>() {}
+             // ^^^ error: missing lifetime specifier
+        "#,
+        );
+    }
+}
diff --git a/crates/ide-diagnostics/src/lib.rs b/crates/ide-diagnostics/src/lib.rs
index ddaef57..11efedd 100644
--- a/crates/ide-diagnostics/src/lib.rs
+++ b/crates/ide-diagnostics/src/lib.rs
@@ -27,6 +27,7 @@
     pub(crate) mod await_outside_of_async;
     pub(crate) mod bad_rtn;
     pub(crate) mod break_outside_of_loop;
+    pub(crate) mod elided_lifetimes_in_path;
     pub(crate) mod expected_function;
     pub(crate) mod generic_args_prohibited;
     pub(crate) mod inactive_code;
@@ -40,6 +41,7 @@
     pub(crate) mod malformed_derive;
     pub(crate) mod mismatched_arg_count;
     pub(crate) mod missing_fields;
+    pub(crate) mod missing_lifetime;
     pub(crate) mod missing_match_arms;
     pub(crate) mod missing_unsafe;
     pub(crate) mod moved_out_of_ref;
@@ -503,6 +505,8 @@
             AnyDiagnostic::BadRtn(d) => handlers::bad_rtn::bad_rtn(&ctx, &d),
             AnyDiagnostic::IncorrectGenericsLen(d) => handlers::incorrect_generics_len::incorrect_generics_len(&ctx, &d),
             AnyDiagnostic::IncorrectGenericsOrder(d) => handlers::incorrect_generics_order::incorrect_generics_order(&ctx, &d),
+            AnyDiagnostic::MissingLifetime(d) => handlers::missing_lifetime::missing_lifetime(&ctx, &d),
+            AnyDiagnostic::ElidedLifetimesInPath(d) => handlers::elided_lifetimes_in_path::elided_lifetimes_in_path(&ctx, &d),
         };
         res.push(d)
     }