From b035c314b4b0ecd2477fde216dbe7e8801f94d0d Mon Sep 17 00:00:00 2001 From: Florian Diebold Date: Sat, 13 Mar 2021 20:05:47 +0100 Subject: Use chalk_ir::OpaqueTyId --- crates/hir_ty/src/db.rs | 4 +-- crates/hir_ty/src/display.rs | 42 ++++++++++++++++++------------- crates/hir_ty/src/infer/expr.rs | 7 +++--- crates/hir_ty/src/lib.rs | 16 ++++++------ crates/hir_ty/src/lower.rs | 12 ++++----- crates/hir_ty/src/traits/chalk.rs | 7 +++--- crates/hir_ty/src/traits/chalk/mapping.rs | 28 +++++---------------- 7 files changed, 53 insertions(+), 63 deletions(-) (limited to 'crates/hir_ty') diff --git a/crates/hir_ty/src/db.rs b/crates/hir_ty/src/db.rs index c198f6903..8a3cc0283 100644 --- a/crates/hir_ty/src/db.rs +++ b/crates/hir_ty/src/db.rs @@ -12,7 +12,7 @@ use la_arena::ArenaMap; use crate::{ method_resolution::{InherentImpls, TraitImpls}, traits::chalk, - Binders, CallableDefId, FnDefId, GenericPredicate, InferenceResult, OpaqueTyId, PolyFnSig, + Binders, CallableDefId, FnDefId, GenericPredicate, ImplTraitId, InferenceResult, PolyFnSig, ReturnTypeImplTraits, TraitRef, Ty, TyDefId, ValueTyDefId, }; use hir_expand::name::Name; @@ -83,7 +83,7 @@ pub trait HirDatabase: DefDatabase + Upcast { #[salsa::interned] fn intern_type_param_id(&self, param_id: TypeParamId) -> InternedTypeParamId; #[salsa::interned] - fn intern_impl_trait_id(&self, id: OpaqueTyId) -> InternedOpaqueTyId; + fn intern_impl_trait_id(&self, id: ImplTraitId) -> InternedOpaqueTyId; #[salsa::interned] fn intern_closure(&self, id: (DefWithBodyId, ExprId)) -> InternedClosureId; diff --git a/crates/hir_ty/src/display.rs b/crates/hir_ty/src/display.rs index 0a13c8636..e6473586b 100644 --- a/crates/hir_ty/src/display.rs +++ b/crates/hir_ty/src/display.rs @@ -13,7 +13,7 @@ use hir_expand::name::Name; use crate::{ db::HirDatabase, from_assoc_type_id, from_foreign_def_id, from_placeholder_idx, primitive, to_assoc_type_id, traits::chalk::from_chalk, utils::generics, AdtId, AliasTy, CallableDefId, - CallableSig, GenericPredicate, Interner, Lifetime, Obligation, OpaqueTy, OpaqueTyId, + CallableSig, GenericPredicate, ImplTraitId, Interner, Lifetime, Obligation, OpaqueTy, ProjectionTy, Scalar, Substs, TraitRef, Ty, TyKind, }; @@ -313,22 +313,26 @@ impl HirDisplay for Ty { )?; } + // FIXME: all this just to decide whether to use parentheses... let datas; let predicates = match t.interned(&Interner) { TyKind::Dyn(predicates) if predicates.len() > 1 => { Cow::Borrowed(predicates.as_ref()) } - &TyKind::Alias(AliasTy::Opaque(OpaqueTy { - opaque_ty_id: OpaqueTyId::ReturnTypeImplTrait(func, idx), - ref parameters, - })) => { - datas = - f.db.return_type_impl_traits(func).expect("impl trait id without data"); - let data = (*datas) - .as_ref() - .map(|rpit| rpit.impl_traits[idx as usize].bounds.clone()); - let bounds = data.subst(parameters); - Cow::Owned(bounds.value) + &TyKind::Alias(AliasTy::Opaque(OpaqueTy { opaque_ty_id, ref parameters })) => { + let impl_trait_id = f.db.lookup_intern_impl_trait_id(opaque_ty_id.into()); + if let ImplTraitId::ReturnTypeImplTrait(func, idx) = impl_trait_id { + datas = + f.db.return_type_impl_traits(func) + .expect("impl trait id without data"); + let data = (*datas) + .as_ref() + .map(|rpit| rpit.impl_traits[idx as usize].bounds.clone()); + let bounds = data.subst(parameters); + Cow::Owned(bounds.value) + } else { + Cow::Borrowed(&[][..]) + } } _ => Cow::Borrowed(&[][..]), }; @@ -499,8 +503,9 @@ impl HirDisplay for Ty { write!(f, "{}", type_alias.name)?; } TyKind::OpaqueType(opaque_ty_id, parameters) => { - match opaque_ty_id { - &OpaqueTyId::ReturnTypeImplTrait(func, idx) => { + let impl_trait_id = f.db.lookup_intern_impl_trait_id((*opaque_ty_id).into()); + match impl_trait_id { + ImplTraitId::ReturnTypeImplTrait(func, idx) => { let datas = f.db.return_type_impl_traits(func).expect("impl trait id without data"); let data = (*datas) @@ -510,7 +515,7 @@ impl HirDisplay for Ty { write_bounds_like_dyn_trait_with_prefix("impl", &bounds.value, f)?; // FIXME: it would maybe be good to distinguish this from the alias type (when debug printing), and to show the substitution } - OpaqueTyId::AsyncBlockTypeImplTrait(..) => { + ImplTraitId::AsyncBlockTypeImplTrait(..) => { write!(f, "impl Future")?; @@ -566,8 +571,9 @@ impl HirDisplay for Ty { } TyKind::Alias(AliasTy::Projection(p_ty)) => p_ty.hir_fmt(f)?, TyKind::Alias(AliasTy::Opaque(opaque_ty)) => { - match opaque_ty.opaque_ty_id { - OpaqueTyId::ReturnTypeImplTrait(func, idx) => { + let impl_trait_id = f.db.lookup_intern_impl_trait_id(opaque_ty.opaque_ty_id.into()); + match impl_trait_id { + ImplTraitId::ReturnTypeImplTrait(func, idx) => { let datas = f.db.return_type_impl_traits(func).expect("impl trait id without data"); let data = (*datas) @@ -576,7 +582,7 @@ impl HirDisplay for Ty { let bounds = data.subst(&opaque_ty.parameters); write_bounds_like_dyn_trait_with_prefix("impl", &bounds.value, f)?; } - OpaqueTyId::AsyncBlockTypeImplTrait(..) => { + ImplTraitId::AsyncBlockTypeImplTrait(..) => { write!(f, "{{async block}}")?; } }; diff --git a/crates/hir_ty/src/infer/expr.rs b/crates/hir_ty/src/infer/expr.rs index 2e21d796c..eee3e6ec5 100644 --- a/crates/hir_ty/src/infer/expr.rs +++ b/crates/hir_ty/src/infer/expr.rs @@ -21,8 +21,8 @@ use crate::{ to_assoc_type_id, traits::{chalk::from_chalk, FnTrait, InEnvironment}, utils::{generics, variant_data, Generics}, - AdtId, Binders, CallableDefId, FnPointer, FnSig, Interner, Obligation, OpaqueTyId, Rawness, - Scalar, Substs, TraitRef, Ty, TyKind, + AdtId, Binders, CallableDefId, FnPointer, FnSig, Interner, Obligation, Rawness, Scalar, Substs, + TraitRef, Ty, TyKind, }; use super::{ @@ -179,7 +179,8 @@ impl<'a> InferenceContext<'a> { // Use the first type parameter as the output type of future. // existenail type AsyncBlockImplTrait: Future let inner_ty = self.infer_expr(*body, &Expectation::none()); - let opaque_ty_id = OpaqueTyId::AsyncBlockTypeImplTrait(self.owner, *body); + let impl_trait_id = crate::ImplTraitId::AsyncBlockTypeImplTrait(self.owner, *body); + let opaque_ty_id = self.db.intern_impl_trait_id(impl_trait_id).into(); TyKind::OpaqueType(opaque_ty_id, Substs::single(inner_ty)).intern(&Interner) } Expr::Loop { body, label } => { diff --git a/crates/hir_ty/src/lib.rs b/crates/hir_ty/src/lib.rs index d1c018283..d6ff968f0 100644 --- a/crates/hir_ty/src/lib.rs +++ b/crates/hir_ty/src/lib.rs @@ -54,6 +54,7 @@ pub type ForeignDefId = chalk_ir::ForeignDefId; pub type AssocTypeId = chalk_ir::AssocTypeId; pub type FnDefId = chalk_ir::FnDefId; pub type ClosureId = chalk_ir::ClosureId; +pub type OpaqueTyId = chalk_ir::OpaqueTyId; pub type PlaceholderIndex = chalk_ir::PlaceholderIndex; #[derive(Clone, PartialEq, Eq, Debug, Hash)] @@ -875,8 +876,8 @@ impl Ty { pub fn impl_trait_bounds(&self, db: &dyn HirDatabase) -> Option> { match self.interned(&Interner) { TyKind::OpaqueType(opaque_ty_id, ..) => { - match opaque_ty_id { - OpaqueTyId::AsyncBlockTypeImplTrait(def, _expr) => { + match db.lookup_intern_impl_trait_id((*opaque_ty_id).into()) { + ImplTraitId::AsyncBlockTypeImplTrait(def, _expr) => { let krate = def.module(db.upcast()).krate(); if let Some(future_trait) = db .lang_item(krate, "future_trait".into()) @@ -894,12 +895,13 @@ impl Ty { None } } - OpaqueTyId::ReturnTypeImplTrait(..) => None, + ImplTraitId::ReturnTypeImplTrait(..) => None, } } TyKind::Alias(AliasTy::Opaque(opaque_ty)) => { - let predicates = match opaque_ty.opaque_ty_id { - OpaqueTyId::ReturnTypeImplTrait(func, idx) => { + let predicates = match db.lookup_intern_impl_trait_id(opaque_ty.opaque_ty_id.into()) + { + ImplTraitId::ReturnTypeImplTrait(func, idx) => { db.return_type_impl_traits(func).map(|it| { let data = (*it) .as_ref() @@ -908,7 +910,7 @@ impl Ty { }) } // It always has an parameter for Future::Output type. - OpaqueTyId::AsyncBlockTypeImplTrait(..) => unreachable!(), + ImplTraitId::AsyncBlockTypeImplTrait(..) => unreachable!(), }; predicates.map(|it| it.value) @@ -1123,7 +1125,7 @@ impl TypeWalk for Vec { } #[derive(Copy, Clone, PartialEq, Eq, Debug, Hash)] -pub enum OpaqueTyId { +pub enum ImplTraitId { ReturnTypeImplTrait(hir_def::FunctionId, u16), AsyncBlockTypeImplTrait(hir_def::DefWithBodyId, ExprId), } diff --git a/crates/hir_ty/src/lower.rs b/crates/hir_ty/src/lower.rs index 78a914cac..e57d5970f 100644 --- a/crates/hir_ty/src/lower.rs +++ b/crates/hir_ty/src/lower.rs @@ -34,7 +34,7 @@ use crate::{ make_mut_slice, variant_data, }, AliasTy, Binders, BoundVar, CallableSig, DebruijnIndex, FnPointer, FnSig, GenericPredicate, - OpaqueTy, OpaqueTyId, PolyFnSig, ProjectionPredicate, ProjectionTy, ReturnTypeImplTrait, + ImplTraitId, OpaqueTy, PolyFnSig, ProjectionPredicate, ProjectionTy, ReturnTypeImplTrait, ReturnTypeImplTraits, Substs, TraitEnvironment, TraitRef, Ty, TyKind, TypeWalk, }; @@ -228,14 +228,12 @@ impl Ty { Some(GenericDefId::FunctionId(f)) => f, _ => panic!("opaque impl trait lowering in non-function"), }; - let impl_trait_id = OpaqueTyId::ReturnTypeImplTrait(func, idx); + let impl_trait_id = ImplTraitId::ReturnTypeImplTrait(func, idx); + let opaque_ty_id = ctx.db.intern_impl_trait_id(impl_trait_id).into(); let generics = generics(ctx.db.upcast(), func.into()); let parameters = Substs::bound_vars(&generics, ctx.in_binders); - TyKind::Alias(AliasTy::Opaque(OpaqueTy { - opaque_ty_id: impl_trait_id, - parameters, - })) - .intern(&Interner) + TyKind::Alias(AliasTy::Opaque(OpaqueTy { opaque_ty_id, parameters })) + .intern(&Interner) } ImplTraitLoweringMode::Param => { let idx = ctx.impl_trait_counter.get(); diff --git a/crates/hir_ty/src/traits/chalk.rs b/crates/hir_ty/src/traits/chalk.rs index e7217bc11..1f3e1c07a 100644 --- a/crates/hir_ty/src/traits/chalk.rs +++ b/crates/hir_ty/src/traits/chalk.rs @@ -177,10 +177,9 @@ impl<'a> chalk_solve::RustIrDatabase for ChalkContext<'a> { } fn opaque_ty_data(&self, id: chalk_ir::OpaqueTyId) -> Arc { - let interned_id = crate::db::InternedOpaqueTyId::from(id); - let full_id = self.db.lookup_intern_impl_trait_id(interned_id); + let full_id = self.db.lookup_intern_impl_trait_id(id.into()); let bound = match full_id { - crate::OpaqueTyId::ReturnTypeImplTrait(func, idx) => { + crate::ImplTraitId::ReturnTypeImplTrait(func, idx) => { let datas = self .db .return_type_impl_traits(func) @@ -202,7 +201,7 @@ impl<'a> chalk_solve::RustIrDatabase for ChalkContext<'a> { let num_vars = datas.num_binders; make_binders(bound, num_vars) } - crate::OpaqueTyId::AsyncBlockTypeImplTrait(..) => { + crate::ImplTraitId::AsyncBlockTypeImplTrait(..) => { if let Some((future_trait, future_output)) = self .db .lang_item(self.krate, "future_trait".into()) diff --git a/crates/hir_ty/src/traits/chalk/mapping.rs b/crates/hir_ty/src/traits/chalk/mapping.rs index 460955756..2a66a2310 100644 --- a/crates/hir_ty/src/traits/chalk/mapping.rs +++ b/crates/hir_ty/src/traits/chalk/mapping.rs @@ -15,7 +15,7 @@ use crate::{ primitive::UintTy, traits::{Canonical, Obligation}, AliasTy, CallableDefId, FnPointer, FnSig, GenericPredicate, InEnvironment, OpaqueTy, - OpaqueTyId, ProjectionPredicate, ProjectionTy, Scalar, Substs, TraitRef, Ty, + ProjectionPredicate, ProjectionTy, Scalar, Substs, TraitRef, Ty, }; use super::interner::*; @@ -41,8 +41,7 @@ impl ToChalk for Ty { chalk_ir::TyKind::AssociatedType(assoc_type_id, substitution).intern(&Interner) } - TyKind::OpaqueType(impl_trait_id, substs) => { - let id = impl_trait_id.to_chalk(db); + TyKind::OpaqueType(id, substs) => { let substitution = substs.to_chalk(db); chalk_ir::TyKind::OpaqueType(id, substitution).intern(&Interner) } @@ -103,7 +102,7 @@ impl ToChalk for Ty { chalk_ir::TyKind::Dyn(bounded_ty).intern(&Interner) } TyKind::Alias(AliasTy::Opaque(opaque_ty)) => { - let opaque_ty_id = opaque_ty.opaque_ty_id.to_chalk(db); + let opaque_ty_id = opaque_ty.opaque_ty_id; let substitution = opaque_ty.parameters.to_chalk(db); chalk_ir::TyKind::Alias(chalk_ir::AliasTy::Opaque(chalk_ir::OpaqueTy { opaque_ty_id, @@ -125,9 +124,9 @@ impl ToChalk for Ty { TyKind::Alias(AliasTy::Projection(ProjectionTy { associated_ty, parameters })) } chalk_ir::TyKind::Alias(chalk_ir::AliasTy::Opaque(opaque_ty)) => { - let impl_trait_id = from_chalk(db, opaque_ty.opaque_ty_id); + let opaque_ty_id = opaque_ty.opaque_ty_id; let parameters = from_chalk(db, opaque_ty.substitution); - TyKind::Alias(AliasTy::Opaque(OpaqueTy { opaque_ty_id: impl_trait_id, parameters })) + TyKind::Alias(AliasTy::Opaque(OpaqueTy { opaque_ty_id, parameters })) } chalk_ir::TyKind::Function(chalk_ir::FnPointer { num_binders, @@ -165,7 +164,7 @@ impl ToChalk for Ty { } chalk_ir::TyKind::OpaqueType(opaque_type_id, subst) => { - TyKind::OpaqueType(from_chalk(db, opaque_type_id), from_chalk(db, subst)) + TyKind::OpaqueType(opaque_type_id, from_chalk(db, subst)) } chalk_ir::TyKind::Scalar(scalar) => TyKind::Scalar(scalar), @@ -268,21 +267,6 @@ impl ToChalk for hir_def::TraitId { } } -impl ToChalk for OpaqueTyId { - type Chalk = chalk_ir::OpaqueTyId; - - fn to_chalk(self, db: &dyn HirDatabase) -> chalk_ir::OpaqueTyId { - db.intern_impl_trait_id(self).into() - } - - fn from_chalk( - db: &dyn HirDatabase, - opaque_ty_id: chalk_ir::OpaqueTyId, - ) -> OpaqueTyId { - db.lookup_intern_impl_trait_id(opaque_ty_id.into()) - } -} - impl ToChalk for hir_def::ImplId { type Chalk = ImplId; -- cgit v1.2.3