Replace static_lifetime usages with error_lifetime, lower outlives goals

Author: Veykril

crates/hir-def/src/lib.rs

@@ -422,6 +422,10 @@ impl ModuleId {
 }
 }
 
+pubfncrate_def_map(self,db:&dynDefDatabase) -> Arc<DefMap>{
+ db.crate_def_map(self.krate)
+}
+
 pubfnkrate(self) -> CrateId{
 self.krate
 }
@@ -438,6 +442,8 @@ impl ModuleId {
 })
 }
 
+/// Returns the module containing `self`, either the parent `mod`, or the module (or block) containing
+/// the block, if `self` corresponds to a block expression.
 pubfncontaining_module(self,db:&dynDefDatabase) -> Option<ModuleId>{
 self.def_map(db).containing_module(self.local_id)
 }
@@ -929,6 +935,18 @@ impl GenericDefId {
 GenericDefId::EnumVariantId(_) => (FileId::BOGUS.into(),None),
 }
 }
+
+pubfnassoc_trait_container(self,db:&dynDefDatabase) -> Option<TraitId>{
+matchmatchself{
+GenericDefId::FunctionId(f) => f.lookup(db).container,
+GenericDefId::TypeAliasId(t) => t.lookup(db).container,
+GenericDefId::ConstId(c) => c.lookup(db).container,
+ _ => returnNone,
+}{
+ItemContainerId::TraitId(trait_) => Some(trait_),
+ _ => None,
+}
+}
 }
 
 implFrom<AssocItemId>forGenericDefId{

crates/hir-ty/src/chalk_ext.rs

@@ -1,6 +1,8 @@
 //! Various extensions traits for Chalk types.
 
-use chalk_ir::{cast::Cast,FloatTy,IntTy,Mutability,Scalar,TyVariableKind,UintTy};
+use chalk_ir::{
+ cast::Cast,FloatTy,IntTy,Mutability,Scalar,TyVariableKind,TypeOutlives,UintTy,
+};
 use hir_def::{
  builtin_type::{BuiltinFloat,BuiltinInt,BuiltinType,BuiltinUint},
  generics::TypeOrConstParamData,
@@ -312,14 +314,17 @@ impl TyExt for Ty {
 .generic_predicates(id.parent)
 .iter()
 .map(|pred| pred.clone().substitute(Interner,&substs))
-.filter(|wc| match&wc.skip_binders(){
+.filter(|wc| match wc.skip_binders(){
 WhereClause::Implemented(tr) => {
 &tr.self_type_parameter(Interner) == self
 }
 WhereClause::AliasEq(AliasEq{
 alias:AliasTy::Projection(proj),
 ty: _,
 }) => &proj.self_type_parameter(db) == self,
+WhereClause::TypeOutlives(TypeOutlives{ ty,lifetime: _ }) => {
+ ty == self
+}
  _ => false,
 })
 .collect::<Vec<_>>();

crates/hir-ty/src/infer.rs

@@ -55,10 +55,10 @@ use triomphe::Arc;
 
 usecrate::{
  db::HirDatabase,
- fold_tys,
+error_lifetime,fold_tys,
  infer::{coerce::CoerceMany, unify::InferenceTable},
  lower::ImplTraitLoweringMode,
-static_lifetime,to_assoc_type_id,
+ to_assoc_type_id,
  traits::FnTrait,
  utils::{InTypeConstIdMetadata,UnevaluatedConstEvaluatorFolder},
 AliasEq,AliasTy,Binders,ClosureId,Const,DomainGoal,GenericArg,Goal,ImplTraitId,
@@ -326,7 +326,7 @@ pub struct Adjustment {
 
 implAdjustment{
 pubfnborrow(m:Mutability,ty:Ty) -> Self{
-let ty = TyKind::Ref(m,static_lifetime(), ty).intern(Interner);
+let ty = TyKind::Ref(m,error_lifetime(), ty).intern(Interner);
 Adjustment{kind:Adjust::Borrow(AutoBorrow::Ref(m)),target: ty }
 }
 }

crates/hir-ty/src/infer/closure.rs

@@ -22,9 +22,9 @@ use stdx::never;
 
 usecrate::{
  db::{HirDatabase,InternedClosure},
- from_chalk_trait_id, from_placeholder_idx, make_binders,
+error_lifetime,from_chalk_trait_id, from_placeholder_idx, make_binders,
  mir::{BorrowKind,MirSpan,MutBorrowKind,ProjectionElem},
-static_lifetime,to_chalk_trait_id,
+ to_chalk_trait_id,
  traits::FnTrait,
  utils::{self, elaborate_clause_supertraits, generics,Generics},
 Adjust,Adjustment,AliasEq,AliasTy,Binders,BindingMode,ChalkTraitId,ClosureId,DynTy,
@@ -324,7 +324,7 @@ impl CapturedItemWithoutTy {
 BorrowKind::Mut{ .. } => Mutability::Mut,
  _ => Mutability::Not,
 };
-TyKind::Ref(m,static_lifetime(), ty).intern(Interner)
+TyKind::Ref(m,error_lifetime(), ty).intern(Interner)
 }
 };
 returnCapturedItem{

crates/hir-ty/src/infer/coerce.rs

@@ -18,11 +18,11 @@ use triomphe::Arc;
 usecrate::{
  autoderef::{Autoderef,AutoderefKind},
  db::HirDatabase,
+ error_lifetime,
  infer::{
 Adjust,Adjustment,AutoBorrow,InferOk,InferenceContext,OverloadedDeref,PointerCast,
 TypeError,TypeMismatch,
 },
- static_lifetime,
  utils::ClosureSubst,
 Canonical,DomainGoal,FnAbi,FnPointer,FnSig,Guidance,InEnvironment,Interner,Solution,
 Substitution,TraitEnvironment,Ty,TyBuilder,TyExt,
@@ -427,7 +427,7 @@ impl InferenceTable<'_> {
 // compare those. Note that this means we use the target
 // mutability [1], since it may be that we are coercing
 // from `&mut T` to `&U`.
-let lt = static_lifetime();// FIXME: handle lifetimes correctly, see rustc
+let lt = error_lifetime();// FIXME: handle lifetimes correctly, see rustc
 let derefd_from_ty = TyKind::Ref(to_mt, lt, referent_ty).intern(Interner);
 match autoderef.table.try_unify(&derefd_from_ty, to_ty){
 Ok(result) => {
@@ -621,7 +621,7 @@ impl InferenceTable<'_> {
 (TyKind::Ref(from_mt, _, from_inner),&TyKind::Ref(to_mt, _, _)) => {
 coerce_mutabilities(*from_mt, to_mt)?;
 
-let lt = static_lifetime();
+let lt = error_lifetime();
 Some((
 Adjustment{kind:Adjust::Deref(None),target: from_inner.clone()},
 Adjustment{

crates/hir-ty/src/infer/expr.rs

@@ -23,6 +23,7 @@ use crate::{
  autoderef::{builtin_deref, deref_by_trait,Autoderef},
  consteval,
  db::{InternedClosure,InternedCoroutine},
+ error_lifetime,
  infer::{
  coerce::{CoerceMany,CoercionCause},
  find_continuable,
@@ -630,7 +631,7 @@ impl InferenceContext<'_> {
 let inner_ty = self.infer_expr_inner(*expr,&expectation);
 match rawness {
 Rawness::RawPtr => TyKind::Raw(mutability, inner_ty),
-Rawness::Ref => TyKind::Ref(mutability,static_lifetime(), inner_ty),
+Rawness::Ref => TyKind::Ref(mutability,error_lifetime(), inner_ty),
 }
 .intern(Interner)
 }

crates/hir-ty/src/infer/pat.rs

@@ -12,6 +12,7 @@ use hir_expand::name::Name;
 
 usecrate::{
  consteval::{try_const_usize, usize_const},
+ error_lifetime,
  infer::{BindingMode,Expectation,InferenceContext,TypeMismatch},
  lower::lower_to_chalk_mutability,
  primitive::UintTy,
@@ -396,14 +397,14 @@ impl InferenceContext<'_> {
 None => {
 let inner_ty = self.table.new_type_var();
 let ref_ty =
-TyKind::Ref(mutability,static_lifetime(), inner_ty.clone()).intern(Interner);
+TyKind::Ref(mutability,error_lifetime(), inner_ty.clone()).intern(Interner);
 // Unification failure will be reported by the caller.
 self.unify(&ref_ty, expected);
  inner_ty
 }
 };
 let subty = self.infer_pat(inner_pat,&expectation, default_bm);
-TyKind::Ref(mutability,static_lifetime(), subty).intern(Interner)
+TyKind::Ref(mutability,error_lifetime(), subty).intern(Interner)
 }
 
 fninfer_bind_pat(
@@ -430,7 +431,7 @@ impl InferenceContext<'_> {
 
 let bound_ty = match mode {
 BindingMode::Ref(mutability) => {
-TyKind::Ref(mutability,static_lifetime(), inner_ty.clone()).intern(Interner)
+TyKind::Ref(mutability,error_lifetime(), inner_ty.clone()).intern(Interner)
 }
 BindingMode::Move => inner_ty.clone(),
 };

crates/hir-ty/src/infer/unify.rs

@@ -16,8 +16,8 @@ use triomphe::Arc;
 
 usesuper::{InferOk,InferResult,InferenceContext,TypeError};
 usecrate::{
- consteval::unknown_const, db::HirDatabase,fold_generic_args, fold_tys_and_consts,
-static_lifetime, to_chalk_trait_id, traits::FnTrait,AliasEq,AliasTy,BoundVar,Canonical,
+ consteval::unknown_const, db::HirDatabase,error_lifetime, fold_generic_args,
+fold_tys_and_consts, to_chalk_trait_id, traits::FnTrait,AliasEq,AliasTy,BoundVar,Canonical,
 Const,ConstValue,DebruijnIndex,DomainGoal,GenericArg,GenericArgData,Goal,GoalData,
 Guidance,InEnvironment,InferenceVar,Interner,Lifetime,OpaqueTyId,ParamKind,ProjectionTy,
 ProjectionTyExt,Scalar,Solution,Substitution,TraitEnvironment,Ty,TyBuilder,TyExt,
@@ -43,40 +43,21 @@ impl InferenceContext<'_> {
 let obligations = pending_obligations
 .iter()
 .filter_map(|obligation| match obligation.value.value.goal.data(Interner){
-GoalData::DomainGoal(DomainGoal::Holds(
- clause @ WhereClause::AliasEq(AliasEq{
-alias:AliasTy::Projection(projection),
- ..
-}),
-)) => {
-let projection_self = projection.self_type_parameter(self.db);
-let uncanonical = chalk_ir::Substitute::apply(
-&obligation.free_vars,
- projection_self,
-Interner,
-);
-ifmatches!(
-self.resolve_ty_shallow(&uncanonical).kind(Interner),
-TyKind::InferenceVar(iv,TyVariableKind::General)if*iv == root,
-){
-Some(chalk_ir::Substitute::apply(
-&obligation.free_vars,
- clause.clone(),
-Interner,
-))
-}else{
-None
-}
-}
-GoalData::DomainGoal(DomainGoal::Holds(
- clause @ WhereClause::Implemented(trait_ref),
-)) => {
-let trait_ref_self = trait_ref.self_type_parameter(Interner);
-let uncanonical = chalk_ir::Substitute::apply(
-&obligation.free_vars,
- trait_ref_self,
-Interner,
-);
+GoalData::DomainGoal(DomainGoal::Holds(clause)) => {
+let ty = match clause {
+WhereClause::AliasEq(AliasEq{
+alias:AliasTy::Projection(projection),
+ ..
+}) => projection.self_type_parameter(self.db),
+WhereClause::Implemented(trait_ref) => {
+ trait_ref.self_type_parameter(Interner)
+}
+WhereClause::TypeOutlives(to) => to.ty.clone(),
+ _ => returnNone,
+};
+
+let uncanonical =
+ chalk_ir::Substitute::apply(&obligation.free_vars, ty,Interner);
 ifmatches!(
 self.resolve_ty_shallow(&uncanonical).kind(Interner),
 TyKind::InferenceVar(iv,TyVariableKind::General)if*iv == root,
@@ -121,8 +102,9 @@ impl<T: HasInterner<Interner = Interner>> Canonicalized<T> {
 VariableKind::Ty(TyVariableKind::General) => ctx.new_type_var().cast(Interner),
 VariableKind::Ty(TyVariableKind::Integer) => ctx.new_integer_var().cast(Interner),
 VariableKind::Ty(TyVariableKind::Float) => ctx.new_float_var().cast(Interner),
-// Chalk can sometimes return new lifetime variables. We just use the static lifetime everywhere
-VariableKind::Lifetime => static_lifetime().cast(Interner),
+// Chalk can sometimes return new lifetime variables. We just replace them by errors
+// for now.
+VariableKind::Lifetime => error_lifetime().cast(Interner),
 VariableKind::Const(ty) => ctx.new_const_var(ty.clone()).cast(Interner),
 }),
 );
@@ -1020,11 +1002,11 @@ mod resolve {
 _var:InferenceVar,
 _outer_binder:DebruijnIndex,
 ) -> Lifetime{
-// fall back all lifetimes to 'static -- currently we don't deal
+// fall back all lifetimes to 'error -- currently we don't deal
 // with any lifetimes, but we can sometimes get some lifetime
 // variables through Chalk's unification, and this at least makes
 // sure we don't leak them outside of inference
-crate::static_lifetime()
+crate::error_lifetime()
 }
 }
 }

crates/hir-ty/src/lib.rs

@@ -622,7 +622,7 @@ pub fn static_lifetime() -> Lifetime {
 }
 
 pubfnerror_lifetime() -> Lifetime{
-static_lifetime()
+LifetimeData::Static.intern(Interner)
 }
 
 pub(crate)fnfold_free_vars<T:HasInterner<Interner = Interner> + TypeFoldable<Interner>>(
@@ -861,7 +861,7 @@ where
 ifcfg!(debug_assertions){
 Err(NoSolution)
 }else{
-Ok(static_lifetime())
+Ok(error_lifetime())
 }
 }
 
@@ -873,7 +873,7 @@ where
 ifcfg!(debug_assertions){
 Err(NoSolution)
 }else{
-Ok(static_lifetime())
+Ok(error_lifetime())
 }
 }
 }