Unnamed repository; edit this file 'description' to name the repository.
Merge pull request #20814 from ChayimFriedman2/mir-ns
internal: Migrate MIR to next solver
53 files changed, 2493 insertions, 2504 deletions
diff --git a/Cargo.lock b/Cargo.lock index 8e2c371bce..6625403572 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -788,6 +788,7 @@ dependencies = [ "intern", "itertools", "la-arena 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)", + "macros", "oorandom", "petgraph", "project-model", @@ -1330,6 +1331,16 @@ dependencies = [ ] [[package]] +name = "macros" +version = "0.0.0" +dependencies = [ + "proc-macro2", + "quote", + "syn", + "synstructure", +] + +[[package]] name = "mbe" version = "0.0.0" dependencies = [ diff --git a/Cargo.toml b/Cargo.toml index 1438d46389..6702bfed87 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -52,6 +52,7 @@ debug = 2 [workspace.dependencies] # local crates +macros = { path = "./crates/macros", version = "0.0.0" } base-db = { path = "./crates/base-db", version = "0.0.0" } cfg = { path = "./crates/cfg", version = "0.0.0", features = ["tt"] } hir = { path = "./crates/hir", version = "0.0.0" } diff --git a/crates/hir-def/src/signatures.rs b/crates/hir-def/src/signatures.rs index 47638610ed..ebbf87cad6 100644 --- a/crates/hir-def/src/signatures.rs +++ b/crates/hir-def/src/signatures.rs @@ -349,6 +349,7 @@ bitflags::bitflags! { #[derive(Debug, Clone, Copy, Eq, PartialEq, Default)] pub struct ImplFlags: u8 { const NEGATIVE = 1 << 1; + const DEFAULT = 1 << 2; const UNSAFE = 1 << 3; } } @@ -374,6 +375,9 @@ impl ImplSignature { if src.value.excl_token().is_some() { flags.insert(ImplFlags::NEGATIVE); } + if src.value.default_token().is_some() { + flags.insert(ImplFlags::DEFAULT); + } let (store, source_map, self_ty, target_trait, generic_params) = crate::expr_store::lower::lower_impl(db, loc.container, src, id); @@ -389,6 +393,16 @@ impl ImplSignature { Arc::new(source_map), ) } + + #[inline] + pub fn is_negative(&self) -> bool { + self.flags.contains(ImplFlags::NEGATIVE) + } + + #[inline] + pub fn is_default(&self) -> bool { + self.flags.contains(ImplFlags::DEFAULT) + } } bitflags::bitflags! { diff --git a/crates/hir-ty/Cargo.toml b/crates/hir-ty/Cargo.toml index 4013d19ad0..ec65633154 100644 --- a/crates/hir-ty/Cargo.toml +++ b/crates/hir-ty/Cargo.toml @@ -50,6 +50,7 @@ tracing-tree.workspace = true # local deps stdx.workspace = true +macros.workspace = true intern.workspace = true hir-def.workspace = true hir-expand.workspace = true diff --git a/crates/hir-ty/src/builder.rs b/crates/hir-ty/src/builder.rs index 798b0f2c0c..706bbe856c 100644 --- a/crates/hir-ty/src/builder.rs +++ b/crates/hir-ty/src/builder.rs @@ -130,11 +130,14 @@ impl<D> TyBuilder<D> { } pub fn fill_with_unknown(self) -> Self { + let interner = DbInterner::conjure(); // self.fill is inlined to make borrow checker happy let mut this = self; let filler = this.param_kinds[this.vec.len()..].iter().map(|x| match x { ParamKind::Type => TyKind::Error.intern(Interner).cast(Interner), - ParamKind::Const(ty) => unknown_const_as_generic(ty.clone()), + ParamKind::Const(ty) => { + unknown_const_as_generic(ty.to_nextsolver(interner)).to_chalk(interner) + } ParamKind::Lifetime => error_lifetime().cast(Interner), }); this.vec.extend(filler.casted(Interner)); @@ -219,13 +222,16 @@ impl TyBuilder<()> { } pub fn unknown_subst(db: &dyn HirDatabase, def: impl Into<GenericDefId>) -> Substitution { + let interner = DbInterner::conjure(); let params = generics(db, def.into()); Substitution::from_iter( Interner, params.iter_id().map(|id| match id { GenericParamId::TypeParamId(_) => TyKind::Error.intern(Interner).cast(Interner), GenericParamId::ConstParamId(id) => { - unknown_const_as_generic(db.const_param_ty(id)).cast(Interner) + unknown_const_as_generic(db.const_param_ty_ns(id)) + .to_chalk(interner) + .cast(Interner) } GenericParamId::LifetimeParamId(_) => error_lifetime().cast(Interner), }), @@ -267,6 +273,7 @@ impl TyBuilder<hir_def::AdtId> { db: &dyn HirDatabase, mut fallback: impl FnMut() -> Ty, ) -> Self { + let interner = DbInterner::conjure(); // Note that we're building ADT, so we never have parent generic parameters. let defaults = db.generic_defaults(self.data.into()); @@ -287,7 +294,9 @@ impl TyBuilder<hir_def::AdtId> { // The defaults may be missing if no param has default, so fill that. let filler = self.param_kinds[self.vec.len()..].iter().map(|x| match x { ParamKind::Type => fallback().cast(Interner), - ParamKind::Const(ty) => unknown_const_as_generic(ty.clone()), + ParamKind::Const(ty) => { + unknown_const_as_generic(ty.to_nextsolver(interner)).to_chalk(interner) + } ParamKind::Lifetime => error_lifetime().cast(Interner), }); self.vec.extend(filler.casted(Interner)); diff --git a/crates/hir-ty/src/consteval.rs b/crates/hir-ty/src/consteval.rs index 8b12c5fd89..002e0823b9 100644 --- a/crates/hir-ty/src/consteval.rs +++ b/crates/hir-ty/src/consteval.rs @@ -1,59 +1,88 @@ //! Constant evaluation details +#[cfg(test)] +mod tests; + use base_db::Crate; -use chalk_ir::{BoundVar, DebruijnIndex, cast::Cast}; use hir_def::{ - EnumVariantId, GeneralConstId, HasModule as _, StaticId, - expr_store::{HygieneId, path::Path}, - hir::Expr, + EnumVariantId, GeneralConstId, + expr_store::{Body, HygieneId, path::Path}, + hir::{Expr, ExprId}, resolver::{Resolver, ValueNs}, type_ref::LiteralConstRef, }; +use hir_def::{HasModule, StaticId}; use hir_expand::Lookup; +use rustc_type_ir::{UnevaluatedConst, inherent::IntoKind}; use stdx::never; use triomphe::Arc; use crate::{ - Const, ConstData, ConstScalar, ConstValue, GenericArg, Interner, MemoryMap, Substitution, - TraitEnvironment, Ty, TyBuilder, + MemoryMap, TraitEnvironment, db::HirDatabase, display::DisplayTarget, generics::Generics, - lower::ParamLoweringMode, - next_solver::{DbInterner, mapping::ChalkToNextSolver}, - to_placeholder_idx, + infer::InferenceContext, + mir::{MirEvalError, MirLowerError}, + next_solver::{ + Const, ConstBytes, ConstKind, DbInterner, ErrorGuaranteed, GenericArg, GenericArgs, + ParamConst, SolverDefId, Ty, ValueConst, + }, }; -use super::mir::{MirEvalError, MirLowerError, interpret_mir, pad16}; - -/// Extension trait for [`Const`] -pub trait ConstExt { - /// Is a [`Const`] unknown? - fn is_unknown(&self) -> bool; -} +use super::mir::{interpret_mir, lower_to_mir, pad16}; -impl ConstExt for Const { - fn is_unknown(&self) -> bool { - match self.data(Interner).value { - // interned Unknown - chalk_ir::ConstValue::Concrete(chalk_ir::ConcreteConst { - interned: ConstScalar::Unknown, - }) => true, - - // interned concrete anything else - chalk_ir::ConstValue::Concrete(..) => false, - - _ => { - tracing::error!( - "is_unknown was called on a non-concrete constant value! {:?}", - self - ); - true +pub(crate) fn path_to_const<'a, 'g>( + db: &'a dyn HirDatabase, + resolver: &Resolver<'a>, + path: &Path, + args: impl FnOnce() -> &'g Generics, + _expected_ty: Ty<'a>, +) -> Option<Const<'a>> { + let interner = DbInterner::new_with(db, Some(resolver.krate()), None); + match resolver.resolve_path_in_value_ns_fully(db, path, HygieneId::ROOT) { + Some(ValueNs::GenericParam(p)) => { + let args = args(); + match args + .type_or_const_param(p.into()) + .and_then(|(idx, p)| p.const_param().map(|p| (idx, p.clone()))) + { + Some((idx, _param)) => { + Some(Const::new_param(interner, ParamConst { index: idx as u32, id: p })) + } + None => { + never!( + "Generic list doesn't contain this param: {:?}, {:?}, {:?}", + args, + path, + p + ); + None + } } } + Some(ValueNs::ConstId(c)) => { + let args = GenericArgs::new_from_iter(interner, []); + Some(Const::new( + interner, + rustc_type_ir::ConstKind::Unevaluated(UnevaluatedConst::new( + SolverDefId::ConstId(c), + args, + )), + )) + } + _ => None, } } +pub fn unknown_const<'db>(_ty: Ty<'db>) -> Const<'db> { + Const::new(DbInterner::conjure(), rustc_type_ir::ConstKind::Error(ErrorGuaranteed)) +} + +pub fn unknown_const_as_generic<'db>(ty: Ty<'db>) -> GenericArg<'db> { + unknown_const(ty).into() +} + #[derive(Debug, Clone, PartialEq, Eq)] pub enum ConstEvalError<'db> { MirLowerError(MirLowerError<'db>), @@ -94,149 +123,189 @@ impl<'db> From<MirEvalError<'db>> for ConstEvalError<'db> { } } -pub(crate) fn path_to_const<'g>( - db: &dyn HirDatabase, - resolver: &Resolver<'_>, - path: &Path, - mode: ParamLoweringMode, - args: impl FnOnce() -> &'g Generics, - debruijn: DebruijnIndex, - expected_ty: Ty, -) -> Option<Const> { - match resolver.resolve_path_in_value_ns_fully(db, path, HygieneId::ROOT) { - Some(ValueNs::GenericParam(p)) => { - let ty = db.const_param_ty(p); - let args = args(); - let value = match mode { - ParamLoweringMode::Placeholder => { - let idx = args.type_or_const_param_idx(p.into()).unwrap(); - ConstValue::Placeholder(to_placeholder_idx(db, p.into(), idx as u32)) - } - ParamLoweringMode::Variable => match args.type_or_const_param_idx(p.into()) { - Some(it) => ConstValue::BoundVar(BoundVar::new(debruijn, it)), - None => { - never!( - "Generic list doesn't contain this param: {:?}, {:?}, {:?}", - args, - path, - p - ); - return None; - } - }, - }; - Some(ConstData { ty, value }.intern(Interner)) - } - Some(ValueNs::ConstId(c)) => Some(intern_const_scalar( - ConstScalar::UnevaluatedConst(c.into(), Substitution::empty(Interner)), - expected_ty, - )), - // FIXME: With feature(adt_const_params), we also need to consider other things here, e.g. struct constructors. - _ => None, - } -} - -pub fn unknown_const(ty: Ty) -> Const { - ConstData { - ty, - value: ConstValue::Concrete(chalk_ir::ConcreteConst { interned: ConstScalar::Unknown }), - } - .intern(Interner) -} - -pub fn unknown_const_as_generic(ty: Ty) -> GenericArg { - unknown_const(ty).cast(Interner) -} - -/// Interns a constant scalar with the given type -pub fn intern_const_scalar(value: ConstScalar, ty: Ty) -> Const { - ConstData { ty, value: ConstValue::Concrete(chalk_ir::ConcreteConst { interned: value }) } - .intern(Interner) -} - /// Interns a constant scalar with the given type -pub fn intern_const_ref( - db: &dyn HirDatabase, +pub fn intern_const_ref<'a>( + db: &'a dyn HirDatabase, value: &LiteralConstRef, - ty: Ty, + ty: Ty<'a>, krate: Crate, -) -> Const { +) -> Const<'a> { let interner = DbInterner::new_with(db, Some(krate), None); - let layout = || db.layout_of_ty(ty.to_nextsolver(interner), TraitEnvironment::empty(krate)); - let bytes = match value { + let layout = db.layout_of_ty(ty, TraitEnvironment::empty(krate)); + let kind = match value { LiteralConstRef::Int(i) => { // FIXME: We should handle failure of layout better. - let size = layout().map(|it| it.size.bytes_usize()).unwrap_or(16); - ConstScalar::Bytes(i.to_le_bytes()[0..size].into(), MemoryMap::default()) + let size = layout.map(|it| it.size.bytes_usize()).unwrap_or(16); + rustc_type_ir::ConstKind::Value(ValueConst::new( + ty, + ConstBytes { + memory: i.to_le_bytes()[0..size].into(), + memory_map: MemoryMap::default(), + }, + )) } LiteralConstRef::UInt(i) => { - let size = layout().map(|it| it.size.bytes_usize()).unwrap_or(16); - ConstScalar::Bytes(i.to_le_bytes()[0..size].into(), MemoryMap::default()) - } - LiteralConstRef::Bool(b) => ConstScalar::Bytes(Box::new([*b as u8]), MemoryMap::default()), - LiteralConstRef::Char(c) => { - ConstScalar::Bytes((*c as u32).to_le_bytes().into(), MemoryMap::default()) + let size = layout.map(|it| it.size.bytes_usize()).unwrap_or(16); + rustc_type_ir::ConstKind::Value(ValueConst::new( + ty, + ConstBytes { + memory: i.to_le_bytes()[0..size].into(), + memory_map: MemoryMap::default(), + }, + )) } - LiteralConstRef::Unknown => ConstScalar::Unknown, + LiteralConstRef::Bool(b) => rustc_type_ir::ConstKind::Value(ValueConst::new( + ty, + ConstBytes { memory: Box::new([*b as u8]), memory_map: MemoryMap::default() }, + )), + LiteralConstRef::Char(c) => rustc_type_ir::ConstKind::Value(ValueConst::new( + ty, + ConstBytes { + memory: (*c as u32).to_le_bytes().into(), + memory_map: MemoryMap::default(), + }, + )), + LiteralConstRef::Unknown => rustc_type_ir::ConstKind::Error(ErrorGuaranteed), }; - intern_const_scalar(bytes, ty) + Const::new(interner, kind) } /// Interns a possibly-unknown target usize -pub fn usize_const(db: &dyn HirDatabase, value: Option<u128>, krate: Crate) -> Const { +pub fn usize_const<'db>(db: &'db dyn HirDatabase, value: Option<u128>, krate: Crate) -> Const<'db> { intern_const_ref( db, &value.map_or(LiteralConstRef::Unknown, LiteralConstRef::UInt), - TyBuilder::usize(), + Ty::new_uint(DbInterner::new_with(db, Some(krate), None), rustc_type_ir::UintTy::Usize), krate, ) } -pub fn try_const_usize(db: &dyn HirDatabase, c: &Const) -> Option<u128> { - match &c.data(Interner).value { - chalk_ir::ConstValue::BoundVar(_) => None, - chalk_ir::ConstValue::InferenceVar(_) => None, - chalk_ir::ConstValue::Placeholder(_) => None, - chalk_ir::ConstValue::Concrete(c) => match &c.interned { - ConstScalar::Bytes(it, _) => Some(u128::from_le_bytes(pad16(it, false))), - ConstScalar::UnevaluatedConst(c, subst) => { - let ec = db.const_eval(*c, subst.clone(), None).ok()?; - try_const_usize(db, &ec) - } - _ => None, - }, +pub fn try_const_usize<'db>(db: &'db dyn HirDatabase, c: Const<'db>) -> Option<u128> { + match c.kind() { + ConstKind::Param(_) => None, + ConstKind::Infer(_) => None, + ConstKind::Bound(_, _) => None, + ConstKind::Placeholder(_) => None, + ConstKind::Unevaluated(unevaluated_const) => { + let c = match unevaluated_const.def { + SolverDefId::ConstId(id) => GeneralConstId::ConstId(id), + SolverDefId::StaticId(id) => GeneralConstId::StaticId(id), + _ => unreachable!(), + }; + let subst = unevaluated_const.args; + let ec = db.const_eval(c, subst, None).ok()?; + try_const_usize(db, ec) + } + ConstKind::Value(val) => Some(u128::from_le_bytes(pad16(&val.value.inner().memory, false))), + ConstKind::Error(_) => None, + ConstKind::Expr(_) => None, } } -pub fn try_const_isize(db: &dyn HirDatabase, c: &Const) -> Option<i128> { - match &c.data(Interner).value { - chalk_ir::ConstValue::BoundVar(_) => None, - chalk_ir::ConstValue::InferenceVar(_) => None, - chalk_ir::ConstValue::Placeholder(_) => None, - chalk_ir::ConstValue::Concrete(c) => match &c.interned { - ConstScalar::Bytes(it, _) => Some(i128::from_le_bytes(pad16(it, true))), - ConstScalar::UnevaluatedConst(c, subst) => { - let ec = db.const_eval(*c, subst.clone(), None).ok()?; - try_const_isize(db, &ec) +pub fn try_const_isize<'db>(db: &'db dyn HirDatabase, c: &Const<'db>) -> Option<i128> { + match (*c).kind() { + ConstKind::Param(_) => None, + ConstKind::Infer(_) => None, + ConstKind::Bound(_, _) => None, + ConstKind::Placeholder(_) => None, + ConstKind::Unevaluated(unevaluated_const) => { + let c = match unevaluated_const.def { + SolverDefId::ConstId(id) => GeneralConstId::ConstId(id), + SolverDefId::StaticId(id) => GeneralConstId::StaticId(id), + _ => unreachable!(), + }; + let subst = unevaluated_const.args; + let ec = db.const_eval(c, subst, None).ok()?; + try_const_isize(db, &ec) + } + ConstKind::Value(val) => Some(i128::from_le_bytes(pad16(&val.value.inner().memory, true))), + ConstKind::Error(_) => None, + ConstKind::Expr(_) => None, + } +} + +pub(crate) fn const_eval_discriminant_variant<'db>( + db: &'db dyn HirDatabase, + variant_id: EnumVariantId, +) -> Result<i128, ConstEvalError<'db>> { + let interner = DbInterner::new_with(db, None, None); + let def = variant_id.into(); + let body = db.body(def); + let loc = variant_id.lookup(db); + if matches!(body[body.body_expr], Expr::Missing) { + let prev_idx = loc.index.checked_sub(1); + let value = match prev_idx { + Some(prev_idx) => { + 1 + db.const_eval_discriminant( + loc.parent.enum_variants(db).variants[prev_idx as usize].0, + )? } - _ => None, - }, + _ => 0, + }; + return Ok(value); } + + let repr = db.enum_signature(loc.parent).repr; + let is_signed = repr.and_then(|repr| repr.int).is_none_or(|int| int.is_signed()); + + let mir_body = db.monomorphized_mir_body( + def, + GenericArgs::new_from_iter(interner, []), + db.trait_environment_for_body(def), + )?; + let c = interpret_mir(db, mir_body, false, None)?.0?; + let c = if is_signed { + try_const_isize(db, &c).unwrap() + } else { + try_const_usize(db, c).unwrap() as i128 + }; + Ok(c) +} + +// FIXME: Ideally constants in const eval should have separate body (issue #7434), and this function should +// get an `InferenceResult` instead of an `InferenceContext`. And we should remove `ctx.clone().resolve_all()` here +// and make this function private. See the fixme comment on `InferenceContext::resolve_all`. +pub(crate) fn eval_to_const<'db>(expr: ExprId, ctx: &mut InferenceContext<'_, 'db>) -> Const<'db> { + let infer = ctx.fixme_resolve_all_clone(); + fn has_closure(body: &Body, expr: ExprId) -> bool { + if matches!(body[expr], Expr::Closure { .. }) { + return true; + } + let mut r = false; + body.walk_child_exprs(expr, |idx| r |= has_closure(body, idx)); + r + } + if has_closure(ctx.body, expr) { + // Type checking clousres need an isolated body (See the above FIXME). Bail out early to prevent panic. + return unknown_const(infer[expr]); + } + if let Expr::Path(p) = &ctx.body[expr] { + let resolver = &ctx.resolver; + if let Some(c) = path_to_const(ctx.db, resolver, p, || ctx.generics(), infer[expr]) { + return c; + } + } + if let Ok(mir_body) = lower_to_mir(ctx.db, ctx.owner, ctx.body, &infer, expr) + && let Ok((Ok(result), _)) = interpret_mir(ctx.db, Arc::new(mir_body), true, None) + { + return result; + } + unknown_const(infer[expr]) } pub(crate) fn const_eval_cycle_result<'db>( _: &'db dyn HirDatabase, _: GeneralConstId, - _: Substitution, + _: GenericArgs<'db>, _: Option<Arc<TraitEnvironment<'db>>>, -) -> Result<Const, ConstEvalError<'db>> { +) -> Result<Const<'db>, ConstEvalError<'db>> { Err(ConstEvalError::MirLowerError(MirLowerError::Loop)) } pub(crate) fn const_eval_static_cycle_result<'db>( _: &'db dyn HirDatabase, _: StaticId, -) -> Result<Const, ConstEvalError<'db>> { +) -> Result<Const<'db>, ConstEvalError<'db>> { Err(ConstEvalError::MirLowerError(MirLowerError::Loop)) } @@ -250,9 +319,9 @@ pub(crate) fn const_eval_discriminant_cycle_result<'db>( pub(crate) fn const_eval_query<'db>( db: &'db dyn HirDatabase, def: GeneralConstId, - subst: Substitution, + subst: GenericArgs<'db>, trait_env: Option<Arc<TraitEnvironment<'db>>>, -) -> Result<Const, ConstEvalError<'db>> { +) -> Result<Const<'db>, ConstEvalError<'db>> { let body = match def { GeneralConstId::ConstId(c) => { db.monomorphized_mir_body(c.into(), subst, db.trait_environment(c.into()))? @@ -269,52 +338,13 @@ pub(crate) fn const_eval_query<'db>( pub(crate) fn const_eval_static_query<'db>( db: &'db dyn HirDatabase, def: StaticId, -) -> Result<Const, ConstEvalError<'db>> { +) -> Result<Const<'db>, ConstEvalError<'db>> { + let interner = DbInterner::new_with(db, None, None); let body = db.monomorphized_mir_body( def.into(), - Substitution::empty(Interner), + GenericArgs::new_from_iter(interner, []), db.trait_environment_for_body(def.into()), )?; let c = interpret_mir(db, body, false, None)?.0?; Ok(c) } - -pub(crate) fn const_eval_discriminant_variant<'db>( - db: &'db dyn HirDatabase, - variant_id: EnumVariantId, -) -> Result<i128, ConstEvalError<'db>> { - let def = variant_id.into(); - let body = db.body(def); - let loc = variant_id.lookup(db); - if matches!(body[body.body_expr], Expr::Missing) { - let prev_idx = loc.index.checked_sub(1); - let value = match prev_idx { - Some(prev_idx) => { - 1 + db.const_eval_discriminant( - loc.parent.enum_variants(db).variants[prev_idx as usize].0, - )? - } - _ => 0, - }; - return Ok(value); - } - - let repr = db.enum_signature(loc.parent).repr; - let is_signed = repr.and_then(|repr| repr.int).is_none_or(|int| int.is_signed()); - - let mir_body = db.monomorphized_mir_body( - def, - Substitution::empty(Interner), - db.trait_environment_for_body(def), - )?; - let c = interpret_mir(db, mir_body, false, None)?.0?; - let c = if is_signed { - try_const_isize(db, &c).unwrap() - } else { - try_const_usize(db, &c).unwrap() as i128 - }; - Ok(c) -} - -#[cfg(test)] -mod tests; diff --git a/crates/hir-ty/src/consteval/tests.rs b/crates/hir-ty/src/consteval/tests.rs index 70a8ae766c..f1aa06d488 100644 --- a/crates/hir-ty/src/consteval/tests.rs +++ b/crates/hir-ty/src/consteval/tests.rs @@ -1,17 +1,23 @@ use base_db::RootQueryDb; -use chalk_ir::Substitution; use hir_def::db::DefDatabase; use hir_expand::EditionedFileId; use rustc_apfloat::{ Float, ieee::{Half as f16, Quad as f128}, }; +use rustc_type_ir::inherent::IntoKind; use test_fixture::WithFixture; use test_utils::skip_slow_tests; use crate::{ - Const, ConstScalar, Interner, MemoryMap, consteval::try_const_usize, db::HirDatabase, - display::DisplayTarget, mir::pad16, setup_tracing, test_db::TestDB, + MemoryMap, + consteval::try_const_usize, + db::HirDatabase, + display::DisplayTarget, + mir::pad16, + next_solver::{Const, ConstBytes, ConstKind, DbInterner, GenericArgs}, + setup_tracing, + test_db::TestDB, }; use super::{ @@ -88,14 +94,12 @@ fn check_answer( panic!("Error in evaluating goal: {err}"); } }; - match &r.data(Interner).value { - chalk_ir::ConstValue::Concrete(c) => match &c.interned { - ConstScalar::Bytes(b, mm) => { - check(b, mm); - } - x => panic!("Expected number but found {x:?}"), - }, - _ => panic!("result of const eval wasn't a concrete const"), + match r.kind() { + ConstKind::Value(value) => { + let ConstBytes { memory, memory_map } = value.value.inner(); + check(memory, memory_map); + } + _ => panic!("Expected number but found {r:?}"), } }); } @@ -117,8 +121,9 @@ fn pretty_print_err(e: ConstEvalError<'_>, db: &TestDB) -> String { err } -fn eval_goal(db: &TestDB, file_id: EditionedFileId) -> Result<Const, ConstEvalError<'_>> { +fn eval_goal(db: &TestDB, file_id: EditionedFileId) -> Result<Const<'_>, ConstEvalError<'_>> { let _tracing = setup_tracing(); + let interner = DbInterner::new_with(db, None, None); let module_id = db.module_for_file(file_id.file_id(db)); let def_map = module_id.def_map(db); let scope = &def_map[module_id.local_id].scope; @@ -137,7 +142,7 @@ fn eval_goal(db: &TestDB, file_id: EditionedFileId) -> Result<Const, ConstEvalEr _ => None, }) .expect("No const named GOAL found in the test"); - db.const_eval(const_id.into(), Substitution::empty(Interner), None) + db.const_eval(const_id.into(), GenericArgs::new_from_iter(interner, []), None) } #[test] @@ -2508,7 +2513,7 @@ fn enums() { ); crate::attach_db(&db, || { let r = eval_goal(&db, file_id).unwrap(); - assert_eq!(try_const_usize(&db, &r), Some(1)); + assert_eq!(try_const_usize(&db, r), Some(1)); }) } diff --git a/crates/hir-ty/src/consteval_chalk.rs b/crates/hir-ty/src/consteval_chalk.rs new file mode 100644 index 0000000000..458974384d --- /dev/null +++ b/crates/hir-ty/src/consteval_chalk.rs @@ -0,0 +1,185 @@ +//! Constant evaluation details + +use base_db::Crate; +use chalk_ir::{BoundVar, DebruijnIndex, cast::Cast}; +use hir_def::{ + expr_store::{HygieneId, path::Path}, + resolver::{Resolver, ValueNs}, + type_ref::LiteralConstRef, +}; +use stdx::never; + +use crate::{ + Const, ConstData, ConstScalar, ConstValue, GenericArg, Interner, MemoryMap, Substitution, + TraitEnvironment, Ty, TyBuilder, + db::HirDatabase, + generics::Generics, + lower::ParamLoweringMode, + next_solver::{ + DbInterner, + mapping::{ChalkToNextSolver, NextSolverToChalk}, + }, + to_placeholder_idx, +}; + +use super::mir::pad16; + +/// Extension trait for [`Const`] +pub trait ConstExt { + /// Is a [`Const`] unknown? + fn is_unknown(&self) -> bool; +} + +impl ConstExt for Const { + fn is_unknown(&self) -> bool { + match self.data(Interner).value { + // interned Unknown + chalk_ir::ConstValue::Concrete(chalk_ir::ConcreteConst { + interned: ConstScalar::Unknown, + }) => true, + + // interned concrete anything else + chalk_ir::ConstValue::Concrete(..) => false, + + _ => { + tracing::error!( + "is_unknown was called on a non-concrete constant value! {:?}", + self + ); + true + } + } + } +} + +pub fn path_to_const<'g>( + db: &dyn HirDatabase, + resolver: &Resolver<'_>, + path: &Path, + mode: ParamLoweringMode, + args: impl FnOnce() -> &'g Generics, + debruijn: DebruijnIndex, + expected_ty: Ty, +) -> Option<Const> { + match resolver.resolve_path_in_value_ns_fully(db, path, HygieneId::ROOT) { + Some(ValueNs::GenericParam(p)) => { + let ty = db.const_param_ty(p); + let args = args(); + let value = match mode { + ParamLoweringMode::Placeholder => { + let idx = args.type_or_const_param_idx(p.into()).unwrap(); + ConstValue::Placeholder(to_placeholder_idx(db, p.into(), idx as u32)) + } + ParamLoweringMode::Variable => match args.type_or_const_param_idx(p.into()) { + Some(it) => ConstValue::BoundVar(BoundVar::new(debruijn, it)), + None => { + never!( + "Generic list doesn't contain this param: {:?}, {:?}, {:?}", + args, + path, + p + ); + return None; + } + }, + }; + Some(ConstData { ty, value }.intern(Interner)) + } + Some(ValueNs::ConstId(c)) => Some(intern_const_scalar( + ConstScalar::UnevaluatedConst(c.into(), Substitution::empty(Interner)), + expected_ty, + )), + // FIXME: With feature(adt_const_params), we also need to consider other things here, e.g. struct constructors. + _ => None, + } +} + +pub fn unknown_const(ty: Ty) -> Const { + ConstData { + ty, + value: ConstValue::Concrete(chalk_ir::ConcreteConst { interned: ConstScalar::Unknown }), + } + .intern(Interner) +} + +pub fn unknown_const_as_generic(ty: Ty) -> GenericArg { + unknown_const(ty).cast(Interner) +} + +/// Interns a constant scalar with the given type +pub fn intern_const_scalar(value: ConstScalar, ty: Ty) -> Const { + ConstData { ty, value: ConstValue::Concrete(chalk_ir::ConcreteConst { interned: value }) } + .intern(Interner) +} + +/// Interns a constant scalar with the given type +pub fn intern_const_ref( + db: &dyn HirDatabase, + value: &LiteralConstRef, + ty: Ty, + krate: Crate, +) -> Const { + let interner = DbInterner::new_with(db, Some(krate), None); + let layout = || db.layout_of_ty(ty.to_nextsolver(interner), TraitEnvironment::empty(krate)); + let bytes = match value { + LiteralConstRef::Int(i) => { + // FIXME: We should handle failure of layout better. + let size = layout().map(|it| it.size.bytes_usize()).unwrap_or(16); + ConstScalar::Bytes(i.to_le_bytes()[0..size].into(), MemoryMap::default()) + } + LiteralConstRef::UInt(i) => { + let size = layout().map(|it| it.size.bytes_usize()).unwrap_or(16); + ConstScalar::Bytes(i.to_le_bytes()[0..size].into(), MemoryMap::default()) + } + LiteralConstRef::Bool(b) => ConstScalar::Bytes(Box::new([*b as u8]), MemoryMap::default()), + LiteralConstRef::Char(c) => { + ConstScalar::Bytes((*c as u32).to_le_bytes().into(), MemoryMap::default()) + } + LiteralConstRef::Unknown => ConstScalar::Unknown, + }; + intern_const_scalar(bytes, ty) +} + +/// Interns a possibly-unknown target usize +pub fn usize_const(db: &dyn HirDatabase, value: Option<u128>, krate: Crate) -> Const { + intern_const_ref( + db, + &value.map_or(LiteralConstRef::Unknown, LiteralConstRef::UInt), + TyBuilder::usize(), + krate, + ) +} + +pub fn try_const_usize(db: &dyn HirDatabase, c: &Const) -> Option<u128> { + let interner = DbInterner::new_with(db, None, None); + match &c.data(Interner).value { + chalk_ir::ConstValue::BoundVar(_) => None, + chalk_ir::ConstValue::InferenceVar(_) => None, + chalk_ir::ConstValue::Placeholder(_) => None, + chalk_ir::ConstValue::Concrete(c) => match &c.interned { + ConstScalar::Bytes(it, _) => Some(u128::from_le_bytes(pad16(it, false))), + ConstScalar::UnevaluatedConst(c, subst) => { + let ec = db.const_eval(*c, subst.to_nextsolver(interner), None).ok()?; + try_const_usize(db, &ec.to_chalk(interner)) + } + _ => None, + }, + } +} + +pub fn try_const_isize(db: &dyn HirDatabase, c: &Const) -> Option<i128> { + let interner = DbInterner::new_with(db, None, None); + match &c.data(Interner).value { + chalk_ir::ConstValue::BoundVar(_) => None, + chalk_ir::ConstValue::InferenceVar(_) => None, + chalk_ir::ConstValue::Placeholder(_) => None, + chalk_ir::ConstValue::Concrete(c) => match &c.interned { + ConstScalar::Bytes(it, _) => Some(i128::from_le_bytes(pad16(it, true))), + ConstScalar::UnevaluatedConst(c, subst) => { + let ec = db.const_eval(*c, subst.to_nextsolver(interner), None).ok()?; + try_const_isize(db, &ec.to_chalk(interner)) + } + _ => None, + }, + } +} diff --git a/crates/hir-ty/src/consteval_nextsolver.rs b/crates/hir-ty/src/consteval_nextsolver.rs deleted file mode 100644 index 2509ba2ef2..0000000000 --- a/crates/hir-ty/src/consteval_nextsolver.rs +++ /dev/null @@ -1,250 +0,0 @@ -//! Constant evaluation details -// FIXME(next-solver): this should get removed as things get moved to rustc_type_ir from chalk_ir -#![allow(unused)] - -use base_db::Crate; -use hir_def::{ - EnumVariantId, GeneralConstId, - expr_store::{Body, HygieneId, path::Path}, - hir::{Expr, ExprId}, - resolver::{Resolver, ValueNs}, - type_ref::LiteralConstRef, -}; -use hir_expand::Lookup; -use rustc_type_ir::{ - UnevaluatedConst, - inherent::{IntoKind, SliceLike}, -}; -use stdx::never; -use triomphe::Arc; - -use crate::{ - ConstScalar, Interner, MemoryMap, Substitution, TraitEnvironment, - consteval::ConstEvalError, - db::HirDatabase, - generics::Generics, - infer::InferenceContext, - next_solver::{ - Const, ConstBytes, ConstKind, DbInterner, ErrorGuaranteed, GenericArg, GenericArgs, - ParamConst, SolverDefId, Ty, ValueConst, - mapping::{ChalkToNextSolver, NextSolverToChalk, convert_binder_to_early_binder}, - }, -}; - -use super::mir::{interpret_mir, lower_to_mir, pad16}; - -pub(crate) fn path_to_const<'a, 'g>( - db: &'a dyn HirDatabase, - resolver: &Resolver<'a>, - path: &Path, - args: impl FnOnce() -> &'g Generics, - expected_ty: Ty<'a>, -) -> Option<Const<'a>> { - let interner = DbInterner::new_with(db, Some(resolver.krate()), None); - match resolver.resolve_path_in_value_ns_fully(db, path, HygieneId::ROOT) { - Some(ValueNs::GenericParam(p)) => { - let args = args(); - match args - .type_or_const_param(p.into()) - .and_then(|(idx, p)| p.const_param().map(|p| (idx, p.clone()))) - { - Some((idx, _param)) => { - Some(Const::new_param(interner, ParamConst { index: idx as u32, id: p })) - } - None => { - never!( - "Generic list doesn't contain this param: {:?}, {:?}, {:?}", - args, - path, - p - ); - None - } - } - } - Some(ValueNs::ConstId(c)) => { - let args = GenericArgs::new_from_iter(interner, []); - Some(Const::new( - interner, - rustc_type_ir::ConstKind::Unevaluated(UnevaluatedConst::new( - SolverDefId::ConstId(c), - args, - )), - )) - } - _ => None, - } -} - -pub fn unknown_const<'db>(ty: Ty<'db>) -> Const<'db> { - Const::new(DbInterner::conjure(), rustc_type_ir::ConstKind::Error(ErrorGuaranteed)) -} - -pub fn unknown_const_as_generic<'db>(ty: Ty<'db>) -> GenericArg<'db> { - unknown_const(ty).into() -} - -/// Interns a constant scalar with the given type -pub fn intern_const_ref<'a>( - db: &'a dyn HirDatabase, - value: &LiteralConstRef, - ty: Ty<'a>, - krate: Crate, -) -> Const<'a> { - let interner = DbInterner::new_with(db, Some(krate), None); - let layout = db.layout_of_ty(ty, TraitEnvironment::empty(krate)); - let kind = match value { - LiteralConstRef::Int(i) => { - // FIXME: We should handle failure of layout better. - let size = layout.map(|it| it.size.bytes_usize()).unwrap_or(16); - rustc_type_ir::ConstKind::Value(ValueConst::new( - ty, - ConstBytes(i.to_le_bytes()[0..size].into(), MemoryMap::default()), - )) - } - LiteralConstRef::UInt(i) => { - let size = layout.map(|it| it.size.bytes_usize()).unwrap_or(16); - rustc_type_ir::ConstKind::Value(ValueConst::new( - ty, - ConstBytes(i.to_le_bytes()[0..size].into(), MemoryMap::default()), - )) - } - LiteralConstRef::Bool(b) => rustc_type_ir::ConstKind::Value(ValueConst::new( - ty, - ConstBytes(Box::new([*b as u8]), MemoryMap::default()), - )), - LiteralConstRef::Char(c) => rustc_type_ir::ConstKind::Value(ValueConst::new( - ty, - ConstBytes((*c as u32).to_le_bytes().into(), MemoryMap::default()), - )), - LiteralConstRef::Unknown => rustc_type_ir::ConstKind::Error(ErrorGuaranteed), - }; - Const::new(interner, kind) -} - -/// Interns a possibly-unknown target usize -pub fn usize_const<'db>(db: &'db dyn HirDatabase, value: Option<u128>, krate: Crate) -> Const<'db> { - intern_const_ref( - db, - &value.map_or(LiteralConstRef::Unknown, LiteralConstRef::UInt), - Ty::new_uint(DbInterner::new_with(db, Some(krate), None), rustc_type_ir::UintTy::Usize), - krate, - ) -} - -pub fn try_const_usize<'db>(db: &'db dyn HirDatabase, c: Const<'db>) -> Option<u128> { - let interner = DbInterner::new_with(db, None, None); - match c.kind() { - ConstKind::Param(_) => None, - ConstKind::Infer(_) => None, - ConstKind::Bound(_, _) => None, - ConstKind::Placeholder(_) => None, - ConstKind::Unevaluated(unevaluated_const) => { - let c = match unevaluated_const.def { - SolverDefId::ConstId(id) => GeneralConstId::ConstId(id), - SolverDefId::StaticId(id) => GeneralConstId::StaticId(id), - _ => unreachable!(), - }; - let subst = unevaluated_const.args.to_chalk(interner); - let ec = db.const_eval(c, subst, None).ok()?.to_nextsolver(interner); - try_const_usize(db, ec) - } - ConstKind::Value(val) => Some(u128::from_le_bytes(pad16(&val.value.inner().0, false))), - ConstKind::Error(_) => None, - ConstKind::Expr(_) => None, - } -} - -pub fn try_const_isize<'db>(db: &'db dyn HirDatabase, c: &Const<'db>) -> Option<i128> { - let interner = DbInterner::new_with(db, None, None); - match (*c).kind() { - ConstKind::Param(_) => None, - ConstKind::Infer(_) => None, - ConstKind::Bound(_, _) => None, - ConstKind::Placeholder(_) => None, - ConstKind::Unevaluated(unevaluated_const) => { - let c = match unevaluated_const.def { - SolverDefId::ConstId(id) => GeneralConstId::ConstId(id), - SolverDefId::StaticId(id) => GeneralConstId::StaticId(id), - _ => unreachable!(), - }; - let subst = unevaluated_const.args.to_chalk(interner); - let ec = db.const_eval(c, subst, None).ok()?.to_nextsolver(interner); - try_const_isize(db, &ec) - } - ConstKind::Value(val) => Some(i128::from_le_bytes(pad16(&val.value.inner().0, true))), - ConstKind::Error(_) => None, - ConstKind::Expr(_) => None, - } -} - -pub(crate) fn const_eval_discriminant_variant<'db>( - db: &'db dyn HirDatabase, - variant_id: EnumVariantId, -) -> Result<i128, ConstEvalError<'db>> { - let interner = DbInterner::new_with(db, None, None); - let def = variant_id.into(); - let body = db.body(def); - let loc = variant_id.lookup(db); - if matches!(body[body.body_expr], Expr::Missing) { - let prev_idx = loc.index.checked_sub(1); - let value = match prev_idx { - Some(prev_idx) => { - 1 + db.const_eval_discriminant( - loc.parent.enum_variants(db).variants[prev_idx as usize].0, - )? - } - _ => 0, - }; - return Ok(value); - } - - let repr = db.enum_signature(loc.parent).repr; - let is_signed = repr.and_then(|repr| repr.int).is_none_or(|int| int.is_signed()); - - let mir_body = db.monomorphized_mir_body( - def, - Substitution::empty(Interner), - db.trait_environment_for_body(def), - )?; - let c = interpret_mir(db, mir_body, false, None)?.0?; - let c = c.to_nextsolver(interner); - let c = if is_signed { - try_const_isize(db, &c).unwrap() - } else { - try_const_usize(db, c).unwrap() as i128 - }; - Ok(c) -} - -// FIXME: Ideally constants in const eval should have separate body (issue #7434), and this function should -// get an `InferenceResult` instead of an `InferenceContext`. And we should remove `ctx.clone().resolve_all()` here -// and make this function private. See the fixme comment on `InferenceContext::resolve_all`. -pub(crate) fn eval_to_const<'db>(expr: ExprId, ctx: &mut InferenceContext<'_, 'db>) -> Const<'db> { - let interner = DbInterner::new_with(ctx.db, None, None); - let infer = ctx.fixme_resolve_all_clone(); - fn has_closure(body: &Body, expr: ExprId) -> bool { - if matches!(body[expr], Expr::Closure { .. }) { - return true; - } - let mut r = false; - body.walk_child_exprs(expr, |idx| r |= has_closure(body, idx)); - r - } - if has_closure(ctx.body, expr) { - // Type checking clousres need an isolated body (See the above FIXME). Bail out early to prevent panic. - return unknown_const(infer[expr]); - } - if let Expr::Path(p) = &ctx.body[expr] { - let resolver = &ctx.resolver; - if let Some(c) = path_to_const(ctx.db, resolver, p, || ctx.generics(), infer[expr]) { - return c; - } - } - if let Ok(mir_body) = lower_to_mir(ctx.db, ctx.owner, ctx.body, &infer, expr) - && let Ok((Ok(result), _)) = interpret_mir(ctx.db, Arc::new(mir_body), true, None) - { - return result.to_nextsolver(interner); - } - unknown_const(infer[expr]) -} diff --git a/crates/hir-ty/src/db.rs b/crates/hir-ty/src/db.rs index 11d3be5c3c..4b33c8a84a 100644 --- a/crates/hir-ty/src/db.rs +++ b/crates/hir-ty/src/db.rs @@ -16,8 +16,8 @@ use smallvec::SmallVec; use triomphe::Arc; use crate::{ - Binders, Const, ImplTraitId, ImplTraits, InferenceResult, Substitution, TraitEnvironment, Ty, - TyDefId, ValueTyDefId, chalk_db, + Binders, ImplTraitId, ImplTraits, InferenceResult, TraitEnvironment, Ty, TyDefId, ValueTyDefId, + chalk_db, consteval::ConstEvalError, dyn_compatibility::DynCompatibilityViolation, layout::{Layout, LayoutError}, @@ -37,50 +37,56 @@ pub trait HirDatabase: DefDatabase + std::fmt::Debug { #[salsa::invoke(crate::mir::mir_body_query)] #[salsa::cycle(cycle_result = crate::mir::mir_body_cycle_result)] - fn mir_body<'db>(&'db self, def: DefWithBodyId) -> Result<Arc<MirBody>, MirLowerError<'db>>; + fn mir_body<'db>( + &'db self, + def: DefWithBodyId, + ) -> Result<Arc<MirBody<'db>>, MirLowerError<'db>>; #[salsa::invoke(crate::mir::mir_body_for_closure_query)] fn mir_body_for_closure<'db>( &'db self, def: InternedClosureId, - ) -> Result<Arc<MirBody>, MirLowerError<'db>>; + ) -> Result<Arc<MirBody<'db>>, MirLowerError<'db>>; #[salsa::invoke(crate::mir::monomorphized_mir_body_query)] #[salsa::cycle(cycle_result = crate::mir::monomorphized_mir_body_cycle_result)] fn monomorphized_mir_body<'db>( &'db self, def: DefWithBodyId, - subst: Substitution, + subst: crate::next_solver::GenericArgs<'db>, env: Arc<TraitEnvironment<'db>>, - ) -> Result<Arc<MirBody>, MirLowerError<'db>>; + ) -> Result<Arc<MirBody<'db>>, MirLowerError<'db>>; #[salsa::invoke(crate::mir::monomorphized_mir_body_for_closure_query)] fn monomorphized_mir_body_for_closure<'db>( &'db self, def: InternedClosureId, - subst: Substitution, + subst: crate::next_solver::GenericArgs<'db>, env: Arc<TraitEnvironment<'db>>, - ) -> Result<Arc<MirBody>, MirLowerError<'db>>; + ) -> Result<Arc<MirBody<'db>>, MirLowerError<'db>>; #[salsa::invoke(crate::mir::borrowck_query)] #[salsa::lru(2024)] fn borrowck<'db>( &'db self, def: DefWithBodyId, - ) -> Result<Arc<[BorrowckResult]>, MirLowerError<'db>>; + ) -> Result<Arc<[BorrowckResult<'db>]>, MirLowerError<'db>>; #[salsa::invoke(crate::consteval::const_eval_query)] #[salsa::cycle(cycle_result = crate::consteval::const_eval_cycle_result)] fn const_eval<'db>( &'db self, def: GeneralConstId, - subst: Substitution, + subst: crate::next_solver::GenericArgs<'db>, trait_env: Option<Arc<TraitEnvironment<'db>>>, - ) -> Result<Const, ConstEvalError<'db>>; + ) -> Result<crate::next_solver::Const<'db>, ConstEvalError<'db>>; #[salsa::invoke(crate::consteval::const_eval_static_query)] #[salsa::cycle(cycle_result = crate::consteval::const_eval_static_cycle_result)] - fn const_eval_static<'db>(&'db self, def: StaticId) -> Result<Const, ConstEvalError<'db>>; + fn const_eval_static<'db>( + &'db self, + def: StaticId, + ) -> Result<crate::next_solver::Const<'db>, ConstEvalError<'db>>; #[salsa::invoke(crate::consteval::const_eval_discriminant_variant)] #[salsa::cycle(cycle_result = crate::consteval::const_eval_discriminant_cycle_result)] diff --git a/crates/hir-ty/src/display.rs b/crates/hir-ty/src/display.rs index d79069901e..bcd93c6699 100644 --- a/crates/hir-ty/src/display.rs +++ b/crates/hir-ty/src/display.rs @@ -52,7 +52,7 @@ use crate::{ AliasEq, AliasTy, Binders, CallableDefId, CallableSig, ConcreteConst, Const, ConstScalar, ConstValue, DomainGoal, FnAbi, GenericArg, ImplTraitId, Interner, Lifetime, LifetimeData, LifetimeOutlives, MemoryMap, OpaqueTy, ProjectionTy, ProjectionTyExt, QuantifiedWhereClause, - TraitEnvironment, TraitRef, TraitRefExt, Ty, TyExt, WhereClause, consteval_nextsolver, + TraitEnvironment, TraitRef, TraitRefExt, Ty, TyExt, WhereClause, consteval, db::{HirDatabase, InternedClosure}, from_assoc_type_id, from_placeholder_idx, generics::generics, @@ -750,8 +750,8 @@ impl<'db> HirDisplay for crate::next_solver::Const<'db> { } rustc_type_ir::ConstKind::Value(const_bytes) => render_const_scalar_ns( f, - &const_bytes.value.inner().0, - &const_bytes.value.inner().1, + &const_bytes.value.inner().memory, + &const_bytes.value.inner().memory_map, const_bytes.ty, ), rustc_type_ir::ConstKind::Unevaluated(unev) => { @@ -1025,7 +1025,7 @@ fn render_const_scalar_inner<'db>( ty.hir_fmt(f) } TyKind::Array(ty, len) => { - let Some(len) = consteval_nextsolver::try_const_usize(f.db, len) else { + let Some(len) = consteval::try_const_usize(f.db, len) else { return f.write_str("<unknown-array-len>"); }; let Ok(layout) = f.db.layout_of_ty(ty, trait_env) else { diff --git a/crates/hir-ty/src/drop.rs b/crates/hir-ty/src/drop.rs index 4bd9691ea0..aaf274799c 100644 --- a/crates/hir-ty/src/drop.rs +++ b/crates/hir-ty/src/drop.rs @@ -7,7 +7,7 @@ use stdx::never; use triomphe::Arc; use crate::{ - TraitEnvironment, consteval_nextsolver, + TraitEnvironment, consteval, db::HirDatabase, method_resolution::TyFingerprint, next_solver::{ @@ -128,7 +128,7 @@ fn has_drop_glue_impl<'db>( .max() .unwrap_or(DropGlue::None), TyKind::Array(ty, len) => { - if consteval_nextsolver::try_const_usize(db, len) == Some(0) { + if consteval::try_const_usize(db, len) == Some(0) { // Arrays of size 0 don't have drop glue. return DropGlue::None; } diff --git a/crates/hir-ty/src/infer/closure/analysis.rs b/crates/hir-ty/src/infer/closure/analysis.rs index 8a6ce0a69b..763b145812 100644 --- a/crates/hir-ty/src/infer/closure/analysis.rs +++ b/crates/hir-ty/src/infer/closure/analysis.rs @@ -28,10 +28,7 @@ use crate::{ db::{HirDatabase, InternedClosure, InternedClosureId}, infer::InferenceContext, mir::{BorrowKind, MirSpan, MutBorrowKind, ProjectionElem}, - next_solver::{ - DbInterner, EarlyBinder, GenericArgs, Ty, TyKind, - mapping::{ChalkToNextSolver, NextSolverToChalk}, - }, + next_solver::{DbInterner, EarlyBinder, GenericArgs, Ty, TyKind}, traits::FnTrait, }; @@ -47,16 +44,14 @@ impl<'db> HirPlace<'db> { fn ty(&self, ctx: &mut InferenceContext<'_, 'db>) -> Ty<'db> { let mut ty = ctx.table.resolve_completely(ctx.result[self.local]); for p in &self.projections { - ty = p - .projected_ty( - ty.to_chalk(ctx.interner()), - ctx.db, - |_, _, _| { - unreachable!("Closure field only happens in MIR"); - }, - ctx.owner.module(ctx.db).krate(), - ) - .to_nextsolver(ctx.interner()); + ty = p.projected_ty( + &ctx.table.infer_ctxt, + ty, + |_, _, _| { + unreachable!("Closure field only happens in MIR"); + }, + ctx.owner.module(ctx.db).krate(), + ); } ty } @@ -865,16 +860,14 @@ impl<'db> InferenceContext<'_, 'db> { continue; } for (i, p) in capture.place.projections.iter().enumerate() { - ty = p - .projected_ty( - ty.to_chalk(self.interner()), - self.db, - |_, _, _| { - unreachable!("Closure field only happens in MIR"); - }, - self.owner.module(self.db).krate(), - ) - .to_nextsolver(self.interner()); + ty = p.projected_ty( + &self.table.infer_ctxt, + ty, + |_, _, _| { + unreachable!("Closure field only happens in MIR"); + }, + self.owner.module(self.db).krate(), + ); if ty.is_raw_ptr() || ty.is_union() { capture.kind = CaptureKind::ByRef(BorrowKind::Shared); self.truncate_capture_spans(capture, i + 1); diff --git a/crates/hir-ty/src/infer/expr.rs b/crates/hir-ty/src/infer/expr.rs index b4140d88db..859dfef70f 100644 --- a/crates/hir-ty/src/infer/expr.rs +++ b/crates/hir-ty/src/infer/expr.rs @@ -28,7 +28,7 @@ use crate::{ Adjust, Adjustment, AutoBorrow, CallableDefId, DeclContext, DeclOrigin, IncorrectGenericsLenKind, Rawness, TraitEnvironment, autoderef::overloaded_deref_ty, - consteval_nextsolver, + consteval, generics::generics, infer::{ AllowTwoPhase, BreakableKind, @@ -896,7 +896,7 @@ impl<'db> InferenceContext<'_, 'db> { Literal::ByteString(bs) => { let byte_type = self.types.u8; - let len = consteval_nextsolver::usize_const( + let len = consteval::usize_const( self.db, Some(bs.len() as u128), self.resolver.krate(), @@ -1221,7 +1221,7 @@ impl<'db> InferenceContext<'_, 'db> { let expected = Expectation::has_type(elem_ty); let (elem_ty, len) = match array { Array::ElementList { elements, .. } if elements.is_empty() => { - (elem_ty, consteval_nextsolver::usize_const(self.db, Some(0), krate)) + (elem_ty, consteval::usize_const(self.db, Some(0), krate)) } Array::ElementList { elements, .. } => { let mut coerce = CoerceMany::with_coercion_sites(elem_ty, elements); @@ -1231,7 +1231,7 @@ impl<'db> InferenceContext<'_, 'db> { } ( coerce.complete(self), - consteval_nextsolver::usize_const(self.db, Some(elements.len() as u128), krate), + consteval::usize_const(self.db, Some(elements.len() as u128), krate), ) } &Array::Repeat { initializer, repeat } => { @@ -1248,7 +1248,7 @@ impl<'db> InferenceContext<'_, 'db> { _ => _ = self.infer_expr(repeat, &Expectation::HasType(usize), ExprIsRead::Yes), } - (elem_ty, consteval_nextsolver::eval_to_const(repeat, self)) + (elem_ty, consteval::eval_to_const(repeat, self)) } }; // Try to evaluate unevaluated constant, and insert variable if is not possible. diff --git a/crates/hir-ty/src/infer/pat.rs b/crates/hir-ty/src/infer/pat.rs index 9f2f86dd3e..452ae31662 100644 --- a/crates/hir-ty/src/infer/pat.rs +++ b/crates/hir-ty/src/infer/pat.rs @@ -14,7 +14,7 @@ use stdx::TupleExt; use crate::{ DeclContext, DeclOrigin, InferenceDiagnostic, - consteval_nextsolver::{self, try_const_usize, usize_const}, + consteval::{self, try_const_usize, usize_const}, infer::{ AllowTwoPhase, BindingMode, Expectation, InferenceContext, TypeMismatch, coerce::CoerceNever, expr::ExprIsRead, @@ -591,11 +591,7 @@ impl<'db> InferenceContext<'_, 'db> { } let len = before.len() + suffix.len(); - let size = consteval_nextsolver::usize_const( - self.db, - Some(len as u128), - self.owner.krate(self.db), - ); + let size = consteval::usize_const(self.db, Some(len as u128), self.owner.krate(self.db)); let elem_ty = self.table.next_ty_var(); let array_ty = Ty::new_array_with_const_len(self.interner(), elem_ty, size); diff --git a/crates/hir-ty/src/infer/path.rs b/crates/hir-ty/src/infer/path.rs index e649e381dd..110f767967 100644 --- a/crates/hir-ty/src/infer/path.rs +++ b/crates/hir-ty/src/infer/path.rs @@ -10,7 +10,7 @@ use rustc_type_ir::inherent::{SliceLike, Ty as _}; use stdx::never; use crate::{ - InferenceDiagnostic, ValueTyDefId, consteval_nextsolver, + InferenceDiagnostic, ValueTyDefId, consteval, generics::generics, infer::diagnostics::InferenceTyLoweringContext as TyLoweringContext, lower_nextsolver::LifetimeElisionKind, @@ -128,7 +128,7 @@ impl<'db> InferenceContext<'_, 'db> { match id { GenericParamId::TypeParamId(_) => self.types.error.into(), GenericParamId::ConstParamId(id) => { - consteval_nextsolver::unknown_const_as_generic(self.db.const_param_ty_ns(id)) + consteval::unknown_const_as_generic(self.db.const_param_ty_ns(id)) } GenericParamId::LifetimeParamId(_) => self.types.re_error.into(), } diff --git a/crates/hir-ty/src/inhabitedness.rs b/crates/hir-ty/src/inhabitedness.rs index bdebe41b29..826f19cf0b 100644 --- a/crates/hir-ty/src/inhabitedness.rs +++ b/crates/hir-ty/src/inhabitedness.rs @@ -11,7 +11,9 @@ use triomphe::Arc; use crate::{ AliasTy, Binders, Interner, Substitution, TraitEnvironment, Ty, TyKind, - consteval::try_const_usize, db::HirDatabase, + consteval::try_const_usize, + db::HirDatabase, + next_solver::{DbInterner, mapping::ChalkToNextSolver}, }; // FIXME: Turn this into a query, it can be quite slow @@ -79,14 +81,17 @@ impl TypeVisitor<Interner> for UninhabitedFrom<'_> { } self.recursive_ty.insert(ty.clone()); self.max_depth -= 1; + let interner = DbInterner::new_with(self.db, None, None); let r = match ty.kind(Interner) { TyKind::Adt(adt, subst) => self.visit_adt(adt.0, subst), TyKind::Never => BREAK_VISIBLY_UNINHABITED, TyKind::Tuple(..) => ty.super_visit_with(self, outer_binder), - TyKind::Array(item_ty, len) => match try_const_usize(self.db, len) { - Some(0) | None => CONTINUE_OPAQUELY_INHABITED, - Some(1..) => item_ty.super_visit_with(self, outer_binder), - }, + TyKind::Array(item_ty, len) => { + match try_const_usize(self.db, len.to_nextsolver(interner)) { + Some(0) | None => CONTINUE_OPAQUELY_INHABITED, + Some(1..) => item_ty.super_visit_with(self, outer_binder), + } + } TyKind::Alias(AliasTy::Projection(projection)) => { // FIXME: I think this currently isn't used for monomorphized bodies, so there is no need to handle // `TyKind::AssociatedType`, but perhaps in the future it will. diff --git a/crates/hir-ty/src/layout.rs b/crates/hir-ty/src/layout.rs index eed36b1bb7..a857602fa0 100644 --- a/crates/hir-ty/src/layout.rs +++ b/crates/hir-ty/src/layout.rs @@ -21,7 +21,7 @@ use triomphe::Arc; use crate::{ TraitEnvironment, - consteval_nextsolver::try_const_usize, + consteval::try_const_usize, db::HirDatabase, next_solver::{ DbInterner, GenericArgs, ParamEnv, Ty, TyKind, TypingMode, diff --git a/crates/hir-ty/src/lib.rs b/crates/hir-ty/src/lib.rs index 4ff5cc5588..76cc65277c 100644 --- a/crates/hir-ty/src/lib.rs +++ b/crates/hir-ty/src/lib.rs @@ -21,6 +21,8 @@ extern crate ra_ap_rustc_type_ir as rustc_type_ir; extern crate ra_ap_rustc_next_trait_solver as rustc_next_trait_solver; +extern crate self as hir_ty; + mod builder; mod chalk_db; mod chalk_ext; @@ -37,7 +39,7 @@ mod utils; pub mod autoderef; pub mod consteval; -pub mod consteval_nextsolver; +pub mod consteval_chalk; pub mod db; pub mod diagnostics; pub mod display; @@ -782,7 +784,12 @@ where _var: InferenceVar, _outer_binder: DebruijnIndex, ) -> Fallible<Const> { - if cfg!(debug_assertions) { Err(NoSolution) } else { Ok(unknown_const(ty)) } + if cfg!(debug_assertions) { + Err(NoSolution) + } else { + let interner = DbInterner::conjure(); + Ok(unknown_const(ty.to_nextsolver(interner)).to_chalk(interner)) + } } fn try_fold_free_var_const( @@ -791,7 +798,12 @@ where _bound_var: BoundVar, _outer_binder: DebruijnIndex, ) -> Fallible<Const> { - if cfg!(debug_assertions) { Err(NoSolution) } else { Ok(unknown_const(ty)) } + if cfg!(debug_assertions) { + Err(NoSolution) + } else { + let interner = DbInterner::conjure(); + Ok(unknown_const(ty.to_nextsolver(interner)).to_chalk(interner)) + } } fn try_fold_inference_lifetime( diff --git a/crates/hir-ty/src/lower.rs b/crates/hir-ty/src/lower.rs index a9b523a4a6..ee7b0cdd1f 100644 --- a/crates/hir-ty/src/lower.rs +++ b/crates/hir-ty/src/lower.rs @@ -49,7 +49,7 @@ use crate::{ ImplTrait, ImplTraitId, ImplTraits, Interner, Lifetime, LifetimeData, LifetimeOutlives, QuantifiedWhereClause, QuantifiedWhereClauses, Substitution, TraitRef, TraitRefExt, Ty, TyBuilder, TyKind, WhereClause, all_super_traits, - consteval::{intern_const_ref, path_to_const, unknown_const, unknown_const_as_generic}, + consteval_chalk::{intern_const_ref, path_to_const, unknown_const, unknown_const_as_generic}, db::HirDatabase, error_lifetime, generics::{Generics, generics, trait_self_param_idx}, diff --git a/crates/hir-ty/src/lower/path.rs b/crates/hir-ty/src/lower/path.rs index cdac1c9829..f988b6160b 100644 --- a/crates/hir-ty/src/lower/path.rs +++ b/crates/hir-ty/src/lower/path.rs @@ -23,7 +23,7 @@ use crate::{ Interner, ParamLoweringMode, PathGenericsSource, PathLoweringDiagnostic, ProjectionTy, QuantifiedWhereClause, Substitution, TraitRef, Ty, TyBuilder, TyDefId, TyKind, TyLoweringContext, WhereClause, - consteval::{unknown_const, unknown_const_as_generic}, + consteval_chalk::{unknown_const, unknown_const_as_generic}, db::HirDatabase, error_lifetime, generics::{Generics, generics}, diff --git a/crates/hir-ty/src/lower_nextsolver.rs b/crates/hir-ty/src/lower_nextsolver.rs index 98881004bb..5a0bccea5f 100644 --- a/crates/hir-ty/src/lower_nextsolver.rs +++ b/crates/hir-ty/src/lower_nextsolver.rs @@ -62,7 +62,7 @@ use crate::next_solver::ParamConst; use crate::{ FnAbi, ImplTraitId, Interner, ParamKind, TraitEnvironment, TyDefId, TyLoweringDiagnostic, TyLoweringDiagnosticKind, - consteval_nextsolver::{intern_const_ref, path_to_const, unknown_const_as_generic}, + consteval::{intern_const_ref, path_to_const, unknown_const_as_generic}, db::HirDatabase, generics::{Generics, generics, trait_self_param_idx}, lower::{Diagnostics, PathDiagnosticCallbackData, create_diagnostics}, diff --git a/crates/hir-ty/src/lower_nextsolver/path.rs b/crates/hir-ty/src/lower_nextsolver/path.rs index babc39694f..b003cc574d 100644 --- a/crates/hir-ty/src/lower_nextsolver/path.rs +++ b/crates/hir-ty/src/lower_nextsolver/path.rs @@ -30,7 +30,7 @@ use stdx::never; use crate::{ GenericArgsProhibitedReason, IncorrectGenericsLenKind, PathGenericsSource, PathLoweringDiagnostic, TyDefId, ValueTyDefId, - consteval_nextsolver::{unknown_const, unknown_const_as_generic}, + consteval::{unknown_const, unknown_const_as_generic}, db::HirDatabase, generics::{Generics, generics}, lower::PathDiagnosticCallbackData, diff --git a/crates/hir-ty/src/method_resolution.rs b/crates/hir-ty/src/method_resolution.rs index 086abc9591..110fee824c 100644 --- a/crates/hir-ty/src/method_resolution.rs +++ b/crates/hir-ty/src/method_resolution.rs @@ -4,13 +4,12 @@ //! and the corresponding code mostly in rustc_hir_analysis/check/method/probe.rs. use std::ops::ControlFlow; -use arrayvec::ArrayVec; use base_db::Crate; use chalk_ir::{UniverseIndex, WithKind, cast::Cast}; use hir_def::{ AdtId, AssocItemId, BlockId, ConstId, FunctionId, HasModule, ImplId, ItemContainerId, Lookup, ModuleId, TraitId, TypeAliasId, - nameres::{DefMap, assoc::ImplItems, block_def_map, crate_def_map}, + nameres::{DefMap, block_def_map, crate_def_map}, signatures::{ConstFlags, EnumFlags, FnFlags, StructFlags, TraitFlags, TypeAliasFlags}, }; use hir_expand::name::Name; @@ -18,7 +17,7 @@ use intern::sym; use rustc_ast_ir::Mutability; use rustc_hash::{FxHashMap, FxHashSet}; use rustc_type_ir::{ - FloatTy, IntTy, UintTy, + FloatTy, IntTy, TypeVisitableExt, UintTy, inherent::{ AdtDef, BoundExistentialPredicates, GenericArgs as _, IntoKind, SliceLike, Ty as _, }, @@ -27,6 +26,8 @@ use smallvec::{SmallVec, smallvec}; use stdx::never; use triomphe::Arc; +use crate::next_solver::infer::InferCtxt; +use crate::next_solver::infer::select::ImplSource; use crate::{ CanonicalVarKinds, DebruijnIndex, GenericArgData, InEnvironment, Interner, TraitEnvironment, TyBuilder, VariableKind, @@ -36,10 +37,10 @@ use crate::{ lang_items::is_box, next_solver::{ Canonical, DbInterner, ErrorGuaranteed, GenericArgs, Goal, Predicate, Region, SolverDefId, - TraitRef, Ty, TyKind, + TraitRef, Ty, TyKind, TypingMode, infer::{ - DefineOpaqueTypes, - traits::{ObligationCause, PredicateObligation}, + DbInternerInferExt, DefineOpaqueTypes, + traits::{Obligation, ObligationCause, PredicateObligation}, }, mapping::NextSolverToChalk, obligation_ctxt::ObligationCtxt, @@ -689,11 +690,12 @@ pub(crate) fn iterate_method_candidates<'db, T>( } pub fn lookup_impl_const<'db>( - interner: DbInterner<'db>, + infcx: &InferCtxt<'db>, env: Arc<TraitEnvironment<'db>>, const_id: ConstId, subs: GenericArgs<'db>, ) -> (ConstId, GenericArgs<'db>) { + let interner = infcx.interner; let db = interner.db; let trait_id = match const_id.lookup(db).container { @@ -708,7 +710,7 @@ pub fn lookup_impl_const<'db>( None => return (const_id, subs), }; - lookup_impl_assoc_item_for_trait_ref(trait_ref, db, env, name) + lookup_impl_assoc_item_for_trait_ref(infcx, trait_ref, env, name) .and_then( |assoc| if let (AssocItemId::ConstId(id), s) = assoc { Some((id, s)) } else { None }, ) @@ -759,6 +761,7 @@ pub(crate) fn lookup_impl_method_query<'db>( fn_subst: GenericArgs<'db>, ) -> (FunctionId, GenericArgs<'db>) { let interner = DbInterner::new_with(db, Some(env.krate), env.block); + let infcx = interner.infer_ctxt().build(TypingMode::PostAnalysis); let ItemContainerId::TraitId(trait_id) = func.lookup(db).container else { return (func, fn_subst); @@ -772,7 +775,7 @@ pub(crate) fn lookup_impl_method_query<'db>( let name = &db.function_signature(func).name; let Some((impl_fn, impl_subst)) = - lookup_impl_assoc_item_for_trait_ref(trait_ref, db, env, name).and_then(|assoc| { + lookup_impl_assoc_item_for_trait_ref(&infcx, trait_ref, env, name).and_then(|assoc| { if let (AssocItemId::FunctionId(id), subst) = assoc { Some((id, subst)) } else { None } }) else { @@ -789,78 +792,53 @@ pub(crate) fn lookup_impl_method_query<'db>( } fn lookup_impl_assoc_item_for_trait_ref<'db>( + infcx: &InferCtxt<'db>, trait_ref: TraitRef<'db>, - db: &'db dyn HirDatabase, env: Arc<TraitEnvironment<'db>>, name: &Name, ) -> Option<(AssocItemId, GenericArgs<'db>)> { - let hir_trait_id = trait_ref.def_id.0; - let self_ty = trait_ref.self_ty(); - let self_ty_fp = TyFingerprint::for_trait_impl(self_ty)?; - let impls = db.trait_impls_in_deps(env.krate); - - let trait_module = hir_trait_id.module(db); - let type_module = match self_ty_fp { - TyFingerprint::Adt(adt_id) => Some(adt_id.module(db)), - TyFingerprint::ForeignType(type_id) => Some(type_id.module(db)), - TyFingerprint::Dyn(trait_id) => Some(trait_id.module(db)), - _ => None, - }; - - let def_blocks: ArrayVec<_, 2> = - [trait_module.containing_block(), type_module.and_then(|it| it.containing_block())] - .into_iter() - .flatten() - .filter_map(|block_id| db.trait_impls_in_block(block_id)) - .collect(); - - let impls = impls - .iter() - .chain(&def_blocks) - .flat_map(|impls| impls.for_trait_and_self_ty(hir_trait_id, self_ty_fp)); - - let table = InferenceTable::new(db, env); - - let (impl_data, impl_subst) = find_matching_impl(impls, table, trait_ref)?; - let item = impl_data.items.iter().find_map(|(n, it)| match *it { - AssocItemId::FunctionId(f) => (n == name).then_some(AssocItemId::FunctionId(f)), - AssocItemId::ConstId(c) => (n == name).then_some(AssocItemId::ConstId(c)), - AssocItemId::TypeAliasId(_) => None, - })?; + let (impl_id, impl_subst) = find_matching_impl(infcx, &env, trait_ref)?; + let item = + impl_id.impl_items(infcx.interner.db).items.iter().find_map(|(n, it)| match *it { + AssocItemId::FunctionId(f) => (n == name).then_some(AssocItemId::FunctionId(f)), + AssocItemId::ConstId(c) => (n == name).then_some(AssocItemId::ConstId(c)), + AssocItemId::TypeAliasId(_) => None, + })?; Some((item, impl_subst)) } -fn find_matching_impl<'db>( - mut impls: impl Iterator<Item = ImplId>, - mut table: InferenceTable<'db>, - actual_trait_ref: TraitRef<'db>, -) -> Option<(&'db ImplItems, GenericArgs<'db>)> { - let db = table.db; - impls.find_map(|impl_| { - table.run_in_snapshot(|table| { - let impl_substs = table.fresh_args_for_item(impl_.into()); - let trait_ref = db - .impl_trait(impl_) - .expect("non-trait method in find_matching_impl") - .instantiate(table.interner(), impl_substs); - - if !table.unify(trait_ref, actual_trait_ref) { - return None; - } +pub(crate) fn find_matching_impl<'db>( + infcx: &InferCtxt<'db>, + env: &TraitEnvironment<'db>, + trait_ref: TraitRef<'db>, +) -> Option<(ImplId, GenericArgs<'db>)> { + let trait_ref = + infcx.at(&ObligationCause::dummy(), env.env).deeply_normalize(trait_ref).ok()?; - if let Some(predicates) = - db.generic_predicates_ns(impl_.into()).instantiate(table.interner(), impl_substs) - { - for predicate in predicates { - if table.try_obligation(predicate.0).no_solution() { - return None; - } - table.register_obligation(predicate.0); - } - } - Some((impl_.impl_items(db), table.resolve_completely(impl_substs))) - }) - }) + let obligation = Obligation::new(infcx.interner, ObligationCause::dummy(), env.env, trait_ref); + + let selection = infcx.select(&obligation).ok()??; + + // Currently, we use a fulfillment context to completely resolve + // all nested obligations. This is because they can inform the + // inference of the impl's type parameters. + let mut ocx = ObligationCtxt::new(infcx); + let impl_source = selection.map(|obligation| ocx.register_obligation(obligation)); + + let errors = ocx.select_all_or_error(); + if !errors.is_empty() { + return None; + } + + let impl_source = infcx.resolve_vars_if_possible(impl_source); + if impl_source.has_non_region_infer() { + return None; + } + + match impl_source { + ImplSource::UserDefined(impl_source) => Some((impl_source.impl_def_id, impl_source.args)), + ImplSource::Param(_) | ImplSource::Builtin(..) => None, + } } fn is_inherent_impl_coherent<'db>( diff --git a/crates/hir-ty/src/mir.rs b/crates/hir-ty/src/mir.rs index a05cc2a02b..936895fb7f 100644 --- a/crates/hir-ty/src/mir.rs +++ b/crates/hir-ty/src/mir.rs @@ -2,18 +2,7 @@ use std::{collections::hash_map::Entry, fmt::Display, iter}; -use crate::{ - CallableDefId, ClosureId, Const, ConstScalar, InferenceResult, Interner, MemoryMap, - Substitution, TraitEnvironment, Ty, TyExt, TyKind, - consteval::usize_const, - db::HirDatabase, - display::{DisplayTarget, HirDisplay}, - infer::{PointerCast, normalize}, - lang_items::is_box, - mapping::ToChalk, -}; use base_db::Crate; -use chalk_ir::Mutability; use either::Either; use hir_def::{ DefWithBodyId, FieldId, StaticId, TupleFieldId, UnionId, VariantId, @@ -21,6 +10,25 @@ use hir_def::{ hir::{BindingAnnotation, BindingId, Expr, ExprId, Ordering, PatId}, }; use la_arena::{Arena, ArenaMap, Idx, RawIdx}; +use rustc_ast_ir::Mutability; +use rustc_hash::FxHashMap; +use rustc_type_ir::inherent::{AdtDef, GenericArgs as _, IntoKind, SliceLike, Ty as _}; +use smallvec::{SmallVec, smallvec}; +use stdx::{impl_from, never}; + +use crate::{ + CallableDefId, InferenceResult, MemoryMap, + consteval::usize_const, + db::{HirDatabase, InternedClosureId}, + display::{DisplayTarget, HirDisplay}, + infer::PointerCast, + lang_items::is_box, + next_solver::{ + Const, DbInterner, ErrorGuaranteed, GenericArgs, ParamEnv, Ty, TyKind, + infer::{InferCtxt, traits::ObligationCause}, + obligation_ctxt::ObligationCtxt, + }, +}; mod borrowck; mod eval; @@ -36,25 +44,22 @@ pub use lower::{MirLowerError, lower_to_mir, mir_body_for_closure_query, mir_bod pub use monomorphization::{ monomorphized_mir_body_for_closure_query, monomorphized_mir_body_query, }; -use rustc_hash::FxHashMap; -use smallvec::{SmallVec, smallvec}; -use stdx::{impl_from, never}; pub(crate) use lower::mir_body_cycle_result; pub(crate) use monomorphization::monomorphized_mir_body_cycle_result; -use super::consteval::{intern_const_scalar, try_const_usize}; +use super::consteval::try_const_usize; -pub type BasicBlockId = Idx<BasicBlock>; -pub type LocalId = Idx<Local>; +pub type BasicBlockId<'db> = Idx<BasicBlock<'db>>; +pub type LocalId<'db> = Idx<Local<'db>>; -fn return_slot() -> LocalId { +fn return_slot<'db>() -> LocalId<'db> { LocalId::from_raw(RawIdx::from(0)) } #[derive(Debug, Clone, PartialEq, Eq)] -pub struct Local { - pub ty: Ty, +pub struct Local<'db> { + pub ty: Ty<'db>, } /// An operand in MIR represents a "value" in Rust, the definition of which is undecided and part of @@ -76,19 +81,19 @@ pub struct Local { /// currently implements it, but it seems like this may be something to check against in the /// validator. #[derive(Debug, PartialEq, Eq, Clone)] -pub struct Operand { - kind: OperandKind, +pub struct Operand<'db> { + kind: OperandKind<'db>, // FIXME : This should actually just be of type `MirSpan`. span: Option<MirSpan>, } #[derive(Debug, PartialEq, Eq, Clone)] -pub enum OperandKind { +pub enum OperandKind<'db> { /// Creates a value by loading the given place. /// /// Before drop elaboration, the type of the place must be `Copy`. After drop elaboration there /// is no such requirement. - Copy(Place), + Copy(Place<'db>), /// Creates a value by performing loading the place, just like the `Copy` operand. /// @@ -97,41 +102,41 @@ pub enum OperandKind { /// place without first re-initializing it. /// /// [UCG#188]: https://github.com/rust-lang/unsafe-code-guidelines/issues/188 - Move(Place), + Move(Place<'db>), /// Constants are already semantically values, and remain unchanged. - Constant(Const), + Constant { konst: Const<'db>, ty: Ty<'db> }, /// NON STANDARD: This kind of operand returns an immutable reference to that static memory. Rustc /// handles it with the `Constant` variant somehow. Static(StaticId), } -impl Operand { - fn from_concrete_const(data: Box<[u8]>, memory_map: MemoryMap<'static>, ty: Ty) -> Self { +impl<'db> Operand<'db> { + fn from_concrete_const(data: Box<[u8]>, memory_map: MemoryMap<'db>, ty: Ty<'db>) -> Self { + let interner = DbInterner::conjure(); Operand { - kind: OperandKind::Constant(intern_const_scalar( - ConstScalar::Bytes(data, memory_map), + kind: OperandKind::Constant { + konst: Const::new_valtree(interner, ty, data, memory_map), ty, - )), + }, span: None, } } - fn from_bytes(data: Box<[u8]>, ty: Ty) -> Self { + fn from_bytes(data: Box<[u8]>, ty: Ty<'db>) -> Self { Operand::from_concrete_const(data, MemoryMap::default(), ty) } - fn const_zst(ty: Ty) -> Operand { + fn const_zst(ty: Ty<'db>) -> Operand<'db> { Self::from_bytes(Box::default(), ty) } fn from_fn( - db: &dyn HirDatabase, + db: &'db dyn HirDatabase, func_id: hir_def::FunctionId, - generic_args: Substitution, - ) -> Operand { - let ty = - chalk_ir::TyKind::FnDef(CallableDefId::FunctionId(func_id).to_chalk(db), generic_args) - .intern(Interner); + generic_args: GenericArgs<'db>, + ) -> Operand<'db> { + let interner = DbInterner::new_with(db, None, None); + let ty = Ty::new_fn_def(interner, CallableDefId::FunctionId(func_id).into(), generic_args); Operand::from_bytes(Box::default(), ty) } } @@ -150,83 +155,81 @@ pub enum ProjectionElem<V, T> { } impl<V, T> ProjectionElem<V, T> { - pub fn projected_ty( + pub fn projected_ty<'db>( &self, - mut base: Ty, - db: &dyn HirDatabase, - closure_field: impl FnOnce(ClosureId, &Substitution, usize) -> Ty, + infcx: &InferCtxt<'db>, + mut base: Ty<'db>, + closure_field: impl FnOnce(InternedClosureId, GenericArgs<'db>, usize) -> Ty<'db>, krate: Crate, - ) -> Ty { + ) -> Ty<'db> { + let interner = infcx.interner; + let db = interner.db; + // we only bail on mir building when there are type mismatches // but error types may pop up resulting in us still attempting to build the mir // so just propagate the error type - if base.is_unknown() { - return TyKind::Error.intern(Interner); + if base.is_ty_error() { + return Ty::new_error(interner, ErrorGuaranteed); } - if matches!(base.kind(Interner), TyKind::Alias(_) | TyKind::AssociatedType(..)) { - base = normalize( - db, - // FIXME: we should get this from caller - TraitEnvironment::empty(krate), - base, - ); + if matches!(base.kind(), TyKind::Alias(..)) { + let mut ocx = ObligationCtxt::new(infcx); + // FIXME: we should get this from caller + let env = ParamEnv::empty(); + match ocx.structurally_normalize_ty(&ObligationCause::dummy(), env, base) { + Ok(it) => base = it, + Err(_) => return Ty::new_error(interner, ErrorGuaranteed), + } } + match self { - ProjectionElem::Deref => match &base.kind(Interner) { - TyKind::Raw(_, inner) | TyKind::Ref(_, _, inner) => inner.clone(), - TyKind::Adt(adt, subst) if is_box(db, adt.0) => { - subst.at(Interner, 0).assert_ty_ref(Interner).clone() - } + ProjectionElem::Deref => match base.kind() { + TyKind::RawPtr(inner, _) | TyKind::Ref(_, inner, _) => inner, + TyKind::Adt(adt_def, subst) if is_box(db, adt_def.def_id().0) => subst.type_at(0), _ => { never!( "Overloaded deref on type {} is not a projection", base.display(db, DisplayTarget::from_crate(db, krate)) ); - TyKind::Error.intern(Interner) + Ty::new_error(interner, ErrorGuaranteed) } }, - ProjectionElem::Field(Either::Left(f)) => match base.kind(Interner) { + ProjectionElem::Field(Either::Left(f)) => match base.kind() { TyKind::Adt(_, subst) => { - db.field_types(f.parent)[f.local_id].clone().substitute(Interner, subst) + db.field_types_ns(f.parent)[f.local_id].instantiate(interner, subst) } ty => { never!("Only adt has field, found {:?}", ty); - TyKind::Error.intern(Interner) + Ty::new_error(interner, ErrorGuaranteed) } }, - ProjectionElem::Field(Either::Right(f)) => match &base.kind(Interner) { - TyKind::Tuple(_, subst) => subst - .as_slice(Interner) - .get(f.index as usize) - .map(|x| x.assert_ty_ref(Interner)) - .cloned() - .unwrap_or_else(|| { + ProjectionElem::Field(Either::Right(f)) => match base.kind() { + TyKind::Tuple(subst) => { + subst.as_slice().get(f.index as usize).copied().unwrap_or_else(|| { never!("Out of bound tuple field"); - TyKind::Error.intern(Interner) - }), + Ty::new_error(interner, ErrorGuaranteed) + }) + } ty => { never!("Only tuple has tuple field: {:?}", ty); - TyKind::Error.intern(Interner) + Ty::new_error(interner, ErrorGuaranteed) } }, - ProjectionElem::ClosureField(f) => match &base.kind(Interner) { - TyKind::Closure(id, subst) => closure_field(*id, subst, *f), + ProjectionElem::ClosureField(f) => match base.kind() { + TyKind::Closure(id, subst) => closure_field(id.0, subst, *f), _ => { never!("Only closure has closure field"); - TyKind::Error.intern(Interner) + Ty::new_error(interner, ErrorGuaranteed) } }, - ProjectionElem::ConstantIndex { .. } | ProjectionElem::Index(_) => { - match &base.kind(Interner) { - TyKind::Array(inner, _) | TyKind::Slice(inner) => inner.clone(), - _ => { - never!("Overloaded index is not a projection"); - TyKind::Error.intern(Interner) - } + ProjectionElem::ConstantIndex { .. } | ProjectionElem::Index(_) => match base.kind() { + TyKind::Array(inner, _) | TyKind::Slice(inner) => inner, + _ => { + never!("Overloaded index is not a projection"); + Ty::new_error(interner, ErrorGuaranteed) } - } - &ProjectionElem::Subslice { from, to } => match &base.kind(Interner) { + }, + &ProjectionElem::Subslice { from, to } => match base.kind() { TyKind::Array(inner, c) => { let next_c = usize_const( db, @@ -236,34 +239,34 @@ impl<V, T> ProjectionElem<V, T> { }, krate, ); - TyKind::Array(inner.clone(), next_c).intern(Interner) + Ty::new_array_with_const_len(interner, inner, next_c) } - TyKind::Slice(_) => base.clone(), + TyKind::Slice(_) => base, _ => { never!("Subslice projection should only happen on slice and array"); - TyKind::Error.intern(Interner) + Ty::new_error(interner, ErrorGuaranteed) } }, ProjectionElem::OpaqueCast(_) => { never!("We don't emit these yet"); - TyKind::Error.intern(Interner) + Ty::new_error(interner, ErrorGuaranteed) } } } } -type PlaceElem = ProjectionElem<LocalId, Ty>; +type PlaceElem<'db> = ProjectionElem<LocalId<'db>, Ty<'db>>; #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] pub struct ProjectionId(u32); #[derive(Debug, Clone, PartialEq, Eq)] -pub struct ProjectionStore { - id_to_proj: FxHashMap<ProjectionId, Box<[PlaceElem]>>, - proj_to_id: FxHashMap<Box<[PlaceElem]>, ProjectionId>, +pub struct ProjectionStore<'db> { + id_to_proj: FxHashMap<ProjectionId, Box<[PlaceElem<'db>]>>, + proj_to_id: FxHashMap<Box<[PlaceElem<'db>]>, ProjectionId>, } -impl Default for ProjectionStore { +impl Default for ProjectionStore<'_> { fn default() -> Self { let mut this = Self { id_to_proj: Default::default(), proj_to_id: Default::default() }; // Ensure that [] will get the id 0 which is used in `ProjectionId::Empty` @@ -272,17 +275,17 @@ impl Default for ProjectionStore { } } -impl ProjectionStore { +impl<'db> ProjectionStore<'db> { pub fn shrink_to_fit(&mut self) { self.id_to_proj.shrink_to_fit(); self.proj_to_id.shrink_to_fit(); } - pub fn intern_if_exist(&self, projection: &[PlaceElem]) -> Option<ProjectionId> { + pub fn intern_if_exist(&self, projection: &[PlaceElem<'db>]) -> Option<ProjectionId> { self.proj_to_id.get(projection).copied() } - pub fn intern(&mut self, projection: Box<[PlaceElem]>) -> ProjectionId { + pub fn intern(&mut self, projection: Box<[PlaceElem<'db>]>) -> ProjectionId { let new_id = ProjectionId(self.proj_to_id.len() as u32); match self.proj_to_id.entry(projection) { Entry::Occupied(id) => *id.get(), @@ -303,11 +306,15 @@ impl ProjectionId { self == ProjectionId::EMPTY } - pub fn lookup(self, store: &ProjectionStore) -> &[PlaceElem] { + pub fn lookup<'a, 'db>(self, store: &'a ProjectionStore<'db>) -> &'a [PlaceElem<'db>] { store.id_to_proj.get(&self).unwrap() } - pub fn project(self, projection: PlaceElem, store: &mut ProjectionStore) -> ProjectionId { + pub fn project<'db>( + self, + projection: PlaceElem<'db>, + store: &mut ProjectionStore<'db>, + ) -> ProjectionId { let mut current = self.lookup(store).to_vec(); current.push(projection); store.intern(current.into()) @@ -315,13 +322,13 @@ impl ProjectionId { } #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] -pub struct Place { - pub local: LocalId, +pub struct Place<'db> { + pub local: LocalId<'db>, pub projection: ProjectionId, } -impl Place { - fn is_parent(&self, child: &Place, store: &ProjectionStore) -> bool { +impl<'db> Place<'db> { + fn is_parent(&self, child: &Place<'db>, store: &ProjectionStore<'db>) -> bool { self.local == child.local && child.projection.lookup(store).starts_with(self.projection.lookup(store)) } @@ -329,39 +336,39 @@ impl Place { /// The place itself is not included fn iterate_over_parents<'a>( &'a self, - store: &'a ProjectionStore, - ) -> impl Iterator<Item = Place> + 'a { + store: &'a ProjectionStore<'db>, + ) -> impl Iterator<Item = Place<'db>> + 'a { let projection = self.projection.lookup(store); (0..projection.len()).map(|x| &projection[0..x]).filter_map(move |x| { Some(Place { local: self.local, projection: store.intern_if_exist(x)? }) }) } - fn project(&self, projection: PlaceElem, store: &mut ProjectionStore) -> Place { + fn project(&self, projection: PlaceElem<'db>, store: &mut ProjectionStore<'db>) -> Place<'db> { Place { local: self.local, projection: self.projection.project(projection, store) } } } -impl From<LocalId> for Place { - fn from(local: LocalId) -> Self { +impl<'db> From<LocalId<'db>> for Place<'db> { + fn from(local: LocalId<'db>) -> Self { Self { local, projection: ProjectionId::EMPTY } } } #[derive(Debug, PartialEq, Eq, Clone)] -pub enum AggregateKind { +pub enum AggregateKind<'db> { /// The type is of the element - Array(Ty), + Array(Ty<'db>), /// The type is of the tuple - Tuple(Ty), - Adt(VariantId, Substitution), + Tuple(Ty<'db>), + Adt(VariantId, GenericArgs<'db>), Union(UnionId, FieldId), - Closure(Ty), + Closure(Ty<'db>), //Coroutine(LocalDefId, SubstsRef, Movability), } #[derive(Debug, Clone, Hash, PartialEq, Eq)] -pub struct SwitchTargets { +pub struct SwitchTargets<'db> { /// Possible values. The locations to branch to in each case /// are found in the corresponding indices from the `targets` vector. values: SmallVec<[u128; 1]>, @@ -378,17 +385,17 @@ pub struct SwitchTargets { // // However we’ve decided to keep this as-is until we figure a case // where some other approach seems to be strictly better than other. - targets: SmallVec<[BasicBlockId; 2]>, + targets: SmallVec<[BasicBlockId<'db>; 2]>, } -impl SwitchTargets { +impl<'db> SwitchTargets<'db> { /// Creates switch targets from an iterator of values and target blocks. /// /// The iterator may be empty, in which case the `SwitchInt` instruction is equivalent to /// `goto otherwise;`. pub fn new( - targets: impl Iterator<Item = (u128, BasicBlockId)>, - otherwise: BasicBlockId, + targets: impl Iterator<Item = (u128, BasicBlockId<'db>)>, + otherwise: BasicBlockId<'db>, ) -> Self { let (values, mut targets): (SmallVec<_>, SmallVec<_>) = targets.unzip(); targets.push(otherwise); @@ -397,12 +404,12 @@ impl SwitchTargets { /// Builds a switch targets definition that jumps to `then` if the tested value equals `value`, /// and to `else_` if not. - pub fn static_if(value: u128, then: BasicBlockId, else_: BasicBlockId) -> Self { + pub fn static_if(value: u128, then: BasicBlockId<'db>, else_: BasicBlockId<'db>) -> Self { Self { values: smallvec![value], targets: smallvec![then, else_] } } /// Returns the fallback target that is jumped to when none of the values match the operand. - pub fn otherwise(&self) -> BasicBlockId { + pub fn otherwise(&self) -> BasicBlockId<'db> { *self.targets.last().unwrap() } @@ -412,33 +419,33 @@ impl SwitchTargets { /// including the `otherwise` fallback target. /// /// Note that this may yield 0 elements. Only the `otherwise` branch is mandatory. - pub fn iter(&self) -> impl Iterator<Item = (u128, BasicBlockId)> + '_ { + pub fn iter(&self) -> impl Iterator<Item = (u128, BasicBlockId<'db>)> + '_ { iter::zip(&self.values, &self.targets).map(|(x, y)| (*x, *y)) } /// Returns a slice with all possible jump targets (including the fallback target). - pub fn all_targets(&self) -> &[BasicBlockId] { + pub fn all_targets(&self) -> &[BasicBlockId<'db>] { &self.targets } /// Finds the `BasicBlock` to which this `SwitchInt` will branch given the /// specific value. This cannot fail, as it'll return the `otherwise` /// branch if there's not a specific match for the value. - pub fn target_for_value(&self, value: u128) -> BasicBlockId { + pub fn target_for_value(&self, value: u128) -> BasicBlockId<'db> { self.iter().find_map(|(v, t)| (v == value).then_some(t)).unwrap_or_else(|| self.otherwise()) } } #[derive(Debug, PartialEq, Eq, Clone)] -pub struct Terminator { +pub struct Terminator<'db> { pub span: MirSpan, - pub kind: TerminatorKind, + pub kind: TerminatorKind<'db>, } #[derive(Debug, PartialEq, Eq, Clone)] -pub enum TerminatorKind { +pub enum TerminatorKind<'db> { /// Block has one successor; we continue execution there. - Goto { target: BasicBlockId }, + Goto { target: BasicBlockId<'db> }, /// Switches based on the computed value. /// @@ -450,9 +457,9 @@ pub enum TerminatorKind { /// Target values may not appear more than once. SwitchInt { /// The discriminant value being tested. - discr: Operand, + discr: Operand<'db>, - targets: SwitchTargets, + targets: SwitchTargets<'db>, }, /// Indicates that the landing pad is finished and that the process should continue unwinding. @@ -503,7 +510,7 @@ pub enum TerminatorKind { /// > The drop glue is executed if, among all statements executed within this `Body`, an assignment to /// > the place or one of its "parents" occurred more recently than a move out of it. This does not /// > consider indirect assignments. - Drop { place: Place, target: BasicBlockId, unwind: Option<BasicBlockId> }, + Drop { place: Place<'db>, target: BasicBlockId<'db>, unwind: Option<BasicBlockId<'db>> }, /// Drops the place and assigns a new value to it. /// @@ -536,10 +543,10 @@ pub enum TerminatorKind { /// /// Disallowed after drop elaboration. DropAndReplace { - place: Place, - value: Operand, - target: BasicBlockId, - unwind: Option<BasicBlockId>, + place: Place<'db>, + value: Operand<'db>, + target: BasicBlockId<'db>, + unwind: Option<BasicBlockId<'db>>, }, /// Roughly speaking, evaluates the `func` operand and the arguments, and starts execution of @@ -554,18 +561,18 @@ pub enum TerminatorKind { /// [#71117]: https://github.com/rust-lang/rust/issues/71117 Call { /// The function that’s being called. - func: Operand, + func: Operand<'db>, /// Arguments the function is called with. /// These are owned by the callee, which is free to modify them. /// This allows the memory occupied by "by-value" arguments to be /// reused across function calls without duplicating the contents. - args: Box<[Operand]>, + args: Box<[Operand<'db>]>, /// Where the returned value will be written - destination: Place, + destination: Place<'db>, /// Where to go after this call returns. If none, the call necessarily diverges. - target: Option<BasicBlockId>, + target: Option<BasicBlockId<'db>>, /// Cleanups to be done if the call unwinds. - cleanup: Option<BasicBlockId>, + cleanup: Option<BasicBlockId<'db>>, /// `true` if this is from a call in HIR rather than from an overloaded /// operator. True for overloaded function call. from_hir_call: bool, @@ -581,11 +588,11 @@ pub enum TerminatorKind { /// necessarily executed even in the case of a panic, for example in `-C panic=abort`. If the /// assertion does not fail, execution continues at the specified basic block. Assert { - cond: Operand, + cond: Operand<'db>, expected: bool, //msg: AssertMessage, - target: BasicBlockId, - cleanup: Option<BasicBlockId>, + target: BasicBlockId<'db>, + cleanup: Option<BasicBlockId<'db>>, }, /// Marks a suspend point. @@ -602,13 +609,13 @@ pub enum TerminatorKind { /// **Needs clarification**: What about the evaluation order of the `resume_arg` and `value`? Yield { /// The value to return. - value: Operand, + value: Operand<'db>, /// Where to resume to. - resume: BasicBlockId, + resume: BasicBlockId<'db>, /// The place to store the resume argument in. - resume_arg: Place, + resume_arg: Place<'db>, /// Cleanup to be done if the coroutine is dropped at this suspend point. - drop: Option<BasicBlockId>, + drop: Option<BasicBlockId<'db>>, }, /// Indicates the end of dropping a coroutine. @@ -631,10 +638,10 @@ pub enum TerminatorKind { /// Disallowed after drop elaboration. FalseEdge { /// The target normal control flow will take. - real_target: BasicBlockId, + real_target: BasicBlockId<'db>, /// A block control flow could conceptually jump to, but won't in /// practice. - imaginary_target: BasicBlockId, + imaginary_target: BasicBlockId<'db>, }, /// A terminator for blocks that only take one path in reality, but where we reserve the right @@ -646,14 +653,14 @@ pub enum TerminatorKind { /// Disallowed after drop elaboration. FalseUnwind { /// The target normal control flow will take. - real_target: BasicBlockId, + real_target: BasicBlockId<'db>, /// The imaginary cleanup block link. This particular path will never be taken /// in practice, but in order to avoid fragility we want to always /// consider it in borrowck. We don't want to accept programs which /// pass borrowck only when `panic=abort` or some assertions are disabled /// due to release vs. debug mode builds. This needs to be an `Option` because /// of the `remove_noop_landing_pads` and `abort_unwinding_calls` passes. - unwind: Option<BasicBlockId>, + unwind: Option<BasicBlockId<'db>>, }, } @@ -840,8 +847,8 @@ impl From<hir_def::hir::CmpOp> for BinOp { } } -impl From<Operand> for Rvalue { - fn from(x: Operand) -> Self { +impl<'db> From<Operand<'db>> for Rvalue<'db> { + fn from(x: Operand<'db>) -> Self { Self::Use(x) } } @@ -870,14 +877,14 @@ pub enum CastKind { } #[derive(Debug, PartialEq, Eq, Clone)] -pub enum Rvalue { +pub enum Rvalue<'db> { /// Yields the operand unchanged - Use(Operand), + Use(Operand<'db>), /// Creates an array where each element is the value of the operand. /// /// Corresponds to source code like `[x; 32]`. - Repeat(Operand, Const), + Repeat(Operand<'db>, Const<'db>), /// Creates a reference of the indicated kind to the place. /// @@ -886,7 +893,7 @@ pub enum Rvalue { /// exactly what the behavior of this operation should be. /// /// `Shallow` borrows are disallowed after drop lowering. - Ref(BorrowKind, Place), + Ref(BorrowKind, Place<'db>), /// Creates a pointer/reference to the given thread local. /// @@ -917,7 +924,7 @@ pub enum Rvalue { /// If the type of the place is an array, this is the array length. For slices (`[T]`, not /// `&[T]`) this accesses the place's metadata to determine the length. This rvalue is /// ill-formed for places of other types. - Len(Place), + Len(Place<'db>), /// Performs essentially all of the casts that can be performed via `as`. /// @@ -925,7 +932,7 @@ pub enum Rvalue { /// /// **FIXME**: Document exactly which `CastKind`s allow which types of casts. Figure out why /// `ArrayToPointer` and `MutToConstPointer` are special. - Cast(CastKind, Operand, Ty), + Cast(CastKind, Operand<'db>, Ty<'db>), // FIXME link to `pointer::offset` when it hits stable. /// * `Offset` has the same semantics as `pointer::offset`, except that the second @@ -957,7 +964,7 @@ pub enum Rvalue { /// when the value of right-hand side is negative. /// /// Other combinations of types and operators are unsupported. - CheckedBinaryOp(BinOp, Operand, Operand), + CheckedBinaryOp(BinOp, Operand<'db>, Operand<'db>), /// Computes a value as described by the operation. //NullaryOp(NullOp, Ty), @@ -968,7 +975,7 @@ pub enum Rvalue { /// Also does two's-complement arithmetic. Negation requires a signed integer or a float; /// bitwise not requires a signed integer, unsigned integer, or bool. Both operation kinds /// return a value with the same type as their operand. - UnaryOp(UnOp, Operand), + UnaryOp(UnOp, Operand<'db>), /// Computes the discriminant of the place, returning it as an integer of type /// [`discriminant_ty`]. Returns zero for types without discriminant. @@ -980,7 +987,7 @@ pub enum Rvalue { /// [`discriminant_ty`]: crate::ty::Ty::discriminant_ty /// [#91095]: https://github.com/rust-lang/rust/issues/91095 /// [`discriminant_for_variant`]: crate::ty::Ty::discriminant_for_variant - Discriminant(Place), + Discriminant(Place<'db>), /// Creates an aggregate value, like a tuple or struct. /// @@ -990,17 +997,17 @@ pub enum Rvalue { /// /// Disallowed after deaggregation for all aggregate kinds except `Array` and `Coroutine`. After /// coroutine lowering, `Coroutine` aggregate kinds are disallowed too. - Aggregate(AggregateKind, Box<[Operand]>), + Aggregate(AggregateKind<'db>, Box<[Operand<'db>]>), /// Transmutes a `*mut u8` into shallow-initialized `Box<T>`. /// /// This is different from a normal transmute because dataflow analysis will treat the box as /// initialized but its content as uninitialized. Like other pointer casts, this in general /// affects alias analysis. - ShallowInitBox(Operand, Ty), + ShallowInitBox(Operand<'db>, Ty<'db>), /// NON STANDARD: allocates memory with the type's layout, and shallow init the box with the resulting pointer. - ShallowInitBoxWithAlloc(Ty), + ShallowInitBoxWithAlloc(Ty<'db>), /// A CopyForDeref is equivalent to a read from a place at the /// codegen level, but is treated specially by drop elaboration. When such a read happens, it @@ -1010,41 +1017,41 @@ pub enum Rvalue { /// read never happened and just projects further. This allows simplifying various MIR /// optimizations and codegen backends that previously had to handle deref operations anywhere /// in a place. - CopyForDeref(Place), + CopyForDeref(Place<'db>), } #[derive(Debug, PartialEq, Eq, Clone)] -pub enum StatementKind { - Assign(Place, Rvalue), - FakeRead(Place), +pub enum StatementKind<'db> { + Assign(Place<'db>, Rvalue<'db>), + FakeRead(Place<'db>), //SetDiscriminant { // place: Box<Place>, // variant_index: VariantIdx, //}, - Deinit(Place), - StorageLive(LocalId), - StorageDead(LocalId), + Deinit(Place<'db>), + StorageLive(LocalId<'db>), + StorageDead(LocalId<'db>), //Retag(RetagKind, Box<Place>), //AscribeUserType(Place, UserTypeProjection, Variance), //Intrinsic(Box<NonDivergingIntrinsic>), Nop, } -impl StatementKind { - fn with_span(self, span: MirSpan) -> Statement { +impl<'db> StatementKind<'db> { + fn with_span(self, span: MirSpan) -> Statement<'db> { Statement { kind: self, span } } } #[derive(Debug, PartialEq, Eq, Clone)] -pub struct Statement { - pub kind: StatementKind, +pub struct Statement<'db> { + pub kind: StatementKind<'db>, pub span: MirSpan, } #[derive(Debug, Default, Clone, PartialEq, Eq)] -pub struct BasicBlock { +pub struct BasicBlock<'db> { /// List of statements in this block. - pub statements: Vec<Statement>, + pub statements: Vec<Statement<'db>>, /// Terminator for this block. /// @@ -1054,7 +1061,7 @@ pub struct BasicBlock { /// exception is that certain passes, such as `simplify_cfg`, swap /// out the terminator temporarily with `None` while they continue /// to recurse over the set of basic blocks. - pub terminator: Option<Terminator>, + pub terminator: Option<Terminator<'db>>, /// If true, this block lies on an unwind path. This is used /// during codegen where distinct kinds of basic blocks may be @@ -1064,35 +1071,35 @@ pub struct BasicBlock { } #[derive(Debug, Clone, PartialEq, Eq)] -pub struct MirBody { - pub projection_store: ProjectionStore, - pub basic_blocks: Arena<BasicBlock>, - pub locals: Arena<Local>, - pub start_block: BasicBlockId, +pub struct MirBody<'db> { + pub projection_store: ProjectionStore<'db>, + pub basic_blocks: Arena<BasicBlock<'db>>, + pub locals: Arena<Local<'db>>, + pub start_block: BasicBlockId<'db>, pub owner: DefWithBodyId, - pub binding_locals: ArenaMap<BindingId, LocalId>, - pub param_locals: Vec<LocalId>, + pub binding_locals: ArenaMap<BindingId, LocalId<'db>>, + pub param_locals: Vec<LocalId<'db>>, /// This field stores the closures directly owned by this body. It is used /// in traversing every mir body. - pub closures: Vec<ClosureId>, + pub closures: Vec<InternedClosureId>, } -impl MirBody { - pub fn local_to_binding_map(&self) -> ArenaMap<LocalId, BindingId> { +impl<'db> MirBody<'db> { + pub fn local_to_binding_map(&self) -> ArenaMap<LocalId<'db>, BindingId> { self.binding_locals.iter().map(|(it, y)| (*y, it)).collect() } - fn walk_places(&mut self, mut f: impl FnMut(&mut Place, &mut ProjectionStore)) { - fn for_operand( - op: &mut Operand, - f: &mut impl FnMut(&mut Place, &mut ProjectionStore), - store: &mut ProjectionStore, + fn walk_places(&mut self, mut f: impl FnMut(&mut Place<'db>, &mut ProjectionStore<'db>)) { + fn for_operand<'db>( + op: &mut Operand<'db>, + f: &mut impl FnMut(&mut Place<'db>, &mut ProjectionStore<'db>), + store: &mut ProjectionStore<'db>, ) { match &mut op.kind { OperandKind::Copy(p) | OperandKind::Move(p) => { f(p, store); } - OperandKind::Constant(_) | OperandKind::Static(_) => (), + OperandKind::Constant { .. } | OperandKind::Static(_) => (), } } for (_, block) in self.basic_blocks.iter_mut() { diff --git a/crates/hir-ty/src/mir/borrowck.rs b/crates/hir-ty/src/mir/borrowck.rs index 08b1e03726..db16c94396 100644 --- a/crates/hir-ty/src/mir/borrowck.rs +++ b/crates/hir-ty/src/mir/borrowck.rs @@ -11,14 +11,15 @@ use rustc_hash::FxHashMap; use stdx::never; use triomphe::Arc; -use crate::next_solver::DbInterner; -use crate::next_solver::mapping::{ChalkToNextSolver, NextSolverToChalk}; use crate::{ - ClosureId, Interner, Substitution, Ty, TyExt, TypeFlags, - db::{HirDatabase, InternedClosure}, + TraitEnvironment, + db::{HirDatabase, InternedClosure, InternedClosureId}, display::DisplayTarget, mir::OperandKind, - utils::ClosureSubst, + next_solver::{ + DbInterner, GenericArgs, SolverDefIds, Ty, TypingMode, + infer::{DbInternerInferExt, InferCtxt}, + }, }; use super::{ @@ -35,45 +36,45 @@ pub enum MutabilityReason { } #[derive(Debug, Clone, PartialEq, Eq)] -pub struct MovedOutOfRef { - pub ty: Ty, +pub struct MovedOutOfRef<'db> { + pub ty: Ty<'db>, pub span: MirSpan, } #[derive(Debug, Clone, PartialEq, Eq)] -pub struct PartiallyMoved { - pub ty: Ty, +pub struct PartiallyMoved<'db> { + pub ty: Ty<'db>, pub span: MirSpan, - pub local: LocalId, + pub local: LocalId<'db>, } #[derive(Debug, Clone, PartialEq, Eq)] -pub struct BorrowRegion { - pub local: LocalId, +pub struct BorrowRegion<'db> { + pub local: LocalId<'db>, pub kind: BorrowKind, pub places: Vec<MirSpan>, } #[derive(Debug, Clone, PartialEq, Eq)] -pub struct BorrowckResult { - pub mir_body: Arc<MirBody>, - pub mutability_of_locals: ArenaMap<LocalId, MutabilityReason>, - pub moved_out_of_ref: Vec<MovedOutOfRef>, - pub partially_moved: Vec<PartiallyMoved>, - pub borrow_regions: Vec<BorrowRegion>, +pub struct BorrowckResult<'db> { + pub mir_body: Arc<MirBody<'db>>, + pub mutability_of_locals: ArenaMap<LocalId<'db>, MutabilityReason>, + pub moved_out_of_ref: Vec<MovedOutOfRef<'db>>, + pub partially_moved: Vec<PartiallyMoved<'db>>, + pub borrow_regions: Vec<BorrowRegion<'db>>, } fn all_mir_bodies<'db>( db: &'db dyn HirDatabase, def: DefWithBodyId, - mut cb: impl FnMut(Arc<MirBody>), + mut cb: impl FnMut(Arc<MirBody<'db>>), ) -> Result<(), MirLowerError<'db>> { fn for_closure<'db>( db: &'db dyn HirDatabase, - c: ClosureId, - cb: &mut impl FnMut(Arc<MirBody>), + c: InternedClosureId, + cb: &mut impl FnMut(Arc<MirBody<'db>>), ) -> Result<(), MirLowerError<'db>> { - match db.mir_body_for_closure(c.into()) { + match db.mir_body_for_closure(c) { Ok(body) => { cb(body.clone()); body.closures.iter().try_for_each(|&it| for_closure(db, it, cb)) @@ -93,14 +94,21 @@ fn all_mir_bodies<'db>( pub fn borrowck_query<'db>( db: &'db dyn HirDatabase, def: DefWithBodyId, -) -> Result<Arc<[BorrowckResult]>, MirLowerError<'db>> { +) -> Result<Arc<[BorrowckResult<'db>]>, MirLowerError<'db>> { let _p = tracing::info_span!("borrowck_query").entered(); + let module = def.module(db); + let interner = DbInterner::new_with(db, Some(module.krate()), module.containing_block()); + let env = db.trait_environment_for_body(def); let mut res = vec![]; all_mir_bodies(db, def, |body| { + // FIXME(next-solver): Opaques. + let infcx = interner.infer_ctxt().build(TypingMode::Borrowck { + defining_opaque_types: SolverDefIds::new_from_iter(interner, []), + }); res.push(BorrowckResult { - mutability_of_locals: mutability_of_locals(db, &body), - moved_out_of_ref: moved_out_of_ref(db, &body), - partially_moved: partially_moved(db, &body), + mutability_of_locals: mutability_of_locals(&infcx, &body), + moved_out_of_ref: moved_out_of_ref(&infcx, &env, &body), + partially_moved: partially_moved(&infcx, &env, &body), borrow_regions: borrow_regions(db, &body), mir_body: body, }); @@ -108,51 +116,49 @@ pub fn borrowck_query<'db>( Ok(res.into()) } -fn make_fetch_closure_field( - db: &dyn HirDatabase, -) -> impl FnOnce(ClosureId, &Substitution, usize) -> Ty + '_ { - |c: ClosureId, subst: &Substitution, f: usize| { - let InternedClosure(def, _) = db.lookup_intern_closure(c.into()); +fn make_fetch_closure_field<'db>( + db: &'db dyn HirDatabase, +) -> impl FnOnce(InternedClosureId, GenericArgs<'db>, usize) -> Ty<'db> + use<'db> { + |c: InternedClosureId, subst: GenericArgs<'db>, f: usize| { + let InternedClosure(def, _) = db.lookup_intern_closure(c); let infer = db.infer(def); - let (captures, _) = infer.closure_info(c.into()); - let parent_subst = ClosureSubst(subst).parent_subst(db); + let (captures, _) = infer.closure_info(c); + let parent_subst = subst.split_closure_args_untupled().parent_args; let interner = DbInterner::new_with(db, None, None); - let parent_subst: crate::next_solver::GenericArgs<'_> = - parent_subst.to_nextsolver(interner); - captures - .get(f) - .expect("broken closure field") - .ty - .instantiate(interner, parent_subst) - .to_chalk(interner) + captures.get(f).expect("broken closure field").ty.instantiate(interner, parent_subst) } } -fn moved_out_of_ref(db: &dyn HirDatabase, body: &MirBody) -> Vec<MovedOutOfRef> { +fn moved_out_of_ref<'db>( + infcx: &InferCtxt<'db>, + env: &TraitEnvironment<'db>, + body: &MirBody<'db>, +) -> Vec<MovedOutOfRef<'db>> { + let db = infcx.interner.db; let mut result = vec![]; - let mut for_operand = |op: &Operand, span: MirSpan| match op.kind { + let mut for_operand = |op: &Operand<'db>, span: MirSpan| match op.kind { OperandKind::Copy(p) | OperandKind::Move(p) => { - let mut ty: Ty = body.locals[p.local].ty.clone(); + let mut ty: Ty<'db> = body.locals[p.local].ty; let mut is_dereference_of_ref = false; for proj in p.projection.lookup(&body.projection_store) { if *proj == ProjectionElem::Deref && ty.as_reference().is_some() { is_dereference_of_ref = true; } ty = proj.projected_ty( + infcx, ty, - db, make_fetch_closure_field(db), body.owner.module(db).krate(), ); } if is_dereference_of_ref - && !ty.clone().is_copy(db, body.owner) - && !ty.data(Interner).flags.intersects(TypeFlags::HAS_ERROR) + && !infcx.type_is_copy_modulo_regions(env.env, ty) + && !ty.references_non_lt_error() { result.push(MovedOutOfRef { span: op.span.unwrap_or(span), ty }); } } - OperandKind::Constant(_) | OperandKind::Static(_) => (), + OperandKind::Constant { .. } | OperandKind::Static(_) => (), }; for (_, block) in body.basic_blocks.iter() { db.unwind_if_revision_cancelled(); @@ -223,26 +229,29 @@ fn moved_out_of_ref(db: &dyn HirDatabase, body: &MirBody) -> Vec<MovedOutOfRef> result } -fn partially_moved(db: &dyn HirDatabase, body: &MirBody) -> Vec<PartiallyMoved> { +fn partially_moved<'db>( + infcx: &InferCtxt<'db>, + env: &TraitEnvironment<'db>, + body: &MirBody<'db>, +) -> Vec<PartiallyMoved<'db>> { + let db = infcx.interner.db; let mut result = vec![]; - let mut for_operand = |op: &Operand, span: MirSpan| match op.kind { + let mut for_operand = |op: &Operand<'db>, span: MirSpan| match op.kind { OperandKind::Copy(p) | OperandKind::Move(p) => { - let mut ty: Ty = body.locals[p.local].ty.clone(); + let mut ty: Ty<'db> = body.locals[p.local].ty; for proj in p.projection.lookup(&body.projection_store) { ty = proj.projected_ty( + infcx, ty, - db, make_fetch_closure_field(db), body.owner.module(db).krate(), ); } - if !ty.clone().is_copy(db, body.owner) - && !ty.data(Interner).flags.intersects(TypeFlags::HAS_ERROR) - { + if !infcx.type_is_copy_modulo_regions(env.env, ty) && !ty.references_non_lt_error() { result.push(PartiallyMoved { span, ty, local: p.local }); } } - OperandKind::Constant(_) | OperandKind::Static(_) => (), + OperandKind::Constant { .. } | OperandKind::Static(_) => (), }; for (_, block) in body.basic_blocks.iter() { db.unwind_if_revision_cancelled(); @@ -313,7 +322,7 @@ fn partially_moved(db: &dyn HirDatabase, body: &MirBody) -> Vec<PartiallyMoved> result } -fn borrow_regions(db: &dyn HirDatabase, body: &MirBody) -> Vec<BorrowRegion> { +fn borrow_regions<'db>(db: &'db dyn HirDatabase, body: &MirBody<'db>) -> Vec<BorrowRegion<'db>> { let mut borrows = FxHashMap::default(); for (_, block) in body.basic_blocks.iter() { db.unwind_if_revision_cancelled(); @@ -321,7 +330,7 @@ fn borrow_regions(db: &dyn HirDatabase, body: &MirBody) -> Vec<BorrowRegion> { if let StatementKind::Assign(_, Rvalue::Ref(kind, p)) = &statement.kind { borrows .entry(p.local) - .and_modify(|it: &mut BorrowRegion| { + .and_modify(|it: &mut BorrowRegion<'db>| { it.places.push(statement.span); }) .or_insert_with(|| BorrowRegion { @@ -363,9 +372,14 @@ enum ProjectionCase { Indirect, } -fn place_case(db: &dyn HirDatabase, body: &MirBody, lvalue: &Place) -> ProjectionCase { +fn place_case<'db>( + infcx: &InferCtxt<'db>, + body: &MirBody<'db>, + lvalue: &Place<'db>, +) -> ProjectionCase { + let db = infcx.interner.db; let mut is_part_of = false; - let mut ty = body.locals[lvalue.local].ty.clone(); + let mut ty = body.locals[lvalue.local].ty; for proj in lvalue.projection.lookup(&body.projection_store).iter() { match proj { ProjectionElem::Deref if ty.as_adt().is_none() => return ProjectionCase::Indirect, // It's indirect in case of reference and raw @@ -379,7 +393,12 @@ fn place_case(db: &dyn HirDatabase, body: &MirBody, lvalue: &Place) -> Projectio } ProjectionElem::OpaqueCast(_) => (), } - ty = proj.projected_ty(ty, db, make_fetch_closure_field(db), body.owner.module(db).krate()); + ty = proj.projected_ty( + infcx, + ty, + make_fetch_closure_field(db), + body.owner.module(db).krate(), + ); } if is_part_of { ProjectionCase::DirectPart } else { ProjectionCase::Direct } } @@ -387,18 +406,18 @@ fn place_case(db: &dyn HirDatabase, body: &MirBody, lvalue: &Place) -> Projectio /// Returns a map from basic blocks to the set of locals that might be ever initialized before /// the start of the block. Only `StorageDead` can remove something from this map, and we ignore /// `Uninit` and `drop` and similar after initialization. -fn ever_initialized_map( - db: &dyn HirDatabase, - body: &MirBody, -) -> ArenaMap<BasicBlockId, ArenaMap<LocalId, bool>> { - let mut result: ArenaMap<BasicBlockId, ArenaMap<LocalId, bool>> = +fn ever_initialized_map<'db>( + db: &'db dyn HirDatabase, + body: &MirBody<'db>, +) -> ArenaMap<BasicBlockId<'db>, ArenaMap<LocalId<'db>, bool>> { + let mut result: ArenaMap<BasicBlockId<'db>, ArenaMap<LocalId<'db>, bool>> = body.basic_blocks.iter().map(|it| (it.0, ArenaMap::default())).collect(); - fn dfs( - db: &dyn HirDatabase, - body: &MirBody, - l: LocalId, - stack: &mut Vec<BasicBlockId>, - result: &mut ArenaMap<BasicBlockId, ArenaMap<LocalId, bool>>, + fn dfs<'db>( + db: &'db dyn HirDatabase, + body: &MirBody<'db>, + l: LocalId<'db>, + stack: &mut Vec<BasicBlockId<'db>>, + result: &mut ArenaMap<BasicBlockId<'db>, ArenaMap<LocalId<'db>, bool>>, ) { while let Some(b) = stack.pop() { let mut is_ever_initialized = result[b][l]; // It must be filled, as we use it as mark for dfs @@ -486,7 +505,11 @@ fn ever_initialized_map( result } -fn push_mut_span(local: LocalId, span: MirSpan, result: &mut ArenaMap<LocalId, MutabilityReason>) { +fn push_mut_span<'db>( + local: LocalId<'db>, + span: MirSpan, + result: &mut ArenaMap<LocalId<'db>, MutabilityReason>, +) { match &mut result[local] { MutabilityReason::Mut { spans } => spans.push(span), it @ (MutabilityReason::Not | MutabilityReason::Unused) => { @@ -495,23 +518,27 @@ fn push_mut_span(local: LocalId, span: MirSpan, result: &mut ArenaMap<LocalId, M }; } -fn record_usage(local: LocalId, result: &mut ArenaMap<LocalId, MutabilityReason>) { +fn record_usage<'db>(local: LocalId<'db>, result: &mut ArenaMap<LocalId<'db>, MutabilityReason>) { if let it @ MutabilityReason::Unused = &mut result[local] { *it = MutabilityReason::Not; }; } -fn record_usage_for_operand(arg: &Operand, result: &mut ArenaMap<LocalId, MutabilityReason>) { +fn record_usage_for_operand<'db>( + arg: &Operand<'db>, + result: &mut ArenaMap<LocalId<'db>, MutabilityReason>, +) { if let OperandKind::Copy(p) | OperandKind::Move(p) = arg.kind { record_usage(p.local, result); } } -fn mutability_of_locals( - db: &dyn HirDatabase, - body: &MirBody, -) -> ArenaMap<LocalId, MutabilityReason> { - let mut result: ArenaMap<LocalId, MutabilityReason> = +fn mutability_of_locals<'db>( + infcx: &InferCtxt<'db>, + body: &MirBody<'db>, +) -> ArenaMap<LocalId<'db>, MutabilityReason> { + let db = infcx.interner.db; + let mut result: ArenaMap<LocalId<'db>, MutabilityReason> = body.locals.iter().map(|it| (it.0, MutabilityReason::Unused)).collect(); let ever_init_maps = ever_initialized_map(db, body); @@ -520,7 +547,7 @@ fn mutability_of_locals( for statement in &block.statements { match &statement.kind { StatementKind::Assign(place, value) => { - match place_case(db, body, place) { + match place_case(infcx, body, place) { ProjectionCase::Direct => { if ever_init_map.get(place.local).copied().unwrap_or_default() { push_mut_span(place.local, statement.span, &mut result); @@ -569,7 +596,7 @@ fn mutability_of_locals( }, p, ) = value - && place_case(db, body, p) != ProjectionCase::Indirect + && place_case(infcx, body, p) != ProjectionCase::Indirect { push_mut_span(p.local, statement.span, &mut result); } diff --git a/crates/hir-ty/src/mir/eval.rs b/crates/hir-ty/src/mir/eval.rs index 6e09cf9aeb..444336ca3f 100644 --- a/crates/hir-ty/src/mir/eval.rs +++ b/crates/hir-ty/src/mir/eval.rs @@ -2,14 +2,11 @@ use std::{borrow::Cow, cell::RefCell, fmt::Write, iter, mem, ops::Range}; -use base_db::Crate; -use base_db::target::TargetLoadError; -use chalk_ir::{Mutability, cast::Cast}; +use base_db::{Crate, target::TargetLoadError}; use either::Either; use hir_def::{ - AdtId, DefWithBodyId, EnumVariantId, FunctionId, HasModule, ItemContainerId, Lookup, StaticId, - VariantId, - builtin_type::BuiltinType, + AdtId, DefWithBodyId, EnumVariantId, FunctionId, GeneralConstId, HasModule, ItemContainerId, + Lookup, StaticId, VariantId, expr_store::HygieneId, item_tree::FieldsShape, lang_item::LangItem, @@ -25,33 +22,33 @@ use rustc_apfloat::{ Float, ieee::{Half as f16, Quad as f128}, }; +use rustc_ast_ir::Mutability; use rustc_hash::{FxHashMap, FxHashSet}; -use rustc_type_ir::inherent::{AdtDef, IntoKind, SliceLike}; +use rustc_type_ir::{ + AliasTyKind, + inherent::{AdtDef, IntoKind, Region as _, SliceLike, Ty as _}, +}; use span::FileId; use stdx::never; use syntax::{SyntaxNodePtr, TextRange}; use triomphe::Arc; use crate::{ - AliasTy, CallableDefId, ClosureId, ComplexMemoryMap, Const, ConstData, ConstScalar, Interner, - MemoryMap, Substitution, ToChalk, TraitEnvironment, Ty, TyBuilder, TyExt, TyKind, - consteval::{ConstEvalError, intern_const_scalar, try_const_usize}, - consteval_nextsolver, - db::{HirDatabase, InternedClosure}, + CallableDefId, ComplexMemoryMap, MemoryMap, TraitEnvironment, + consteval::{self, ConstEvalError, try_const_usize}, + db::{HirDatabase, InternedClosure, InternedClosureId}, display::{ClosureStyle, DisplayTarget, HirDisplay}, infer::PointerCast, layout::{Layout, LayoutError, RustcEnumVariantIdx}, method_resolution::{is_dyn_method, lookup_impl_const}, next_solver::{ - DbInterner, TypingMode, - infer::{DbInternerInferExt, InferCtxt}, - mapping::{ - ChalkToNextSolver, NextSolverToChalk, convert_args_for_result, convert_ty_for_result, - }, + Const, ConstBytes, ConstKind, DbInterner, ErrorGuaranteed, GenericArgs, Region, + SolverDefId, Ty, TyKind, TypingMode, UnevaluatedConst, ValueConst, + infer::{DbInternerInferExt, InferCtxt, traits::ObligationCause}, + obligation_ctxt::ObligationCtxt, }, - static_lifetime, traits::FnTrait, - utils::{ClosureSubst, detect_variant_from_bytes}, + utils::detect_variant_from_bytes, }; use super::{ @@ -88,14 +85,14 @@ macro_rules! not_supported { #[derive(Debug, Default, Clone, PartialEq, Eq)] pub struct VTableMap<'db> { - ty_to_id: FxHashMap<crate::next_solver::Ty<'db>, usize>, - id_to_ty: Vec<crate::next_solver::Ty<'db>>, + ty_to_id: FxHashMap<Ty<'db>, usize>, + id_to_ty: Vec<Ty<'db>>, } impl<'db> VTableMap<'db> { const OFFSET: usize = 1000; // We should add some offset to ids to make 0 (null) an invalid id. - fn id(&mut self, ty: crate::next_solver::Ty<'db>) -> usize { + fn id(&mut self, ty: Ty<'db>) -> usize { if let Some(it) = self.ty_to_id.get(&ty) { return *it; } @@ -105,13 +102,13 @@ impl<'db> VTableMap<'db> { id } - pub(crate) fn ty(&self, id: usize) -> Result<'db, crate::next_solver::Ty<'db>> { + pub(crate) fn ty(&self, id: usize) -> Result<'db, Ty<'db>> { id.checked_sub(VTableMap::OFFSET) .and_then(|id| self.id_to_ty.get(id).copied()) .ok_or(MirEvalError::InvalidVTableId(id)) } - fn ty_of_bytes(&self, bytes: &[u8]) -> Result<'db, crate::next_solver::Ty<'db>> { + fn ty_of_bytes(&self, bytes: &[u8]) -> Result<'db, Ty<'db>> { let id = from_bytes!(usize, bytes); self.ty(id) } @@ -153,45 +150,45 @@ impl TlsData { } } -struct StackFrame { - locals: Locals, - destination: Option<BasicBlockId>, +struct StackFrame<'db> { + locals: Locals<'db>, + destination: Option<BasicBlockId<'db>>, prev_stack_ptr: usize, span: (MirSpan, DefWithBodyId), } #[derive(Clone)] -enum MirOrDynIndex { - Mir(Arc<MirBody>), +enum MirOrDynIndex<'db> { + Mir(Arc<MirBody<'db>>), Dyn(usize), } -pub struct Evaluator<'a> { - db: &'a dyn HirDatabase, - trait_env: Arc<TraitEnvironment<'a>>, +pub struct Evaluator<'db> { + db: &'db dyn HirDatabase, + trait_env: Arc<TraitEnvironment<'db>>, target_data_layout: Arc<TargetDataLayout>, stack: Vec<u8>, heap: Vec<u8>, - code_stack: Vec<StackFrame>, + code_stack: Vec<StackFrame<'db>>, /// Stores the global location of the statics. We const evaluate every static first time we need it /// and see it's missing, then we add it to this to reuse. static_locations: FxHashMap<StaticId, Address>, /// We don't really have function pointers, i.e. pointers to some assembly instructions that we can run. Instead, we /// store the type as an interned id in place of function and vtable pointers, and we recover back the type at the /// time of use. - vtable_map: VTableMap<'a>, + vtable_map: VTableMap<'db>, thread_local_storage: TlsData, random_state: oorandom::Rand64, stdout: Vec<u8>, stderr: Vec<u8>, - layout_cache: RefCell<FxHashMap<crate::next_solver::Ty<'a>, Arc<Layout>>>, - projected_ty_cache: RefCell<FxHashMap<(Ty, PlaceElem), Ty>>, + layout_cache: RefCell<FxHashMap<Ty<'db>, Arc<Layout>>>, + projected_ty_cache: RefCell<FxHashMap<(Ty<'db>, PlaceElem<'db>), Ty<'db>>>, not_special_fn_cache: RefCell<FxHashSet<FunctionId>>, - mir_or_dyn_index_cache: RefCell<FxHashMap<(FunctionId, Substitution), MirOrDynIndex>>, - /// Constantly dropping and creating `Locals` is very costly. We store + mir_or_dyn_index_cache: RefCell<FxHashMap<(FunctionId, GenericArgs<'db>), MirOrDynIndex<'db>>>, + /// Constantly dropping and creating `Locals<'db>` is very costly. We store /// old locals that we normally want to drop here, to reuse their allocations /// later. - unused_locals_store: RefCell<FxHashMap<DefWithBodyId, Vec<Locals>>>, + unused_locals_store: RefCell<FxHashMap<DefWithBodyId, Vec<Locals<'db>>>>, cached_ptr_size: usize, cached_fn_trait_func: Option<FunctionId>, cached_fn_mut_trait_func: Option<FunctionId>, @@ -205,8 +202,7 @@ pub struct Evaluator<'a> { stack_depth_limit: usize, /// Maximum count of bytes that heap and stack can grow memory_limit: usize, - interner: DbInterner<'a>, - infcx: InferCtxt<'a>, + infcx: InferCtxt<'db>, } #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] @@ -225,9 +221,9 @@ struct Interval { } #[derive(Debug, Clone)] -struct IntervalAndTy { +struct IntervalAndTy<'db> { interval: Interval, - ty: Ty, + ty: Ty<'db>, } impl Interval { @@ -256,18 +252,18 @@ impl Interval { } } -impl IntervalAndTy { - fn get<'a, 'db>(&self, memory: &'a Evaluator<'db>) -> Result<'db, &'a [u8]> { +impl<'db> IntervalAndTy<'db> { + fn get<'a>(&self, memory: &'a Evaluator<'db>) -> Result<'db, &'a [u8]> { memory.read_memory(self.interval.addr, self.interval.size) } - fn new<'db>( + fn new( addr: Address, - ty: Ty, + ty: Ty<'db>, evaluator: &Evaluator<'db>, - locals: &Locals, - ) -> Result<'db, IntervalAndTy> { - let size = evaluator.size_of_sized(&ty, locals, "type of interval")?; + locals: &Locals<'db>, + ) -> Result<'db, IntervalAndTy<'db>> { + let size = evaluator.size_of_sized(ty, locals, "type of interval")?; Ok(IntervalAndTy { interval: Interval { addr, size }, ty }) } } @@ -346,7 +342,7 @@ impl Address { #[derive(Clone, PartialEq, Eq)] pub enum MirEvalError<'db> { ConstEvalError(String, Box<ConstEvalError<'db>>), - LayoutError(LayoutError, Ty), + LayoutError(LayoutError, Ty<'db>), TargetDataLayoutNotAvailable(TargetLoadError), /// Means that code had undefined behavior. We don't try to actively detect UB, but if it was detected /// then use this type of error. @@ -354,20 +350,20 @@ pub enum MirEvalError<'db> { Panic(String), // FIXME: This should be folded into ConstEvalError? MirLowerError(FunctionId, MirLowerError<'db>), - MirLowerErrorForClosure(ClosureId, MirLowerError<'db>), - TypeIsUnsized(Ty, &'static str), + MirLowerErrorForClosure(InternedClosureId, MirLowerError<'db>), + TypeIsUnsized(Ty<'db>, &'static str), NotSupported(String), - InvalidConst(Const), + InvalidConst(Const<'db>), InFunction( Box<MirEvalError<'db>>, - Vec<(Either<FunctionId, ClosureId>, MirSpan, DefWithBodyId)>, + Vec<(Either<FunctionId, InternedClosureId>, MirSpan, DefWithBodyId)>, ), ExecutionLimitExceeded, StackOverflow, /// FIXME: Fold this into InternalError InvalidVTableId(usize), /// ? - CoerceUnsizedError(Ty), + CoerceUnsizedError(Ty<'db>), /// These should not occur, usually indicates a bug in mir lowering. InternalError(Box<str>), } @@ -443,13 +439,8 @@ impl MirEvalError<'_> { let function_name = db.function_signature(*func); let self_ = match func.lookup(db).container { ItemContainerId::ImplId(impl_id) => Some({ - let generics = crate::generics::generics(db, impl_id.into()); - let interner = DbInterner::new_with(db, None, None); - let substs = generics.placeholder_subst(db); - let args: crate::next_solver::GenericArgs<'_> = - substs.to_nextsolver(interner); db.impl_self_ty(impl_id) - .instantiate(interner, args) + .instantiate_identity() .display(db, display_target) .to_string() }), @@ -535,10 +526,7 @@ impl std::fmt::Debug for MirEvalError<'_> { Self::InternalError(arg0) => f.debug_tuple("InternalError").field(arg0).finish(), Self::InvalidVTableId(arg0) => f.debug_tuple("InvalidVTableId").field(arg0).finish(), Self::NotSupported(arg0) => f.debug_tuple("NotSupported").field(arg0).finish(), - Self::InvalidConst(arg0) => { - let data = &arg0.data(Interner); - f.debug_struct("InvalidConst").field("ty", &data.ty).field("value", &arg0).finish() - } + Self::InvalidConst(arg0) => f.debug_tuple("InvalidConst").field(&arg0).finish(), Self::InFunction(e, stack) => { f.debug_struct("WithStack").field("error", e).field("stack", &stack).finish() } @@ -549,12 +537,12 @@ impl std::fmt::Debug for MirEvalError<'_> { type Result<'db, T> = std::result::Result<T, MirEvalError<'db>>; #[derive(Debug, Default)] -struct DropFlags { - need_drop: FxHashSet<Place>, +struct DropFlags<'db> { + need_drop: FxHashSet<Place<'db>>, } -impl DropFlags { - fn add_place(&mut self, p: Place, store: &ProjectionStore) { +impl<'db> DropFlags<'db> { + fn add_place(&mut self, p: Place<'db>, store: &ProjectionStore<'db>) { if p.iterate_over_parents(store).any(|it| self.need_drop.contains(&it)) { return; } @@ -562,7 +550,7 @@ impl DropFlags { self.need_drop.insert(p); } - fn remove_place(&mut self, p: &Place, store: &ProjectionStore) -> bool { + fn remove_place(&mut self, p: &Place<'db>, store: &ProjectionStore<'db>) -> bool { // FIXME: replace parents with parts if let Some(parent) = p.iterate_over_parents(store).find(|it| self.need_drop.contains(it)) { self.need_drop.remove(&parent); @@ -577,10 +565,10 @@ impl DropFlags { } #[derive(Debug)] -struct Locals { - ptr: ArenaMap<LocalId, Interval>, - body: Arc<MirBody>, - drop_flags: DropFlags, +struct Locals<'db> { + ptr: ArenaMap<LocalId<'db>, Interval>, + body: Arc<MirBody<'db>>, + drop_flags: DropFlags<'db>, } pub struct MirOutput { @@ -599,7 +587,7 @@ impl MirOutput { pub fn interpret_mir<'db>( db: &'db dyn HirDatabase, - body: Arc<MirBody>, + body: Arc<MirBody<'db>>, // FIXME: This is workaround. Ideally, const generics should have a separate body (issue #7434), but now // they share their body with their parent, so in MIR lowering we have locals of the parent body, which // might have placeholders. With this argument, we (wrongly) assume that every placeholder type has @@ -607,10 +595,10 @@ pub fn interpret_mir<'db>( // (and probably should) do better here, for example by excluding bindings outside of the target expression. assert_placeholder_ty_is_unused: bool, trait_env: Option<Arc<TraitEnvironment<'db>>>, -) -> Result<'db, (Result<'db, Const>, MirOutput)> { - let ty = body.locals[return_slot()].ty.clone(); +) -> Result<'db, (Result<'db, Const<'db>>, MirOutput)> { + let ty = body.locals[return_slot()].ty; let mut evaluator = Evaluator::new(db, body.owner, assert_placeholder_ty_is_unused, trait_env)?; - let it: Result<'db, Const> = (|| { + let it: Result<'db, Const<'db>> = (|| { if evaluator.ptr_size() != size_of::<usize>() { not_supported!("targets with different pointer size from host"); } @@ -618,7 +606,7 @@ pub fn interpret_mir<'db>( let bytes = interval.get(&evaluator)?; let mut memory_map = evaluator.create_memory_map( bytes, - &ty, + ty, &Locals { ptr: ArenaMap::new(), body, drop_flags: DropFlags::default() }, )?; let bytes = bytes.into(); @@ -629,13 +617,7 @@ pub fn interpret_mir<'db>( memory_map.vtable.shrink_to_fit(); MemoryMap::Complex(Box::new(memory_map)) }; - // SAFETY: will never use this without a db - Ok(intern_const_scalar( - ConstScalar::Bytes(bytes, unsafe { - std::mem::transmute::<MemoryMap<'_>, MemoryMap<'static>>(memory_map) - }), - ty, - )) + Ok(Const::new_valtree(evaluator.interner(), ty, bytes, memory_map)) })(); Ok((it, MirOutput { stdout: evaluator.stdout, stderr: evaluator.stderr })) } @@ -652,13 +634,15 @@ impl<'db> Evaluator<'db> { assert_placeholder_ty_is_unused: bool, trait_env: Option<Arc<TraitEnvironment<'db>>>, ) -> Result<'db, Evaluator<'db>> { - let crate_id = owner.module(db).krate(); + let module = owner.module(db); + let crate_id = module.krate(); let target_data_layout = match db.target_data_layout(crate_id) { Ok(target_data_layout) => target_data_layout, Err(e) => return Err(MirEvalError::TargetDataLayoutNotAvailable(e)), }; let cached_ptr_size = target_data_layout.pointer_size().bytes_usize(); - let interner = DbInterner::new_with(db, None, None); + let interner = DbInterner::new_with(db, Some(crate_id), module.containing_block()); + let infcx = interner.infer_ctxt().build(TypingMode::PostAnalysis); Ok(Evaluator { target_data_layout, stack: vec![0], @@ -692,21 +676,25 @@ impl<'db> Evaluator<'db> { cached_fn_once_trait_func: LangItem::FnOnce.resolve_trait(db, crate_id).and_then(|x| { x.trait_items(db).method_by_name(&Name::new_symbol_root(sym::call_once)) }), - interner, - infcx: interner.infer_ctxt().build(TypingMode::non_body_analysis()), + infcx, }) } - fn place_addr(&self, p: &Place, locals: &Locals) -> Result<'db, Address> { + #[inline] + fn interner(&self) -> DbInterner<'db> { + self.infcx.interner + } + + fn place_addr(&self, p: &Place<'db>, locals: &Locals<'db>) -> Result<'db, Address> { Ok(self.place_addr_and_ty_and_metadata(p, locals)?.0) } - fn place_interval(&self, p: &Place, locals: &Locals) -> Result<'db, Interval> { + fn place_interval(&self, p: &Place<'db>, locals: &Locals<'db>) -> Result<'db, Interval> { let place_addr_and_ty = self.place_addr_and_ty_and_metadata(p, locals)?; Ok(Interval { addr: place_addr_and_ty.0, size: self.size_of_sized( - &place_addr_and_ty.1, + place_addr_and_ty.1, locals, "Type of place that we need its interval", )?, @@ -717,54 +705,46 @@ impl<'db> Evaluator<'db> { self.cached_ptr_size } - fn projected_ty(&self, ty: Ty, proj: PlaceElem) -> Ty { + fn projected_ty(&self, ty: Ty<'db>, proj: PlaceElem<'db>) -> Ty<'db> { let pair = (ty, proj); if let Some(r) = self.projected_ty_cache.borrow().get(&pair) { - return r.clone(); + return *r; } let (ty, proj) = pair; let r = proj.projected_ty( - ty.clone(), - self.db, + &self.infcx, + ty, |c, subst, f| { - let InternedClosure(def, _) = self.db.lookup_intern_closure(c.into()); + let InternedClosure(def, _) = self.db.lookup_intern_closure(c); let infer = self.db.infer(def); - let (captures, _) = infer.closure_info(c.into()); - let parent_subst = ClosureSubst(subst).parent_subst(self.db); + let (captures, _) = infer.closure_info(c); + let parent_subst = subst.split_closure_args_untupled().parent_args; captures .get(f) .expect("broken closure field") .ty - .instantiate( - self.interner, - <_ as ChalkToNextSolver<'db, crate::next_solver::GenericArgs<'db>>>::to_nextsolver( - &parent_subst, - self.interner, - ), - ) - .to_chalk(self.interner) + .instantiate(self.interner(), parent_subst) }, self.crate_id, ); - self.projected_ty_cache.borrow_mut().insert((ty, proj), r.clone()); + self.projected_ty_cache.borrow_mut().insert((ty, proj), r); r } fn place_addr_and_ty_and_metadata<'a>( &'a self, - p: &Place, - locals: &'a Locals, - ) -> Result<'db, (Address, Ty, Option<IntervalOrOwned>)> { - let interner = DbInterner::new_with(self.db, None, None); + p: &Place<'db>, + locals: &'a Locals<'db>, + ) -> Result<'db, (Address, Ty<'db>, Option<IntervalOrOwned>)> { let mut addr = locals.ptr[p.local].addr; - let mut ty: Ty = locals.body.locals[p.local].ty.clone(); + let mut ty: Ty<'db> = locals.body.locals[p.local].ty; let mut metadata: Option<IntervalOrOwned> = None; // locals are always sized for proj in p.projection.lookup(&locals.body.projection_store) { - let prev_ty = ty.clone(); + let prev_ty = ty; ty = self.projected_ty(ty, proj.clone()); match proj { ProjectionElem::Deref => { - metadata = if self.size_align_of(&ty, locals)?.is_none() { + metadata = if self.size_align_of(ty, locals)?.is_none() { Some( Interval { addr: addr.offset(self.ptr_size()), size: self.ptr_size() } .into(), @@ -782,12 +762,12 @@ impl<'db> Evaluator<'db> { ); metadata = None; // Result of index is always sized let ty_size = - self.size_of_sized(&ty, locals, "array inner type should be sized")?; + self.size_of_sized(ty, locals, "array inner type should be sized")?; addr = addr.offset(ty_size * offset); } &ProjectionElem::ConstantIndex { from_end, offset } => { let offset = if from_end { - let len = match prev_ty.kind(Interner) { + let len = match prev_ty.kind() { TyKind::Array(_, c) => match try_const_usize(self.db, c) { Some(it) => it as u64, None => { @@ -806,13 +786,13 @@ impl<'db> Evaluator<'db> { }; metadata = None; // Result of index is always sized let ty_size = - self.size_of_sized(&ty, locals, "array inner type should be sized")?; + self.size_of_sized(ty, locals, "array inner type should be sized")?; addr = addr.offset(ty_size * offset); } &ProjectionElem::Subslice { from, to } => { - let inner_ty = match &ty.kind(Interner) { - TyKind::Array(inner, _) | TyKind::Slice(inner) => inner.clone(), - _ => TyKind::Error.intern(Interner), + let inner_ty = match ty.kind() { + TyKind::Array(inner, _) | TyKind::Slice(inner) => inner, + _ => Ty::new_error(self.interner(), ErrorGuaranteed), }; metadata = match metadata { Some(it) => { @@ -824,23 +804,23 @@ impl<'db> Evaluator<'db> { None => None, }; let ty_size = - self.size_of_sized(&inner_ty, locals, "array inner type should be sized")?; + self.size_of_sized(inner_ty, locals, "array inner type should be sized")?; addr = addr.offset(ty_size * (from as usize)); } &ProjectionElem::ClosureField(f) => { - let layout = self.layout(prev_ty.to_nextsolver(interner))?; + let layout = self.layout(prev_ty)?; let offset = layout.fields.offset(f).bytes_usize(); addr = addr.offset(offset); metadata = None; } ProjectionElem::Field(Either::Right(f)) => { - let layout = self.layout(prev_ty.to_nextsolver(interner))?; + let layout = self.layout(prev_ty)?; let offset = layout.fields.offset(f.index as usize).bytes_usize(); addr = addr.offset(offset); metadata = None; // tuple field is always sized FIXME: This is wrong, the tail can be unsized } ProjectionElem::Field(Either::Left(f)) => { - let layout = self.layout(prev_ty.to_nextsolver(interner))?; + let layout = self.layout(prev_ty)?; let variant_layout = match &layout.variants { Variants::Single { .. } | Variants::Empty => &layout, Variants::Multiple { variants, .. } => { @@ -862,7 +842,7 @@ impl<'db> Evaluator<'db> { .bytes_usize(); addr = addr.offset(offset); // Unsized field metadata is equal to the metadata of the struct - if self.size_align_of(&ty, locals)?.is_some() { + if self.size_align_of(ty, locals)?.is_some() { metadata = None; } } @@ -872,51 +852,47 @@ impl<'db> Evaluator<'db> { Ok((addr, ty, metadata)) } - fn layout(&self, ty: crate::next_solver::Ty<'db>) -> Result<'db, Arc<Layout>> { + fn layout(&self, ty: Ty<'db>) -> Result<'db, Arc<Layout>> { if let Some(x) = self.layout_cache.borrow().get(&ty) { return Ok(x.clone()); } - let interner = DbInterner::new_with(self.db, None, None); let r = self .db .layout_of_ty(ty, self.trait_env.clone()) - .map_err(|e| MirEvalError::LayoutError(e, convert_ty_for_result(interner, ty)))?; + .map_err(|e| MirEvalError::LayoutError(e, ty))?; self.layout_cache.borrow_mut().insert(ty, r.clone()); Ok(r) } - fn layout_adt(&self, adt: AdtId, subst: Substitution) -> Result<'db, Arc<Layout>> { - let interner = DbInterner::new_with(self.db, None, None); - self.layout(crate::next_solver::Ty::new( - interner, - rustc_type_ir::TyKind::Adt( - crate::next_solver::AdtDef::new(adt, interner), - subst.to_nextsolver(interner), - ), - )) + fn layout_adt(&self, adt: AdtId, subst: GenericArgs<'db>) -> Result<'db, Arc<Layout>> { + self.layout(Ty::new_adt(self.interner(), adt, subst)) } - fn place_ty<'a>(&'a self, p: &Place, locals: &'a Locals) -> Result<'db, Ty> { + fn place_ty<'a>(&'a self, p: &Place<'db>, locals: &'a Locals<'db>) -> Result<'db, Ty<'db>> { Ok(self.place_addr_and_ty_and_metadata(p, locals)?.1) } - fn operand_ty(&self, o: &Operand, locals: &Locals) -> Result<'db, Ty> { + fn operand_ty(&self, o: &Operand<'db>, locals: &Locals<'db>) -> Result<'db, Ty<'db>> { Ok(match &o.kind { OperandKind::Copy(p) | OperandKind::Move(p) => self.place_ty(p, locals)?, - OperandKind::Constant(c) => c.data(Interner).ty.clone(), + OperandKind::Constant { konst: _, ty } => *ty, &OperandKind::Static(s) => { - let ty = self.db.infer(s.into())[self.db.body(s.into()).body_expr] - .to_chalk(self.interner); - TyKind::Ref(Mutability::Not, static_lifetime(), ty).intern(Interner) + let ty = self.db.infer(s.into())[self.db.body(s.into()).body_expr]; + Ty::new_ref( + self.interner(), + Region::new_static(self.interner()), + ty, + Mutability::Not, + ) } }) } fn operand_ty_and_eval( &mut self, - o: &Operand, - locals: &mut Locals, - ) -> Result<'db, IntervalAndTy> { + o: &Operand<'db>, + locals: &mut Locals<'db>, + ) -> Result<'db, IntervalAndTy<'db>> { Ok(IntervalAndTy { interval: self.eval_operand(o, locals)?, ty: self.operand_ty(o, locals)?, @@ -925,7 +901,7 @@ impl<'db> Evaluator<'db> { fn interpret_mir( &mut self, - body: Arc<MirBody>, + body: Arc<MirBody<'db>>, args: impl Iterator<Item = IntervalOrOwned>, ) -> Result<'db, Interval> { if let Some(it) = self.stack_depth_limit.checked_sub(1) { @@ -989,8 +965,8 @@ impl<'db> Evaluator<'db> { .iter() .map(|it| self.operand_ty_and_eval(it, locals)) .collect::<Result<'db, Vec<_>>>()?; - let stack_frame = match &fn_ty.kind(Interner) { - TyKind::Function(_) => { + let stack_frame = match fn_ty.kind() { + TyKind::FnPtr(..) => { let bytes = self.eval_operand(func, locals)?; self.exec_fn_pointer( bytes, @@ -1002,7 +978,7 @@ impl<'db> Evaluator<'db> { )? } TyKind::FnDef(def, generic_args) => self.exec_fn_def( - CallableDefId::from_chalk(self.db, *def), + def.0, generic_args, destination_interval, &args, @@ -1089,8 +1065,8 @@ impl<'db> Evaluator<'db> { fn fill_locals_for_body( &mut self, - body: &MirBody, - locals: &mut Locals, + body: &MirBody<'db>, + locals: &mut Locals<'db>, args: impl Iterator<Item = IntervalOrOwned>, ) -> Result<'db, ()> { let mut remain_args = body.param_locals.len(); @@ -1113,9 +1089,9 @@ impl<'db> Evaluator<'db> { fn create_locals_for_body( &mut self, - body: &Arc<MirBody>, + body: &Arc<MirBody<'db>>, destination: Option<Interval>, - ) -> Result<'db, (Locals, usize)> { + ) -> Result<'db, (Locals<'db>, usize)> { let mut locals = match self.unused_locals_store.borrow_mut().entry(body.owner).or_default().pop() { None => Locals { @@ -1139,7 +1115,7 @@ impl<'db> Evaluator<'db> { continue; } let (size, align) = self.size_align_of_sized( - &it.ty, + it.ty, &locals, "no unsized local in extending stack", )?; @@ -1162,8 +1138,11 @@ impl<'db> Evaluator<'db> { Ok((locals, prev_stack_pointer)) } - fn eval_rvalue(&mut self, r: &Rvalue, locals: &mut Locals) -> Result<'db, IntervalOrOwned> { - let interner = DbInterner::new_with(self.db, None, None); + fn eval_rvalue( + &mut self, + r: &Rvalue<'db>, + locals: &mut Locals<'db>, + ) -> Result<'db, IntervalOrOwned> { use IntervalOrOwned::*; Ok(match r { Rvalue::Use(it) => Borrowed(self.eval_operand(it, locals)?), @@ -1189,33 +1168,33 @@ impl<'db> Evaluator<'db> { Rvalue::UnaryOp(op, val) => { let mut c = self.eval_operand(val, locals)?.get(self)?; let mut ty = self.operand_ty(val, locals)?; - while let TyKind::Ref(_, _, z) = ty.kind(Interner) { - ty = z.clone(); - let size = self.size_of_sized(&ty, locals, "operand of unary op")?; + while let TyKind::Ref(_, z, _) = ty.kind() { + ty = z; + let size = self.size_of_sized(ty, locals, "operand of unary op")?; c = self.read_memory(Address::from_bytes(c)?, size)?; } - if let TyKind::Scalar(chalk_ir::Scalar::Float(f)) = ty.kind(Interner) { + if let TyKind::Float(f) = ty.kind() { match f { - chalk_ir::FloatTy::F16 => { + rustc_type_ir::FloatTy::F16 => { let c = -from_bytes!(f16, u16, c); Owned(u16::try_from(c.to_bits()).unwrap().to_le_bytes().into()) } - chalk_ir::FloatTy::F32 => { + rustc_type_ir::FloatTy::F32 => { let c = -from_bytes!(f32, c); Owned(c.to_le_bytes().into()) } - chalk_ir::FloatTy::F64 => { + rustc_type_ir::FloatTy::F64 => { let c = -from_bytes!(f64, c); Owned(c.to_le_bytes().into()) } - chalk_ir::FloatTy::F128 => { + rustc_type_ir::FloatTy::F128 => { let c = -from_bytes!(f128, u128, c); Owned(c.to_bits().to_le_bytes().into()) } } } else { let mut c = c.to_vec(); - if ty.as_builtin() == Some(BuiltinType::Bool) { + if matches!(ty.kind(), TyKind::Bool) { c[0] = 1 - c[0]; } else { match op { @@ -1241,8 +1220,8 @@ impl<'db> Evaluator<'db> { let mut lc = lc.get(self)?; let mut rc = rc.get(self)?; let mut ty = self.operand_ty(lhs, locals)?; - while let TyKind::Ref(_, _, z) = ty.kind(Interner) { - ty = z.clone(); + while let TyKind::Ref(_, z, _) = ty.kind() { + ty = z; let size = if ty.is_str() { if *op != BinOp::Eq { never!("Only eq is builtin for `str`"); @@ -1258,14 +1237,14 @@ impl<'db> Evaluator<'db> { rc = self.read_memory(Address::from_bytes(rc)?, ls)?; break 'binary_op Owned(vec![u8::from(lc == rc)]); } else { - self.size_of_sized(&ty, locals, "operand of binary op")? + self.size_of_sized(ty, locals, "operand of binary op")? }; lc = self.read_memory(Address::from_bytes(lc)?, size)?; rc = self.read_memory(Address::from_bytes(rc)?, size)?; } - if let TyKind::Scalar(chalk_ir::Scalar::Float(f)) = ty.kind(Interner) { + if let TyKind::Float(f) = ty.kind() { match f { - chalk_ir::FloatTy::F16 => { + rustc_type_ir::FloatTy::F16 => { let l = from_bytes!(f16, u16, lc); let r = from_bytes!(f16, u16, rc); match op { @@ -1298,7 +1277,7 @@ impl<'db> Evaluator<'db> { ), } } - chalk_ir::FloatTy::F32 => { + rustc_type_ir::FloatTy::F32 => { let l = from_bytes!(f32, lc); let r = from_bytes!(f32, rc); match op { @@ -1326,7 +1305,7 @@ impl<'db> Evaluator<'db> { ), } } - chalk_ir::FloatTy::F64 => { + rustc_type_ir::FloatTy::F64 => { let l = from_bytes!(f64, lc); let r = from_bytes!(f64, rc); match op { @@ -1354,7 +1333,7 @@ impl<'db> Evaluator<'db> { ), } } - chalk_ir::FloatTy::F128 => { + rustc_type_ir::FloatTy::F128 => { let l = from_bytes!(f128, u128, lc); let r = from_bytes!(f128, u128, rc); match op { @@ -1384,7 +1363,7 @@ impl<'db> Evaluator<'db> { } } } else { - let is_signed = matches!(ty.as_builtin(), Some(BuiltinType::Int(_))); + let is_signed = matches!(ty.kind(), TyKind::Int(_)); let l128 = IntValue::from_bytes(lc, is_signed); let r128 = IntValue::from_bytes(rc, is_signed); match op { @@ -1455,7 +1434,7 @@ impl<'db> Evaluator<'db> { Owned(result.to_le_bytes().to_vec()) } Rvalue::Repeat(it, len) => { - let len = match try_const_usize(self.db, len) { + let len = match try_const_usize(self.db, *len) { Some(it) => it as usize, None => not_supported!("non evaluatable array len in repeat Rvalue"), }; @@ -1465,7 +1444,7 @@ impl<'db> Evaluator<'db> { } Rvalue::ShallowInitBox(_, _) => not_supported!("shallow init box"), Rvalue::ShallowInitBoxWithAlloc(ty) => { - let Some((size, align)) = self.size_align_of(ty, locals)? else { + let Some((size, align)) = self.size_align_of(*ty, locals)? else { not_supported!("unsized box initialization"); }; let addr = self.heap_allocate(size, align)?; @@ -1487,7 +1466,7 @@ impl<'db> Evaluator<'db> { Owned(r) } AggregateKind::Tuple(ty) => { - let layout = self.layout(ty.to_nextsolver(interner))?; + let layout = self.layout(*ty)?; Owned(self.construct_with_layout( layout.size.bytes_usize(), &layout, @@ -1496,8 +1475,10 @@ impl<'db> Evaluator<'db> { )?) } AggregateKind::Union(it, f) => { - let layout = - self.layout_adt((*it).into(), Substitution::empty(Interner))?; + let layout = self.layout_adt( + (*it).into(), + GenericArgs::new_from_iter(self.interner(), []), + )?; let offset = layout .fields .offset(u32::from(f.local_id.into_raw()) as usize) @@ -1509,7 +1490,7 @@ impl<'db> Evaluator<'db> { } AggregateKind::Adt(it, subst) => { let (size, variant_layout, tag) = - self.layout_of_variant(*it, subst.clone(), locals)?; + self.layout_of_variant(*it, *subst, locals)?; Owned(self.construct_with_layout( size, &variant_layout, @@ -1518,7 +1499,7 @@ impl<'db> Evaluator<'db> { )?) } AggregateKind::Closure(ty) => { - let layout = self.layout(ty.to_nextsolver(interner))?; + let layout = self.layout(*ty)?; Owned(self.construct_with_layout( layout.size.bytes_usize(), &layout, @@ -1532,11 +1513,7 @@ impl<'db> Evaluator<'db> { CastKind::PointerCoercion(cast) => match cast { PointerCast::ReifyFnPointer | PointerCast::ClosureFnPointer(_) => { let current_ty = self.operand_ty(operand, locals)?; - if let TyKind::FnDef(_, _) | TyKind::Closure(_, _) = - ¤t_ty.kind(Interner) - { - let interner = DbInterner::new_with(self.db, None, None); - let current_ty = current_ty.to_nextsolver(interner); + if let TyKind::FnDef(_, _) | TyKind::Closure(_, _) = current_ty.kind() { let id = self.vtable_map.id(current_ty); let ptr_size = self.ptr_size(); Owned(id.to_le_bytes()[0..ptr_size].to_vec()) @@ -1549,7 +1526,7 @@ impl<'db> Evaluator<'db> { PointerCast::Unsize => { let current_ty = self.operand_ty(operand, locals)?; let addr = self.eval_operand(operand, locals)?; - self.coerce_unsized(addr, ¤t_ty, target_ty)? + self.coerce_unsized(addr, current_ty, *target_ty)? } PointerCast::MutToConstPointer | PointerCast::UnsafeFnPointer => { // This is no-op @@ -1566,40 +1543,34 @@ impl<'db> Evaluator<'db> { | CastKind::PointerExposeAddress | CastKind::PointerFromExposedAddress => { let current_ty = self.operand_ty(operand, locals)?; - let is_signed = matches!( - current_ty.kind(Interner), - TyKind::Scalar(chalk_ir::Scalar::Int(_)) - ); + let is_signed = matches!(current_ty.kind(), TyKind::Int(_)); let current = pad16(self.eval_operand(operand, locals)?.get(self)?, is_signed); let dest_size = - self.size_of_sized(target_ty, locals, "destination of int to int cast")?; + self.size_of_sized(*target_ty, locals, "destination of int to int cast")?; Owned(current[0..dest_size].to_vec()) } CastKind::FloatToInt => { let ty = self.operand_ty(operand, locals)?; - let TyKind::Scalar(chalk_ir::Scalar::Float(ty)) = ty.kind(Interner) else { + let TyKind::Float(ty) = ty.kind() else { not_supported!("invalid float to int cast"); }; let value = self.eval_operand(operand, locals)?.get(self)?; let value = match ty { - chalk_ir::FloatTy::F32 => { + rustc_type_ir::FloatTy::F32 => { let value = value.try_into().unwrap(); f32::from_le_bytes(value) as f64 } - chalk_ir::FloatTy::F64 => { + rustc_type_ir::FloatTy::F64 => { let value = value.try_into().unwrap(); f64::from_le_bytes(value) } - chalk_ir::FloatTy::F16 | chalk_ir::FloatTy::F128 => { + rustc_type_ir::FloatTy::F16 | rustc_type_ir::FloatTy::F128 => { not_supported!("unstable floating point type f16 and f128"); } }; - let is_signed = matches!( - target_ty.kind(Interner), - TyKind::Scalar(chalk_ir::Scalar::Int(_)) - ); + let is_signed = matches!(target_ty.kind(), TyKind::Int(_)); let dest_size = - self.size_of_sized(target_ty, locals, "destination of float to int cast")?; + self.size_of_sized(*target_ty, locals, "destination of float to int cast")?; let dest_bits = dest_size * 8; let (max, min) = if dest_bits == 128 { (i128::MAX, i128::MIN) @@ -1615,53 +1586,46 @@ impl<'db> Evaluator<'db> { } CastKind::FloatToFloat => { let ty = self.operand_ty(operand, locals)?; - let TyKind::Scalar(chalk_ir::Scalar::Float(ty)) = ty.kind(Interner) else { + let TyKind::Float(ty) = ty.kind() else { not_supported!("invalid float to int cast"); }; let value = self.eval_operand(operand, locals)?.get(self)?; let value = match ty { - chalk_ir::FloatTy::F32 => { + rustc_type_ir::FloatTy::F32 => { let value = value.try_into().unwrap(); f32::from_le_bytes(value) as f64 } - chalk_ir::FloatTy::F64 => { + rustc_type_ir::FloatTy::F64 => { let value = value.try_into().unwrap(); f64::from_le_bytes(value) } - chalk_ir::FloatTy::F16 | chalk_ir::FloatTy::F128 => { + rustc_type_ir::FloatTy::F16 | rustc_type_ir::FloatTy::F128 => { not_supported!("unstable floating point type f16 and f128"); } }; - let TyKind::Scalar(chalk_ir::Scalar::Float(target_ty)) = - target_ty.kind(Interner) - else { + let TyKind::Float(target_ty) = target_ty.kind() else { not_supported!("invalid float to float cast"); }; match target_ty { - chalk_ir::FloatTy::F32 => Owned((value as f32).to_le_bytes().to_vec()), - chalk_ir::FloatTy::F64 => Owned((value as f64).to_le_bytes().to_vec()), - chalk_ir::FloatTy::F16 | chalk_ir::FloatTy::F128 => { + rustc_type_ir::FloatTy::F32 => Owned((value as f32).to_le_bytes().to_vec()), + rustc_type_ir::FloatTy::F64 => Owned((value as f64).to_le_bytes().to_vec()), + rustc_type_ir::FloatTy::F16 | rustc_type_ir::FloatTy::F128 => { not_supported!("unstable floating point type f16 and f128"); } } } CastKind::IntToFloat => { let current_ty = self.operand_ty(operand, locals)?; - let is_signed = matches!( - current_ty.kind(Interner), - TyKind::Scalar(chalk_ir::Scalar::Int(_)) - ); + let is_signed = matches!(current_ty.kind(), TyKind::Int(_)); let value = pad16(self.eval_operand(operand, locals)?.get(self)?, is_signed); let value = i128::from_le_bytes(value); - let TyKind::Scalar(chalk_ir::Scalar::Float(target_ty)) = - target_ty.kind(Interner) - else { + let TyKind::Float(target_ty) = target_ty.kind() else { not_supported!("invalid int to float cast"); }; match target_ty { - chalk_ir::FloatTy::F32 => Owned((value as f32).to_le_bytes().to_vec()), - chalk_ir::FloatTy::F64 => Owned((value as f64).to_le_bytes().to_vec()), - chalk_ir::FloatTy::F16 | chalk_ir::FloatTy::F128 => { + rustc_type_ir::FloatTy::F32 => Owned((value as f32).to_le_bytes().to_vec()), + rustc_type_ir::FloatTy::F64 => Owned((value as f64).to_le_bytes().to_vec()), + rustc_type_ir::FloatTy::F16 | rustc_type_ir::FloatTy::F128 => { not_supported!("unstable floating point type f16 and f128"); } } @@ -1675,10 +1639,12 @@ impl<'db> Evaluator<'db> { }) } - fn compute_discriminant(&self, ty: Ty, bytes: &[u8]) -> Result<'db, i128> { - let interner = DbInterner::new_with(self.db, None, None); - let layout = self.layout(ty.to_nextsolver(interner))?; - let &TyKind::Adt(chalk_ir::AdtId(AdtId::EnumId(e)), _) = ty.kind(Interner) else { + fn compute_discriminant(&self, ty: Ty<'db>, bytes: &[u8]) -> Result<'db, i128> { + let layout = self.layout(ty)?; + let TyKind::Adt(adt_def, _) = ty.kind() else { + return Ok(0); + }; + let AdtId::EnumId(e) = adt_def.def_id().0 else { return Ok(0); }; match &layout.variants { @@ -1720,35 +1686,35 @@ impl<'db> Evaluator<'db> { fn coerce_unsized_look_through_fields<T>( &self, - ty: &Ty, - goal: impl Fn(&TyKind) -> Option<T>, + ty: Ty<'db>, + goal: impl Fn(TyKind<'db>) -> Option<T>, ) -> Result<'db, T> { - let kind = ty.kind(Interner); + let kind = ty.kind(); if let Some(it) = goal(kind) { return Ok(it); } - if let TyKind::Adt(id, subst) = kind - && let AdtId::StructId(struct_id) = id.0 + if let TyKind::Adt(adt_ef, subst) = kind + && let AdtId::StructId(struct_id) = adt_ef.def_id().0 { - let field_types = self.db.field_types(struct_id.into()); + let field_types = self.db.field_types_ns(struct_id.into()); if let Some(ty) = - field_types.iter().last().map(|it| it.1.clone().substitute(Interner, subst)) + field_types.iter().last().map(|it| it.1.instantiate(self.interner(), subst)) { - return self.coerce_unsized_look_through_fields(&ty, goal); + return self.coerce_unsized_look_through_fields(ty, goal); } } - Err(MirEvalError::CoerceUnsizedError(ty.clone())) + Err(MirEvalError::CoerceUnsizedError(ty)) } fn coerce_unsized( &mut self, addr: Interval, - current_ty: &Ty, - target_ty: &Ty, + current_ty: Ty<'db>, + target_ty: Ty<'db>, ) -> Result<'db, IntervalOrOwned> { - fn for_ptr(it: &TyKind) -> Option<Ty> { + fn for_ptr<'db>(it: TyKind<'db>) -> Option<Ty<'db>> { match it { - TyKind::Raw(_, ty) | TyKind::Ref(_, _, ty) => Some(ty.clone()), + TyKind::RawPtr(ty, _) | TyKind::Ref(_, ty, _) => Some(ty), _ => None, } } @@ -1761,15 +1727,15 @@ impl<'db> Evaluator<'db> { /// Adds metadata to the address and create the fat pointer result of the unsizing operation. fn unsizing_ptr_from_addr( &mut self, - target_ty: Ty, - current_ty: Ty, + target_ty: Ty<'db>, + current_ty: Ty<'db>, addr: Interval, ) -> Result<'db, IntervalOrOwned> { use IntervalOrOwned::*; - Ok(match &target_ty.kind(Interner) { - TyKind::Slice(_) => match ¤t_ty.kind(Interner) { + Ok(match &target_ty.kind() { + TyKind::Slice(_) => match ¤t_ty.kind() { TyKind::Array(_, size) => { - let len = match try_const_usize(self.db, size) { + let len = match try_const_usize(self.db, *size) { None => { not_supported!("unevaluatble len of array in coerce unsized") } @@ -1785,9 +1751,7 @@ impl<'db> Evaluator<'db> { not_supported!("slice unsizing from non array type {t:?}") } }, - TyKind::Dyn(_) => { - let interner = DbInterner::new_with(self.db, None, None); - let current_ty = current_ty.to_nextsolver(interner); + TyKind::Dynamic(..) => { let vtable = self.vtable_map.id(current_ty); let mut r = Vec::with_capacity(16); let addr = addr.get(self)?; @@ -1795,12 +1759,14 @@ impl<'db> Evaluator<'db> { r.extend(vtable.to_le_bytes()); Owned(r) } - TyKind::Adt(id, target_subst) => match ¤t_ty.kind(Interner) { - TyKind::Adt(current_id, current_subst) => { + TyKind::Adt(adt_def, target_subst) => match ¤t_ty.kind() { + TyKind::Adt(current_adt_def, current_subst) => { + let id = adt_def.def_id().0; + let current_id = current_adt_def.def_id().0; if id != current_id { not_supported!("unsizing struct with different type"); } - let id = match id.0 { + let id = match id { AdtId::StructId(s) => s, AdtId::UnionId(_) => not_supported!("unsizing unions"), AdtId::EnumId(_) => not_supported!("unsizing enums"), @@ -1809,12 +1775,10 @@ impl<'db> Evaluator<'db> { else { not_supported!("unsizing struct without field"); }; - let target_last_field = self.db.field_types(id.into())[last_field] - .clone() - .substitute(Interner, target_subst); - let current_last_field = self.db.field_types(id.into())[last_field] - .clone() - .substitute(Interner, current_subst); + let target_last_field = self.db.field_types_ns(id.into())[last_field] + .instantiate(self.interner(), target_subst); + let current_last_field = self.db.field_types_ns(id.into())[last_field] + .instantiate(self.interner(), current_subst); return self.unsizing_ptr_from_addr( target_last_field, current_last_field, @@ -1830,10 +1794,9 @@ impl<'db> Evaluator<'db> { fn layout_of_variant( &mut self, it: VariantId, - subst: Substitution, - locals: &Locals, + subst: GenericArgs<'db>, + locals: &Locals<'db>, ) -> Result<'db, (usize, Arc<Layout>, Option<(usize, usize, i128)>)> { - let interner = DbInterner::new_with(self.db, None, None); let adt = it.adt_id(self.db); if let DefWithBodyId::VariantId(f) = locals.body.owner && let VariantId::EnumVariantId(it) = it @@ -1843,11 +1806,7 @@ impl<'db> Evaluator<'db> { // Computing the exact size of enums require resolving the enum discriminants. In order to prevent loops (and // infinite sized type errors) we use a dummy layout let i = self.const_eval_discriminant(it)?; - return Ok(( - 16, - self.layout(crate::next_solver::Ty::new_empty_tuple(interner))?, - Some((0, 16, i)), - )); + return Ok((16, self.layout(Ty::new_empty_tuple(self.interner()))?, Some((0, 16, i)))); } let layout = self.layout_adt(adt, subst)?; Ok(match &layout.variants { @@ -1930,7 +1889,11 @@ impl<'db> Evaluator<'db> { Ok(result) } - fn eval_operand(&mut self, it: &Operand, locals: &mut Locals) -> Result<'db, Interval> { + fn eval_operand( + &mut self, + it: &Operand<'db>, + locals: &mut Locals<'db>, + ) -> Result<'db, Interval> { Ok(match &it.kind { OperandKind::Copy(p) | OperandKind::Move(p) => { locals.drop_flags.remove_place(p, &locals.body.projection_store); @@ -1940,32 +1903,30 @@ impl<'db> Evaluator<'db> { let addr = self.eval_static(*st, locals)?; Interval::new(addr, self.ptr_size()) } - OperandKind::Constant(konst) => self.allocate_const_in_heap(locals, konst)?, + OperandKind::Constant { konst, .. } => self.allocate_const_in_heap(locals, *konst)?, }) } #[allow(clippy::double_parens)] - fn allocate_const_in_heap(&mut self, locals: &Locals, konst: &Const) -> Result<'db, Interval> { - let interner = self.interner; - let ConstData { ty, value: chalk_ir::ConstValue::Concrete(c) } = &konst.data(Interner) - else { - not_supported!("evaluating non concrete constant"); - }; + fn allocate_const_in_heap( + &mut self, + locals: &Locals<'db>, + konst: Const<'db>, + ) -> Result<'db, Interval> { let result_owner; - let (v, memory_map) = match &c.interned { - ConstScalar::Bytes(v, mm) => (v, mm), - ConstScalar::UnevaluatedConst(const_id, subst) => 'b: { - let mut const_id = *const_id; - let mut subst = subst.clone(); + let value = match konst.kind() { + ConstKind::Value(value) => value, + ConstKind::Unevaluated(UnevaluatedConst { def: const_id, args: subst }) => 'b: { + let mut const_id = match const_id { + SolverDefId::ConstId(it) => GeneralConstId::from(it), + SolverDefId::StaticId(it) => it.into(), + _ => unreachable!("unevaluated consts should be consts or statics"), + }; + let mut subst = subst; if let hir_def::GeneralConstId::ConstId(c) = const_id { - let (c, s) = lookup_impl_const( - self.interner, - self.trait_env.clone(), - c, - subst.to_nextsolver(self.interner), - ); + let (c, s) = lookup_impl_const(&self.infcx, self.trait_env.clone(), c, subst); const_id = hir_def::GeneralConstId::ConstId(c); - subst = s.to_chalk(self.interner); + subst = s; } result_owner = self .db @@ -1974,15 +1935,15 @@ impl<'db> Evaluator<'db> { let name = const_id.name(self.db); MirEvalError::ConstEvalError(name, Box::new(e)) })?; - if let chalk_ir::ConstValue::Concrete(c) = &result_owner.data(Interner).value - && let ConstScalar::Bytes(v, mm) = &c.interned - { - break 'b (v, mm); + if let ConstKind::Value(value) = result_owner.kind() { + break 'b value; } not_supported!("unevaluatable constant"); } - ConstScalar::Unknown => not_supported!("evaluating unknown const"), + _ => not_supported!("evaluating unknown const"), }; + let ValueConst { ty, value } = value; + let ConstBytes { memory: v, memory_map } = value.inner(); let patch_map = memory_map.transform_addresses(|b, align| { let addr = self.heap_allocate(b.len(), align)?; self.write_memory(addr, b)?; @@ -1996,7 +1957,7 @@ impl<'db> Evaluator<'db> { } else if size < 16 && v.len() == 16 { Cow::Borrowed(&v[0..size]) } else { - return Err(MirEvalError::InvalidConst(konst.clone())); + return Err(MirEvalError::InvalidConst(konst)); } } else { Cow::Borrowed(v) @@ -2012,17 +1973,17 @@ impl<'db> Evaluator<'db> { MemoryMap::Complex(cm) => cm.vtable.ty_of_bytes(bytes), }, addr, - ty.to_nextsolver(interner), + ty, locals, )?; Ok(Interval::new(addr, size)) } - fn eval_place(&mut self, p: &Place, locals: &Locals) -> Result<'db, Interval> { + fn eval_place(&mut self, p: &Place<'db>, locals: &Locals<'db>) -> Result<'db, Interval> { let addr = self.place_addr(p, locals)?; Ok(Interval::new( addr, - self.size_of_sized(&self.place_ty(p, locals)?, locals, "type of this place")?, + self.size_of_sized(self.place_ty(p, locals)?, locals, "type of this place")?, )) } @@ -2118,9 +2079,12 @@ impl<'db> Evaluator<'db> { Ok(()) } - fn size_align_of(&self, ty: &Ty, locals: &Locals) -> Result<'db, Option<(usize, usize)>> { - let interner = DbInterner::new_with(self.db, None, None); - if let Some(layout) = self.layout_cache.borrow().get(&ty.to_nextsolver(interner)) { + fn size_align_of( + &self, + ty: Ty<'db>, + locals: &Locals<'db>, + ) -> Result<'db, Option<(usize, usize)>> { + if let Some(layout) = self.layout_cache.borrow().get(&ty) { return Ok(layout .is_sized() .then(|| (layout.size.bytes_usize(), layout.align.bytes() as usize))); @@ -2133,7 +2097,7 @@ impl<'db> Evaluator<'db> { // infinite sized type errors) we use a dummy size return Ok(Some((16, 16))); } - let layout = self.layout(ty.to_nextsolver(interner)); + let layout = self.layout(ty); if self.assert_placeholder_ty_is_unused && matches!(layout, Err(MirEvalError::LayoutError(LayoutError::HasPlaceholder, _))) { @@ -2145,10 +2109,15 @@ impl<'db> Evaluator<'db> { /// A version of `self.size_of` which returns error if the type is unsized. `what` argument should /// be something that complete this: `error: type {ty} was unsized. {what} should be sized` - fn size_of_sized(&self, ty: &Ty, locals: &Locals, what: &'static str) -> Result<'db, usize> { + fn size_of_sized( + &self, + ty: Ty<'db>, + locals: &Locals<'db>, + what: &'static str, + ) -> Result<'db, usize> { match self.size_align_of(ty, locals)? { Some(it) => Ok(it.0), - None => Err(MirEvalError::TypeIsUnsized(ty.clone(), what)), + None => Err(MirEvalError::TypeIsUnsized(ty, what)), } } @@ -2156,13 +2125,13 @@ impl<'db> Evaluator<'db> { /// be something that complete this: `error: type {ty} was unsized. {what} should be sized` fn size_align_of_sized( &self, - ty: &Ty, - locals: &Locals, + ty: Ty<'db>, + locals: &Locals<'db>, what: &'static str, ) -> Result<'db, (usize, usize)> { match self.size_align_of(ty, locals)? { Some(it) => Ok(it), - None => Err(MirEvalError::TypeIsUnsized(ty.clone(), what)), + None => Err(MirEvalError::TypeIsUnsized(ty, what)), } } @@ -2197,23 +2166,22 @@ impl<'db> Evaluator<'db> { fn create_memory_map( &self, bytes: &[u8], - ty: &Ty, - locals: &Locals, + ty: Ty<'db>, + locals: &Locals<'db>, ) -> Result<'db, ComplexMemoryMap<'db>> { fn rec<'db>( this: &Evaluator<'db>, bytes: &[u8], - ty: &Ty, - locals: &Locals, + ty: Ty<'db>, + locals: &Locals<'db>, mm: &mut ComplexMemoryMap<'db>, stack_depth_limit: usize, ) -> Result<'db, ()> { - let interner = DbInterner::new_with(this.db, None, None); if stack_depth_limit.checked_sub(1).is_none() { return Err(MirEvalError::StackOverflow); } - match ty.kind(Interner) { - TyKind::Ref(_, _, t) => { + match ty.kind() { + TyKind::Ref(_, t, _) => { let size = this.size_align_of(t, locals)?; match size { Some((size, _)) => { @@ -2226,29 +2194,28 @@ impl<'db> Evaluator<'db> { None => { let mut check_inner = None; let (addr, meta) = bytes.split_at(bytes.len() / 2); - let element_size = match t.kind(Interner) { + let element_size = match t.kind() { TyKind::Str => 1, TyKind::Slice(t) => { - check_inner = Some(t.clone()); + check_inner = Some(t); this.size_of_sized(t, locals, "slice inner type")? } - TyKind::Dyn(_) => { + TyKind::Dynamic(..) => { let t = this.vtable_map.ty_of_bytes(meta)?; - let t = convert_ty_for_result(interner, t); - check_inner = Some(t.clone()); - this.size_of_sized(&t, locals, "dyn concrete type")? + check_inner = Some(t); + this.size_of_sized(t, locals, "dyn concrete type")? } _ => return Ok(()), }; - let count = match t.kind(Interner) { - TyKind::Dyn(_) => 1, + let count = match t.kind() { + TyKind::Dynamic(..) => 1, _ => from_bytes!(usize, meta), }; let size = element_size * count; let addr = Address::from_bytes(addr)?; let b = this.read_memory(addr, size)?; mm.insert(addr.to_usize(), b.into()); - if let Some(ty) = &check_inner { + if let Some(ty) = check_inner { for i in 0..count { let offset = element_size * i; rec( @@ -2282,12 +2249,11 @@ impl<'db> Evaluator<'db> { )?; } } - TyKind::Tuple(_, subst) => { - let layout = this.layout(ty.to_nextsolver(interner))?; - for (id, ty) in subst.iter(Interner).enumerate() { - let ty = ty.assert_ty_ref(Interner); // Tuple only has type argument + TyKind::Tuple(subst) => { + let layout = this.layout(ty)?; + for (id, ty) in subst.iter().enumerate() { let offset = layout.fields.offset(id).bytes_usize(); - let size = this.layout(ty.to_nextsolver(interner))?.size.bytes_usize(); + let size = this.layout(ty)?.size.bytes_usize(); rec( this, &bytes[offset..offset + size], @@ -2298,18 +2264,18 @@ impl<'db> Evaluator<'db> { )?; } } - TyKind::Adt(adt, subst) => match adt.0 { + TyKind::Adt(adt, subst) => match adt.def_id().0 { AdtId::StructId(s) => { let data = s.fields(this.db); - let layout = this.layout(ty.to_nextsolver(interner))?; - let field_types = this.db.field_types(s.into()); + let layout = this.layout(ty)?; + let field_types = this.db.field_types_ns(s.into()); for (f, _) in data.fields().iter() { let offset = layout .fields .offset(u32::from(f.into_raw()) as usize) .bytes_usize(); - let ty = &field_types[f].clone().substitute(Interner, subst); - let size = this.layout(ty.to_nextsolver(interner))?.size.bytes_usize(); + let ty = field_types[f].instantiate(this.interner(), subst); + let size = this.layout(ty)?.size.bytes_usize(); rec( this, &bytes[offset..offset + size], @@ -2321,7 +2287,7 @@ impl<'db> Evaluator<'db> { } } AdtId::EnumId(e) => { - let layout = this.layout(ty.to_nextsolver(interner))?; + let layout = this.layout(ty)?; if let Some((v, l)) = detect_variant_from_bytes( &layout, this.db, @@ -2330,13 +2296,12 @@ impl<'db> Evaluator<'db> { e, ) { let data = v.fields(this.db); - let field_types = this.db.field_types(v.into()); + let field_types = this.db.field_types_ns(v.into()); for (f, _) in data.fields().iter() { let offset = l.fields.offset(u32::from(f.into_raw()) as usize).bytes_usize(); - let ty = &field_types[f].clone().substitute(Interner, subst); - let size = - this.layout(ty.to_nextsolver(interner))?.size.bytes_usize(); + let ty = field_types[f].instantiate(this.interner(), subst); + let size = this.layout(ty)?.size.bytes_usize(); rec( this, &bytes[offset..offset + size], @@ -2350,9 +2315,17 @@ impl<'db> Evaluator<'db> { } AdtId::UnionId(_) => (), }, - TyKind::Alias(AliasTy::Projection(proj)) => { - let ty = this.db.normalize_projection(proj.clone(), this.trait_env.clone()); - rec(this, bytes, &ty, locals, mm, stack_depth_limit - 1)?; + TyKind::Alias(AliasTyKind::Projection, _) => { + let mut ocx = ObligationCtxt::new(&this.infcx); + let ty = ocx + .structurally_normalize_ty( + &ObligationCause::dummy(), + this.trait_env.env, + ty, + ) + .map_err(|_| MirEvalError::NotSupported("couldn't normalize".to_owned()))?; + + rec(this, bytes, ty, locals, mm, stack_depth_limit - 1)?; } _ => (), } @@ -2366,23 +2339,18 @@ impl<'db> Evaluator<'db> { fn patch_addresses( &mut self, patch_map: &FxHashMap<usize, usize>, - ty_of_bytes: impl Fn(&[u8]) -> Result<'db, crate::next_solver::Ty<'db>> + Copy, + ty_of_bytes: impl Fn(&[u8]) -> Result<'db, Ty<'db>> + Copy, addr: Address, - ty: crate::next_solver::Ty<'db>, - locals: &Locals, + ty: Ty<'db>, + locals: &Locals<'db>, ) -> Result<'db, ()> { - let interner = DbInterner::new_with(self.db, None, None); // FIXME: support indirect references let layout = self.layout(ty)?; - let my_size = self.size_of_sized( - &convert_ty_for_result(interner, ty), - locals, - "value to patch address", - )?; + let my_size = self.size_of_sized(ty, locals, "value to patch address")?; use rustc_type_ir::TyKind; match ty.kind() { TyKind::Ref(_, t, _) => { - let size = self.size_align_of(&convert_ty_for_result(interner, t), locals)?; + let size = self.size_align_of(t, locals)?; match size { Some(_) => { let current = from_bytes!(usize, self.read_memory(addr, my_size)?); @@ -2407,7 +2375,7 @@ impl<'db> Evaluator<'db> { AdtId::StructId(s) => { for (i, (_, ty)) in self.db.field_types_ns(s.into()).iter().enumerate() { let offset = layout.fields.offset(i).bytes_usize(); - let ty = ty.instantiate(interner, args); + let ty = ty.instantiate(self.interner(), args); self.patch_addresses( patch_map, ty_of_bytes, @@ -2428,7 +2396,7 @@ impl<'db> Evaluator<'db> { ) { for (i, (_, ty)) in self.db.field_types_ns(ev.into()).iter().enumerate() { let offset = layout.fields.offset(i).bytes_usize(); - let ty = ty.instantiate(interner, args); + let ty = ty.instantiate(self.interner(), args); self.patch_addresses( patch_map, ty_of_bytes, @@ -2447,15 +2415,11 @@ impl<'db> Evaluator<'db> { } } TyKind::Array(inner, len) => { - let len = match consteval_nextsolver::try_const_usize(self.db, len) { + let len = match consteval::try_const_usize(self.db, len) { Some(it) => it as usize, None => not_supported!("non evaluatable array len in patching addresses"), }; - let size = self.size_of_sized( - &convert_ty_for_result(interner, inner), - locals, - "inner of array", - )?; + let size = self.size_of_sized(inner, locals, "inner of array")?; for i in 0..len { self.patch_addresses( patch_map, @@ -2498,29 +2462,22 @@ impl<'db> Evaluator<'db> { &mut self, bytes: Interval, destination: Interval, - args: &[IntervalAndTy], - locals: &Locals, - target_bb: Option<BasicBlockId>, + args: &[IntervalAndTy<'db>], + locals: &Locals<'db>, + target_bb: Option<BasicBlockId<'db>>, span: MirSpan, - ) -> Result<'db, Option<StackFrame>> { + ) -> Result<'db, Option<StackFrame<'db>>> { let id = from_bytes!(usize, bytes.get(self)?); let next_ty = self.vtable_map.ty(id)?; - let interner = DbInterner::new_with(self.db, None, None); use rustc_type_ir::TyKind; match next_ty.kind() { - TyKind::FnDef(def, generic_args) => self.exec_fn_def( - def.0, - &convert_args_for_result(interner, generic_args.as_slice()), - destination, - args, - locals, - target_bb, - span, - ), + TyKind::FnDef(def, generic_args) => { + self.exec_fn_def(def.0, generic_args, destination, args, locals, target_bb, span) + } TyKind::Closure(id, generic_args) => self.exec_closure( - id.0.into(), + id.0, bytes.slice(0..0), - &convert_args_for_result(interner, generic_args.as_slice()), + generic_args, destination, args, locals, @@ -2532,21 +2489,17 @@ impl<'db> Evaluator<'db> { fn exec_closure( &mut self, - closure: ClosureId, + closure: InternedClosureId, closure_data: Interval, - generic_args: &Substitution, + generic_args: GenericArgs<'db>, destination: Interval, - args: &[IntervalAndTy], - locals: &Locals, + args: &[IntervalAndTy<'db>], + locals: &Locals<'db>, span: MirSpan, - ) -> Result<'db, Option<StackFrame>> { + ) -> Result<'db, Option<StackFrame<'db>>> { let mir_body = self .db - .monomorphized_mir_body_for_closure( - closure.into(), - generic_args.clone(), - self.trait_env.clone(), - ) + .monomorphized_mir_body_for_closure(closure, generic_args, self.trait_env.clone()) .map_err(|it| MirEvalError::MirLowerErrorForClosure(closure, it))?; let closure_data = if mir_body.locals[mir_body.param_locals[0]].ty.as_reference().is_some() { @@ -2572,14 +2525,13 @@ impl<'db> Evaluator<'db> { fn exec_fn_def( &mut self, def: CallableDefId, - generic_args: &Substitution, + generic_args: GenericArgs<'db>, destination: Interval, - args: &[IntervalAndTy], - locals: &Locals, - target_bb: Option<BasicBlockId>, + args: &[IntervalAndTy<'db>], + locals: &Locals<'db>, + target_bb: Option<BasicBlockId<'db>>, span: MirSpan, - ) -> Result<'db, Option<StackFrame>> { - let generic_args = generic_args.clone(); + ) -> Result<'db, Option<StackFrame<'db>>> { match def { CallableDefId::FunctionId(def) => { if self.detect_fn_trait(def).is_some() { @@ -2633,36 +2585,26 @@ impl<'db> Evaluator<'db> { fn get_mir_or_dyn_index( &self, def: FunctionId, - generic_args: Substitution, - locals: &Locals, + generic_args: GenericArgs<'db>, + locals: &Locals<'db>, span: MirSpan, - ) -> Result<'db, MirOrDynIndex> { + ) -> Result<'db, MirOrDynIndex<'db>> { let pair = (def, generic_args); if let Some(r) = self.mir_or_dyn_index_cache.borrow().get(&pair) { return Ok(r.clone()); } let (def, generic_args) = pair; - let r = if let Some(self_ty_idx) = is_dyn_method( - self.interner, - self.trait_env.clone(), - def, - generic_args.to_nextsolver(self.interner), - ) { + let r = if let Some(self_ty_idx) = + is_dyn_method(self.interner(), self.trait_env.clone(), def, generic_args) + { MirOrDynIndex::Dyn(self_ty_idx) } else { - let (imp, generic_args) = self.db.lookup_impl_method( - self.trait_env.clone(), - def, - generic_args.to_nextsolver(self.interner), - ); + let (imp, generic_args) = + self.db.lookup_impl_method(self.trait_env.clone(), def, generic_args); let mir_body = self .db - .monomorphized_mir_body( - imp.into(), - generic_args.to_chalk(self.interner), - self.trait_env.clone(), - ) + .monomorphized_mir_body(imp.into(), generic_args, self.trait_env.clone()) .map_err(|e| { MirEvalError::InFunction( Box::new(MirEvalError::MirLowerError(imp, e)), @@ -2678,18 +2620,17 @@ impl<'db> Evaluator<'db> { fn exec_fn_with_args( &mut self, mut def: FunctionId, - args: &[IntervalAndTy], - generic_args: Substitution, - locals: &Locals, + args: &[IntervalAndTy<'db>], + generic_args: GenericArgs<'db>, + locals: &Locals<'db>, destination: Interval, - target_bb: Option<BasicBlockId>, + target_bb: Option<BasicBlockId<'db>>, span: MirSpan, - ) -> Result<'db, Option<StackFrame>> { - let interner = DbInterner::new_with(self.db, None, None); + ) -> Result<'db, Option<StackFrame<'db>>> { if self.detect_and_exec_special_function( def, args, - &generic_args, + generic_args, locals, destination, span, @@ -2700,7 +2641,7 @@ impl<'db> Evaluator<'db> { def = redirect_def; } let arg_bytes = args.iter().map(|it| IntervalOrOwned::Borrowed(it.interval)); - match self.get_mir_or_dyn_index(def, generic_args.clone(), locals, span)? { + match self.get_mir_or_dyn_index(def, generic_args, locals, span)? { MirOrDynIndex::Dyn(self_ty_idx) => { // In the layout of current possible receiver, which at the moment of writing this code is one of // `&T`, `&mut T`, `Box<T>`, `Rc<T>`, `Arc<T>`, and `Pin<P>` where `P` is one of possible receivers, @@ -2712,18 +2653,16 @@ impl<'db> Evaluator<'db> { .vtable_map .ty_of_bytes(&first_arg[self.ptr_size()..self.ptr_size() * 2])?; let mut args_for_target = args.to_vec(); - let ty = convert_ty_for_result(interner, ty); args_for_target[0] = IntervalAndTy { interval: args_for_target[0].interval.slice(0..self.ptr_size()), - ty: ty.clone(), + ty, }; - let ty = ty.clone().cast(Interner); - let generics_for_target = Substitution::from_iter( - Interner, + let generics_for_target = GenericArgs::new_from_iter( + self.interner(), generic_args - .iter(Interner) + .iter() .enumerate() - .map(|(i, it)| if i == self_ty_idx { &ty } else { it }), + .map(|(i, it)| if i == self_ty_idx { ty.into() } else { it }), ); self.exec_fn_with_args( def, @@ -2749,14 +2688,14 @@ impl<'db> Evaluator<'db> { fn exec_looked_up_function( &mut self, - mir_body: Arc<MirBody>, - locals: &Locals, + mir_body: Arc<MirBody<'db>>, + locals: &Locals<'db>, def: FunctionId, arg_bytes: impl Iterator<Item = IntervalOrOwned>, span: MirSpan, destination: Interval, - target_bb: Option<BasicBlockId>, - ) -> Result<'db, Option<StackFrame>> { + target_bb: Option<BasicBlockId<'db>>, + ) -> Result<'db, Option<StackFrame<'db>>> { Ok(if let Some(target_bb) = target_bb { let (mut locals, prev_stack_ptr) = self.create_locals_for_body(&mir_body, Some(destination))?; @@ -2778,47 +2717,40 @@ impl<'db> Evaluator<'db> { fn exec_fn_trait( &mut self, def: FunctionId, - args: &[IntervalAndTy], - generic_args: Substitution, - locals: &Locals, + args: &[IntervalAndTy<'db>], + generic_args: GenericArgs<'db>, + locals: &Locals<'db>, destination: Interval, - target_bb: Option<BasicBlockId>, + target_bb: Option<BasicBlockId<'db>>, span: MirSpan, - ) -> Result<'db, Option<StackFrame>> { - let interner = DbInterner::new_with(self.db, None, None); + ) -> Result<'db, Option<StackFrame<'db>>> { let func = args .first() .ok_or_else(|| MirEvalError::InternalError("fn trait with no arg".into()))?; - let mut func_ty = func.ty.clone(); + let mut func_ty = func.ty; let mut func_data = func.interval; - while let TyKind::Ref(_, _, z) = func_ty.kind(Interner) { - func_ty = z.clone(); - if matches!(func_ty.kind(Interner), TyKind::Dyn(_)) { + while let TyKind::Ref(_, z, _) = func_ty.kind() { + func_ty = z; + if matches!(func_ty.kind(), TyKind::Dynamic(..)) { let id = from_bytes!(usize, &func_data.get(self)?[self.ptr_size()..self.ptr_size() * 2]); func_data = func_data.slice(0..self.ptr_size()); - func_ty = convert_ty_for_result(interner, self.vtable_map.ty(id)?); + func_ty = self.vtable_map.ty(id)?; } - let size = self.size_of_sized(&func_ty, locals, "self type of fn trait")?; + let size = self.size_of_sized(func_ty, locals, "self type of fn trait")?; func_data = Interval { addr: Address::from_bytes(func_data.get(self)?)?, size }; } - match &func_ty.kind(Interner) { - TyKind::FnDef(def, subst) => self.exec_fn_def( - CallableDefId::from_chalk(self.db, *def), - subst, - destination, - &args[1..], - locals, - target_bb, - span, - ), - TyKind::Function(_) => { + match func_ty.kind() { + TyKind::FnDef(def, subst) => { + self.exec_fn_def(def.0, subst, destination, &args[1..], locals, target_bb, span) + } + TyKind::FnPtr(..) => { self.exec_fn_pointer(func_data, destination, &args[1..], locals, target_bb, span) } TyKind::Closure(closure, subst) => self.exec_closure( - *closure, + closure.0, func_data, - &ClosureSubst(subst).parent_subst(self.db), + subst.split_closure_args_untupled().parent_args, destination, &args[1..], locals, @@ -2829,12 +2761,8 @@ impl<'db> Evaluator<'db> { let arg0 = func; let args = &args[1..]; let arg1 = { - let ty = TyKind::Tuple( - args.len(), - Substitution::from_iter(Interner, args.iter().map(|it| it.ty.clone())), - ) - .intern(Interner); - let layout = self.layout(ty.to_nextsolver(interner))?; + let ty = Ty::new_tup_from_iter(self.interner(), args.iter().map(|it| it.ty)); + let layout = self.layout(ty)?; let result = self.construct_with_layout( layout.size.bytes_usize(), &layout, @@ -2860,7 +2788,7 @@ impl<'db> Evaluator<'db> { } } - fn eval_static(&mut self, st: StaticId, locals: &Locals) -> Result<'db, Address> { + fn eval_static(&mut self, st: StaticId, locals: &Locals<'db>) -> Result<'db, Address> { if let Some(o) = self.static_locations.get(&st) { return Ok(*o); }; @@ -2869,11 +2797,10 @@ impl<'db> Evaluator<'db> { let konst = self.db.const_eval_static(st).map_err(|e| { MirEvalError::ConstEvalError(static_data.name.as_str().to_owned(), Box::new(e)) })?; - self.allocate_const_in_heap(locals, &konst)? + self.allocate_const_in_heap(locals, konst)? } else { - let ty = - self.db.infer(st.into())[self.db.body(st.into()).body_expr].to_chalk(self.interner); - let Some((size, align)) = self.size_align_of(&ty, locals)? else { + let ty = self.db.infer(st.into())[self.db.body(st.into()).body_expr]; + let Some((size, align)) = self.size_align_of(ty, locals)? else { not_supported!("unsized extern static"); }; let addr = self.heap_allocate(size, align)?; @@ -2907,7 +2834,12 @@ impl<'db> Evaluator<'db> { } } - fn drop_place(&mut self, place: &Place, locals: &mut Locals, span: MirSpan) -> Result<'db, ()> { + fn drop_place( + &mut self, + place: &Place<'db>, + locals: &mut Locals<'db>, + span: MirSpan, + ) -> Result<'db, ()> { let (addr, ty, metadata) = self.place_addr_and_ty_and_metadata(place, locals)?; if !locals.drop_flags.remove_place(place, &locals.body.projection_store) { return Ok(()); @@ -2921,8 +2853,8 @@ impl<'db> Evaluator<'db> { fn run_drop_glue_deep( &mut self, - ty: Ty, - locals: &Locals, + ty: Ty<'db>, + locals: &Locals<'db>, addr: Address, _metadata: &[u8], span: MirSpan, @@ -2936,7 +2868,7 @@ impl<'db> Evaluator<'db> { return Ok(()); }; - let generic_args = Substitution::from1(Interner, ty.clone()); + let generic_args = GenericArgs::new_from_iter(self.interner(), [ty.into()]); if let Ok(MirOrDynIndex::Mir(body)) = self.get_mir_or_dyn_index(drop_fn, generic_args, locals, span) { @@ -2950,26 +2882,27 @@ impl<'db> Evaluator<'db> { None, )?; } - match ty.kind(Interner) { - TyKind::Adt(id, subst) => { - match id.0 { + match ty.kind() { + TyKind::Adt(adt_def, subst) => { + let id = adt_def.def_id().0; + match id { AdtId::StructId(s) => { let data = self.db.struct_signature(s); if data.flags.contains(StructFlags::IS_MANUALLY_DROP) { return Ok(()); } - let layout = self.layout_adt(id.0, subst.clone())?; + let layout = self.layout_adt(id, subst)?; let variant_fields = s.fields(self.db); match variant_fields.shape { FieldsShape::Record | FieldsShape::Tuple => { - let field_types = self.db.field_types(s.into()); + let field_types = self.db.field_types_ns(s.into()); for (field, _) in variant_fields.fields().iter() { let offset = layout .fields .offset(u32::from(field.into_raw()) as usize) .bytes_usize(); let addr = addr.offset(offset); - let ty = field_types[field].clone().substitute(Interner, subst); + let ty = field_types[field].instantiate(self.interner(), subst); self.run_drop_glue_deep(ty, locals, addr, &[], span)?; } } @@ -2980,28 +2913,34 @@ impl<'db> Evaluator<'db> { AdtId::EnumId(_) => (), } } - TyKind::AssociatedType(_, _) - | TyKind::Scalar(_) - | TyKind::Tuple(_, _) + TyKind::Bool + | TyKind::Char + | TyKind::Int(_) + | TyKind::Uint(_) + | TyKind::Float(_) + | TyKind::Tuple(_) | TyKind::Array(_, _) | TyKind::Slice(_) - | TyKind::Raw(_, _) + | TyKind::RawPtr(_, _) | TyKind::Ref(_, _, _) - | TyKind::OpaqueType(_, _) + | TyKind::Alias(..) | TyKind::FnDef(_, _) | TyKind::Str | TyKind::Never | TyKind::Closure(_, _) | TyKind::Coroutine(_, _) + | TyKind::CoroutineClosure(..) | TyKind::CoroutineWitness(_, _) | TyKind::Foreign(_) - | TyKind::Error + | TyKind::Error(_) + | TyKind::Param(_) | TyKind::Placeholder(_) - | TyKind::Dyn(_) - | TyKind::Alias(_) - | TyKind::Function(_) - | TyKind::BoundVar(_) - | TyKind::InferenceVar(_, _) => (), + | TyKind::Dynamic(..) + | TyKind::FnPtr(..) + | TyKind::Bound(..) + | TyKind::Infer(..) + | TyKind::Pat(..) + | TyKind::UnsafeBinder(..) => (), }; Ok(()) } @@ -3020,9 +2959,9 @@ impl<'db> Evaluator<'db> { pub fn render_const_using_debug_impl<'db>( db: &'db dyn HirDatabase, owner: DefWithBodyId, - c: &Const, + c: Const<'db>, + ty: Ty<'db>, ) -> Result<'db, String> { - let interner = DbInterner::new_with(db, None, None); let mut evaluator = Evaluator::new(db, owner, false, None)?; let locals = &Locals { ptr: ArenaMap::new(), @@ -3051,12 +2990,11 @@ pub fn render_const_using_debug_impl<'db>( // and its ABI doesn't break yet, we put it in memory manually. let a2 = evaluator.heap_allocate(evaluator.ptr_size() * 2, evaluator.ptr_size())?; evaluator.write_memory(a2, &data.addr.to_bytes())?; - let debug_fmt_fn_ptr = evaluator.vtable_map.id(TyKind::FnDef( - CallableDefId::FunctionId(debug_fmt_fn).to_chalk(db), - Substitution::from1(Interner, c.data(Interner).ty.clone()), - ) - .intern(Interner) - .to_nextsolver(interner)); + let debug_fmt_fn_ptr = evaluator.vtable_map.id(Ty::new_fn_def( + evaluator.interner(), + CallableDefId::FunctionId(debug_fmt_fn).into(), + GenericArgs::new_from_iter(evaluator.interner(), [ty.into()]), + )); evaluator.write_memory(a2.offset(evaluator.ptr_size()), &debug_fmt_fn_ptr.to_le_bytes())?; // a3 = ::core::fmt::Arguments::new_v1(a1, a2) // FIXME: similarly, we should call function here, not directly working with memory. diff --git a/crates/hir-ty/src/mir/eval/shim.rs b/crates/hir-ty/src/mir/eval/shim.rs index 9ef0012a89..c45ae9dcc3 100644 --- a/crates/hir-ty/src/mir/eval/shim.rs +++ b/crates/hir-ty/src/mir/eval/shim.rs @@ -3,32 +3,21 @@ //! use std::cmp::{self, Ordering}; -use chalk_ir::TyKind; -use hir_def::signatures::FunctionSignature; -use hir_def::{ - CrateRootModuleId, - builtin_type::{BuiltinInt, BuiltinUint}, - resolver::HasResolver, -}; +use hir_def::{CrateRootModuleId, resolver::HasResolver, signatures::FunctionSignature}; use hir_expand::name::Name; use intern::{Symbol, sym}; +use rustc_type_ir::inherent::{AdtDef, IntoKind, SliceLike, Ty as _}; use stdx::never; -use crate::next_solver::mapping::NextSolverToChalk; use crate::{ display::DisplayTarget, drop::{DropGlue, has_drop_glue}, - error_lifetime, mir::eval::{ - Address, AdtId, Arc, BuiltinType, Evaluator, FunctionId, HasModule, HirDisplay, - InternedClosure, Interner, Interval, IntervalAndTy, IntervalOrOwned, ItemContainerId, - LangItem, Layout, Locals, Lookup, MirEvalError, MirSpan, Mutability, Result, Substitution, - Ty, TyBuilder, TyExt, pad16, - }, - next_solver::{ - DbInterner, - mapping::{ChalkToNextSolver, convert_ty_for_result}, + Address, AdtId, Arc, Evaluator, FunctionId, GenericArgs, HasModule, HirDisplay, + InternedClosure, Interval, IntervalAndTy, IntervalOrOwned, ItemContainerId, LangItem, + Layout, Locals, Lookup, MirEvalError, MirSpan, Mutability, Result, Ty, TyKind, pad16, }, + next_solver::Region, }; mod simd; @@ -53,9 +42,9 @@ impl<'db> Evaluator<'db> { pub(super) fn detect_and_exec_special_function( &mut self, def: FunctionId, - args: &[IntervalAndTy], - generic_args: &Substitution, - locals: &Locals, + args: &[IntervalAndTy<'db>], + generic_args: GenericArgs<'db>, + locals: &Locals<'db>, destination: Interval, span: MirSpan, ) -> Result<'db, bool> { @@ -118,18 +107,16 @@ impl<'db> Evaluator<'db> { if let ItemContainerId::TraitId(t) = def.lookup(self.db).container && self.db.lang_attr(t.into()) == Some(LangItem::Clone) { - let [self_ty] = generic_args.as_slice(Interner) else { + let [self_ty] = generic_args.as_slice() else { not_supported!("wrong generic arg count for clone"); }; - let Some(self_ty) = self_ty.ty(Interner) else { + let Some(self_ty) = self_ty.ty() else { not_supported!("wrong generic arg kind for clone"); }; // Clone has special impls for tuples and function pointers - if matches!( - self_ty.kind(Interner), - TyKind::Function(_) | TyKind::Tuple(..) | TyKind::Closure(..) - ) { - self.exec_clone(def, args, self_ty.clone(), locals, destination, span)?; + if matches!(self_ty.kind(), TyKind::FnPtr(..) | TyKind::Tuple(..) | TyKind::Closure(..)) + { + self.exec_clone(def, args, self_ty, locals, destination, span)?; return Ok(true); } // Return early to prevent caching clone as non special fn. @@ -161,15 +148,14 @@ impl<'db> Evaluator<'db> { fn exec_clone( &mut self, def: FunctionId, - args: &[IntervalAndTy], - self_ty: Ty, - locals: &Locals, + args: &[IntervalAndTy<'db>], + self_ty: Ty<'db>, + locals: &Locals<'db>, destination: Interval, span: MirSpan, ) -> Result<'db, ()> { - let interner = self.interner; - match self_ty.kind(Interner) { - TyKind::Function(_) => { + match self_ty.kind() { + TyKind::FnPtr(..) => { let [arg] = args else { not_supported!("wrong arg count for clone"); }; @@ -182,30 +168,35 @@ impl<'db> Evaluator<'db> { not_supported!("wrong arg count for clone"); }; let addr = Address::from_bytes(arg.get(self)?)?; - let InternedClosure(closure_owner, _) = self.db.lookup_intern_closure((*id).into()); + let InternedClosure(closure_owner, _) = self.db.lookup_intern_closure(id.0); let infer = self.db.infer(closure_owner); - let (captures, _) = infer.closure_info((*id).into()); - let layout = self.layout(self_ty.to_nextsolver(interner))?; + let (captures, _) = infer.closure_info(id.0); + let layout = self.layout(self_ty)?; let db = self.db; - let ty_iter = captures - .iter() - .map(|c| c.ty(db, subst.to_nextsolver(interner)).to_chalk(interner)); + let ty_iter = captures.iter().map(|c| c.ty(db, subst)); self.exec_clone_for_fields(ty_iter, layout, addr, def, locals, destination, span)?; } - TyKind::Tuple(_, subst) => { + TyKind::Tuple(subst) => { let [arg] = args else { not_supported!("wrong arg count for clone"); }; let addr = Address::from_bytes(arg.get(self)?)?; - let layout = self.layout(self_ty.to_nextsolver(interner))?; - let ty_iter = subst.iter(Interner).map(|ga| ga.assert_ty_ref(Interner).clone()); - self.exec_clone_for_fields(ty_iter, layout, addr, def, locals, destination, span)?; + let layout = self.layout(self_ty)?; + self.exec_clone_for_fields( + subst.iter(), + layout, + addr, + def, + locals, + destination, + span, + )?; } _ => { self.exec_fn_with_args( def, args, - Substitution::from1(Interner, self_ty), + GenericArgs::new_from_iter(self.interner(), [self_ty.into()]), locals, destination, None, @@ -218,21 +209,25 @@ impl<'db> Evaluator<'db> { fn exec_clone_for_fields( &mut self, - ty_iter: impl Iterator<Item = Ty>, + ty_iter: impl Iterator<Item = Ty<'db>>, layout: Arc<Layout>, addr: Address, def: FunctionId, - locals: &Locals, + locals: &Locals<'db>, destination: Interval, span: MirSpan, ) -> Result<'db, ()> { - let interner = DbInterner::new_with(self.db, None, None); for (i, ty) in ty_iter.enumerate() { - let size = self.layout(ty.to_nextsolver(interner))?.size.bytes_usize(); + let size = self.layout(ty)?.size.bytes_usize(); let tmp = self.heap_allocate(self.ptr_size(), self.ptr_size())?; let arg = IntervalAndTy { interval: Interval { addr: tmp, size: self.ptr_size() }, - ty: TyKind::Ref(Mutability::Not, error_lifetime(), ty.clone()).intern(Interner), + ty: Ty::new_ref( + self.interner(), + Region::error(self.interner()), + ty, + Mutability::Not, + ), }; let offset = layout.fields.offset(i).bytes_usize(); self.write_memory(tmp, &addr.offset(offset).to_bytes())?; @@ -251,7 +246,7 @@ impl<'db> Evaluator<'db> { fn exec_alloc_fn( &mut self, alloc_fn: &Symbol, - args: &[IntervalAndTy], + args: &[IntervalAndTy<'db>], destination: Interval, ) -> Result<'db, ()> { match alloc_fn { @@ -313,9 +308,9 @@ impl<'db> Evaluator<'db> { fn exec_lang_item( &mut self, it: LangItem, - generic_args: &Substitution, - args: &[IntervalAndTy], - locals: &Locals, + generic_args: GenericArgs<'db>, + args: &[IntervalAndTy<'db>], + locals: &Locals<'db>, span: MirSpan, ) -> Result<'db, Vec<u8>> { use LangItem::*; @@ -328,7 +323,7 @@ impl<'db> Evaluator<'db> { "argument of BeginPanic is not provided".into(), ))? .clone(); - while let TyKind::Ref(_, _, ty) = arg.ty.kind(Interner) { + while let TyKind::Ref(_, ty, _) = arg.ty.kind() { if ty.is_str() { let (pointee, metadata) = arg.interval.get(self)?.split_at(self.ptr_size()); let len = from_bytes!(usize, metadata); @@ -347,13 +342,10 @@ impl<'db> Evaluator<'db> { let pointee = arg.interval.get(self)?; arg = IntervalAndTy { interval: Interval::new(Address::from_bytes(pointee)?, size), - ty: ty.clone(), + ty, }; } - Err(MirEvalError::Panic(format!( - "unknown-panic-payload: {:?}", - arg.ty.kind(Interner) - ))) + Err(MirEvalError::Panic(format!("unknown-panic-payload: {:?}", arg.ty.kind()))) } SliceLen => { let arg = args.next().ok_or(MirEvalError::InternalError( @@ -364,18 +356,17 @@ impl<'db> Evaluator<'db> { Ok(arg[ptr_size..].into()) } DropInPlace => { - let ty = - generic_args.as_slice(Interner).first().and_then(|it| it.ty(Interner)).ok_or( - MirEvalError::InternalError( - "generic argument of drop_in_place is not provided".into(), - ), - )?; + let ty = generic_args.as_slice().first().and_then(|it| it.ty()).ok_or( + MirEvalError::InternalError( + "generic argument of drop_in_place is not provided".into(), + ), + )?; let arg = args.next().ok_or(MirEvalError::InternalError( "argument of drop_in_place is not provided".into(), ))?; let arg = arg.interval.get(self)?.to_owned(); self.run_drop_glue_deep( - ty.clone(), + ty, locals, Address::from_bytes(&arg[0..self.ptr_size()])?, &arg[self.ptr_size()..], @@ -390,9 +381,9 @@ impl<'db> Evaluator<'db> { fn exec_syscall( &mut self, id: i64, - args: &[IntervalAndTy], + args: &[IntervalAndTy<'db>], destination: Interval, - _locals: &Locals, + _locals: &Locals<'db>, _span: MirSpan, ) -> Result<'db, ()> { match id { @@ -420,10 +411,10 @@ impl<'db> Evaluator<'db> { fn exec_extern_c( &mut self, as_str: &str, - args: &[IntervalAndTy], - _generic_args: &Substitution, + args: &[IntervalAndTy<'db>], + _generic_args: GenericArgs<'db>, destination: Interval, - locals: &Locals, + locals: &Locals<'db>, span: MirSpan, ) -> Result<'db, ()> { match as_str { @@ -586,14 +577,13 @@ impl<'db> Evaluator<'db> { fn exec_intrinsic( &mut self, name: &str, - args: &[IntervalAndTy], - generic_args: &Substitution, + args: &[IntervalAndTy<'db>], + generic_args: GenericArgs<'db>, destination: Interval, - locals: &Locals, + locals: &Locals<'db>, span: MirSpan, needs_override: bool, ) -> Result<'db, bool> { - let interner = DbInterner::new_with(self.db, None, None); if let Some(name) = name.strip_prefix("atomic_") { return self .exec_atomic_intrinsic(name, args, generic_args, destination, locals, span) @@ -751,9 +741,7 @@ impl<'db> Evaluator<'db> { } match name { "size_of" => { - let Some(ty) = - generic_args.as_slice(Interner).first().and_then(|it| it.ty(Interner)) - else { + let Some(ty) = generic_args.as_slice().first().and_then(|it| it.ty()) else { return Err(MirEvalError::InternalError( "size_of generic arg is not provided".into(), )); @@ -764,20 +752,16 @@ impl<'db> Evaluator<'db> { // FIXME: `min_align_of` was renamed to `align_of` in Rust 1.89 // (https://github.com/rust-lang/rust/pull/142410) "min_align_of" | "align_of" => { - let Some(ty) = - generic_args.as_slice(Interner).first().and_then(|it| it.ty(Interner)) - else { + let Some(ty) = generic_args.as_slice().first().and_then(|it| it.ty()) else { return Err(MirEvalError::InternalError( "align_of generic arg is not provided".into(), )); }; - let align = self.layout(ty.to_nextsolver(interner))?.align.bytes(); + let align = self.layout(ty)?.align.bytes(); destination.write_from_bytes(self, &align.to_le_bytes()[0..destination.size]) } "size_of_val" => { - let Some(ty) = - generic_args.as_slice(Interner).first().and_then(|it| it.ty(Interner)) - else { + let Some(ty) = generic_args.as_slice().first().and_then(|it| it.ty()) else { return Err(MirEvalError::InternalError( "size_of_val generic arg is not provided".into(), )); @@ -798,9 +782,7 @@ impl<'db> Evaluator<'db> { // FIXME: `min_align_of_val` was renamed to `align_of_val` in Rust 1.89 // (https://github.com/rust-lang/rust/pull/142410) "min_align_of_val" | "align_of_val" => { - let Some(ty) = - generic_args.as_slice(Interner).first().and_then(|it| it.ty(Interner)) - else { + let Some(ty) = generic_args.as_slice().first().and_then(|it| it.ty()) else { return Err(MirEvalError::InternalError( "align_of_val generic arg is not provided".into(), )); @@ -819,9 +801,7 @@ impl<'db> Evaluator<'db> { } } "type_name" => { - let Some(ty) = - generic_args.as_slice(Interner).first().and_then(|it| it.ty(Interner)) - else { + let Some(ty) = generic_args.as_slice().first().and_then(|it| it.ty()) else { return Err(MirEvalError::InternalError( "type_name generic arg is not provided".into(), )); @@ -848,18 +828,12 @@ impl<'db> Evaluator<'db> { .write_from_bytes(self, &len.to_le_bytes()) } "needs_drop" => { - let Some(ty) = - generic_args.as_slice(Interner).first().and_then(|it| it.ty(Interner)) - else { + let Some(ty) = generic_args.as_slice().first().and_then(|it| it.ty()) else { return Err(MirEvalError::InternalError( "size_of generic arg is not provided".into(), )); }; - let result = match has_drop_glue( - &self.infcx, - ty.to_nextsolver(self.interner), - self.trait_env.clone(), - ) { + let result = match has_drop_glue(&self.infcx, ty, self.trait_env.clone()) { DropGlue::HasDropGlue => true, DropGlue::None => false, DropGlue::DependOnParams => { @@ -922,9 +896,7 @@ impl<'db> Evaluator<'db> { let lhs = i128::from_le_bytes(pad16(lhs.get(self)?, false)); let rhs = i128::from_le_bytes(pad16(rhs.get(self)?, false)); let ans = lhs.wrapping_sub(rhs); - let Some(ty) = - generic_args.as_slice(Interner).first().and_then(|it| it.ty(Interner)) - else { + let Some(ty) = generic_args.as_slice().first().and_then(|it| it.ty()) else { return Err(MirEvalError::InternalError( "ptr_offset_from generic arg is not provided".into(), )); @@ -1013,13 +985,11 @@ impl<'db> Evaluator<'db> { "const_eval_select args are not provided".into(), )); }; - let result_ty = TyKind::Tuple( - 2, - Substitution::from_iter(Interner, [lhs.ty.clone(), TyBuilder::bool()]), - ) - .intern(Interner); - let op_size = - self.size_of_sized(&lhs.ty, locals, "operand of add_with_overflow")?; + let result_ty = Ty::new_tup_from_iter( + self.interner(), + [lhs.ty, Ty::new_bool(self.interner())].into_iter(), + ); + let op_size = self.size_of_sized(lhs.ty, locals, "operand of add_with_overflow")?; let lhs = u128::from_le_bytes(pad16(lhs.get(self)?, false)); let rhs = u128::from_le_bytes(pad16(rhs.get(self)?, false)); let (ans, u128overflow) = match name { @@ -1031,7 +1001,7 @@ impl<'db> Evaluator<'db> { let is_overflow = u128overflow || ans.to_le_bytes()[op_size..].iter().any(|&it| it != 0 && it != 255); let is_overflow = vec![u8::from(is_overflow)]; - let layout = self.layout(result_ty.to_nextsolver(interner))?; + let layout = self.layout(result_ty)?; let result = self.construct_with_layout( layout.size.bytes_usize(), &layout, @@ -1048,9 +1018,7 @@ impl<'db> Evaluator<'db> { "copy_nonoverlapping args are not provided".into(), )); }; - let Some(ty) = - generic_args.as_slice(Interner).first().and_then(|it| it.ty(Interner)) - else { + let Some(ty) = generic_args.as_slice().first().and_then(|it| it.ty()) else { return Err(MirEvalError::InternalError( "copy_nonoverlapping generic arg is not provided".into(), )); @@ -1069,43 +1037,35 @@ impl<'db> Evaluator<'db> { return Err(MirEvalError::InternalError("offset args are not provided".into())); }; let ty = if name == "offset" { - let Some(ty0) = - generic_args.as_slice(Interner).first().and_then(|it| it.ty(Interner)) - else { + let Some(ty0) = generic_args.as_slice().first().and_then(|it| it.ty()) else { return Err(MirEvalError::InternalError( "offset generic arg is not provided".into(), )); }; - let Some(ty1) = - generic_args.as_slice(Interner).get(1).and_then(|it| it.ty(Interner)) - else { + let Some(ty1) = generic_args.as_slice().get(1).and_then(|it| it.ty()) else { return Err(MirEvalError::InternalError( "offset generic arg is not provided".into(), )); }; if !matches!( - ty1.as_builtin(), - Some( - BuiltinType::Int(BuiltinInt::Isize) - | BuiltinType::Uint(BuiltinUint::Usize) - ) + ty1.kind(), + TyKind::Int(rustc_type_ir::IntTy::Isize) + | TyKind::Uint(rustc_type_ir::UintTy::Usize) ) { return Err(MirEvalError::InternalError( "offset generic arg is not usize or isize".into(), )); } - match ty0.as_raw_ptr() { - Some((ty, _)) => ty, - None => { + match ty0.kind() { + TyKind::RawPtr(ty, _) => ty, + _ => { return Err(MirEvalError::InternalError( "offset generic arg is not a raw pointer".into(), )); } } } else { - let Some(ty) = - generic_args.as_slice(Interner).first().and_then(|it| it.ty(Interner)) - else { + let Some(ty) = generic_args.as_slice().first().and_then(|it| it.ty()) else { return Err(MirEvalError::InternalError( "arith_offset generic arg is not provided".into(), )); @@ -1230,9 +1190,7 @@ impl<'db> Evaluator<'db> { "discriminant_value arg is not provided".into(), )); }; - let Some(ty) = - generic_args.as_slice(Interner).first().and_then(|it| it.ty(Interner)) - else { + let Some(ty) = generic_args.as_slice().first().and_then(|it| it.ty()) else { return Err(MirEvalError::InternalError( "discriminant_value generic arg is not provided".into(), )); @@ -1240,7 +1198,7 @@ impl<'db> Evaluator<'db> { let addr = Address::from_bytes(arg.get(self)?)?; let size = self.size_of_sized(ty, locals, "discriminant_value ptr type")?; let interval = Interval { addr, size }; - let r = self.compute_discriminant(ty.clone(), interval.get(self)?)?; + let r = self.compute_discriminant(ty, interval.get(self)?)?; destination.write_from_bytes(self, &r.to_le_bytes()[0..destination.size]) } "const_eval_select" => { @@ -1250,14 +1208,13 @@ impl<'db> Evaluator<'db> { )); }; let mut args = vec![const_fn.clone()]; - let TyKind::Tuple(_, fields) = tuple.ty.kind(Interner) else { + let TyKind::Tuple(fields) = tuple.ty.kind() else { return Err(MirEvalError::InternalError( "const_eval_select arg[0] is not a tuple".into(), )); }; - let layout = self.layout(tuple.ty.to_nextsolver(interner))?; - for (i, field) in fields.iter(Interner).enumerate() { - let field = field.assert_ty_ref(Interner).clone(); + let layout = self.layout(tuple.ty)?; + for (i, field) in fields.iter().enumerate() { let offset = layout.fields.offset(i).bytes_usize(); let addr = tuple.interval.addr.offset(offset); args.push(IntervalAndTy::new(addr, field, self, locals)?); @@ -1271,7 +1228,7 @@ impl<'db> Evaluator<'db> { def, &args, // FIXME: wrong for manual impls of `FnOnce` - Substitution::empty(Interner), + GenericArgs::new_from_iter(self.interner(), []), locals, destination, None, @@ -1297,9 +1254,7 @@ impl<'db> Evaluator<'db> { )); }; let dst = Address::from_bytes(ptr.get(self)?)?; - let Some(ty) = - generic_args.as_slice(Interner).first().and_then(|it| it.ty(Interner)) - else { + let Some(ty) = generic_args.as_slice().first().and_then(|it| it.ty()) else { return Err(MirEvalError::InternalError( "write_via_copy generic arg is not provided".into(), )); @@ -1316,9 +1271,7 @@ impl<'db> Evaluator<'db> { }; let count = from_bytes!(usize, count.get(self)?); let val = from_bytes!(u8, val.get(self)?); - let Some(ty) = - generic_args.as_slice(Interner).first().and_then(|it| it.ty(Interner)) - else { + let Some(ty) = generic_args.as_slice().first().and_then(|it| it.ty()) else { return Err(MirEvalError::InternalError( "write_bytes generic arg is not provided".into(), )); @@ -1346,16 +1299,14 @@ impl<'db> Evaluator<'db> { "three_way_compare args are not provided".into(), )); }; - let Some(ty) = - generic_args.as_slice(Interner).first().and_then(|it| it.ty(Interner)) - else { + let Some(ty) = generic_args.as_slice().first().and_then(|it| it.ty()) else { return Err(MirEvalError::InternalError( "three_way_compare generic arg is not provided".into(), )); }; - let signed = match ty.as_builtin().unwrap() { - BuiltinType::Int(_) => true, - BuiltinType::Uint(_) => false, + let signed = match ty.kind() { + TyKind::Int(_) => true, + TyKind::Uint(_) => false, _ => { return Err(MirEvalError::InternalError( "three_way_compare expects an integral type".into(), @@ -1379,8 +1330,8 @@ impl<'db> Evaluator<'db> { result = (l as i8).cmp(&(r as i8)); } if let Some(e) = LangItem::Ordering.resolve_enum(self.db, self.crate_id) { - let ty = self.db.ty(e.into()).skip_binder().to_chalk(interner); - let r = self.compute_discriminant(ty.clone(), &[result as i8 as u8])?; + let ty = self.db.ty(e.into()).skip_binder(); + let r = self.compute_discriminant(ty, &[result as i8 as u8])?; destination.write_from_bytes(self, &r.to_le_bytes()[0..destination.size])?; Ok(()) } else { @@ -1409,38 +1360,37 @@ impl<'db> Evaluator<'db> { fn size_align_of_unsized( &mut self, - ty: &Ty, + ty: Ty<'db>, metadata: Interval, - locals: &Locals, + locals: &Locals<'db>, ) -> Result<'db, (usize, usize)> { - let interner = DbInterner::new_with(self.db, None, None); - Ok(match ty.kind(Interner) { + Ok(match ty.kind() { TyKind::Str => (from_bytes!(usize, metadata.get(self)?), 1), TyKind::Slice(inner) => { let len = from_bytes!(usize, metadata.get(self)?); let (size, align) = self.size_align_of_sized(inner, locals, "slice inner type")?; (size * len, align) } - TyKind::Dyn(_) => self.size_align_of_sized( - &convert_ty_for_result(interner, self.vtable_map.ty_of_bytes(metadata.get(self)?)?), + TyKind::Dynamic(..) => self.size_align_of_sized( + self.vtable_map.ty_of_bytes(metadata.get(self)?)?, locals, "dyn concrete type", )?, - TyKind::Adt(id, subst) => { - let id = id.0; - let layout = self.layout_adt(id, subst.clone())?; + TyKind::Adt(adt_def, subst) => { + let id = adt_def.def_id().0; + let layout = self.layout_adt(id, subst)?; let id = match id { AdtId::StructId(s) => s, _ => not_supported!("unsized enum or union"), }; - let field_types = &self.db.field_types(id.into()); + let field_types = self.db.field_types_ns(id.into()); let last_field_ty = - field_types.iter().next_back().unwrap().1.clone().substitute(Interner, subst); + field_types.iter().next_back().unwrap().1.instantiate(self.interner(), subst); let sized_part_size = layout.fields.offset(field_types.iter().count() - 1).bytes_usize(); let sized_part_align = layout.align.bytes() as usize; let (unsized_part_size, unsized_part_align) = - self.size_align_of_unsized(&last_field_ty, metadata, locals)?; + self.size_align_of_unsized(last_field_ty, metadata, locals)?; let align = sized_part_align.max(unsized_part_align) as isize; let size = (sized_part_size + unsized_part_size) as isize; // Must add any necessary padding to `size` @@ -1463,13 +1413,12 @@ impl<'db> Evaluator<'db> { fn exec_atomic_intrinsic( &mut self, name: &str, - args: &[IntervalAndTy], - generic_args: &Substitution, + args: &[IntervalAndTy<'db>], + generic_args: GenericArgs<'db>, destination: Interval, - locals: &Locals, + locals: &Locals<'db>, _span: MirSpan, ) -> Result<'db, ()> { - let interner = DbInterner::new_with(self.db, None, None); // We are a single threaded runtime with no UB checking and no optimization, so // we can implement atomic intrinsics as normal functions. @@ -1479,8 +1428,7 @@ impl<'db> Evaluator<'db> { // The rest of atomic intrinsics have exactly one generic arg - let Some(ty) = generic_args.as_slice(Interner).first().and_then(|it| it.ty(Interner)) - else { + let Some(ty) = generic_args.as_slice().first().and_then(|it| it.ty()) else { return Err(MirEvalError::InternalError( "atomic intrinsic generic arg is not provided".into(), )); @@ -1562,12 +1510,11 @@ impl<'db> Evaluator<'db> { } else { (arg0_interval, false) }; - let result_ty = TyKind::Tuple( - 2, - Substitution::from_iter(Interner, [ty.clone(), TyBuilder::bool()]), - ) - .intern(Interner); - let layout = self.layout(result_ty.to_nextsolver(interner))?; + let result_ty = Ty::new_tup_from_iter( + self.interner(), + [ty, Ty::new_bool(self.interner())].into_iter(), + ); + let layout = self.layout(result_ty)?; let result = self.construct_with_layout( layout.size.bytes_usize(), &layout, diff --git a/crates/hir-ty/src/mir/eval/shim/simd.rs b/crates/hir-ty/src/mir/eval/shim/simd.rs index 8e62c764b9..ade94b94c0 100644 --- a/crates/hir-ty/src/mir/eval/shim/simd.rs +++ b/crates/hir-ty/src/mir/eval/shim/simd.rs @@ -2,7 +2,6 @@ use std::cmp::Ordering; -use crate::TyKind; use crate::consteval::try_const_usize; use super::*; @@ -23,22 +22,20 @@ macro_rules! not_supported { } impl<'db> Evaluator<'db> { - fn detect_simd_ty(&self, ty: &Ty) -> Result<'db, (usize, Ty)> { - match ty.kind(Interner) { - TyKind::Adt(id, subst) => { - let len = match subst.as_slice(Interner).get(1).and_then(|it| it.constant(Interner)) - { + fn detect_simd_ty(&self, ty: Ty<'db>) -> Result<'db, (usize, Ty<'db>)> { + match ty.kind() { + TyKind::Adt(adt_def, subst) => { + let len = match subst.as_slice().get(1).and_then(|it| it.konst()) { Some(len) => len, _ => { - if let AdtId::StructId(id) = id.0 { + if let AdtId::StructId(id) = adt_def.def_id().0 { let struct_data = id.fields(self.db); let fields = struct_data.fields(); let Some((first_field, _)) = fields.iter().next() else { not_supported!("simd type with no field"); }; - let field_ty = self.db.field_types(id.into())[first_field] - .clone() - .substitute(Interner, subst); + let field_ty = self.db.field_types_ns(id.into())[first_field] + .instantiate(self.interner(), subst); return Ok((fields.len(), field_ty)); } return Err(MirEvalError::InternalError( @@ -48,14 +45,12 @@ impl<'db> Evaluator<'db> { }; match try_const_usize(self.db, len) { Some(len) => { - let Some(ty) = - subst.as_slice(Interner).first().and_then(|it| it.ty(Interner)) - else { + let Some(ty) = subst.as_slice().first().and_then(|it| it.ty()) else { return Err(MirEvalError::InternalError( "simd type with no ty param".into(), )); }; - Ok((len as usize, ty.clone())) + Ok((len as usize, ty)) } None => Err(MirEvalError::InternalError( "simd type with unevaluatable len param".into(), @@ -69,10 +64,10 @@ impl<'db> Evaluator<'db> { pub(super) fn exec_simd_intrinsic( &mut self, name: &str, - args: &[IntervalAndTy], - _generic_args: &Substitution, + args: &[IntervalAndTy<'db>], + _generic_args: GenericArgs<'db>, destination: Interval, - _locals: &Locals, + _locals: &Locals<'db>, _span: MirSpan, ) -> Result<'db, ()> { match name { @@ -99,8 +94,8 @@ impl<'db> Evaluator<'db> { let [left, right] = args else { return Err(MirEvalError::InternalError("simd args are not provided".into())); }; - let (len, ty) = self.detect_simd_ty(&left.ty)?; - let is_signed = matches!(ty.as_builtin(), Some(BuiltinType::Int(_))); + let (len, ty) = self.detect_simd_ty(left.ty)?; + let is_signed = matches!(ty.kind(), TyKind::Int(_)); let size = left.interval.size / len; let dest_size = destination.size / len; let mut destination_bytes = vec![]; @@ -137,7 +132,7 @@ impl<'db> Evaluator<'db> { "simd_bitmask args are not provided".into(), )); }; - let (op_len, _) = self.detect_simd_ty(&op.ty)?; + let (op_len, _) = self.detect_simd_ty(op.ty)?; let op_count = op.interval.size / op_len; let mut result: u64 = 0; for (i, val) in op.get(self)?.chunks(op_count).enumerate() { @@ -153,7 +148,7 @@ impl<'db> Evaluator<'db> { "simd_shuffle args are not provided".into(), )); }; - let TyKind::Array(_, index_len) = index.ty.kind(Interner) else { + let TyKind::Array(_, index_len) = index.ty.kind() else { return Err(MirEvalError::InternalError( "simd_shuffle index argument has non-array type".into(), )); @@ -166,7 +161,7 @@ impl<'db> Evaluator<'db> { )); } }; - let (left_len, _) = self.detect_simd_ty(&left.ty)?; + let (left_len, _) = self.detect_simd_ty(left.ty)?; let left_size = left.interval.size / left_len; let vector = left.get(self)?.chunks(left_size).chain(right.get(self)?.chunks(left_size)); diff --git a/crates/hir-ty/src/mir/eval/tests.rs b/crates/hir-ty/src/mir/eval/tests.rs index 82c0a8070c..4eb4aa9159 100644 --- a/crates/hir-ty/src/mir/eval/tests.rs +++ b/crates/hir-ty/src/mir/eval/tests.rs @@ -4,15 +4,20 @@ use span::Edition; use syntax::{TextRange, TextSize}; use test_fixture::WithFixture; -use crate::display::DisplayTarget; use crate::{ - Interner, Substitution, db::HirDatabase, mir::MirLowerError, setup_tracing, test_db::TestDB, + db::HirDatabase, + display::DisplayTarget, + mir::MirLowerError, + next_solver::{DbInterner, GenericArgs}, + setup_tracing, + test_db::TestDB, }; use super::{MirEvalError, interpret_mir}; fn eval_main(db: &TestDB, file_id: EditionedFileId) -> Result<(String, String), MirEvalError<'_>> { crate::attach_db(db, || { + let interner = DbInterner::new_with(db, None, None); let module_id = db.module_for_file(file_id.file_id(db)); let def_map = module_id.def_map(db); let scope = &def_map[module_id.local_id].scope; @@ -34,7 +39,7 @@ fn eval_main(db: &TestDB, file_id: EditionedFileId) -> Result<(String, String), let body = db .monomorphized_mir_body( func_id.into(), - Substitution::empty(Interner), + GenericArgs::new_from_iter(interner, []), db.trait_environment(func_id.into()), ) .map_err(|e| MirEvalError::MirLowerError(func_id, e))?; @@ -631,11 +636,16 @@ fn main() { ); } +#[ignore = " +FIXME(next-solver): +This does not work currently because I replaced homemade selection with selection by the trait solver; +This will work once we implement `Interner::impl_specializes()` properly. +"] #[test] fn specialization_array_clone() { check_pass( r#" -//- minicore: copy, derive, slice, index, coerce_unsized +//- minicore: copy, derive, slice, index, coerce_unsized, panic impl<T: Clone, const N: usize> Clone for [T; N] { #[inline] fn clone(&self) -> Self { @@ -650,8 +660,7 @@ trait SpecArrayClone: Clone { impl<T: Clone> SpecArrayClone for T { #[inline] default fn clone<const N: usize>(array: &[T; N]) -> [T; N] { - // FIXME: panic here when we actually implement specialization. - from_slice(array) + panic!("should go to the specialized impl") } } diff --git a/crates/hir-ty/src/mir/lower.rs b/crates/hir-ty/src/mir/lower.rs index ec7bff7082..92f9cd4261 100644 --- a/crates/hir-ty/src/mir/lower.rs +++ b/crates/hir-ty/src/mir/lower.rs @@ -3,10 +3,9 @@ use std::{fmt::Write, iter, mem}; use base_db::Crate; -use chalk_ir::{BoundVar, ConstData, DebruijnIndex, TyKind}; use hir_def::{ - AdtId, DefWithBodyId, EnumVariantId, GeneralConstId, HasModule, ItemContainerId, LocalFieldId, - Lookup, TraitId, TupleId, TypeOrConstParamId, + AdtId, DefWithBodyId, EnumVariantId, GeneralConstId, GenericParamId, HasModule, + ItemContainerId, LocalFieldId, Lookup, TraitId, TupleId, expr_store::{Body, ExpressionStore, HygieneId, path::Path}, hir::{ ArithOp, Array, BinaryOp, BindingAnnotation, BindingId, ExprId, LabelId, Literal, MatchArm, @@ -20,37 +19,33 @@ use hir_expand::name::Name; use la_arena::ArenaMap; use rustc_apfloat::Float; use rustc_hash::FxHashMap; -use rustc_type_ir::inherent::IntoKind; +use rustc_type_ir::inherent::{Const as _, IntoKind, SliceLike, Ty as _}; use span::{Edition, FileId}; use syntax::TextRange; use triomphe::Arc; use crate::{ - Adjust, Adjustment, AutoBorrow, CallableDefId, TraitEnvironment, TyBuilder, TyExt, + Adjust, Adjustment, AutoBorrow, CallableDefId, TraitEnvironment, consteval::ConstEvalError, db::{HirDatabase, InternedClosure, InternedClosureId}, display::{DisplayTarget, HirDisplay, hir_display_with_store}, - error_lifetime, generics::generics, infer::{CaptureKind, CapturedItem, TypeMismatch, cast::CastTy}, inhabitedness::is_ty_uninhabited_from, layout::LayoutError, - mapping::ToChalk, mir::{ - AggregateKind, Arena, BasicBlock, BasicBlockId, BinOp, BorrowKind, CastKind, ConstScalar, - Either, Expr, FieldId, Idx, InferenceResult, Interner, Local, LocalId, MemoryMap, MirBody, - MirSpan, Mutability, Operand, Place, PlaceElem, PointerCast, ProjectionElem, - ProjectionStore, RawIdx, Rvalue, Statement, StatementKind, Substitution, SwitchTargets, - Terminator, TerminatorKind, TupleFieldId, Ty, UnOp, VariantId, intern_const_scalar, - return_slot, + AggregateKind, Arena, BasicBlock, BasicBlockId, BinOp, BorrowKind, CastKind, Either, Expr, + FieldId, GenericArgs, Idx, InferenceResult, Local, LocalId, MemoryMap, MirBody, MirSpan, + Mutability, Operand, Place, PlaceElem, PointerCast, ProjectionElem, ProjectionStore, + RawIdx, Rvalue, Statement, StatementKind, SwitchTargets, Terminator, TerminatorKind, + TupleFieldId, Ty, UnOp, VariantId, return_slot, }, next_solver::{ - DbInterner, - mapping::{ChalkToNextSolver, NextSolverToChalk}, + Const, DbInterner, ParamConst, Region, TyKind, TypingMode, UnevaluatedConst, + infer::{DbInternerInferExt, InferCtxt}, + mapping::NextSolverToChalk, }, - static_lifetime, traits::FnTrait, - utils::ClosureSubst, }; use super::OperandKind; @@ -61,33 +56,33 @@ mod pattern_matching; mod tests; #[derive(Debug, Clone)] -struct LoopBlocks { - begin: BasicBlockId, +struct LoopBlocks<'db> { + begin: BasicBlockId<'db>, /// `None` for loops that are not terminating - end: Option<BasicBlockId>, - place: Place, + end: Option<BasicBlockId<'db>>, + place: Place<'db>, drop_scope_index: usize, } #[derive(Debug, Clone, Default)] -struct DropScope { +struct DropScope<'db> { /// locals, in order of definition (so we should run drop glues in reverse order) - locals: Vec<LocalId>, + locals: Vec<LocalId<'db>>, } struct MirLowerCtx<'a, 'db> { - result: MirBody, + result: MirBody<'db>, owner: DefWithBodyId, - current_loop_blocks: Option<LoopBlocks>, - labeled_loop_blocks: FxHashMap<LabelId, LoopBlocks>, - discr_temp: Option<Place>, + current_loop_blocks: Option<LoopBlocks<'db>>, + labeled_loop_blocks: FxHashMap<LabelId, LoopBlocks<'db>>, + discr_temp: Option<Place<'db>>, db: &'db dyn HirDatabase, body: &'a Body, infer: &'a InferenceResult<'db>, resolver: Resolver<'db>, - drop_scopes: Vec<DropScope>, + drop_scopes: Vec<DropScope<'db>>, env: Arc<TraitEnvironment<'db>>, - interner: DbInterner<'db>, + infcx: InferCtxt<'db>, } // FIXME: Make this smaller, its stored in database queries @@ -103,7 +98,7 @@ pub enum MirLowerError<'db> { RecordLiteralWithoutPath, UnresolvedMethod(String), UnresolvedField, - UnsizedTemporary(Ty), + UnsizedTemporary(Ty<'db>), MissingFunctionDefinition(DefWithBodyId, ExprId), TypeMismatch(TypeMismatch<'db>), HasErrors, @@ -118,22 +113,22 @@ pub enum MirLowerError<'db> { LangItemNotFound(LangItem), MutatingRvalue, UnresolvedLabel, - UnresolvedUpvar(Place), + UnresolvedUpvar(Place<'db>), InaccessibleLocal, // monomorphization errors: - GenericArgNotProvided(TypeOrConstParamId, Substitution), + GenericArgNotProvided(GenericParamId, GenericArgs<'db>), } /// A token to ensuring that each drop scope is popped at most once, thanks to the compiler that checks moves. struct DropScopeToken; impl DropScopeToken { - fn pop_and_drop( + fn pop_and_drop<'db>( self, - ctx: &mut MirLowerCtx<'_, '_>, - current: BasicBlockId, + ctx: &mut MirLowerCtx<'_, 'db>, + current: BasicBlockId<'db>, span: MirSpan, - ) -> BasicBlockId { + ) -> BasicBlockId<'db> { std::mem::forget(self); ctx.pop_drop_scope_internal(current, span) } @@ -199,15 +194,24 @@ impl MirLowerError<'_> { e.actual.display(db, display_target), )?, MirLowerError::GenericArgNotProvided(id, subst) => { - let parent = id.parent; - let param = &db.generic_params(parent)[id.local_id]; + let param_name = match *id { + GenericParamId::TypeParamId(id) => { + db.generic_params(id.parent())[id.local_id()].name().cloned() + } + GenericParamId::ConstParamId(id) => { + db.generic_params(id.parent())[id.local_id()].name().cloned() + } + GenericParamId::LifetimeParamId(id) => { + Some(db.generic_params(id.parent)[id.local_id].name.clone()) + } + }; writeln!( f, "Generic arg not provided for {}", - param.name().unwrap_or(&Name::missing()).display(db, display_target.edition) + param_name.unwrap_or(Name::missing()).display(db, display_target.edition) )?; writeln!(f, "Provided args: [")?; - for g in subst.iter(Interner) { + for g in subst.iter() { write!(f, " {},", g.display(db, display_target))?; } writeln!(f, "]")?; @@ -285,7 +289,7 @@ impl<'a, 'db> MirLowerCtx<'a, 'db> { is_cleanup: false, }); let locals = Arena::new(); - let binding_locals: ArenaMap<BindingId, LocalId> = ArenaMap::new(); + let binding_locals: ArenaMap<BindingId, LocalId<'db>> = ArenaMap::new(); let mir = MirBody { projection_store: ProjectionStore::default(), basic_blocks, @@ -299,6 +303,7 @@ impl<'a, 'db> MirLowerCtx<'a, 'db> { let resolver = owner.resolver(db); let env = db.trait_environment_for_body(owner); let interner = DbInterner::new_with(db, Some(env.krate), env.block); + let infcx = interner.infer_ctxt().build(TypingMode::non_body_analysis()); MirLowerCtx { result: mir, @@ -312,12 +317,22 @@ impl<'a, 'db> MirLowerCtx<'a, 'db> { discr_temp: None, drop_scopes: vec![DropScope::default()], env, - interner, + infcx, } } - fn temp(&mut self, ty: Ty, current: BasicBlockId, span: MirSpan) -> Result<'db, LocalId> { - if matches!(ty.kind(Interner), TyKind::Slice(_) | TyKind::Dyn(_)) { + #[inline] + fn interner(&self) -> DbInterner<'db> { + self.infcx.interner + } + + fn temp( + &mut self, + ty: Ty<'db>, + current: BasicBlockId<'db>, + span: MirSpan, + ) -> Result<'db, LocalId<'db>> { + if matches!(ty.kind(), TyKind::Slice(_) | TyKind::Dynamic(..)) { return Err(MirLowerError::UnsizedTemporary(ty)); } let l = self.result.locals.alloc(Local { ty }); @@ -328,8 +343,8 @@ impl<'a, 'db> MirLowerCtx<'a, 'db> { fn lower_expr_to_some_operand( &mut self, expr_id: ExprId, - current: BasicBlockId, - ) -> Result<'db, Option<(Operand, BasicBlockId)>> { + current: BasicBlockId<'db>, + ) -> Result<'db, Option<(Operand<'db>, BasicBlockId<'db>)>> { if !self.has_adjustments(expr_id) && let Expr::Literal(l) = &self.body[expr_id] { @@ -345,15 +360,18 @@ impl<'a, 'db> MirLowerCtx<'a, 'db> { fn lower_expr_to_place_with_adjust( &mut self, expr_id: ExprId, - place: Place, - current: BasicBlockId, + place: Place<'db>, + current: BasicBlockId<'db>, adjustments: &[Adjustment<'db>], - ) -> Result<'db, Option<BasicBlockId>> { + ) -> Result<'db, Option<BasicBlockId<'db>>> { match adjustments.split_last() { Some((last, rest)) => match &last.kind { Adjust::NeverToAny => { - let temp = - self.temp(TyKind::Never.intern(Interner), current, MirSpan::Unknown)?; + let temp = self.temp( + Ty::new(self.interner(), TyKind::Never), + current, + MirSpan::Unknown, + )?; self.lower_expr_to_place_with_adjust(expr_id, temp.into(), current, rest) } Adjust::Deref(_) => { @@ -392,7 +410,7 @@ impl<'a, 'db> MirLowerCtx<'a, 'db> { Rvalue::Cast( CastKind::PointerCoercion(*cast), Operand { kind: OperandKind::Copy(p), span: None }, - last.target.to_chalk(self.interner), + last.target, ), expr_id.into(), ); @@ -406,9 +424,9 @@ impl<'a, 'db> MirLowerCtx<'a, 'db> { fn lower_expr_to_place( &mut self, expr_id: ExprId, - place: Place, - prev_block: BasicBlockId, - ) -> Result<'db, Option<BasicBlockId>> { + place: Place<'db>, + prev_block: BasicBlockId<'db>, + ) -> Result<'db, Option<BasicBlockId<'db>>> { if let Some(adjustments) = self.infer.expr_adjustments.get(&expr_id) { return self.lower_expr_to_place_with_adjust(expr_id, place, prev_block, adjustments); } @@ -418,9 +436,9 @@ impl<'a, 'db> MirLowerCtx<'a, 'db> { fn lower_expr_to_place_without_adjust( &mut self, expr_id: ExprId, - place: Place, - mut current: BasicBlockId, - ) -> Result<'db, Option<BasicBlockId>> { + place: Place<'db>, + mut current: BasicBlockId<'db>, + ) -> Result<'db, Option<BasicBlockId<'db>>> { match &self.body[expr_id] { Expr::OffsetOf(_) => { not_supported!("builtin#offset_of") @@ -443,14 +461,7 @@ impl<'a, 'db> MirLowerCtx<'a, 'db> { if let Some((assoc, subst)) = self.infer.assoc_resolutions_for_expr(expr_id) { match assoc { hir_def::AssocItemId::ConstId(c) => { - self.lower_const( - c.into(), - current, - place, - subst.to_chalk(self.interner), - expr_id.into(), - self.expr_ty_without_adjust(expr_id), - )?; + self.lower_const(c.into(), current, place, subst, expr_id.into())?; return Ok(Some(current)); } hir_def::AssocItemId::FunctionId(_) => { @@ -506,9 +517,8 @@ impl<'a, 'db> MirLowerCtx<'a, 'db> { const_id.into(), current, place, - Substitution::empty(Interner), + GenericArgs::new_from_iter(self.interner(), []), expr_id.into(), - self.expr_ty_without_adjust(expr_id), )?; Ok(Some(current)) } @@ -520,7 +530,7 @@ impl<'a, 'db> MirLowerCtx<'a, 'db> { variant_id, current, place, - ty.to_chalk(self.interner), + ty, Box::new([]), expr_id.into(), )?; @@ -533,25 +543,21 @@ impl<'a, 'db> MirLowerCtx<'a, 'db> { not_supported!("owner without generic def id"); }; let generics = generics(self.db, def); - let ty = self.expr_ty_without_adjust(expr_id); + let index = generics + .type_or_const_param_idx(p.into()) + .ok_or(MirLowerError::TypeError("fail to lower const generic param"))? + as u32; self.push_assignment( current, place, Rvalue::from(Operand { - kind: OperandKind::Constant( - ConstData { - ty, - value: chalk_ir::ConstValue::BoundVar(BoundVar::new( - DebruijnIndex::INNERMOST, - generics.type_or_const_param_idx(p.into()).ok_or( - MirLowerError::TypeError( - "fail to lower const generic param", - ), - )?, - )), - } - .intern(Interner), - ), + kind: OperandKind::Constant { + konst: Const::new_param( + self.interner(), + ParamConst { id: p, index }, + ), + ty: self.db.const_param_ty_ns(p), + }, span: None, }), expr_id.into(), @@ -603,7 +609,7 @@ impl<'a, 'db> MirLowerCtx<'a, 'db> { then_target, place, Box::new([1]), - TyBuilder::bool(), + Ty::new_bool(self.interner()), MirSpan::Unknown, )?; if let Some(else_target) = else_target { @@ -611,7 +617,7 @@ impl<'a, 'db> MirLowerCtx<'a, 'db> { else_target, place, Box::new([0]), - TyBuilder::bool(), + Ty::new_bool(self.interner()), MirSpan::Unknown, )?; } @@ -653,11 +659,11 @@ impl<'a, 'db> MirLowerCtx<'a, 'db> { } Expr::Call { callee, args, .. } => { if let Some((func_id, generic_args)) = self.infer.method_resolution(expr_id) { - let ty = chalk_ir::TyKind::FnDef( - CallableDefId::FunctionId(func_id).to_chalk(self.db), - generic_args.to_chalk(self.interner), - ) - .intern(Interner); + let ty = Ty::new_fn_def( + self.interner(), + CallableDefId::FunctionId(func_id).into(), + generic_args, + ); let func = Operand::from_bytes(Box::default(), ty); return self.lower_call_and_args( func, @@ -669,9 +675,9 @@ impl<'a, 'db> MirLowerCtx<'a, 'db> { ); } let callee_ty = self.expr_ty_after_adjustments(*callee); - match &callee_ty.kind(Interner) { - chalk_ir::TyKind::FnDef(..) => { - let func = Operand::from_bytes(Box::default(), callee_ty.clone()); + match callee_ty.kind() { + TyKind::FnDef(..) => { + let func = Operand::from_bytes(Box::default(), callee_ty); self.lower_call_and_args( func, args.iter().copied(), @@ -681,7 +687,7 @@ impl<'a, 'db> MirLowerCtx<'a, 'db> { expr_id.into(), ) } - chalk_ir::TyKind::Function(_) => { + TyKind::FnPtr(..) => { let Some((func, current)) = self.lower_expr_to_some_operand(*callee, current)? else { @@ -701,7 +707,7 @@ impl<'a, 'db> MirLowerCtx<'a, 'db> { "method resolution not emitted for closure (Are Fn traits available?)" ); } - TyKind::Error => { + TyKind::Error(_) => { Err(MirLowerError::MissingFunctionDefinition(self.owner, expr_id)) } _ => Err(MirLowerError::TypeError("function call on bad type")), @@ -714,7 +720,7 @@ impl<'a, 'db> MirLowerCtx<'a, 'db> { method_name.display(self.db, self.edition()).to_string(), ) })?; - let func = Operand::from_fn(self.db, func_id, generic_args.to_chalk(self.interner)); + let func = Operand::from_fn(self.db, func_id, generic_args); self.lower_call_and_args( func, iter::once(*receiver).chain(args.iter().copied()), @@ -862,8 +868,8 @@ impl<'a, 'db> MirLowerCtx<'a, 'db> { ), None => MirLowerError::RecordLiteralWithoutPath, })?; - let subst = match self.expr_ty_without_adjust(expr_id).kind(Interner) { - TyKind::Adt(_, s) => s.clone(), + let subst = match self.expr_ty_without_adjust(expr_id).kind() { + TyKind::Adt(_, s) => s, _ => not_supported!("Non ADT record literal"), }; let variant_fields = variant_id.fields(self.db); @@ -952,12 +958,12 @@ impl<'a, 'db> MirLowerCtx<'a, 'db> { let rvalue = if self.infer.coercion_casts.contains(expr) { Rvalue::Use(it) } else { - let source_ty = self.infer[*expr].to_chalk(self.interner); - let target_ty = self.infer[expr_id].to_chalk(self.interner); + let source_ty = self.infer[*expr]; + let target_ty = self.infer[expr_id]; let cast_kind = if source_ty.as_reference().is_some() { CastKind::PointerCoercion(PointerCast::ArrayToPointer) } else { - cast_kind(self.db, &source_ty, &target_ty)? + cast_kind(self.db, source_ty, target_ty)? }; Rvalue::Cast(cast_kind, it, target_ty) @@ -1034,8 +1040,8 @@ impl<'a, 'db> MirLowerCtx<'a, 'db> { let lhs_ty = self.expr_ty_without_adjust(*lhs); let rhs_ty = self.expr_ty_without_adjust(*rhs); if matches!(op, BinaryOp::CmpOp(syntax::ast::CmpOp::Eq { .. })) - && lhs_ty.as_raw_ptr().is_some() - && rhs_ty.as_raw_ptr().is_some() + && matches!(lhs_ty.kind(), TyKind::RawPtr(..)) + && matches!(rhs_ty.kind(), TyKind::RawPtr(..)) { break 'b true; } @@ -1044,15 +1050,26 @@ impl<'a, 'db> MirLowerCtx<'a, 'db> { BinaryOp::ArithOp(ArithOp::Shl | ArithOp::Shr) | BinaryOp::Assignment { op: Some(ArithOp::Shl | ArithOp::Shr) } ); - lhs_ty.is_scalar() - && rhs_ty.is_scalar() - && (lhs_ty == rhs_ty || builtin_inequal_impls) + matches!( + lhs_ty.kind(), + TyKind::Bool + | TyKind::Char + | TyKind::Int(_) + | TyKind::Uint(_) + | TyKind::Float(_) + ) && matches!( + rhs_ty.kind(), + TyKind::Bool + | TyKind::Char + | TyKind::Int(_) + | TyKind::Uint(_) + | TyKind::Float(_) + ) && (lhs_ty == rhs_ty || builtin_inequal_impls) }; if !is_builtin && let Some((func_id, generic_args)) = self.infer.method_resolution(expr_id) { - let func = - Operand::from_fn(self.db, func_id, generic_args.to_chalk(self.interner)); + let func = Operand::from_fn(self.db, func_id, generic_args); return self.lower_call_and_args( func, [*lhs, *rhs].into_iter(), @@ -1185,7 +1202,7 @@ impl<'a, 'db> MirLowerCtx<'a, 'db> { current, place, Rvalue::Aggregate( - AggregateKind::Adt(st.into(), subst.clone()), + AggregateKind::Adt(st.into(), subst), st.fields(self.db) .fields() .iter() @@ -1193,9 +1210,10 @@ impl<'a, 'db> MirLowerCtx<'a, 'db> { let o = match it.1.name.as_str() { "start" => lp.take(), "end" => rp.take(), - "exhausted" => { - Some(Operand::from_bytes(Box::new([0]), TyBuilder::bool())) - } + "exhausted" => Some(Operand::from_bytes( + Box::new([0]), + Ty::new_bool(self.interner()), + )), _ => None, }; o.ok_or(MirLowerError::UnresolvedField) @@ -1208,11 +1226,11 @@ impl<'a, 'db> MirLowerCtx<'a, 'db> { } Expr::Closure { .. } => { let ty = self.expr_ty_without_adjust(expr_id); - let TyKind::Closure(id, _) = ty.kind(Interner) else { + let TyKind::Closure(id, _) = ty.kind() else { not_supported!("closure with non closure type"); }; - self.result.closures.push(*id); - let (captures, _) = self.infer.closure_info((*id).into()); + self.result.closures.push(id.0); + let (captures, _) = self.infer.closure_info(id.0); let mut operands = vec![]; for capture in captures.iter() { let p = Place { @@ -1236,7 +1254,7 @@ impl<'a, 'db> MirLowerCtx<'a, 'db> { ProjectionElem::Subslice { from, to } } ProjectionElem::OpaqueCast(it) => { - ProjectionElem::OpaqueCast(it.to_chalk(self.interner)) + ProjectionElem::OpaqueCast(it) } #[allow(unreachable_patterns)] ProjectionElem::Index(it) => match it {}, @@ -1246,15 +1264,11 @@ impl<'a, 'db> MirLowerCtx<'a, 'db> { }; match &capture.kind { CaptureKind::ByRef(bk) => { - let placeholder_subst: crate::next_solver::GenericArgs<'db> = - self.placeholder_subst().to_nextsolver(self.interner); - let tmp_ty = capture - .ty - .instantiate(self.interner, placeholder_subst) - .to_chalk(self.interner); + let tmp_ty = capture.ty.instantiate_identity(); // FIXME: Handle more than one span. let capture_spans = capture.spans(); - let tmp: Place = self.temp(tmp_ty, current, capture_spans[0])?.into(); + let tmp: Place<'db> = + self.temp(tmp_ty, current, capture_spans[0])?.into(); self.push_assignment( current, tmp, @@ -1299,8 +1313,8 @@ impl<'a, 'db> MirLowerCtx<'a, 'db> { } Expr::Array(l) => match l { Array::ElementList { elements, .. } => { - let elem_ty = match &self.expr_ty_without_adjust(expr_id).kind(Interner) { - TyKind::Array(ty, _) => ty.clone(), + let elem_ty = match self.expr_ty_without_adjust(expr_id).kind() { + TyKind::Array(ty, _) => ty, _ => { return Err(MirLowerError::TypeError( "Array expression with non array type", @@ -1331,8 +1345,8 @@ impl<'a, 'db> MirLowerCtx<'a, 'db> { else { return Ok(None); }; - let len = match &self.expr_ty_without_adjust(expr_id).kind(Interner) { - TyKind::Array(_, len) => len.clone(), + let len = match self.expr_ty_without_adjust(expr_id).kind() { + TyKind::Array(_, len) => len, _ => { return Err(MirLowerError::TypeError( "Array repeat expression with non array type", @@ -1354,16 +1368,13 @@ impl<'a, 'db> MirLowerCtx<'a, 'db> { } } - fn placeholder_subst(&mut self) -> Substitution { - match self.owner.as_generic_def_id(self.db) { - Some(it) => TyBuilder::placeholder_subst(self.db, it), - None => Substitution::empty(Interner), - } - } - - fn push_field_projection(&mut self, place: &mut Place, expr_id: ExprId) -> Result<'db, ()> { + fn push_field_projection( + &mut self, + place: &mut Place<'db>, + expr_id: ExprId, + ) -> Result<'db, ()> { if let Expr::Field { expr, name } = &self.body[expr_id] { - if let TyKind::Tuple(..) = self.expr_ty_after_adjustments(*expr).kind(Interner) { + if let TyKind::Tuple(..) = self.expr_ty_after_adjustments(*expr).kind() { let index = name.as_tuple_index().ok_or(MirLowerError::TypeError("named field on tuple"))? as u32; @@ -1386,7 +1397,11 @@ impl<'a, 'db> MirLowerCtx<'a, 'db> { Ok(()) } - fn lower_literal_or_const_to_operand(&mut self, ty: Ty, loc: &ExprId) -> Result<'db, Operand> { + fn lower_literal_or_const_to_operand( + &mut self, + ty: Ty<'db>, + loc: &ExprId, + ) -> Result<'db, Operand<'db>> { match &self.body[*loc] { Expr::Literal(l) => self.lower_literal_to_operand(ty, l), Expr::Path(c) => { @@ -1407,7 +1422,10 @@ impl<'a, 'db> MirLowerCtx<'a, 'db> { match pr { ResolveValueResult::ValueNs(v, _) => { if let ValueNs::ConstId(c) = v { - self.lower_const_to_operand(Substitution::empty(Interner), c.into(), ty) + self.lower_const_to_operand( + GenericArgs::new_from_iter(self.interner(), []), + c.into(), + ) } else { not_supported!("bad path in range pattern"); } @@ -1423,13 +1441,8 @@ impl<'a, 'db> MirLowerCtx<'a, 'db> { } } - fn lower_literal_to_operand(&mut self, ty: Ty, l: &Literal) -> Result<'db, Operand> { - let interner = DbInterner::new_with(self.db, None, None); - let size = || { - self.db - .layout_of_ty(ty.to_nextsolver(interner), self.env.clone()) - .map(|it| it.size.bytes_usize()) - }; + fn lower_literal_to_operand(&mut self, ty: Ty<'db>, l: &Literal) -> Result<'db, Operand<'db>> { + let size = || self.db.layout_of_ty(ty, self.env.clone()).map(|it| it.size.bytes_usize()); const USIZE_SIZE: usize = size_of::<usize>(); let bytes: Box<[_]> = match l { hir_def::hir::Literal::String(b) => { @@ -1475,48 +1488,57 @@ impl<'a, 'db> MirLowerCtx<'a, 'db> { Ok(Operand::from_concrete_const(bytes, MemoryMap::default(), ty)) } - fn new_basic_block(&mut self) -> BasicBlockId { + fn new_basic_block(&mut self) -> BasicBlockId<'db> { self.result.basic_blocks.alloc(BasicBlock::default()) } fn lower_const( &mut self, const_id: GeneralConstId, - prev_block: BasicBlockId, - place: Place, - subst: Substitution, + prev_block: BasicBlockId<'db>, + place: Place<'db>, + subst: GenericArgs<'db>, span: MirSpan, - ty: Ty, ) -> Result<'db, ()> { - let c = self.lower_const_to_operand(subst, const_id, ty)?; + let c = self.lower_const_to_operand(subst, const_id)?; self.push_assignment(prev_block, place, c.into(), span); Ok(()) } fn lower_const_to_operand( &mut self, - subst: Substitution, + subst: GenericArgs<'db>, const_id: GeneralConstId, - ty: Ty, - ) -> Result<'db, Operand> { - let c = if subst.len(Interner) != 0 { + ) -> Result<'db, Operand<'db>> { + let konst = if subst.len() != 0 { // We can't evaluate constant with substitution now, as generics are not monomorphized in lowering. - intern_const_scalar(ConstScalar::UnevaluatedConst(const_id, subst), ty) + Const::new_unevaluated( + self.interner(), + UnevaluatedConst { def: const_id.into(), args: subst }, + ) } else { let name = const_id.name(self.db); self.db .const_eval(const_id, subst, None) .map_err(|e| MirLowerError::ConstEvalError(name.into(), Box::new(e)))? }; - Ok(Operand { kind: OperandKind::Constant(c), span: None }) + let ty = self + .db + .value_ty(match const_id { + GeneralConstId::ConstId(id) => id.into(), + GeneralConstId::StaticId(id) => id.into(), + }) + .unwrap() + .instantiate(self.interner(), subst); + Ok(Operand { kind: OperandKind::Constant { konst, ty }, span: None }) } fn write_bytes_to_place( &mut self, - prev_block: BasicBlockId, - place: Place, + prev_block: BasicBlockId<'db>, + place: Place<'db>, cv: Box<[u8]>, - ty: Ty, + ty: Ty<'db>, span: MirSpan, ) -> Result<'db, ()> { self.push_assignment(prev_block, place, Operand::from_bytes(cv, ty).into(), span); @@ -1526,14 +1548,14 @@ impl<'a, 'db> MirLowerCtx<'a, 'db> { fn lower_enum_variant( &mut self, variant_id: EnumVariantId, - prev_block: BasicBlockId, - place: Place, - ty: Ty, - fields: Box<[Operand]>, + prev_block: BasicBlockId<'db>, + place: Place<'db>, + ty: Ty<'db>, + fields: Box<[Operand<'db>]>, span: MirSpan, - ) -> Result<'db, BasicBlockId> { - let subst = match ty.kind(Interner) { - TyKind::Adt(_, subst) => subst.clone(), + ) -> Result<'db, BasicBlockId<'db>> { + let subst = match ty.kind() { + TyKind::Adt(_, subst) => subst, _ => implementation_error!("Non ADT enum"), }; self.push_assignment( @@ -1547,13 +1569,13 @@ impl<'a, 'db> MirLowerCtx<'a, 'db> { fn lower_call_and_args( &mut self, - func: Operand, + func: Operand<'db>, args: impl Iterator<Item = ExprId>, - place: Place, - mut current: BasicBlockId, + place: Place<'db>, + mut current: BasicBlockId<'db>, is_uninhabited: bool, span: MirSpan, - ) -> Result<'db, Option<BasicBlockId>> { + ) -> Result<'db, Option<BasicBlockId<'db>>> { let Some(args) = args .map(|arg| { if let Some((temp, c)) = self.lower_expr_to_some_operand(arg, current)? { @@ -1572,13 +1594,13 @@ impl<'a, 'db> MirLowerCtx<'a, 'db> { fn lower_call( &mut self, - func: Operand, - args: Box<[Operand]>, - place: Place, - current: BasicBlockId, + func: Operand<'db>, + args: Box<[Operand<'db>]>, + place: Place<'db>, + current: BasicBlockId<'db>, is_uninhabited: bool, span: MirSpan, - ) -> Result<'db, Option<BasicBlockId>> { + ) -> Result<'db, Option<BasicBlockId<'db>>> { let b = if is_uninhabited { None } else { Some(self.new_basic_block()) }; self.set_terminator( current, @@ -1595,56 +1617,63 @@ impl<'a, 'db> MirLowerCtx<'a, 'db> { Ok(b) } - fn is_unterminated(&mut self, source: BasicBlockId) -> bool { + fn is_unterminated(&mut self, source: BasicBlockId<'db>) -> bool { self.result.basic_blocks[source].terminator.is_none() } - fn set_terminator(&mut self, source: BasicBlockId, terminator: TerminatorKind, span: MirSpan) { + fn set_terminator( + &mut self, + source: BasicBlockId<'db>, + terminator: TerminatorKind<'db>, + span: MirSpan, + ) { self.result.basic_blocks[source].terminator = Some(Terminator { span, kind: terminator }); } - fn set_goto(&mut self, source: BasicBlockId, target: BasicBlockId, span: MirSpan) { + fn set_goto(&mut self, source: BasicBlockId<'db>, target: BasicBlockId<'db>, span: MirSpan) { self.set_terminator(source, TerminatorKind::Goto { target }, span); } - fn expr_ty_without_adjust(&self, e: ExprId) -> Ty { - self.infer[e].to_chalk(self.interner) + fn expr_ty_without_adjust(&self, e: ExprId) -> Ty<'db> { + self.infer[e] } - fn expr_ty_after_adjustments(&self, e: ExprId) -> Ty { + fn expr_ty_after_adjustments(&self, e: ExprId) -> Ty<'db> { let mut ty = None; if let Some(it) = self.infer.expr_adjustments.get(&e) && let Some(it) = it.last() { - ty = Some(it.target.to_chalk(self.interner)); + ty = Some(it.target); } ty.unwrap_or_else(|| self.expr_ty_without_adjust(e)) } - fn push_statement(&mut self, block: BasicBlockId, statement: Statement) { + fn push_statement(&mut self, block: BasicBlockId<'db>, statement: Statement<'db>) { self.result.basic_blocks[block].statements.push(statement); } - fn push_fake_read(&mut self, block: BasicBlockId, p: Place, span: MirSpan) { + fn push_fake_read(&mut self, block: BasicBlockId<'db>, p: Place<'db>, span: MirSpan) { self.push_statement(block, StatementKind::FakeRead(p).with_span(span)); } fn push_assignment( &mut self, - block: BasicBlockId, - place: Place, - rvalue: Rvalue, + block: BasicBlockId<'db>, + place: Place<'db>, + rvalue: Rvalue<'db>, span: MirSpan, ) { self.push_statement(block, StatementKind::Assign(place, rvalue).with_span(span)); } - fn discr_temp_place(&mut self, current: BasicBlockId) -> Place { + fn discr_temp_place(&mut self, current: BasicBlockId<'db>) -> Place<'db> { match &self.discr_temp { Some(it) => *it, None => { - let tmp: Place = self - .temp(TyBuilder::discr_ty(), current, MirSpan::Unknown) + // FIXME: rustc's ty is dependent on the adt type, maybe we need to do that as well + let discr_ty = Ty::new_int(self.interner(), rustc_type_ir::IntTy::I128); + let tmp: Place<'db> = self + .temp(discr_ty, current, MirSpan::Unknown) .expect("discr_ty is never unsized") .into(); self.discr_temp = Some(tmp); @@ -1655,12 +1684,12 @@ impl<'a, 'db> MirLowerCtx<'a, 'db> { fn lower_loop( &mut self, - prev_block: BasicBlockId, - place: Place, + prev_block: BasicBlockId<'db>, + place: Place<'db>, label: Option<LabelId>, span: MirSpan, - f: impl FnOnce(&mut MirLowerCtx<'_, 'db>, BasicBlockId) -> Result<'db, ()>, - ) -> Result<'db, Option<BasicBlockId>> { + f: impl FnOnce(&mut MirLowerCtx<'_, 'db>, BasicBlockId<'db>) -> Result<'db, ()>, + ) -> Result<'db, Option<BasicBlockId<'db>>> { let begin = self.new_basic_block(); let prev = self.current_loop_blocks.replace(LoopBlocks { begin, @@ -1695,10 +1724,10 @@ impl<'a, 'db> MirLowerCtx<'a, 'db> { fn merge_blocks( &mut self, - b1: Option<BasicBlockId>, - b2: Option<BasicBlockId>, + b1: Option<BasicBlockId<'db>>, + b2: Option<BasicBlockId<'db>>, span: MirSpan, - ) -> Option<BasicBlockId> { + ) -> Option<BasicBlockId<'db>> { match (b1, b2) { (None, None) => None, (None, Some(b)) | (Some(b), None) => Some(b), @@ -1711,7 +1740,7 @@ impl<'a, 'db> MirLowerCtx<'a, 'db> { } } - fn current_loop_end(&mut self) -> Result<'db, BasicBlockId> { + fn current_loop_end(&mut self) -> Result<'db, BasicBlockId<'db>> { let r = match self .current_loop_blocks .as_mut() @@ -1738,7 +1767,7 @@ impl<'a, 'db> MirLowerCtx<'a, 'db> { fn is_uninhabited(&self, expr_id: ExprId) -> bool { is_ty_uninhabited_from( self.db, - &self.infer[expr_id].to_chalk(self.interner), + &self.infer[expr_id].to_chalk(self.interner()), self.owner.module(self.db), self.env.clone(), ) @@ -1746,15 +1775,15 @@ impl<'a, 'db> MirLowerCtx<'a, 'db> { /// This function push `StorageLive` statement for the binding, and applies changes to add `StorageDead` and /// `Drop` in the appropriated places. - fn push_storage_live(&mut self, b: BindingId, current: BasicBlockId) -> Result<'db, ()> { + fn push_storage_live(&mut self, b: BindingId, current: BasicBlockId<'db>) -> Result<'db, ()> { let l = self.binding_local(b)?; self.push_storage_live_for_local(l, current, MirSpan::BindingId(b)) } fn push_storage_live_for_local( &mut self, - l: LocalId, - current: BasicBlockId, + l: LocalId<'db>, + current: BasicBlockId<'db>, span: MirSpan, ) -> Result<'db, ()> { self.drop_scopes.last_mut().unwrap().locals.push(l); @@ -1770,11 +1799,11 @@ impl<'a, 'db> MirLowerCtx<'a, 'db> { fn lower_block_to_place( &mut self, statements: &[hir_def::hir::Statement], - mut current: BasicBlockId, + mut current: BasicBlockId<'db>, tail: Option<ExprId>, - place: Place, + place: Place<'db>, span: MirSpan, - ) -> Result<'db, Option<Idx<BasicBlock>>> { + ) -> Result<'db, Option<Idx<BasicBlock<'db>>>> { let scope = self.push_drop_scope(); for statement in statements.iter() { match statement { @@ -1847,10 +1876,10 @@ impl<'a, 'db> MirLowerCtx<'a, 'db> { fn lower_params_and_bindings( &mut self, - params: impl Iterator<Item = (PatId, Ty)> + Clone, - self_binding: Option<(BindingId, Ty)>, + params: impl Iterator<Item = (PatId, Ty<'db>)> + Clone, + self_binding: Option<(BindingId, Ty<'db>)>, pick_binding: impl Fn(BindingId) -> bool, - ) -> Result<'db, BasicBlockId> { + ) -> Result<'db, BasicBlockId<'db>> { let base_param_count = self.result.param_locals.len(); let self_binding = match self_binding { Some((self_binding, ty)) => { @@ -1881,10 +1910,9 @@ impl<'a, 'db> MirLowerCtx<'a, 'db> { continue; } if !self.result.binding_locals.contains_idx(id) { - self.result.binding_locals.insert( - id, - self.result.locals.alloc(Local { ty: self.infer[id].to_chalk(self.interner) }), - ); + self.result + .binding_locals + .insert(id, self.result.locals.alloc(Local { ty: self.infer[id] })); } } let mut current = self.result.start_block; @@ -1919,7 +1947,7 @@ impl<'a, 'db> MirLowerCtx<'a, 'db> { Ok(current) } - fn binding_local(&self, b: BindingId) -> Result<'db, LocalId> { + fn binding_local(&self, b: BindingId) -> Result<'db, LocalId<'db>> { match self.result.binding_locals.get(b) { Some(it) => Ok(*it), None => { @@ -1968,9 +1996,9 @@ impl<'a, 'db> MirLowerCtx<'a, 'db> { fn drop_until_scope( &mut self, scope_index: usize, - mut current: BasicBlockId, + mut current: BasicBlockId<'db>, span: MirSpan, - ) -> BasicBlockId { + ) -> BasicBlockId<'db> { for scope in self.drop_scopes[scope_index..].to_vec().iter().rev() { self.emit_drop_and_storage_dead_for_scope(scope, &mut current, span); } @@ -1990,9 +2018,9 @@ impl<'a, 'db> MirLowerCtx<'a, 'db> { /// Don't call directly fn pop_drop_scope_internal( &mut self, - mut current: BasicBlockId, + mut current: BasicBlockId<'db>, span: MirSpan, - ) -> BasicBlockId { + ) -> BasicBlockId<'db> { let scope = self.drop_scopes.pop().unwrap(); self.emit_drop_and_storage_dead_for_scope(&scope, &mut current, span); current @@ -2000,9 +2028,9 @@ impl<'a, 'db> MirLowerCtx<'a, 'db> { fn pop_drop_scope_assert_finished( &mut self, - mut current: BasicBlockId, + mut current: BasicBlockId<'db>, span: MirSpan, - ) -> Result<'db, BasicBlockId> { + ) -> Result<'db, BasicBlockId<'db>> { current = self.pop_drop_scope_internal(current, span); if !self.drop_scopes.is_empty() { implementation_error!("Mismatched count between drop scope push and pops"); @@ -2012,12 +2040,12 @@ impl<'a, 'db> MirLowerCtx<'a, 'db> { fn emit_drop_and_storage_dead_for_scope( &mut self, - scope: &DropScope, - current: &mut Idx<BasicBlock>, + scope: &DropScope<'db>, + current: &mut Idx<BasicBlock<'db>>, span: MirSpan, ) { for &l in scope.locals.iter().rev() { - if !self.result.locals[l].ty.clone().is_copy(self.db, self.owner) { + if !self.infcx.type_is_copy_modulo_regions(self.env.env, self.result.locals[l].ty) { let prev = std::mem::replace(current, self.new_basic_block()); self.set_terminator( prev, @@ -2032,12 +2060,11 @@ impl<'a, 'db> MirLowerCtx<'a, 'db> { fn cast_kind<'db>( db: &'db dyn HirDatabase, - source_ty: &Ty, - target_ty: &Ty, + source_ty: Ty<'db>, + target_ty: Ty<'db>, ) -> Result<'db, CastKind> { - let interner = DbInterner::new_with(db, None, None); - let from = CastTy::from_ty(db, source_ty.to_nextsolver(interner)); - let cast = CastTy::from_ty(db, target_ty.to_nextsolver(interner)); + let from = CastTy::from_ty(db, source_ty); + let cast = CastTy::from_ty(db, target_ty); Ok(match (from, cast) { (Some(CastTy::Ptr(..) | CastTy::FnPtr), Some(CastTy::Int(_))) => { CastKind::PointerExposeAddress @@ -2056,7 +2083,7 @@ fn cast_kind<'db>( pub fn mir_body_for_closure_query<'db>( db: &'db dyn HirDatabase, closure: InternedClosureId, -) -> Result<'db, Arc<MirBody>> { +) -> Result<'db, Arc<MirBody<'db>>> { let InternedClosure(owner, expr) = db.lookup_intern_closure(closure); let body = db.body(owner); let infer = db.infer(owner); @@ -2068,29 +2095,34 @@ pub fn mir_body_for_closure_query<'db>( }; let (captures, kind) = infer.closure_info(closure); let mut ctx = MirLowerCtx::new(db, owner, &body, &infer); - let substs: &Substitution = &substs.to_chalk(ctx.interner); // 0 is return local - ctx.result.locals.alloc(Local { ty: infer[*root].to_chalk(ctx.interner) }); + ctx.result.locals.alloc(Local { ty: infer[*root] }); let closure_local = ctx.result.locals.alloc(Local { ty: match kind { - FnTrait::FnOnce | FnTrait::AsyncFnOnce => infer[expr].to_chalk(ctx.interner), - FnTrait::FnMut | FnTrait::AsyncFnMut => { - TyKind::Ref(Mutability::Mut, error_lifetime(), infer[expr].to_chalk(ctx.interner)) - .intern(Interner) - } - FnTrait::Fn | FnTrait::AsyncFn => { - TyKind::Ref(Mutability::Not, error_lifetime(), infer[expr].to_chalk(ctx.interner)) - .intern(Interner) - } + FnTrait::FnOnce | FnTrait::AsyncFnOnce => infer[expr], + FnTrait::FnMut | FnTrait::AsyncFnMut => Ty::new_ref( + ctx.interner(), + Region::error(ctx.interner()), + infer[expr], + Mutability::Mut, + ), + FnTrait::Fn | FnTrait::AsyncFn => Ty::new_ref( + ctx.interner(), + Region::error(ctx.interner()), + infer[expr], + Mutability::Not, + ), }, }); ctx.result.param_locals.push(closure_local); - let Some(sig) = ClosureSubst(substs).sig_ty(db).callable_sig(db) else { + let Some(sig) = + substs.split_closure_args_untupled().closure_sig_as_fn_ptr_ty.callable_sig(ctx.interner()) + else { implementation_error!("closure has not callable sig"); }; let resolver_guard = ctx.resolver.update_to_inner_scope(db, owner, expr); let current = ctx.lower_params_and_bindings( - args.iter().zip(sig.params().iter()).map(|(it, y)| (*it, y.clone())), + args.iter().zip(sig.skip_binder().inputs().iter()).map(|(it, y)| (*it, y)), None, |_| true, )?; @@ -2099,7 +2131,8 @@ pub fn mir_body_for_closure_query<'db>( let current = ctx.pop_drop_scope_assert_finished(current, root.into())?; ctx.set_terminator(current, TerminatorKind::Return, (*root).into()); } - let mut upvar_map: FxHashMap<LocalId, Vec<(&CapturedItem<'_>, usize)>> = FxHashMap::default(); + let mut upvar_map: FxHashMap<LocalId<'db>, Vec<(&CapturedItem<'_>, usize)>> = + FxHashMap::default(); for (i, capture) in captures.iter().enumerate() { let local = ctx.binding_local(capture.place.local)?; upvar_map.entry(local).or_default().push((capture, i)); @@ -2164,7 +2197,7 @@ pub fn mir_body_for_closure_query<'db>( pub fn mir_body_query<'db>( db: &'db dyn HirDatabase, def: DefWithBodyId, -) -> Result<'db, Arc<MirBody>> { +) -> Result<'db, Arc<MirBody<'db>>> { let krate = def.krate(db); let edition = krate.data(db).edition; let detail = match def { @@ -2200,7 +2233,7 @@ pub fn mir_body_query<'db>( pub(crate) fn mir_body_cycle_result<'db>( _db: &'db dyn HirDatabase, _def: DefWithBodyId, -) -> Result<'db, Arc<MirBody>> { +) -> Result<'db, Arc<MirBody<'db>>> { Err(MirLowerError::Loop) } @@ -2212,7 +2245,7 @@ pub fn lower_to_mir<'db>( // FIXME: root_expr should always be the body.body_expr, but since `X` in `[(); X]` doesn't have its own specific body yet, we // need to take this input explicitly. root_expr: ExprId, -) -> Result<'db, MirBody> { +) -> Result<'db, MirBody<'db>> { if infer.type_mismatches().next().is_some() || infer.is_erroneous() { return Err(MirLowerError::HasErrors); } @@ -2229,18 +2262,12 @@ pub fn lower_to_mir<'db>( if body.body_expr == root_expr { // otherwise it's an inline const, and has no parameter if let DefWithBodyId::FunctionId(fid) = owner { - let substs = TyBuilder::placeholder_subst(db, fid); - let interner = DbInterner::new_with(db, None, None); - let args: crate::next_solver::GenericArgs<'_> = substs.to_nextsolver(interner); - let callable_sig = db - .callable_item_signature(fid.into()) - .instantiate(interner, args) - .skip_binder() - .to_chalk(interner); - let mut params = callable_sig.params().iter(); - let self_param = body.self_param.and_then(|id| Some((id, params.next()?.clone()))); + let callable_sig = + db.callable_item_signature(fid.into()).instantiate_identity().skip_binder(); + let mut params = callable_sig.inputs().iter(); + let self_param = body.self_param.and_then(|id| Some((id, params.next()?))); break 'b ctx.lower_params_and_bindings( - body.params.iter().zip(params).map(|(it, y)| (*it, y.clone())), + body.params.iter().zip(params).map(|(it, y)| (*it, y)), self_param, binding_picker, )?; diff --git a/crates/hir-ty/src/mir/lower/as_place.rs b/crates/hir-ty/src/mir/lower/as_place.rs index bd7b644618..52f1412a06 100644 --- a/crates/hir-ty/src/mir/lower/as_place.rs +++ b/crates/hir-ty/src/mir/lower/as_place.rs @@ -1,10 +1,14 @@ //! MIR lowering for places -use crate::mir::{MutBorrowKind, Operand, OperandKind}; - -use super::*; use hir_def::FunctionId; use intern::sym; +use rustc_type_ir::inherent::{AdtDef, Region as _, Ty as _}; + +use super::*; +use crate::{ + mir::{MutBorrowKind, Operand, OperandKind}, + next_solver::Region, +}; macro_rules! not_supported { ($it: expr) => { @@ -16,8 +20,8 @@ impl<'db> MirLowerCtx<'_, 'db> { fn lower_expr_to_some_place_without_adjust( &mut self, expr_id: ExprId, - prev_block: BasicBlockId, - ) -> Result<'db, Option<(Place, BasicBlockId)>> { + prev_block: BasicBlockId<'db>, + ) -> Result<'db, Option<(Place<'db>, BasicBlockId<'db>)>> { let ty = self.expr_ty_without_adjust(expr_id); let place = self.temp(ty, prev_block, expr_id.into())?; let Some(current) = @@ -31,12 +35,12 @@ impl<'db> MirLowerCtx<'_, 'db> { fn lower_expr_to_some_place_with_adjust( &mut self, expr_id: ExprId, - prev_block: BasicBlockId, + prev_block: BasicBlockId<'db>, adjustments: &[Adjustment<'db>], - ) -> Result<'db, Option<(Place, BasicBlockId)>> { + ) -> Result<'db, Option<(Place<'db>, BasicBlockId<'db>)>> { let ty = adjustments .last() - .map(|it| it.target.to_chalk(self.interner)) + .map(|it| it.target) .unwrap_or_else(|| self.expr_ty_without_adjust(expr_id)); let place = self.temp(ty, prev_block, expr_id.into())?; let Some(current) = @@ -49,11 +53,11 @@ impl<'db> MirLowerCtx<'_, 'db> { pub(super) fn lower_expr_as_place_with_adjust( &mut self, - current: BasicBlockId, + current: BasicBlockId<'db>, expr_id: ExprId, upgrade_rvalue: bool, adjustments: &[Adjustment<'db>], - ) -> Result<'db, Option<(Place, BasicBlockId)>> { + ) -> Result<'db, Option<(Place<'db>, BasicBlockId<'db>)>> { let try_rvalue = |this: &mut MirLowerCtx<'_, 'db>| { if !upgrade_rvalue { return Err(MirLowerError::MutatingRvalue); @@ -89,11 +93,11 @@ impl<'db> MirLowerCtx<'_, 'db> { current, r, rest.last() - .map(|it| it.target.to_chalk(self.interner)) + .map(|it| it.target) .unwrap_or_else(|| self.expr_ty_without_adjust(expr_id)), - last.target.to_chalk(self.interner), + last.target, expr_id.into(), - match od.0.to_chalk(self.interner) { + match od.0 { Some(Mutability::Mut) => true, Some(Mutability::Not) => false, None => { @@ -111,10 +115,10 @@ impl<'db> MirLowerCtx<'_, 'db> { pub(super) fn lower_expr_as_place( &mut self, - current: BasicBlockId, + current: BasicBlockId<'db>, expr_id: ExprId, upgrade_rvalue: bool, - ) -> Result<'db, Option<(Place, BasicBlockId)>> { + ) -> Result<'db, Option<(Place<'db>, BasicBlockId<'db>)>> { match self.infer.expr_adjustments.get(&expr_id) { Some(a) => self.lower_expr_as_place_with_adjust(current, expr_id, upgrade_rvalue, a), None => self.lower_expr_as_place_without_adjust(current, expr_id, upgrade_rvalue), @@ -123,10 +127,10 @@ impl<'db> MirLowerCtx<'_, 'db> { pub(super) fn lower_expr_as_place_without_adjust( &mut self, - current: BasicBlockId, + current: BasicBlockId<'db>, expr_id: ExprId, upgrade_rvalue: bool, - ) -> Result<'db, Option<(Place, BasicBlockId)>> { + ) -> Result<'db, Option<(Place<'db>, BasicBlockId<'db>)>> { let try_rvalue = |this: &mut MirLowerCtx<'_, 'db>| { if !upgrade_rvalue { return Err(MirLowerError::MutatingRvalue); @@ -149,9 +153,13 @@ impl<'db> MirLowerCtx<'_, 'db> { } ValueNs::StaticId(s) => { let ty = self.expr_ty_without_adjust(expr_id); - let ref_ty = - TyKind::Ref(Mutability::Not, static_lifetime(), ty).intern(Interner); - let temp: Place = self.temp(ref_ty, current, expr_id.into())?.into(); + let ref_ty = Ty::new_ref( + self.interner(), + Region::new_static(self.interner()), + ty, + Mutability::Not, + ); + let temp: Place<'db> = self.temp(ref_ty, current, expr_id.into())?.into(); self.push_assignment( current, temp, @@ -167,10 +175,10 @@ impl<'db> MirLowerCtx<'_, 'db> { } } Expr::UnaryOp { expr, op: hir_def::hir::UnaryOp::Deref } => { - let is_builtin = match self.expr_ty_without_adjust(*expr).kind(Interner) { - TyKind::Ref(..) | TyKind::Raw(..) => true, + let is_builtin = match self.expr_ty_without_adjust(*expr).kind() { + TyKind::Ref(..) | TyKind::RawPtr(..) => true, TyKind::Adt(id, _) => { - if let Some(lang_item) = self.db.lang_attr(id.0.into()) { + if let Some(lang_item) = self.db.lang_attr(id.def_id().0.into()) { lang_item == LangItem::OwnedBox } else { false @@ -219,9 +227,9 @@ impl<'db> MirLowerCtx<'_, 'db> { Expr::Index { base, index } => { let base_ty = self.expr_ty_after_adjustments(*base); let index_ty = self.expr_ty_after_adjustments(*index); - if index_ty != TyBuilder::usize() + if !matches!(index_ty.kind(), TyKind::Uint(rustc_ast_ir::UintTy::Usize)) || !matches!( - base_ty.strip_reference().kind(Interner), + base_ty.strip_reference().kind(), TyKind::Array(..) | TyKind::Slice(..) ) { @@ -230,7 +238,6 @@ impl<'db> MirLowerCtx<'_, 'db> { "[overloaded index]".to_owned(), )); }; - let index_fn = (index_fn.0, index_fn.1.to_chalk(self.interner)); let Some((base_place, current)) = self.lower_expr_as_place(current, *base, true)? else { @@ -279,24 +286,26 @@ impl<'db> MirLowerCtx<'_, 'db> { fn lower_overloaded_index( &mut self, - current: BasicBlockId, - place: Place, - base_ty: Ty, - result_ty: Ty, - index_operand: Operand, + current: BasicBlockId<'db>, + place: Place<'db>, + base_ty: Ty<'db>, + result_ty: Ty<'db>, + index_operand: Operand<'db>, span: MirSpan, - index_fn: (FunctionId, Substitution), - ) -> Result<'db, Option<(Place, BasicBlockId)>> { + index_fn: (FunctionId, GenericArgs<'db>), + ) -> Result<'db, Option<(Place<'db>, BasicBlockId<'db>)>> { let mutability = match base_ty.as_reference() { Some((_, _, mutability)) => mutability, None => Mutability::Not, }; - let result_ref = TyKind::Ref(mutability, error_lifetime(), result_ty).intern(Interner); - let mut result: Place = self.temp(result_ref, current, span)?.into(); - let index_fn_op = Operand::const_zst( - TyKind::FnDef(CallableDefId::FunctionId(index_fn.0).to_chalk(self.db), index_fn.1) - .intern(Interner), - ); + let result_ref = + Ty::new_ref(self.interner(), Region::error(self.interner()), result_ty, mutability); + let mut result: Place<'db> = self.temp(result_ref, current, span)?.into(); + let index_fn_op = Operand::const_zst(Ty::new_fn_def( + self.interner(), + CallableDefId::FunctionId(index_fn.0).into(), + index_fn.1, + )); let Some(current) = self.lower_call( index_fn_op, Box::new([Operand { kind: OperandKind::Copy(place), span: None }, index_operand]), @@ -314,14 +323,14 @@ impl<'db> MirLowerCtx<'_, 'db> { fn lower_overloaded_deref( &mut self, - current: BasicBlockId, - place: Place, - source_ty: Ty, - target_ty: Ty, + current: BasicBlockId<'db>, + place: Place<'db>, + source_ty: Ty<'db>, + target_ty: Ty<'db>, span: MirSpan, mutability: bool, - ) -> Result<'db, Option<(Place, BasicBlockId)>> { - let (chalk_mut, trait_lang_item, trait_method_name, borrow_kind) = if !mutability { + ) -> Result<'db, Option<(Place<'db>, BasicBlockId<'db>)>> { + let (mutability, trait_lang_item, trait_method_name, borrow_kind) = if !mutability { ( Mutability::Not, LangItem::Deref, @@ -336,9 +345,10 @@ impl<'db> MirLowerCtx<'_, 'db> { BorrowKind::Mut { kind: MutBorrowKind::Default }, ) }; - let ty_ref = TyKind::Ref(chalk_mut, error_lifetime(), source_ty.clone()).intern(Interner); - let target_ty_ref = TyKind::Ref(chalk_mut, error_lifetime(), target_ty).intern(Interner); - let ref_place: Place = self.temp(ty_ref, current, span)?.into(); + let error_region = Region::error(self.interner()); + let ty_ref = Ty::new_ref(self.interner(), error_region, source_ty, mutability); + let target_ty_ref = Ty::new_ref(self.interner(), error_region, target_ty, mutability); + let ref_place: Place<'db> = self.temp(ty_ref, current, span)?.into(); self.push_assignment(current, ref_place, Rvalue::Ref(borrow_kind, place), span); let deref_trait = self .resolve_lang_item(trait_lang_item)? @@ -348,14 +358,12 @@ impl<'db> MirLowerCtx<'_, 'db> { .trait_items(self.db) .method_by_name(&trait_method_name) .ok_or(MirLowerError::LangItemNotFound(trait_lang_item))?; - let deref_fn_op = Operand::const_zst( - TyKind::FnDef( - CallableDefId::FunctionId(deref_fn).to_chalk(self.db), - Substitution::from1(Interner, source_ty), - ) - .intern(Interner), - ); - let mut result: Place = self.temp(target_ty_ref, current, span)?.into(); + let deref_fn_op = Operand::const_zst(Ty::new_fn_def( + self.interner(), + CallableDefId::FunctionId(deref_fn).into(), + GenericArgs::new_from_iter(self.interner(), [source_ty.into()]), + )); + let mut result: Place<'db> = self.temp(target_ty_ref, current, span)?.into(); let Some(current) = self.lower_call( deref_fn_op, Box::new([Operand { kind: OperandKind::Copy(ref_place), span: None }]), diff --git a/crates/hir-ty/src/mir/lower/pattern_matching.rs b/crates/hir-ty/src/mir/lower/pattern_matching.rs index 359c4fbb2e..b1b86ab2c6 100644 --- a/crates/hir-ty/src/mir/lower/pattern_matching.rs +++ b/crates/hir-ty/src/mir/lower/pattern_matching.rs @@ -1,18 +1,18 @@ //! MIR lowering for patterns use hir_def::{AssocItemId, hir::ExprId, signatures::VariantFields}; +use rustc_type_ir::inherent::{IntoKind, SliceLike, Ty as _}; -use crate::next_solver::mapping::NextSolverToChalk; +use crate::next_solver::GenericArgs; use crate::{ BindingMode, mir::{ LocalId, MutBorrowKind, Operand, OperandKind, lower::{ - BasicBlockId, BinOp, BindingId, BorrowKind, Either, Expr, FieldId, Idx, Interner, - MemoryMap, MirLowerCtx, MirLowerError, MirSpan, Pat, PatId, Place, PlaceElem, - ProjectionElem, RecordFieldPat, ResolveValueResult, Result, Rvalue, Substitution, - SwitchTargets, TerminatorKind, TupleFieldId, TupleId, TyBuilder, TyKind, ValueNs, - VariantId, + BasicBlockId, BinOp, BindingId, BorrowKind, Either, Expr, FieldId, Idx, MemoryMap, + MirLowerCtx, MirLowerError, MirSpan, Pat, PatId, Place, PlaceElem, ProjectionElem, + RecordFieldPat, ResolveValueResult, Result, Rvalue, SwitchTargets, TerminatorKind, + TupleFieldId, TupleId, Ty, TyKind, ValueNs, VariantId, }, }, }; @@ -63,11 +63,11 @@ impl<'db> MirLowerCtx<'_, 'db> { /// so it should be an empty block. pub(super) fn pattern_match( &mut self, - current: BasicBlockId, - current_else: Option<BasicBlockId>, - cond_place: Place, + current: BasicBlockId<'db>, + current_else: Option<BasicBlockId<'db>>, + cond_place: Place<'db>, pattern: PatId, - ) -> Result<'db, (BasicBlockId, Option<BasicBlockId>)> { + ) -> Result<'db, (BasicBlockId<'db>, Option<BasicBlockId<'db>>)> { let (current, current_else) = self.pattern_match_inner( current, current_else, @@ -87,10 +87,10 @@ impl<'db> MirLowerCtx<'_, 'db> { pub(super) fn pattern_match_assignment( &mut self, - current: BasicBlockId, - value: Place, + current: BasicBlockId<'db>, + value: Place<'db>, pattern: PatId, - ) -> Result<'db, BasicBlockId> { + ) -> Result<'db, BasicBlockId<'db>> { let (current, _) = self.pattern_match_inner(current, None, value, pattern, MatchingMode::Assign)?; Ok(current) @@ -99,9 +99,9 @@ impl<'db> MirLowerCtx<'_, 'db> { pub(super) fn match_self_param( &mut self, id: BindingId, - current: BasicBlockId, - local: LocalId, - ) -> Result<'db, (BasicBlockId, Option<BasicBlockId>)> { + current: BasicBlockId<'db>, + local: LocalId<'db>, + ) -> Result<'db, (BasicBlockId<'db>, Option<BasicBlockId<'db>>)> { self.pattern_match_binding( id, BindingMode::Move, @@ -114,12 +114,12 @@ impl<'db> MirLowerCtx<'_, 'db> { fn pattern_match_inner( &mut self, - mut current: BasicBlockId, - mut current_else: Option<BasicBlockId>, - mut cond_place: Place, + mut current: BasicBlockId<'db>, + mut current_else: Option<BasicBlockId<'db>>, + mut cond_place: Place<'db>, pattern: PatId, mode: MatchingMode, - ) -> Result<'db, (BasicBlockId, Option<BasicBlockId>)> { + ) -> Result<'db, (BasicBlockId<'db>, Option<BasicBlockId<'db>>)> { let cnt = self.infer.pat_adjustments.get(&pattern).map(|x| x.len()).unwrap_or_default(); cond_place.projection = self.result.projection_store.intern( cond_place @@ -135,8 +135,8 @@ impl<'db> MirLowerCtx<'_, 'db> { Pat::Missing => return Err(MirLowerError::IncompletePattern), Pat::Wild => (current, current_else), Pat::Tuple { args, ellipsis } => { - let subst = match self.infer[pattern].to_chalk(self.interner).kind(Interner) { - TyKind::Tuple(_, s) => s.clone(), + let subst = match self.infer[pattern].kind() { + TyKind::Tuple(s) => s, _ => { return Err(MirLowerError::TypeError( "non tuple type matched with tuple pattern", @@ -148,7 +148,7 @@ impl<'db> MirLowerCtx<'_, 'db> { current_else, args, *ellipsis, - (0..subst.len(Interner)).map(|i| { + (0..subst.len()).map(|i| { PlaceElem::Field(Either::Right(TupleFieldId { tuple: TupleId(!0), // Dummy as it is unused index: i as u32, @@ -209,14 +209,11 @@ impl<'db> MirLowerCtx<'_, 'db> { } Pat::Range { start, end } => { let mut add_check = |l: &ExprId, binop| -> Result<'db, ()> { - let lv = self.lower_literal_or_const_to_operand( - self.infer[pattern].to_chalk(self.interner), - l, - )?; + let lv = self.lower_literal_or_const_to_operand(self.infer[pattern], l)?; let else_target = *current_else.get_or_insert_with(|| self.new_basic_block()); let next = self.new_basic_block(); - let discr: Place = - self.temp(TyBuilder::bool(), current, pattern.into())?.into(); + let discr: Place<'db> = + self.temp(Ty::new_bool(self.interner()), current, pattern.into())?.into(); self.push_assignment( current, discr, @@ -252,12 +249,11 @@ impl<'db> MirLowerCtx<'_, 'db> { Pat::Slice { prefix, slice, suffix } => { if mode == MatchingMode::Check { // emit runtime length check for slice - if let TyKind::Slice(_) = - self.infer[pattern].to_chalk(self.interner).kind(Interner) - { + if let TyKind::Slice(_) = self.infer[pattern].kind() { let pattern_len = prefix.len() + suffix.len(); - let place_len: Place = - self.temp(TyBuilder::usize(), current, pattern.into())?.into(); + let place_len: Place<'db> = self + .temp(Ty::new_usize(self.interner()), current, pattern.into())? + .into(); self.push_assignment( current, place_len, @@ -287,10 +283,11 @@ impl<'db> MirLowerCtx<'_, 'db> { let c = Operand::from_concrete_const( pattern_len.to_le_bytes().into(), MemoryMap::default(), - TyBuilder::usize(), + Ty::new_usize(self.interner()), ); - let discr: Place = - self.temp(TyBuilder::bool(), current, pattern.into())?.into(); + let discr: Place<'db> = self + .temp(Ty::new_bool(self.interner()), current, pattern.into())? + .into(); self.push_assignment( current, discr, @@ -398,26 +395,19 @@ impl<'db> MirLowerCtx<'_, 'db> { if let Some(x) = self.infer.assoc_resolutions_for_pat(pattern) && let AssocItemId::ConstId(c) = x.0 { - break 'b (c, x.1.to_chalk(self.interner)); + break 'b (c, x.1); } if let ResolveValueResult::ValueNs(ValueNs::ConstId(c), _) = pr { - break 'b (c, Substitution::empty(Interner)); + break 'b (c, GenericArgs::new_from_iter(self.interner(), [])); } not_supported!("path in pattern position that is not const or variant") }; - let tmp: Place = self - .temp(self.infer[pattern].to_chalk(self.interner), current, pattern.into())? - .into(); + let tmp: Place<'db> = + self.temp(self.infer[pattern], current, pattern.into())?.into(); let span = pattern.into(); - self.lower_const( - c.into(), - current, - tmp, - subst, - span, - self.infer[pattern].to_chalk(self.interner), - )?; - let tmp2: Place = self.temp(TyBuilder::bool(), current, pattern.into())?.into(); + self.lower_const(c.into(), current, tmp, subst, span)?; + let tmp2: Place<'db> = + self.temp(Ty::new_bool(self.interner()), current, pattern.into())?.into(); self.push_assignment( current, tmp2, @@ -444,10 +434,7 @@ impl<'db> MirLowerCtx<'_, 'db> { Pat::Lit(l) => match &self.body[*l] { Expr::Literal(l) => { if mode == MatchingMode::Check { - let c = self.lower_literal_to_operand( - self.infer[pattern].to_chalk(self.interner), - l, - )?; + let c = self.lower_literal_to_operand(self.infer[pattern], l)?; self.pattern_match_const(current_else, current, c, cond_place, pattern)? } else { (current, current_else) @@ -519,11 +506,11 @@ impl<'db> MirLowerCtx<'_, 'db> { &mut self, id: BindingId, mode: BindingMode, - cond_place: Place, + cond_place: Place<'db>, span: MirSpan, - current: BasicBlockId, - current_else: Option<BasicBlockId>, - ) -> Result<'db, (BasicBlockId, Option<BasicBlockId>)> { + current: BasicBlockId<'db>, + current_else: Option<BasicBlockId<'db>>, + ) -> Result<'db, (BasicBlockId<'db>, Option<BasicBlockId<'db>>)> { let target_place = self.binding_local(id)?; self.push_storage_live(id, current)?; self.push_match_assignment(current, target_place, mode, cond_place, span); @@ -532,10 +519,10 @@ impl<'db> MirLowerCtx<'_, 'db> { fn push_match_assignment( &mut self, - current: BasicBlockId, - target_place: LocalId, + current: BasicBlockId<'db>, + target_place: LocalId<'db>, mode: BindingMode, - cond_place: Place, + cond_place: Place<'db>, span: MirSpan, ) { self.push_assignment( @@ -558,15 +545,16 @@ impl<'db> MirLowerCtx<'_, 'db> { fn pattern_match_const( &mut self, - current_else: Option<BasicBlockId>, - current: BasicBlockId, - c: Operand, - cond_place: Place, + current_else: Option<BasicBlockId<'db>>, + current: BasicBlockId<'db>, + c: Operand<'db>, + cond_place: Place<'db>, pattern: Idx<Pat>, - ) -> Result<'db, (BasicBlockId, Option<BasicBlockId>)> { + ) -> Result<'db, (BasicBlockId<'db>, Option<BasicBlockId<'db>>)> { let then_target = self.new_basic_block(); let else_target = current_else.unwrap_or_else(|| self.new_basic_block()); - let discr: Place = self.temp(TyBuilder::bool(), current, pattern.into())?.into(); + let discr: Place<'db> = + self.temp(Ty::new_bool(self.interner()), current, pattern.into())?.into(); self.push_assignment( current, discr, @@ -591,14 +579,14 @@ impl<'db> MirLowerCtx<'_, 'db> { fn pattern_matching_variant( &mut self, - cond_place: Place, + cond_place: Place<'db>, variant: VariantId, - mut current: BasicBlockId, + mut current: BasicBlockId<'db>, span: MirSpan, - mut current_else: Option<BasicBlockId>, + mut current_else: Option<BasicBlockId<'db>>, shape: AdtPatternShape<'_>, mode: MatchingMode, - ) -> Result<'db, (BasicBlockId, Option<BasicBlockId>)> { + ) -> Result<'db, (BasicBlockId<'db>, Option<BasicBlockId<'db>>)> { Ok(match variant { VariantId::EnumVariantId(v) => { if mode == MatchingMode::Check { @@ -647,11 +635,11 @@ impl<'db> MirLowerCtx<'_, 'db> { shape: AdtPatternShape<'_>, variant_data: &VariantFields, v: VariantId, - current: BasicBlockId, - current_else: Option<BasicBlockId>, - cond_place: &Place, + current: BasicBlockId<'db>, + current_else: Option<BasicBlockId<'db>>, + cond_place: &Place<'db>, mode: MatchingMode, - ) -> Result<'db, (BasicBlockId, Option<BasicBlockId>)> { + ) -> Result<'db, (BasicBlockId<'db>, Option<BasicBlockId<'db>>)> { Ok(match shape { AdtPatternShape::Record { args } => { let it = args @@ -690,12 +678,12 @@ impl<'db> MirLowerCtx<'_, 'db> { fn pattern_match_adt( &mut self, - mut current: BasicBlockId, - mut current_else: Option<BasicBlockId>, - args: impl Iterator<Item = (PlaceElem, PatId)>, - cond_place: &Place, + mut current: BasicBlockId<'db>, + mut current_else: Option<BasicBlockId<'db>>, + args: impl Iterator<Item = (PlaceElem<'db>, PatId)>, + cond_place: &Place<'db>, mode: MatchingMode, - ) -> Result<'db, (BasicBlockId, Option<BasicBlockId>)> { + ) -> Result<'db, (BasicBlockId<'db>, Option<BasicBlockId<'db>>)> { for (proj, arg) in args { let cond_place = cond_place.project(proj, &mut self.result.projection_store); (current, current_else) = @@ -706,14 +694,14 @@ impl<'db> MirLowerCtx<'_, 'db> { fn pattern_match_tuple_like( &mut self, - current: BasicBlockId, - current_else: Option<BasicBlockId>, + current: BasicBlockId<'db>, + current_else: Option<BasicBlockId<'db>>, args: &[PatId], ellipsis: Option<u32>, - fields: impl DoubleEndedIterator<Item = PlaceElem> + Clone, - cond_place: &Place, + fields: impl DoubleEndedIterator<Item = PlaceElem<'db>> + Clone, + cond_place: &Place<'db>, mode: MatchingMode, - ) -> Result<'db, (BasicBlockId, Option<BasicBlockId>)> { + ) -> Result<'db, (BasicBlockId<'db>, Option<BasicBlockId<'db>>)> { let (al, ar) = args.split_at(ellipsis.map_or(args.len(), |it| it as usize)); let it = al .iter() diff --git a/crates/hir-ty/src/mir/lower/tests.rs b/crates/hir-ty/src/mir/lower/tests.rs index ee088bd06c..38fc7ad78a 100644 --- a/crates/hir-ty/src/mir/lower/tests.rs +++ b/crates/hir-ty/src/mir/lower/tests.rs @@ -1,14 +1,8 @@ -use hir_def::db::DefDatabase; -use rustc_hash::FxHashMap; -use span::Edition; use test_fixture::WithFixture; -use triomphe::Arc; -use crate::{db::HirDatabase, mir::MirBody, setup_tracing, test_db::TestDB}; +use crate::{db::HirDatabase, setup_tracing, test_db::TestDB}; -fn lower_mir( - #[rust_analyzer::rust_fixture] ra_fixture: &str, -) -> FxHashMap<String, Result<Arc<MirBody>, ()>> { +fn lower_mir(#[rust_analyzer::rust_fixture] ra_fixture: &str) { let _tracing = setup_tracing(); let (db, file_ids) = TestDB::with_many_files(ra_fixture); crate::attach_db(&db, || { @@ -20,14 +14,9 @@ fn lower_mir( hir_def::ModuleDefId::FunctionId(it) => Some(it), _ => None, }); - funcs - .map(|func| { - let name = - db.function_signature(func).name.display(&db, Edition::CURRENT).to_string(); - let mir = db.mir_body(func.into()); - (name, mir.map_err(drop)) - }) - .collect() + for func in funcs { + _ = db.mir_body(func.into()); + } }) } diff --git a/crates/hir-ty/src/mir/monomorphization.rs b/crates/hir-ty/src/mir/monomorphization.rs index 4bc81a4806..745f73948d 100644 --- a/crates/hir-ty/src/mir/monomorphization.rs +++ b/crates/hir-ty/src/mir/monomorphization.rs @@ -7,232 +7,129 @@ //! //! So the monomorphization should be called even if the substitution is empty. -use std::mem; - -use chalk_ir::{ - ConstData, DebruijnIndex, - fold::{FallibleTypeFolder, TypeFoldable, TypeSuperFoldable}, -}; use hir_def::DefWithBodyId; +use rustc_type_ir::inherent::{IntoKind, SliceLike}; +use rustc_type_ir::{ + FallibleTypeFolder, TypeFlags, TypeFoldable, TypeSuperFoldable, TypeVisitableExt, +}; use triomphe::Arc; -use crate::next_solver::DbInterner; -use crate::next_solver::mapping::{ChalkToNextSolver, NextSolverToChalk}; +use crate::next_solver::{Const, ConstKind, Region, RegionKind}; use crate::{ - Const, Interner, ProjectionTy, Substitution, TraitEnvironment, Ty, TyKind, - consteval::{intern_const_scalar, unknown_const}, - db::{HirDatabase, InternedClosure, InternedClosureId}, - from_placeholder_idx, - generics::{Generics, generics}, - infer::normalize, + TraitEnvironment, + db::{HirDatabase, InternedClosureId}, + next_solver::{ + DbInterner, GenericArgs, Ty, TyKind, TypingMode, + infer::{DbInternerInferExt, InferCtxt, traits::ObligationCause}, + obligation_ctxt::ObligationCtxt, + references_non_lt_error, + }, }; use super::{MirBody, MirLowerError, Operand, OperandKind, Rvalue, StatementKind, TerminatorKind}; -macro_rules! not_supported { - ($it: expr) => { - return Err(MirLowerError::NotSupported(format!($it))) - }; -} - -struct Filler<'a, 'db> { - db: &'db dyn HirDatabase, +struct Filler<'db> { + infcx: InferCtxt<'db>, trait_env: Arc<TraitEnvironment<'db>>, - subst: &'a Substitution, - generics: Option<Generics>, - interner: DbInterner<'db>, + subst: GenericArgs<'db>, } -impl<'a, 'db> FallibleTypeFolder<Interner> for Filler<'a, 'db> { + +impl<'db> FallibleTypeFolder<DbInterner<'db>> for Filler<'db> { type Error = MirLowerError<'db>; - fn as_dyn(&mut self) -> &mut dyn FallibleTypeFolder<Interner, Error = Self::Error> { - self + fn cx(&self) -> DbInterner<'db> { + self.infcx.interner } - fn interner(&self) -> Interner { - Interner - } + fn try_fold_ty(&mut self, ty: Ty<'db>) -> Result<Ty<'db>, Self::Error> { + if !ty.has_type_flags(TypeFlags::HAS_ALIAS | TypeFlags::HAS_PARAM) { + return Ok(ty); + } - fn try_fold_ty( - &mut self, - ty: Ty, - outer_binder: DebruijnIndex, - ) -> std::result::Result<Ty, Self::Error> { - match ty.kind(Interner) { - TyKind::AssociatedType(id, subst) => { - // I don't know exactly if and why this is needed, but it looks like `normalize_ty` likes - // this kind of associated types. - Ok(TyKind::Alias(chalk_ir::AliasTy::Projection(ProjectionTy { - associated_ty_id: *id, - substitution: subst.clone().try_fold_with(self, outer_binder)?, - })) - .intern(Interner)) - } - TyKind::Alias(chalk_ir::AliasTy::Opaque(chalk_ir::OpaqueTy { - opaque_ty_id: id, - substitution: subst, - })) - | TyKind::OpaqueType(id, subst) => { - let impl_trait_id = self.db.lookup_intern_impl_trait_id((*id).into()); - let subst = subst.clone().try_fold_with(self.as_dyn(), outer_binder)?; - match impl_trait_id { - crate::ImplTraitId::ReturnTypeImplTrait(func, idx) => { - let infer = self.db.infer(func.into()); - let filler = &mut Filler { - db: self.db, - trait_env: self.trait_env.clone(), - subst: &subst, - generics: Some(generics(self.db, func.into())), - interner: self.interner, - }; - filler.try_fold_ty( - infer.type_of_rpit[idx.to_nextsolver(self.interner)] - .to_chalk(self.interner), - outer_binder, - ) - } - crate::ImplTraitId::TypeAliasImplTrait(..) => { - not_supported!("type alias impl trait"); - } - crate::ImplTraitId::AsyncBlockTypeImplTrait(_, _) => { - not_supported!("async block impl trait"); - } - } + match ty.kind() { + TyKind::Alias(..) => { + // First instantiate params. + let ty = ty.try_super_fold_with(self)?; + + let mut ocx = ObligationCtxt::new(&self.infcx); + let ty = ocx + .structurally_normalize_ty(&ObligationCause::dummy(), self.trait_env.env, ty) + .map_err(|_| MirLowerError::NotSupported("can't normalize alias".to_owned()))?; + ty.try_super_fold_with(self) } - _ => ty.try_super_fold_with(self.as_dyn(), outer_binder), + TyKind::Param(param) => Ok(self + .subst + .as_slice() + .get(param.index as usize) + .and_then(|arg| arg.ty()) + .ok_or_else(|| { + MirLowerError::GenericArgNotProvided(param.id.into(), self.subst) + })?), + _ => ty.try_super_fold_with(self), } } - fn try_fold_free_placeholder_const( - &mut self, - _ty: chalk_ir::Ty<Interner>, - idx: chalk_ir::PlaceholderIndex, - _outer_binder: DebruijnIndex, - ) -> std::result::Result<chalk_ir::Const<Interner>, Self::Error> { - let it = from_placeholder_idx(self.db, idx).0; - let Some(idx) = self.generics.as_ref().and_then(|g| g.type_or_const_param_idx(it)) else { - not_supported!("missing idx in generics"); + fn try_fold_const(&mut self, ct: Const<'db>) -> Result<Const<'db>, Self::Error> { + let ConstKind::Param(param) = ct.kind() else { + return ct.try_super_fold_with(self); }; - Ok(self - .subst - .as_slice(Interner) - .get(idx) - .and_then(|it| it.constant(Interner)) - .ok_or_else(|| MirLowerError::GenericArgNotProvided(it, self.subst.clone()))? - .clone()) + self.subst + .as_slice() + .get(param.index as usize) + .and_then(|arg| arg.konst()) + .ok_or_else(|| MirLowerError::GenericArgNotProvided(param.id.into(), self.subst)) } - fn try_fold_free_placeholder_ty( - &mut self, - idx: chalk_ir::PlaceholderIndex, - _outer_binder: DebruijnIndex, - ) -> std::result::Result<Ty, Self::Error> { - let it = from_placeholder_idx(self.db, idx).0; - let Some(idx) = self.generics.as_ref().and_then(|g| g.type_or_const_param_idx(it)) else { - not_supported!("missing idx in generics"); + fn try_fold_region(&mut self, region: Region<'db>) -> Result<Region<'db>, Self::Error> { + let RegionKind::ReEarlyParam(param) = region.kind() else { + return Ok(region); }; - Ok(self - .subst - .as_slice(Interner) - .get(idx) - .and_then(|it| it.ty(Interner)) - .ok_or_else(|| MirLowerError::GenericArgNotProvided(it, self.subst.clone()))? - .clone()) - } - - fn try_fold_const( - &mut self, - constant: chalk_ir::Const<Interner>, - outer_binder: DebruijnIndex, - ) -> Result<chalk_ir::Const<Interner>, Self::Error> { - let next_ty = normalize( - self.db, - self.trait_env.clone(), - constant.data(Interner).ty.clone().try_fold_with(self, outer_binder)?, - ); - ConstData { ty: next_ty, value: constant.data(Interner).value.clone() } - .intern(Interner) - .try_super_fold_with(self, outer_binder) + self.subst + .as_slice() + .get(param.index as usize) + .and_then(|arg| arg.region()) + .ok_or_else(|| MirLowerError::GenericArgNotProvided(param.id.into(), self.subst)) } } -impl<'a, 'db> Filler<'a, 'db> { - fn fill_ty(&mut self, ty: &mut Ty) -> Result<(), MirLowerError<'db>> { - let tmp = mem::replace(ty, TyKind::Error.intern(Interner)); - *ty = normalize( - self.db, - self.trait_env.clone(), - tmp.try_fold_with(self, DebruijnIndex::INNERMOST)?, - ); - Ok(()) - } - - fn fill_const(&mut self, c: &mut Const) -> Result<(), MirLowerError<'db>> { - let tmp = mem::replace(c, unknown_const(c.data(Interner).ty.clone())); - *c = tmp.try_fold_with(self, DebruijnIndex::INNERMOST)?; - Ok(()) +impl<'db> Filler<'db> { + fn new( + db: &'db dyn HirDatabase, + env: Arc<TraitEnvironment<'db>>, + subst: GenericArgs<'db>, + ) -> Self { + let interner = DbInterner::new_with(db, Some(env.krate), env.block); + let infcx = interner.infer_ctxt().build(TypingMode::PostAnalysis); + Self { infcx, trait_env: env, subst } } - fn fill_subst(&mut self, ty: &mut Substitution) -> Result<(), MirLowerError<'db>> { - let tmp = mem::replace(ty, Substitution::empty(Interner)); - *ty = tmp.try_fold_with(self, DebruijnIndex::INNERMOST)?; - Ok(()) + fn fill<T: TypeFoldable<DbInterner<'db>> + Copy>( + &mut self, + t: &mut T, + ) -> Result<(), MirLowerError<'db>> { + // Can't deep normalized as that'll try to normalize consts and fail. + *t = t.try_fold_with(self)?; + if references_non_lt_error(t) { + Err(MirLowerError::NotSupported("monomorphization resulted in errors".to_owned())) + } else { + Ok(()) + } } - fn fill_operand(&mut self, op: &mut Operand) -> Result<(), MirLowerError<'db>> { + fn fill_operand(&mut self, op: &mut Operand<'db>) -> Result<(), MirLowerError<'db>> { match &mut op.kind { - OperandKind::Constant(c) => { - match &c.data(Interner).value { - chalk_ir::ConstValue::BoundVar(b) => { - let resolved = self - .subst - .as_slice(Interner) - .get(b.index) - .ok_or_else(|| { - MirLowerError::GenericArgNotProvided( - self.generics - .as_ref() - .and_then(|it| it.iter().nth(b.index)) - .and_then(|(id, _)| match id { - hir_def::GenericParamId::ConstParamId(id) => { - Some(hir_def::TypeOrConstParamId::from(id)) - } - hir_def::GenericParamId::TypeParamId(id) => { - Some(hir_def::TypeOrConstParamId::from(id)) - } - _ => None, - }) - .unwrap(), - self.subst.clone(), - ) - })? - .assert_const_ref(Interner); - *c = resolved.clone(); - } - chalk_ir::ConstValue::InferenceVar(_) - | chalk_ir::ConstValue::Placeholder(_) => {} - chalk_ir::ConstValue::Concrete(cc) => match &cc.interned { - crate::ConstScalar::UnevaluatedConst(const_id, subst) => { - let mut subst = subst.clone(); - self.fill_subst(&mut subst)?; - *c = intern_const_scalar( - crate::ConstScalar::UnevaluatedConst(*const_id, subst), - c.data(Interner).ty.clone(), - ); - } - crate::ConstScalar::Bytes(_, _) | crate::ConstScalar::Unknown => (), - }, - } - self.fill_const(c)?; + OperandKind::Constant { konst, ty } => { + self.fill(konst)?; + self.fill(ty)?; } OperandKind::Copy(_) | OperandKind::Move(_) | OperandKind::Static(_) => (), } Ok(()) } - fn fill_body(&mut self, body: &mut MirBody) -> Result<(), MirLowerError<'db>> { + fn fill_body(&mut self, body: &mut MirBody<'db>) -> Result<(), MirLowerError<'db>> { for (_, l) in body.locals.iter_mut() { - self.fill_ty(&mut l.ty)?; + self.fill(&mut l.ty)?; } for (_, bb) in body.basic_blocks.iter_mut() { for statement in &mut bb.statements { @@ -245,20 +142,20 @@ impl<'a, 'db> Filler<'a, 'db> { match ak { super::AggregateKind::Array(ty) | super::AggregateKind::Tuple(ty) - | super::AggregateKind::Closure(ty) => self.fill_ty(ty)?, - super::AggregateKind::Adt(_, subst) => self.fill_subst(subst)?, + | super::AggregateKind::Closure(ty) => self.fill(ty)?, + super::AggregateKind::Adt(_, subst) => self.fill(subst)?, super::AggregateKind::Union(_, _) => (), } } Rvalue::ShallowInitBox(_, ty) | Rvalue::ShallowInitBoxWithAlloc(ty) => { - self.fill_ty(ty)?; + self.fill(ty)?; } Rvalue::Use(op) => { self.fill_operand(op)?; } Rvalue::Repeat(op, len) => { self.fill_operand(op)?; - self.fill_const(len)?; + self.fill(len)?; } Rvalue::Ref(_, _) | Rvalue::Len(_) @@ -312,12 +209,10 @@ impl<'a, 'db> Filler<'a, 'db> { pub fn monomorphized_mir_body_query<'db>( db: &'db dyn HirDatabase, owner: DefWithBodyId, - subst: Substitution, + subst: GenericArgs<'db>, trait_env: Arc<crate::TraitEnvironment<'db>>, -) -> Result<Arc<MirBody>, MirLowerError<'db>> { - let generics = owner.as_generic_def_id(db).map(|g_def| generics(db, g_def)); - let interner = DbInterner::new_with(db, Some(trait_env.krate), trait_env.block); - let filler = &mut Filler { db, subst: &subst, trait_env, generics, interner }; +) -> Result<Arc<MirBody<'db>>, MirLowerError<'db>> { + let mut filler = Filler::new(db, trait_env, subst); let body = db.mir_body(owner)?; let mut body = (*body).clone(); filler.fill_body(&mut body)?; @@ -327,22 +222,19 @@ pub fn monomorphized_mir_body_query<'db>( pub(crate) fn monomorphized_mir_body_cycle_result<'db>( _db: &'db dyn HirDatabase, _: DefWithBodyId, - _: Substitution, + _: GenericArgs<'db>, _: Arc<crate::TraitEnvironment<'db>>, -) -> Result<Arc<MirBody>, MirLowerError<'db>> { +) -> Result<Arc<MirBody<'db>>, MirLowerError<'db>> { Err(MirLowerError::Loop) } pub fn monomorphized_mir_body_for_closure_query<'db>( db: &'db dyn HirDatabase, closure: InternedClosureId, - subst: Substitution, + subst: GenericArgs<'db>, trait_env: Arc<crate::TraitEnvironment<'db>>, -) -> Result<Arc<MirBody>, MirLowerError<'db>> { - let InternedClosure(owner, _) = db.lookup_intern_closure(closure); - let generics = owner.as_generic_def_id(db).map(|g_def| generics(db, g_def)); - let interner = DbInterner::new_with(db, Some(trait_env.krate), trait_env.block); - let filler = &mut Filler { db, subst: &subst, trait_env, generics, interner }; +) -> Result<Arc<MirBody<'db>>, MirLowerError<'db>> { + let mut filler = Filler::new(db, trait_env, subst); let body = db.mir_body_for_closure(closure)?; let mut body = (*body).clone(); filler.fill_body(&mut body)?; diff --git a/crates/hir-ty/src/mir/pretty.rs b/crates/hir-ty/src/mir/pretty.rs index aad54f8843..e46edb8159 100644 --- a/crates/hir-ty/src/mir/pretty.rs +++ b/crates/hir-ty/src/mir/pretty.rs @@ -11,8 +11,7 @@ use hir_expand::{Lookup, name::Name}; use la_arena::ArenaMap; use crate::{ - ClosureId, - db::HirDatabase, + db::{HirDatabase, InternedClosureId}, display::{ClosureStyle, DisplayTarget, HirDisplay}, mir::{PlaceElem, ProjectionElem, StatementKind, TerminatorKind}, }; @@ -37,8 +36,8 @@ macro_rules! wln { }; } -impl MirBody { - pub fn pretty_print(&self, db: &dyn HirDatabase, display_target: DisplayTarget) -> String { +impl<'db> MirBody<'db> { + pub fn pretty_print(&self, db: &'db dyn HirDatabase, display_target: DisplayTarget) -> String { let hir_body = db.body(self.owner); let mut ctx = MirPrettyCtx::new(self, &hir_body, db, display_target); ctx.for_body(|this| match ctx.body.owner { @@ -81,7 +80,7 @@ impl MirBody { // String with lines is rendered poorly in `dbg` macros, which I use very much, so this // function exists to solve that. - pub fn dbg(&self, db: &dyn HirDatabase, display_target: DisplayTarget) -> impl Debug { + pub fn dbg(&self, db: &'db dyn HirDatabase, display_target: DisplayTarget) -> impl Debug { struct StringDbg(String); impl Debug for StringDbg { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { @@ -92,17 +91,17 @@ impl MirBody { } } -struct MirPrettyCtx<'a> { - body: &'a MirBody, +struct MirPrettyCtx<'a, 'db> { + body: &'a MirBody<'db>, hir_body: &'a Body, - db: &'a dyn HirDatabase, + db: &'db dyn HirDatabase, result: String, indent: String, - local_to_binding: ArenaMap<LocalId, BindingId>, + local_to_binding: ArenaMap<LocalId<'db>, BindingId>, display_target: DisplayTarget, } -impl Write for MirPrettyCtx<'_> { +impl Write for MirPrettyCtx<'_, '_> { fn write_str(&mut self, s: &str) -> std::fmt::Result { let mut it = s.split('\n'); // note: `.lines()` is wrong here self.write(it.next().unwrap_or_default()); @@ -114,12 +113,12 @@ impl Write for MirPrettyCtx<'_> { } } -enum LocalName { - Unknown(LocalId), - Binding(Name, LocalId), +enum LocalName<'db> { + Unknown(LocalId<'db>), + Binding(Name, LocalId<'db>), } -impl HirDisplay for LocalName { +impl<'db> HirDisplay for LocalName<'db> { fn hir_fmt( &self, f: &mut crate::display::HirFormatter<'_>, @@ -133,8 +132,8 @@ impl HirDisplay for LocalName { } } -impl<'a> MirPrettyCtx<'a> { - fn for_body(&mut self, name: impl FnOnce(&mut MirPrettyCtx<'_>)) { +impl<'a, 'db> MirPrettyCtx<'a, 'db> { + fn for_body(&mut self, name: impl FnOnce(&mut MirPrettyCtx<'_, 'db>)) { name(self); self.with_block(|this| { this.locals(); @@ -146,8 +145,8 @@ impl<'a> MirPrettyCtx<'a> { } } - fn for_closure(&mut self, closure: ClosureId) { - let body = match self.db.mir_body_for_closure(closure.into()) { + fn for_closure(&mut self, closure: InternedClosureId) { + let body = match self.db.mir_body_for_closure(closure) { Ok(it) => it, Err(e) => { wln!(self, "// error in {closure:?}: {e:?}"); @@ -168,7 +167,7 @@ impl<'a> MirPrettyCtx<'a> { self.indent = ctx.indent; } - fn with_block(&mut self, f: impl FnOnce(&mut MirPrettyCtx<'_>)) { + fn with_block(&mut self, f: impl FnOnce(&mut MirPrettyCtx<'_, 'db>)) { self.indent += " "; wln!(self, "{{"); f(self); @@ -180,9 +179,9 @@ impl<'a> MirPrettyCtx<'a> { } fn new( - body: &'a MirBody, + body: &'a MirBody<'db>, hir_body: &'a Body, - db: &'a dyn HirDatabase, + db: &'db dyn HirDatabase, display_target: DisplayTarget, ) -> Self { let local_to_binding = body.local_to_binding_map(); @@ -217,14 +216,14 @@ impl<'a> MirPrettyCtx<'a> { } } - fn local_name(&self, local: LocalId) -> LocalName { + fn local_name(&self, local: LocalId<'db>) -> LocalName<'db> { match self.local_to_binding.get(local) { Some(b) => LocalName::Binding(self.hir_body[*b].name.clone(), local), None => LocalName::Unknown(local), } } - fn basic_block_id(&self, basic_block_id: BasicBlockId) -> String { + fn basic_block_id(&self, basic_block_id: BasicBlockId<'db>) -> String { format!("'bb{}", u32::from(basic_block_id.into_raw())) } @@ -312,8 +311,12 @@ impl<'a> MirPrettyCtx<'a> { } } - fn place(&mut self, p: &Place) { - fn f(this: &mut MirPrettyCtx<'_>, local: LocalId, projections: &[PlaceElem]) { + fn place(&mut self, p: &Place<'db>) { + fn f<'db>( + this: &mut MirPrettyCtx<'_, 'db>, + local: LocalId<'db>, + projections: &[PlaceElem<'db>], + ) { let Some((last, head)) = projections.split_last() else { // no projection w!(this, "{}", this.local_name(local).display_test(this.db, this.display_target)); @@ -373,19 +376,19 @@ impl<'a> MirPrettyCtx<'a> { f(self, p.local, p.projection.lookup(&self.body.projection_store)); } - fn operand(&mut self, r: &Operand) { + fn operand(&mut self, r: &Operand<'db>) { match &r.kind { OperandKind::Copy(p) | OperandKind::Move(p) => { // MIR at the time of writing doesn't have difference between move and copy, so we show them // equally. Feel free to change it. self.place(p); } - OperandKind::Constant(c) => w!(self, "Const({})", self.hir_display(c)), + OperandKind::Constant { konst, .. } => w!(self, "Const({})", self.hir_display(konst)), OperandKind::Static(s) => w!(self, "Static({:?})", s), } } - fn rvalue(&mut self, r: &Rvalue) { + fn rvalue(&mut self, r: &Rvalue<'db>) { match r { Rvalue::Use(op) => self.operand(op), Rvalue::Ref(r, p) => { @@ -475,7 +478,7 @@ impl<'a> MirPrettyCtx<'a> { } } - fn operand_list(&mut self, it: &[Operand]) { + fn operand_list(&mut self, it: &[Operand<'db>]) { let mut it = it.iter(); if let Some(first) = it.next() { self.operand(first); @@ -486,7 +489,10 @@ impl<'a> MirPrettyCtx<'a> { } } - fn hir_display<T: HirDisplay>(&self, ty: &'a T) -> impl Display + 'a { + fn hir_display<'b, T: HirDisplay>(&self, ty: &'b T) -> impl Display + use<'a, 'b, 'db, T> + where + 'db: 'b, + { ty.display_test(self.db, self.display_target) .with_closure_style(ClosureStyle::ClosureWithSubst) } diff --git a/crates/hir-ty/src/next_solver/consts.rs b/crates/hir-ty/src/next_solver/consts.rs index aae48eeaf9..da86fa3ae5 100644 --- a/crates/hir-ty/src/next_solver/consts.rs +++ b/crates/hir-ty/src/next_solver/consts.rs @@ -4,6 +4,7 @@ use std::hash::Hash; use hir_def::{ConstParamId, TypeOrConstParamId}; use intern::{Interned, Symbol}; +use macros::{TypeFoldable, TypeVisitable}; use rustc_ast_ir::{try_visit, visit::VisitorResult}; use rustc_type_ir::{ BoundVar, FlagComputation, Flags, TypeFoldable, TypeSuperFoldable, TypeSuperVisitable, @@ -23,7 +24,7 @@ use super::{BoundVarKind, DbInterner, ErrorGuaranteed, GenericArgs, Placeholder, pub type ConstKind<'db> = rustc_type_ir::ConstKind<DbInterner<'db>>; pub type UnevaluatedConst<'db> = rustc_type_ir::UnevaluatedConst<DbInterner<'db>>; -#[salsa::interned(constructor = new_, debug)] +#[salsa::interned(constructor = new_)] pub struct Const<'db> { #[returns(ref)] kind_: InternedWrapperNoDebug<WithCachedTypeInfo<ConstKind<'db>>>, @@ -61,6 +62,21 @@ impl<'db> Const<'db> { Const::new(interner, ConstKind::Placeholder(placeholder)) } + pub fn new_valtree( + interner: DbInterner<'db>, + ty: Ty<'db>, + memory: Box<[u8]>, + memory_map: MemoryMap<'db>, + ) -> Self { + Const::new( + interner, + ConstKind::Value(ValueConst { + ty, + value: Valtree::new(ConstBytes { memory, memory_map }), + }), + ) + } + pub fn is_ct_infer(&self) -> bool { matches!(&self.inner().internee, ConstKind::Infer(_)) } @@ -77,6 +93,12 @@ impl<'db> Const<'db> { } } +impl<'db> std::fmt::Debug for Const<'db> { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + self.inner().internee.fmt(f) + } +} + impl<'db> std::fmt::Debug for InternedWrapperNoDebug<WithCachedTypeInfo<ConstKind<'db>>> { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { self.0.internee.fmt(f) @@ -135,9 +157,12 @@ impl ParamConst { /// A type-level constant value. /// /// Represents a typed, fully evaluated constant. -#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)] +#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash, TypeFoldable, TypeVisitable)] pub struct ValueConst<'db> { pub(crate) ty: Ty<'db>, + // FIXME: Should we ignore this for TypeVisitable, TypeFoldable? + #[type_visitable(ignore)] + #[type_foldable(identity)] pub(crate) value: Valtree<'db>, } @@ -158,33 +183,15 @@ impl<'db> rustc_type_ir::inherent::ValueConst<DbInterner<'db>> for ValueConst<'d } } -impl<'db> rustc_type_ir::TypeVisitable<DbInterner<'db>> for ValueConst<'db> { - fn visit_with<V: rustc_type_ir::TypeVisitor<DbInterner<'db>>>( - &self, - visitor: &mut V, - ) -> V::Result { - self.ty.visit_with(visitor) - } -} - -impl<'db> rustc_type_ir::TypeFoldable<DbInterner<'db>> for ValueConst<'db> { - fn fold_with<F: rustc_type_ir::TypeFolder<DbInterner<'db>>>(self, folder: &mut F) -> Self { - ValueConst { ty: self.ty.fold_with(folder), value: self.value } - } - fn try_fold_with<F: rustc_type_ir::FallibleTypeFolder<DbInterner<'db>>>( - self, - folder: &mut F, - ) -> Result<Self, F::Error> { - Ok(ValueConst { ty: self.ty.try_fold_with(folder)?, value: self.value }) - } -} - #[derive(Debug, Clone, PartialEq, Eq)] -pub struct ConstBytes<'db>(pub Box<[u8]>, pub MemoryMap<'db>); +pub struct ConstBytes<'db> { + pub memory: Box<[u8]>, + pub memory_map: MemoryMap<'db>, +} impl Hash for ConstBytes<'_> { fn hash<H: std::hash::Hasher>(&self, state: &mut H) { - self.0.hash(state) + self.memory.hash(state) } } @@ -212,7 +219,7 @@ impl<'db> Valtree<'db> { } } -#[derive(Copy, Clone, Debug, Hash, PartialEq, Eq)] +#[derive(Copy, Clone, Debug, Hash, PartialEq, Eq, TypeVisitable, TypeFoldable)] pub struct ExprConst; impl rustc_type_ir::inherent::ParamLike for ParamConst { @@ -412,29 +419,6 @@ impl<'db> PlaceholderLike<DbInterner<'db>> for PlaceholderConst { } } -impl<'db> TypeVisitable<DbInterner<'db>> for ExprConst { - fn visit_with<V: rustc_type_ir::TypeVisitor<DbInterner<'db>>>( - &self, - visitor: &mut V, - ) -> V::Result { - // Ensure we get back to this when we fill in the fields - let ExprConst = &self; - V::Result::output() - } -} - -impl<'db> TypeFoldable<DbInterner<'db>> for ExprConst { - fn try_fold_with<F: rustc_type_ir::FallibleTypeFolder<DbInterner<'db>>>( - self, - folder: &mut F, - ) -> Result<Self, F::Error> { - Ok(ExprConst) - } - fn fold_with<F: rustc_type_ir::TypeFolder<DbInterner<'db>>>(self, folder: &mut F) -> Self { - ExprConst - } -} - impl<'db> Relate<DbInterner<'db>> for ExprConst { fn relate<R: rustc_type_ir::relate::TypeRelation<DbInterner<'db>>>( relation: &mut R, diff --git a/crates/hir-ty/src/next_solver/def_id.rs b/crates/hir-ty/src/next_solver/def_id.rs index 918a311ea9..3e4c4171be 100644 --- a/crates/hir-ty/src/next_solver/def_id.rs +++ b/crates/hir-ty/src/next_solver/def_id.rs @@ -1,8 +1,8 @@ //! Definition of `SolverDefId` use hir_def::{ - AdtId, CallableDefId, ConstId, EnumId, EnumVariantId, FunctionId, GenericDefId, ImplId, - StaticId, StructId, TraitId, TypeAliasId, UnionId, + AdtId, CallableDefId, ConstId, EnumId, EnumVariantId, FunctionId, GeneralConstId, GenericDefId, + ImplId, StaticId, StructId, TraitId, TypeAliasId, UnionId, }; use rustc_type_ir::inherent; use stdx::impl_from; @@ -119,6 +119,16 @@ impl From<GenericDefId> for SolverDefId { } } +impl From<GeneralConstId> for SolverDefId { + #[inline] + fn from(value: GeneralConstId) -> Self { + match value { + GeneralConstId::ConstId(const_id) => SolverDefId::ConstId(const_id), + GeneralConstId::StaticId(static_id) => SolverDefId::StaticId(static_id), + } + } +} + impl TryFrom<SolverDefId> for GenericDefId { type Error = SolverDefId; diff --git a/crates/hir-ty/src/next_solver/generic_arg.rs b/crates/hir-ty/src/next_solver/generic_arg.rs index 89a4d9202a..79527dac2f 100644 --- a/crates/hir-ty/src/next_solver/generic_arg.rs +++ b/crates/hir-ty/src/next_solver/generic_arg.rs @@ -2,6 +2,7 @@ use hir_def::{GenericDefId, GenericParamId}; use intern::{Interned, Symbol}; +use macros::{TypeFoldable, TypeVisitable}; use rustc_type_ir::inherent::Const as _; use rustc_type_ir::{ ClosureArgs, CollectAndApply, ConstVid, CoroutineArgs, CoroutineClosureArgs, FnSig, FnSigTys, @@ -23,7 +24,7 @@ use super::{ interned_vec_db, }; -#[derive(Copy, Clone, PartialEq, Eq, Hash)] +#[derive(Copy, Clone, PartialEq, Eq, Hash, TypeVisitable, TypeFoldable)] pub enum GenericArg<'db> { Ty(Ty<'db>), Lifetime(Region<'db>), @@ -55,6 +56,13 @@ impl<'db> GenericArg<'db> { } } + pub fn konst(self) -> Option<Const<'db>> { + match self.kind() { + GenericArgKind::Const(konst) => Some(konst), + _ => None, + } + } + pub fn region(self) -> Option<Region<'db>> { match self.kind() { GenericArgKind::Lifetime(r) => Some(r), @@ -72,7 +80,7 @@ impl<'db> From<Term<'db>> for GenericArg<'db> { } } -#[derive(Copy, Clone, PartialEq, Eq, Hash)] +#[derive(Copy, Clone, PartialEq, Eq, Hash, TypeVisitable, TypeFoldable)] pub enum Term<'db> { Ty(Ty<'db>), Const(Const<'db>), @@ -130,39 +138,6 @@ impl<'db> IntoKind for GenericArg<'db> { } } -impl<'db> TypeVisitable<DbInterner<'db>> for GenericArg<'db> { - fn visit_with<V: rustc_type_ir::TypeVisitor<DbInterner<'db>>>( - &self, - visitor: &mut V, - ) -> V::Result { - match self { - GenericArg::Lifetime(lt) => lt.visit_with(visitor), - GenericArg::Ty(ty) => ty.visit_with(visitor), - GenericArg::Const(ct) => ct.visit_with(visitor), - } - } -} - -impl<'db> TypeFoldable<DbInterner<'db>> for GenericArg<'db> { - fn try_fold_with<F: rustc_type_ir::FallibleTypeFolder<DbInterner<'db>>>( - self, - folder: &mut F, - ) -> Result<Self, F::Error> { - match self.kind() { - GenericArgKind::Lifetime(lt) => lt.try_fold_with(folder).map(Into::into), - GenericArgKind::Type(ty) => ty.try_fold_with(folder).map(Into::into), - GenericArgKind::Const(ct) => ct.try_fold_with(folder).map(Into::into), - } - } - fn fold_with<F: rustc_type_ir::TypeFolder<DbInterner<'db>>>(self, folder: &mut F) -> Self { - match self.kind() { - GenericArgKind::Lifetime(lt) => lt.fold_with(folder).into(), - GenericArgKind::Type(ty) => ty.fold_with(folder).into(), - GenericArgKind::Const(ct) => ct.fold_with(folder).into(), - } - } -} - impl<'db> Relate<DbInterner<'db>> for GenericArg<'db> { fn relate<R: rustc_type_ir::relate::TypeRelation<DbInterner<'db>>>( relation: &mut R, @@ -553,36 +528,6 @@ impl<'db> From<Const<'db>> for Term<'db> { } } -impl<'db> TypeVisitable<DbInterner<'db>> for Term<'db> { - fn visit_with<V: rustc_type_ir::TypeVisitor<DbInterner<'db>>>( - &self, - visitor: &mut V, - ) -> V::Result { - match self { - Term::Ty(ty) => ty.visit_with(visitor), - Term::Const(ct) => ct.visit_with(visitor), - } - } -} - -impl<'db> TypeFoldable<DbInterner<'db>> for Term<'db> { - fn try_fold_with<F: rustc_type_ir::FallibleTypeFolder<DbInterner<'db>>>( - self, - folder: &mut F, - ) -> Result<Self, F::Error> { - match self.kind() { - TermKind::Ty(ty) => ty.try_fold_with(folder).map(Into::into), - TermKind::Const(ct) => ct.try_fold_with(folder).map(Into::into), - } - } - fn fold_with<F: rustc_type_ir::TypeFolder<DbInterner<'db>>>(self, folder: &mut F) -> Self { - match self.kind() { - TermKind::Ty(ty) => ty.fold_with(folder).into(), - TermKind::Const(ct) => ct.fold_with(folder).into(), - } - } -} - impl<'db> Relate<DbInterner<'db>> for Term<'db> { fn relate<R: rustc_type_ir::relate::TypeRelation<DbInterner<'db>>>( relation: &mut R, diff --git a/crates/hir-ty/src/next_solver/infer/select.rs b/crates/hir-ty/src/next_solver/infer/select.rs index 392e2b9329..79b0a29332 100644 --- a/crates/hir-ty/src/next_solver/infer/select.rs +++ b/crates/hir-ty/src/next_solver/infer/select.rs @@ -1,6 +1,7 @@ use std::ops::ControlFlow; use hir_def::{ImplId, TraitId}; +use macros::{TypeFoldable, TypeVisitable}; use rustc_type_ir::{ Interner, solve::{BuiltinImplSource, CandidateSource, Certainty, inspect::ProbeKind}, @@ -177,7 +178,7 @@ pub type SelectionResult<'db, T> = Result<Option<T>, SelectionError<'db>>; /// ### The type parameter `N` /// /// See explanation on `ImplSourceUserDefinedData`. -#[derive(Debug, Clone, PartialEq, Eq, Hash)] +#[derive(Debug, Clone, PartialEq, Eq, Hash, TypeVisitable, TypeFoldable)] pub enum ImplSource<'db, N> { /// ImplSource identifying a particular impl. UserDefined(ImplSourceUserDefinedData<'db, N>), @@ -242,8 +243,10 @@ impl<'db, N> ImplSource<'db, N> { /// is `Obligation`, as one might expect. During codegen, however, this /// is `()`, because codegen only requires a shallow resolution of an /// impl, and nested obligations are satisfied later. -#[derive(Debug, Clone, PartialEq, Eq, Hash)] +#[derive(Debug, Clone, PartialEq, Eq, Hash, TypeVisitable, TypeFoldable)] pub struct ImplSourceUserDefinedData<'db, N> { + #[type_visitable(ignore)] + #[type_foldable(identity)] pub impl_def_id: ImplId, pub args: GenericArgs<'db>, pub nested: Vec<N>, diff --git a/crates/hir-ty/src/next_solver/infer/traits.rs b/crates/hir-ty/src/next_solver/infer/traits.rs index 9fa1fa7fb4..bc905c2e0b 100644 --- a/crates/hir-ty/src/next_solver/infer/traits.rs +++ b/crates/hir-ty/src/next_solver/infer/traits.rs @@ -8,6 +8,7 @@ use std::{ }; use hir_def::TraitId; +use macros::{TypeFoldable, TypeVisitable}; use rustc_type_ir::elaborate::Elaboratable; use rustc_type_ir::{ PredicatePolarity, Upcast, @@ -65,8 +66,10 @@ impl ObligationCause { /// either identifying an `impl` (e.g., `impl Eq for i32`) that /// satisfies the obligation, or else finding a bound that is in /// scope. The eventual result is usually a `Selection` (defined below). -#[derive(Clone, Debug)] +#[derive(Clone, Debug, TypeVisitable, TypeFoldable)] pub struct Obligation<'db, T> { + #[type_foldable(identity)] + #[type_visitable(ignore)] /// The reason we have to prove this thing. pub cause: ObligationCause, @@ -117,39 +120,6 @@ impl<'db> Elaboratable<DbInterner<'db>> for PredicateObligation<'db> { } } -impl<'db, T: TypeVisitable<DbInterner<'db>>> TypeVisitable<DbInterner<'db>> for Obligation<'db, T> { - fn visit_with<V: rustc_type_ir::TypeVisitor<DbInterner<'db>>>( - &self, - visitor: &mut V, - ) -> V::Result { - rustc_ast_ir::try_visit!(self.param_env.visit_with(visitor)); - self.predicate.visit_with(visitor) - } -} - -impl<'db, T: TypeFoldable<DbInterner<'db>>> TypeFoldable<DbInterner<'db>> for Obligation<'db, T> { - fn try_fold_with<F: rustc_type_ir::FallibleTypeFolder<DbInterner<'db>>>( - self, - folder: &mut F, - ) -> Result<Self, F::Error> { - Ok(Obligation { - cause: self.cause.clone(), - param_env: self.param_env.try_fold_with(folder)?, - predicate: self.predicate.try_fold_with(folder)?, - recursion_depth: self.recursion_depth, - }) - } - - fn fold_with<F: rustc_type_ir::TypeFolder<DbInterner<'db>>>(self, folder: &mut F) -> Self { - Obligation { - cause: self.cause.clone(), - param_env: self.param_env.fold_with(folder), - predicate: self.predicate.fold_with(folder), - recursion_depth: self.recursion_depth, - } - } -} - impl<'db, T: Copy> Obligation<'db, T> { pub fn as_goal(&self) -> Goal<'db, T> { Goal { param_env: self.param_env, predicate: self.predicate } diff --git a/crates/hir-ty/src/next_solver/interner.rs b/crates/hir-ty/src/next_solver/interner.rs index 4a0ede35ac..cd1667527b 100644 --- a/crates/hir-ty/src/next_solver/interner.rs +++ b/crates/hir-ty/src/next_solver/interner.rs @@ -1,77 +1,81 @@ //! Things related to the Interner in the next-trait-solver. -#![allow(unused)] +#![allow(unused)] // FIXME(next-solver): Remove this. + +use std::{fmt, ops::ControlFlow}; pub use tls_db::{attach_db, attach_db_allow_change, with_attached_db}; use base_db::Crate; use chalk_ir::{ProgramClauseImplication, SeparatorTraitRef, Variances}; -use hir_def::lang_item::LangItem; -use hir_def::signatures::{FieldData, FnFlags, ImplFlags, StructFlags, TraitFlags}; -use hir_def::{AdtId, BlockId, GenericDefId, TypeAliasId, VariantId}; -use hir_def::{AttrDefId, Lookup}; -use hir_def::{CallableDefId, EnumVariantId, ItemContainerId, StructId, UnionId}; +use hir_def::{ + AdtId, AttrDefId, BlockId, CallableDefId, EnumVariantId, GenericDefId, ItemContainerId, Lookup, + StructId, TypeAliasId, UnionId, VariantId, + lang_item::LangItem, + signatures::{FieldData, FnFlags, ImplFlags, StructFlags, TraitFlags}, +}; use intern::sym::non_exhaustive; use intern::{Interned, impl_internable, sym}; use la_arena::Idx; use rustc_abi::{Align, ReprFlags, ReprOptions}; +use rustc_ast_ir::visit::VisitorResult; use rustc_hash::FxHashSet; -use rustc_index::bit_set::DenseBitSet; -use rustc_type_ir::elaborate::elaborate; -use rustc_type_ir::error::TypeError; -use rustc_type_ir::inherent::{ - AdtDef as _, GenericArgs as _, GenericsOf, IntoKind, SliceLike as _, Span as _, -}; -use rustc_type_ir::lang_items::{SolverAdtLangItem, SolverLangItem, SolverTraitLangItem}; -use rustc_type_ir::solve::SizedTraitKind; +use rustc_index::{IndexVec, bit_set::DenseBitSet}; use rustc_type_ir::{ - AliasTerm, AliasTermKind, AliasTy, AliasTyKind, EarlyBinder, FlagComputation, Flags, - ImplPolarity, InferTy, ProjectionPredicate, TraitPredicate, TraitRef, Upcast, + AliasTerm, AliasTermKind, AliasTy, AliasTyKind, BoundVar, CollectAndApply, DebruijnIndex, + EarlyBinder, FlagComputation, Flags, GenericArgKind, ImplPolarity, InferTy, + ProjectionPredicate, RegionKind, TermKind, TraitPredicate, TraitRef, TypeVisitableExt, + UniverseIndex, Upcast, Variance, WithCachedTypeInfo, + elaborate::{self, elaborate}, + error::TypeError, + inherent::{ + self, AdtDef as _, Const as _, GenericArgs as _, GenericsOf, IntoKind, ParamEnv as _, + Region as _, SliceLike as _, Span as _, Ty as _, + }, + ir_print, + lang_items::{SolverAdtLangItem, SolverLangItem, SolverTraitLangItem}, + relate, + solve::SizedTraitKind, }; use salsa::plumbing::AsId; use smallvec::{SmallVec, smallvec}; -use std::fmt; -use std::ops::ControlFlow; use syntax::ast::SelfParamKind; +use tracing::debug; use triomphe::Arc; -use rustc_ast_ir::visit::VisitorResult; -use rustc_index::IndexVec; -use rustc_type_ir::TypeVisitableExt; -use rustc_type_ir::{ - BoundVar, CollectAndApply, DebruijnIndex, GenericArgKind, RegionKind, TermKind, UniverseIndex, - Variance, WithCachedTypeInfo, elaborate, - inherent::{self, Const as _, Region as _, Ty as _}, - ir_print, relate, -}; - -use crate::lower_nextsolver::{self, TyLoweringContext}; -use crate::method_resolution::{ALL_FLOAT_FPS, ALL_INT_FPS, TyFingerprint}; -use crate::next_solver::infer::InferCtxt; -use crate::next_solver::util::{ContainsTypeErrors, explicit_item_bounds, for_trait_impls}; -use crate::next_solver::{ - AdtIdWrapper, BoundConst, CallableIdWrapper, CanonicalVarKind, ClosureIdWrapper, - CoroutineIdWrapper, Ctor, FnSig, FxIndexMap, ImplIdWrapper, InternedWrapperNoDebug, - RegionAssumptions, SolverContext, SolverDefIds, TraitIdWrapper, TypeAliasIdWrapper, +use crate::{ + ConstScalar, FnAbi, Interner, + db::HirDatabase, + lower_nextsolver::{self, TyLoweringContext}, + method_resolution::{ALL_FLOAT_FPS, ALL_INT_FPS, TyFingerprint}, + next_solver::{ + AdtIdWrapper, BoundConst, CallableIdWrapper, CanonicalVarKind, ClosureIdWrapper, + CoroutineIdWrapper, Ctor, FnSig, FxIndexMap, ImplIdWrapper, InternedWrapperNoDebug, + RegionAssumptions, SolverContext, SolverDefIds, TraitIdWrapper, TypeAliasIdWrapper, + TypingMode, + infer::{ + DbInternerInferExt, InferCtxt, + traits::{Obligation, ObligationCause}, + }, + obligation_ctxt::ObligationCtxt, + util::{ContainsTypeErrors, explicit_item_bounds, for_trait_impls}, + }, }; -use crate::{ConstScalar, FnAbi, Interner, db::HirDatabase}; -use super::generics::generics; -use super::util::sizedness_constraint_for_ty; use super::{ Binder, BoundExistentialPredicate, BoundExistentialPredicates, BoundTy, BoundTyKind, Clause, - Clauses, Const, ConstKind, ErrorGuaranteed, ExprConst, ExternalConstraints, + ClauseKind, Clauses, Const, ConstKind, ErrorGuaranteed, ExprConst, ExternalConstraints, ExternalConstraintsData, GenericArg, GenericArgs, InternedClausesWrapper, ParamConst, ParamEnv, ParamTy, PlaceholderConst, PlaceholderTy, PredefinedOpaques, PredefinedOpaquesData, Predicate, - PredicateKind, Term, Ty, TyKind, Tys, ValueConst, + PredicateKind, SolverDefId, Term, Ty, TyKind, Tys, Valtree, ValueConst, abi::Safety, fold::{BoundVarReplacer, BoundVarReplacerDelegate, FnMutDelegate}, - generics::Generics, + generics::{Generics, generics}, mapping::ChalkToNextSolver, region::{ BoundRegion, BoundRegionKind, EarlyParamRegion, LateParamRegion, PlaceholderRegion, Region, }, + util::sizedness_constraint_for_ty, }; -use super::{ClauseKind, SolverDefId, Valtree}; #[macro_export] #[doc(hidden)] @@ -1102,7 +1106,15 @@ impl<'db> rustc_type_ir::Interner for DbInterner<'db> { fn alias_ty_kind(self, alias: rustc_type_ir::AliasTy<Self>) -> AliasTyKind { match alias.def_id { SolverDefId::InternedOpaqueTyId(_) => AliasTyKind::Opaque, - SolverDefId::TypeAliasId(_) => AliasTyKind::Projection, + SolverDefId::TypeAliasId(type_alias) => match type_alias.loc(self.db).container { + ItemContainerId::ImplId(impl_) + if self.db.impl_signature(impl_).target_trait.is_none() => + { + AliasTyKind::Inherent + } + ItemContainerId::TraitId(_) | ItemContainerId::ImplId(_) => AliasTyKind::Projection, + _ => AliasTyKind::Free, + }, _ => unimplemented!("Unexpected alias: {:?}", alias.def_id), } } @@ -1113,7 +1125,19 @@ impl<'db> rustc_type_ir::Interner for DbInterner<'db> { ) -> rustc_type_ir::AliasTermKind { match alias.def_id { SolverDefId::InternedOpaqueTyId(_) => AliasTermKind::OpaqueTy, - SolverDefId::TypeAliasId(_) => AliasTermKind::ProjectionTy, + SolverDefId::TypeAliasId(type_alias) => match type_alias.loc(self.db).container { + ItemContainerId::ImplId(impl_) + if self.db.impl_signature(impl_).target_trait.is_none() => + { + AliasTermKind::InherentTy + } + ItemContainerId::TraitId(_) | ItemContainerId::ImplId(_) => { + AliasTermKind::ProjectionTy + } + _ => AliasTermKind::FreeTy, + }, + // rustc creates an `AnonConst` for consts, and evaluates them with CTFE (normalizing projections + // via selection, similar to ours `find_matching_impl()`, and not with the trait solver), so mimic it. SolverDefId::ConstId(_) => AliasTermKind::UnevaluatedConst, _ => unimplemented!("Unexpected alias: {:?}", alias.def_id), } @@ -1676,8 +1700,7 @@ impl<'db> rustc_type_ir::Interner for DbInterner<'db> { } fn impl_is_default(self, impl_def_id: Self::ImplId) -> bool { - // FIXME - false + self.db.impl_signature(impl_def_id.0).is_default() } #[tracing::instrument(skip(self), ret)] @@ -1731,7 +1754,7 @@ impl<'db> rustc_type_ir::Interner for DbInterner<'db> { } fn delay_bug(self, msg: impl ToString) -> Self::ErrorGuaranteed { - panic!("Bug encountered in next-trait-solver.") + panic!("Bug encountered in next-trait-solver: {}", msg.to_string()) } fn is_general_coroutine(self, coroutine_def_id: Self::CoroutineId) -> bool { @@ -1929,7 +1952,12 @@ impl<'db> rustc_type_ir::Interner for DbInterner<'db> { false } - fn impl_specializes(self, impl_def_id: Self::ImplId, victim_def_id: Self::ImplId) -> bool { + // FIXME(next-solver): Make this a query? Can this make cycles? + fn impl_specializes( + self, + specializing_impl_def_id: Self::ImplId, + parent_impl_def_id: Self::ImplId, + ) -> bool { false } diff --git a/crates/hir-ty/src/next_solver/mapping.rs b/crates/hir-ty/src/next_solver/mapping.rs index b32a5ec292..1a5982cc00 100644 --- a/crates/hir-ty/src/next_solver/mapping.rs +++ b/crates/hir-ty/src/next_solver/mapping.rs @@ -539,7 +539,7 @@ impl<'db> ChalkToNextSolver<'db, Const<'db>> for chalk_ir::Const<Interner> { ConstScalar::Bytes(bytes, memory) => { rustc_type_ir::ConstKind::Value(ValueConst::new( data.ty.to_nextsolver(interner), - ConstBytes(bytes.clone(), memory.clone()), + ConstBytes { memory: bytes.clone(), memory_map: memory.clone() }, )) } ConstScalar::UnevaluatedConst(c, subst) => { @@ -1710,8 +1710,10 @@ pub fn convert_const_for_result<'db>( let bytes = value_const.value.inner(); let value = chalk_ir::ConstValue::Concrete(chalk_ir::ConcreteConst { // SAFETY: we will never actually use this without a database - interned: ConstScalar::Bytes(bytes.0.clone(), unsafe { - std::mem::transmute::<MemoryMap<'db>, MemoryMap<'static>>(bytes.1.clone()) + interned: ConstScalar::Bytes(bytes.memory.clone(), unsafe { + std::mem::transmute::<MemoryMap<'db>, MemoryMap<'static>>( + bytes.memory_map.clone(), + ) }), }); return chalk_ir::ConstData { diff --git a/crates/hir-ty/src/next_solver/predicate.rs b/crates/hir-ty/src/next_solver/predicate.rs index 1623fa342a..9dda9d06da 100644 --- a/crates/hir-ty/src/next_solver/predicate.rs +++ b/crates/hir-ty/src/next_solver/predicate.rs @@ -3,6 +3,7 @@ use std::cmp::Ordering; use intern::Interned; +use macros::{TypeFoldable, TypeVisitable}; use rustc_ast_ir::try_visit; use rustc_type_ir::{ self as ty, CollectAndApply, DebruijnIndex, EarlyBinder, FlagComputation, Flags, @@ -424,7 +425,7 @@ impl<'db> rustc_type_ir::TypeSuperVisitable<DbInterner<'db>> for Clauses<'db> { pub struct Clause<'db>(pub(crate) Predicate<'db>); // We could cram the reveal into the clauses like rustc does, probably -#[derive(Copy, Clone, Debug, Hash, PartialEq, Eq)] +#[derive(Copy, Clone, Debug, Hash, PartialEq, Eq, TypeVisitable, TypeFoldable)] pub struct ParamEnv<'db> { pub(crate) clauses: Clauses<'db>, } @@ -435,28 +436,6 @@ impl<'db> ParamEnv<'db> { } } -impl<'db> TypeVisitable<DbInterner<'db>> for ParamEnv<'db> { - fn visit_with<V: rustc_type_ir::TypeVisitor<DbInterner<'db>>>( - &self, - visitor: &mut V, - ) -> V::Result { - try_visit!(self.clauses.visit_with(visitor)); - V::Result::output() - } -} - -impl<'db> TypeFoldable<DbInterner<'db>> for ParamEnv<'db> { - fn try_fold_with<F: rustc_type_ir::FallibleTypeFolder<DbInterner<'db>>>( - self, - folder: &mut F, - ) -> Result<Self, F::Error> { - Ok(ParamEnv { clauses: self.clauses.try_fold_with(folder)? }) - } - fn fold_with<F: rustc_type_ir::TypeFolder<DbInterner<'db>>>(self, folder: &mut F) -> Self { - ParamEnv { clauses: self.clauses.fold_with(folder) } - } -} - impl<'db> rustc_type_ir::inherent::ParamEnv<DbInterner<'db>> for ParamEnv<'db> { fn caller_bounds(self) -> impl rustc_type_ir::inherent::SliceLike<Item = Clause<'db>> { self.clauses diff --git a/crates/hir-ty/src/next_solver/solver.rs b/crates/hir-ty/src/next_solver/solver.rs index a161423da4..2457447ee3 100644 --- a/crates/hir-ty/src/next_solver/solver.rs +++ b/crates/hir-ty/src/next_solver/solver.rs @@ -149,13 +149,9 @@ impl<'db> SolverDelegate for SolverContext<'db> { fn fetch_eligible_assoc_item( &self, goal_trait_ref: rustc_type_ir::TraitRef<Self::Interner>, - trait_assoc_def_id: <Self::Interner as rustc_type_ir::Interner>::DefId, + trait_assoc_def_id: SolverDefId, impl_id: ImplIdWrapper, - ) -> Result<Option<<Self::Interner as rustc_type_ir::Interner>::DefId>, ErrorGuaranteed> { - let trait_assoc_id = match trait_assoc_def_id { - SolverDefId::TypeAliasId(id) => id, - _ => panic!("Unexpected SolverDefId"), - }; + ) -> Result<Option<SolverDefId>, ErrorGuaranteed> { let trait_ = self .0 .interner @@ -167,18 +163,47 @@ impl<'db> SolverDelegate for SolverContext<'db> { .def_id .0; let trait_data = trait_.trait_items(self.0.interner.db()); - let id = - impl_id.0.impl_items(self.0.interner.db()).items.iter().find_map(|item| -> Option<_> { - match item { - (_, AssocItemId::TypeAliasId(type_alias)) => { - let name = &self.0.interner.db().type_alias_signature(*type_alias).name; - let found_trait_assoc_id = trait_data.associated_type_by_name(name)?; - (found_trait_assoc_id == trait_assoc_id).then_some(*type_alias) - } - _ => None, - } - }); - Ok(id.map(SolverDefId::TypeAliasId)) + let impl_items = impl_id.0.impl_items(self.0.interner.db()); + let id = match trait_assoc_def_id { + SolverDefId::TypeAliasId(trait_assoc_id) => { + let trait_assoc_data = self.0.interner.db.type_alias_signature(trait_assoc_id); + impl_items + .items + .iter() + .find_map(|(impl_assoc_name, impl_assoc_id)| { + if let AssocItemId::TypeAliasId(impl_assoc_id) = *impl_assoc_id + && *impl_assoc_name == trait_assoc_data.name + { + Some(impl_assoc_id) + } else { + None + } + }) + .map(SolverDefId::TypeAliasId) + } + SolverDefId::ConstId(trait_assoc_id) => { + let trait_assoc_data = self.0.interner.db.const_signature(trait_assoc_id); + let trait_assoc_name = trait_assoc_data + .name + .as_ref() + .expect("unnamed consts should not get passed to the solver"); + impl_items + .items + .iter() + .find_map(|(impl_assoc_name, impl_assoc_id)| { + if let AssocItemId::ConstId(impl_assoc_id) = *impl_assoc_id + && impl_assoc_name == trait_assoc_name + { + Some(impl_assoc_id) + } else { + None + } + }) + .map(SolverDefId::ConstId) + } + _ => panic!("Unexpected SolverDefId"), + }; + Ok(id) } fn is_transmutable( @@ -200,9 +225,9 @@ impl<'db> SolverDelegate for SolverContext<'db> { SolverDefId::StaticId(c) => GeneralConstId::StaticId(c), _ => unreachable!(), }; - let subst = uv.args.to_chalk(self.interner); + let subst = uv.args; let ec = self.cx().db.const_eval(c, subst, None).ok()?; - Some(ec.to_nextsolver(self.interner)) + Some(ec) } fn compute_goal_fast_path( diff --git a/crates/hir-ty/src/next_solver/ty.rs b/crates/hir-ty/src/next_solver/ty.rs index 11ca0b03eb..c5969120c9 100644 --- a/crates/hir-ty/src/next_solver/ty.rs +++ b/crates/hir-ty/src/next_solver/ty.rs @@ -8,11 +8,10 @@ use hir_def::{AdtId, GenericDefId, TypeOrConstParamId, TypeParamId}; use intern::{Interned, Symbol, sym}; use rustc_abi::{Float, Integer, Size}; use rustc_ast_ir::{Mutability, try_visit, visit::VisitorResult}; -use rustc_type_ir::TyVid; use rustc_type_ir::{ BoundVar, ClosureKind, CollectAndApply, FlagComputation, Flags, FloatTy, FloatVid, InferTy, - IntTy, IntVid, Interner, TypeFoldable, TypeSuperFoldable, TypeSuperVisitable, TypeVisitable, - TypeVisitableExt, TypeVisitor, UintTy, WithCachedTypeInfo, + IntTy, IntVid, Interner, TyVid, TypeFoldable, TypeSuperFoldable, TypeSuperVisitable, + TypeVisitable, TypeVisitableExt, TypeVisitor, UintTy, WithCachedTypeInfo, inherent::{ Abi, AdtDef as _, BoundVarLike, Const as _, GenericArgs as _, IntoKind, ParamLike, PlaceholderLike, Safety as _, SliceLike, Ty as _, @@ -24,14 +23,13 @@ use rustc_type_ir::{ use salsa::plumbing::{AsId, FromId}; use smallvec::SmallVec; -use crate::next_solver::{AdtDef, Binder}; use crate::{ FnAbi, db::HirDatabase, interner::InternedWrapperNoDebug, next_solver::{ - CallableIdWrapper, ClosureIdWrapper, Const, CoroutineIdWrapper, FnSig, GenericArg, - PolyFnSig, TypeAliasIdWrapper, + AdtDef, Binder, CallableIdWrapper, ClosureIdWrapper, Const, CoroutineIdWrapper, FnSig, + GenericArg, PolyFnSig, Region, TypeAliasIdWrapper, abi::Safety, util::{CoroutineArgsExt, IntegerTypeExt}, }, @@ -392,7 +390,7 @@ impl<'db> Ty<'db> { /// Whether the type contains some non-lifetime, aka. type or const, error type. pub fn references_non_lt_error(self) -> bool { - self.references_error() && self.visit_with(&mut ReferencesNonLifetimeError).is_break() + references_non_lt_error(&self) } pub fn callable_sig(self, interner: DbInterner<'db>) -> Option<Binder<'db, FnSig<'db>>> { @@ -409,6 +407,13 @@ impl<'db> Ty<'db> { } } + pub fn as_reference(self) -> Option<(Ty<'db>, Region<'db>, Mutability)> { + match self.kind() { + TyKind::Ref(lifetime, ty, mutability) => Some((ty, lifetime, mutability)), + _ => None, + } + } + pub fn as_reference_or_ptr(self) -> Option<(Ty<'db>, Rawness, Mutability)> { match self.kind() { TyKind::Ref(_, ty, mutability) => Some((ty, Rawness::Ref, mutability)), @@ -417,6 +422,18 @@ impl<'db> Ty<'db> { } } + pub fn strip_references(self) -> Ty<'db> { + let mut t = self; + while let TyKind::Ref(_lifetime, ty, _mutability) = t.kind() { + t = ty; + } + t + } + + pub fn strip_reference(self) -> Ty<'db> { + self.as_reference().map_or(self, |(ty, _, _)| ty) + } + /// Replace infer vars with errors. /// /// This needs to be called for every type that may contain infer vars and is yielded to outside inference, @@ -428,6 +445,10 @@ impl<'db> Ty<'db> { } } +pub fn references_non_lt_error<'db, T: TypeVisitableExt<DbInterner<'db>>>(t: &T) -> bool { + t.references_error() && t.visit_with(&mut ReferencesNonLifetimeError).is_break() +} + struct ReferencesNonLifetimeError; impl<'db> TypeVisitor<DbInterner<'db>> for ReferencesNonLifetimeError { diff --git a/crates/hir-ty/src/utils.rs b/crates/hir-ty/src/utils.rs index 427c4bb684..e989e4c006 100644 --- a/crates/hir-ty/src/utils.rs +++ b/crates/hir-ty/src/utils.rs @@ -20,11 +20,10 @@ use hir_expand::name::Name; use intern::sym; use rustc_abi::TargetDataLayout; use rustc_hash::FxHashSet; -use rustc_type_ir::inherent::{GenericArgs, IntoKind, SliceLike}; +use rustc_type_ir::inherent::{IntoKind, SliceLike}; use smallvec::{SmallVec, smallvec}; use span::Edition; -use crate::next_solver::mapping::NextSolverToChalk; use crate::{ ChalkTraitId, Const, ConstScalar, Interner, Substitution, TargetFeatures, TraitRef, TraitRefExt, Ty, @@ -34,7 +33,7 @@ use crate::{ mir::pad16, next_solver::{ DbInterner, - mapping::{ChalkToNextSolver, convert_args_for_result}, + mapping::{ChalkToNextSolver, NextSolverToChalk, convert_args_for_result}, }, to_chalk_trait_id, }; @@ -196,15 +195,6 @@ pub(super) fn associated_type_by_name_including_super_traits( pub(crate) struct ClosureSubst<'a>(pub(crate) &'a Substitution); impl<'a> ClosureSubst<'a> { - pub(crate) fn parent_subst(&self, db: &dyn HirDatabase) -> Substitution { - let interner = DbInterner::new_with(db, None, None); - let subst = - <Substitution as ChalkToNextSolver<crate::next_solver::GenericArgs<'_>>>::to_nextsolver( - self.0, interner, - ); - subst.split_closure_args().parent_args.to_chalk(interner) - } - pub(crate) fn sig_ty(&self, db: &dyn HirDatabase) -> Ty { let interner = DbInterner::new_with(db, None, None); let subst = @@ -310,10 +300,12 @@ impl FallibleTypeFolder<Interner> for UnevaluatedConstEvaluatorFolder<'_> { if let chalk_ir::ConstValue::Concrete(c) = &constant.data(Interner).value && let ConstScalar::UnevaluatedConst(id, subst) = &c.interned { - if let Ok(eval) = self.db.const_eval(*id, subst.clone(), None) { - return Ok(eval); + let interner = DbInterner::conjure(); + if let Ok(eval) = self.db.const_eval(*id, subst.to_nextsolver(interner), None) { + return Ok(eval.to_chalk(interner)); } else { - return Ok(unknown_const(constant.data(Interner).ty.clone())); + return Ok(unknown_const(constant.data(Interner).ty.to_nextsolver(interner)) + .to_chalk(interner)); } } Ok(constant) diff --git a/crates/hir/src/lib.rs b/crates/hir/src/lib.rs index cce2564a9e..59038c2656 100644 --- a/crates/hir/src/lib.rs +++ b/crates/hir/src/lib.rs @@ -75,7 +75,7 @@ use hir_ty::{ GenericArgData, Interner, ParamKind, ProjectionTy, QuantifiedWhereClause, Scalar, Substitution, TraitEnvironment, TraitRefExt, Ty, TyBuilder, TyDefId, TyExt, TyKind, TyLoweringDiagnostic, ValueTyDefId, WhereClause, all_super_traits, autoderef, check_orphan_rules, - consteval::{ConstExt, try_const_usize, unknown_const_as_generic}, + consteval_chalk::{ConstExt, try_const_usize, unknown_const_as_generic}, diagnostics::BodyValidationDiagnostic, direct_super_traits, error_lifetime, known_const_to_ast, layout::{Layout as TyLayout, RustcEnumVariantIdx, RustcFieldIdx, TagEncoding}, @@ -2153,8 +2153,11 @@ impl DefWithBody { mir::MirSpan::Unknown => continue, }; acc.push( - MovedOutOfRef { ty: Type::new_for_crate(krate, moof.ty.clone()), span } - .into(), + MovedOutOfRef { + ty: Type::new_for_crate(krate, moof.ty.to_chalk(interner)), + span, + } + .into(), ) } let mol = &borrowck_result.mutability_of_locals; @@ -2649,9 +2652,10 @@ impl Function { db: &dyn HirDatabase, span_formatter: impl Fn(FileId, TextRange) -> String, ) -> Result<String, ConstEvalError<'_>> { + let interner = DbInterner::new_with(db, None, None); let body = db.monomorphized_mir_body( self.id.into(), - Substitution::empty(Interner), + GenericArgs::new_from_iter(interner, []), db.trait_environment(self.id.into()), )?; let (result, output) = interpret_mir(db, body, false, None)?; @@ -2933,8 +2937,10 @@ impl Const { /// Evaluate the constant. pub fn eval(self, db: &dyn HirDatabase) -> Result<EvaluatedConst, ConstEvalError<'_>> { - db.const_eval(self.id.into(), Substitution::empty(Interner), None) - .map(|it| EvaluatedConst { const_: it, def: self.id.into() }) + let interner = DbInterner::new_with(db, None, None); + let ty = db.value_ty(self.id.into()).unwrap().instantiate_identity().to_chalk(interner); + db.const_eval(self.id.into(), GenericArgs::new_from_iter(interner, []), None) + .map(|it| EvaluatedConst { const_: it.to_chalk(interner), def: self.id.into(), ty }) } } @@ -2947,6 +2953,7 @@ impl HasVisibility for Const { pub struct EvaluatedConst { def: DefWithBodyId, const_: hir_ty::Const, + ty: hir_ty::Ty, } impl EvaluatedConst { @@ -2955,6 +2962,7 @@ impl EvaluatedConst { } pub fn render_debug<'db>(&self, db: &'db dyn HirDatabase) -> Result<String, MirEvalError<'db>> { + let interner = DbInterner::new_with(db, None, None); let data = self.const_.data(Interner); if let TyKind::Scalar(s) = data.ty.kind(Interner) && matches!(s, Scalar::Int(_) | Scalar::Uint(_)) @@ -2972,7 +2980,12 @@ impl EvaluatedConst { return Ok(result); } } - mir::render_const_using_debug_impl(db, self.def, &self.const_) + mir::render_const_using_debug_impl( + db, + self.def, + self.const_.to_nextsolver(interner), + self.ty.to_nextsolver(interner), + ) } } @@ -3011,8 +3024,10 @@ impl Static { /// Evaluate the static initializer. pub fn eval(self, db: &dyn HirDatabase) -> Result<EvaluatedConst, ConstEvalError<'_>> { - db.const_eval(self.id.into(), Substitution::empty(Interner), None) - .map(|it| EvaluatedConst { const_: it, def: self.id.into() }) + let interner = DbInterner::new_with(db, None, None); + let ty = db.value_ty(self.id.into()).unwrap().instantiate_identity().to_chalk(interner); + db.const_eval(self.id.into(), GenericArgs::new_from_iter(interner, []), None) + .map(|it| EvaluatedConst { const_: it.to_chalk(interner), def: self.id.into(), ty }) } } diff --git a/crates/hir/src/source_analyzer.rs b/crates/hir/src/source_analyzer.rs index 1faa3c4165..a4bc3e8f1a 100644 --- a/crates/hir/src/source_analyzer.rs +++ b/crates/hir/src/source_analyzer.rs @@ -35,7 +35,6 @@ use hir_expand::{ mod_path::{ModPath, PathKind, path}, name::{AsName, Name}, }; -use hir_ty::next_solver::GenericArgs; use hir_ty::{ Adjustment, AliasTy, InferenceResult, Interner, LifetimeElisionKind, ProjectionTy, Substitution, ToChalk, TraitEnvironment, Ty, TyKind, TyLoweringContext, @@ -47,7 +46,8 @@ use hir_ty::{ lang_items::lang_items_for_bin_op, method_resolution, next_solver::{ - DbInterner, + DbInterner, GenericArgs, TypingMode, + infer::DbInternerInferExt, mapping::{ChalkToNextSolver, NextSolverToChalk}, }, }; @@ -1439,12 +1439,9 @@ impl<'db> SourceAnalyzer<'db> { None => return (const_id, subs), }; let env = db.trait_environment_for_body(owner); - method_resolution::lookup_impl_const( - DbInterner::new_with(db, None, None), - env, - const_id, - subs, - ) + let interner = DbInterner::new_with(db, Some(env.krate), env.block); + let infcx = interner.infer_ctxt().build(TypingMode::PostAnalysis); + method_resolution::lookup_impl_const(&infcx, env, const_id, subs) } fn lang_trait_fn( diff --git a/crates/ide/src/hover/tests.rs b/crates/ide/src/hover/tests.rs index 8bc0b3f6ab..df18006168 100644 --- a/crates/ide/src/hover/tests.rs +++ b/crates/ide/src/hover/tests.rs @@ -6306,6 +6306,8 @@ const FOO$0: (&str, &str) = { ); } +// FIXME(next-solver): this fails to normalize the const, probably due to the solver +// refusing to give the impl because of the error type. #[test] fn hover_const_eval_in_generic_trait() { // Doesn't compile, but we shouldn't crash. @@ -6327,12 +6329,16 @@ fn test() { *FOO* ```rust - ra_test_fixture::S + ra_test_fixture::Trait ``` ```rust - const FOO: bool = true + const FOO: bool = false ``` + + --- + + `Self` = `S<{unknown}>` "#]], ); } diff --git a/crates/ide/src/inlay_hints/implicit_drop.rs b/crates/ide/src/inlay_hints/implicit_drop.rs index d0539abe28..1e272fe3ba 100644 --- a/crates/ide/src/inlay_hints/implicit_drop.rs +++ b/crates/ide/src/inlay_hints/implicit_drop.rs @@ -6,7 +6,7 @@ //! } //! ``` use hir::{ - ChalkTyInterner, DefWithBody, + DefWithBody, db::{DefDatabase as _, HirDatabase as _}, mir::{MirSpan, TerminatorKind}, }; @@ -46,7 +46,7 @@ pub(super) fn hints( if !place.projection.is_empty() { continue; // Ignore complex cases for now } - if mir.locals[place.local].ty.adt_id(ChalkTyInterner).is_none() { + if mir.locals[place.local].ty.as_adt().is_none() { continue; // Arguably only ADTs have significant drop impls } let Some(&binding_idx) = local_to_binding.get(place.local) else { diff --git a/crates/macros/Cargo.toml b/crates/macros/Cargo.toml new file mode 100644 index 0000000000..8184cc6d1c --- /dev/null +++ b/crates/macros/Cargo.toml @@ -0,0 +1,19 @@ +[package] +name = "macros" +version = "0.0.0" +repository.workspace = true +description = "Proc macros for rust-analyzer." + +authors.workspace = true +edition.workspace = true +license.workspace = true +rust-version.workspace = true + +[lib] +proc-macro = true + +[dependencies] +proc-macro2 = "1" +quote = "1" +syn = "2.0.9" +synstructure = "0.13.0" diff --git a/crates/macros/src/lib.rs b/crates/macros/src/lib.rs new file mode 100644 index 0000000000..8bafcf498c --- /dev/null +++ b/crates/macros/src/lib.rs @@ -0,0 +1,164 @@ +//! Proc macros for rust-analyzer. + +use quote::{ToTokens, quote}; +use syn::parse_quote; +use synstructure::decl_derive; + +decl_derive!( + [TypeFoldable, attributes(type_foldable)] => + /// Derives `TypeFoldable` for the annotated `struct` or `enum` (`union` is not supported). + /// + /// The fold will produce a value of the same struct or enum variant as the input, with + /// each field respectively folded using the `TypeFoldable` implementation for its type. + /// However, if a field of a struct or an enum variant is annotated with + /// `#[type_foldable(identity)]` then that field will retain its incumbent value (and its + /// type is not required to implement `TypeFoldable`). + type_foldable_derive +); +decl_derive!( + [TypeVisitable, attributes(type_visitable)] => + /// Derives `TypeVisitable` for the annotated `struct` or `enum` (`union` is not supported). + /// + /// Each field of the struct or enum variant will be visited in definition order, using the + /// `TypeVisitable` implementation for its type. However, if a field of a struct or an enum + /// variant is annotated with `#[type_visitable(ignore)]` then that field will not be + /// visited (and its type is not required to implement `TypeVisitable`). + type_visitable_derive +); + +fn type_visitable_derive(mut s: synstructure::Structure<'_>) -> proc_macro2::TokenStream { + if let syn::Data::Union(_) = s.ast().data { + panic!("cannot derive on union") + } + + // ignore fields with #[type_visitable(ignore)] + s.filter(|bi| { + let mut ignored = false; + + bi.ast().attrs.iter().for_each(|attr| { + if !attr.path().is_ident("type_visitable") { + return; + } + let _ = attr.parse_nested_meta(|nested| { + if nested.path.is_ident("ignore") { + ignored = true; + } + Ok(()) + }); + }); + + !ignored + }); + + if !s.ast().generics.lifetimes().any(|lt| lt.lifetime.ident == "db") { + s.add_impl_generic(parse_quote! { 'db }); + } + + s.add_bounds(synstructure::AddBounds::Generics); + let body_visit = s.each(|bind| { + quote! { + match ::rustc_type_ir::VisitorResult::branch( + ::rustc_type_ir::TypeVisitable::visit_with(#bind, __visitor) + ) { + ::core::ops::ControlFlow::Continue(()) => {}, + ::core::ops::ControlFlow::Break(r) => { + return ::rustc_type_ir::VisitorResult::from_residual(r); + }, + } + } + }); + s.bind_with(|_| synstructure::BindStyle::Move); + + s.bound_impl( + quote!(::rustc_type_ir::TypeVisitable<::hir_ty::next_solver::DbInterner<'db>>), + quote! { + fn visit_with<__V: ::rustc_type_ir::TypeVisitor<::hir_ty::next_solver::DbInterner<'db>>>( + &self, + __visitor: &mut __V + ) -> __V::Result { + match *self { #body_visit } + <__V::Result as ::rustc_type_ir::VisitorResult>::output() + } + }, + ) +} + +fn type_foldable_derive(mut s: synstructure::Structure<'_>) -> proc_macro2::TokenStream { + if let syn::Data::Union(_) = s.ast().data { + panic!("cannot derive on union") + } + + if !s.ast().generics.lifetimes().any(|lt| lt.lifetime.ident == "db") { + s.add_impl_generic(parse_quote! { 'db }); + } + + s.add_bounds(synstructure::AddBounds::Generics); + s.bind_with(|_| synstructure::BindStyle::Move); + let try_body_fold = s.each_variant(|vi| { + let bindings = vi.bindings(); + vi.construct(|_, index| { + let bind = &bindings[index]; + + // retain value of fields with #[type_foldable(identity)] + if has_ignore_attr(&bind.ast().attrs, "type_foldable", "identity") { + bind.to_token_stream() + } else { + quote! { + ::rustc_type_ir::TypeFoldable::try_fold_with(#bind, __folder)? + } + } + }) + }); + + let body_fold = s.each_variant(|vi| { + let bindings = vi.bindings(); + vi.construct(|_, index| { + let bind = &bindings[index]; + + // retain value of fields with #[type_foldable(identity)] + if has_ignore_attr(&bind.ast().attrs, "type_foldable", "identity") { + bind.to_token_stream() + } else { + quote! { + ::rustc_type_ir::TypeFoldable::fold_with(#bind, __folder) + } + } + }) + }); + + s.bound_impl( + quote!(::rustc_type_ir::TypeFoldable<::hir_ty::next_solver::DbInterner<'db>>), + quote! { + fn try_fold_with<__F: ::rustc_type_ir::FallibleTypeFolder<::hir_ty::next_solver::DbInterner<'db>>>( + self, + __folder: &mut __F + ) -> Result<Self, __F::Error> { + Ok(match self { #try_body_fold }) + } + + fn fold_with<__F: ::rustc_type_ir::TypeFolder<::hir_ty::next_solver::DbInterner<'db>>>( + self, + __folder: &mut __F + ) -> Self { + match self { #body_fold } + } + }, + ) +} + +fn has_ignore_attr(attrs: &[syn::Attribute], name: &'static str, meta: &'static str) -> bool { + let mut ignored = false; + attrs.iter().for_each(|attr| { + if !attr.path().is_ident(name) { + return; + } + let _ = attr.parse_nested_meta(|nested| { + if nested.path.is_ident(meta) { + ignored = true; + } + Ok(()) + }); + }); + + ignored +} |