diff options
Diffstat (limited to 'compiler/rustc_traits/src/chalk')
| -rw-r--r-- | compiler/rustc_traits/src/chalk/db.rs | 88 | ||||
| -rw-r--r-- | compiler/rustc_traits/src/chalk/lowering.rs | 8 | ||||
| -rw-r--r-- | compiler/rustc_traits/src/chalk/mod.rs | 39 |
3 files changed, 120 insertions, 15 deletions
diff --git a/compiler/rustc_traits/src/chalk/db.rs b/compiler/rustc_traits/src/chalk/db.rs index bb48ed93618..433e2fffc32 100644 --- a/compiler/rustc_traits/src/chalk/db.rs +++ b/compiler/rustc_traits/src/chalk/db.rs @@ -10,6 +10,9 @@ use rustc_middle::traits::ChalkRustInterner as RustInterner; use rustc_middle::ty::subst::{InternalSubsts, Subst, SubstsRef}; use rustc_middle::ty::{self, AssocItemContainer, AssocKind, TyCtxt, TypeFoldable}; +use rustc_ast::ast; +use rustc_attr as attr; + use rustc_hir::def_id::DefId; use rustc_span::symbol::sym; @@ -18,7 +21,6 @@ use std::fmt; use std::sync::Arc; use crate::chalk::lowering::{self, LowerInto}; -use rustc_ast::ast; pub struct RustIrDatabase<'tcx> { pub(crate) interner: RustInterner<'tcx>, @@ -205,12 +207,32 @@ impl<'tcx> chalk_solve::RustIrDatabase<RustInterner<'tcx>> for RustIrDatabase<'t fn adt_repr( &self, adt_id: chalk_ir::AdtId<RustInterner<'tcx>>, - ) -> chalk_solve::rust_ir::AdtRepr { + ) -> Arc<chalk_solve::rust_ir::AdtRepr<RustInterner<'tcx>>> { let adt_def = adt_id.0; - chalk_solve::rust_ir::AdtRepr { - repr_c: adt_def.repr.c(), - repr_packed: adt_def.repr.packed(), - } + let int = |i| chalk_ir::TyKind::Scalar(chalk_ir::Scalar::Int(i)).intern(&self.interner); + let uint = |i| chalk_ir::TyKind::Scalar(chalk_ir::Scalar::Uint(i)).intern(&self.interner); + Arc::new(chalk_solve::rust_ir::AdtRepr { + c: adt_def.repr.c(), + packed: adt_def.repr.packed(), + int: adt_def.repr.int.map(|i| match i { + attr::IntType::SignedInt(ty) => match ty { + ast::IntTy::Isize => int(chalk_ir::IntTy::Isize), + ast::IntTy::I8 => int(chalk_ir::IntTy::I8), + ast::IntTy::I16 => int(chalk_ir::IntTy::I16), + ast::IntTy::I32 => int(chalk_ir::IntTy::I32), + ast::IntTy::I64 => int(chalk_ir::IntTy::I64), + ast::IntTy::I128 => int(chalk_ir::IntTy::I128), + }, + attr::IntType::UnsignedInt(ty) => match ty { + ast::UintTy::Usize => uint(chalk_ir::UintTy::Usize), + ast::UintTy::U8 => uint(chalk_ir::UintTy::U8), + ast::UintTy::U16 => uint(chalk_ir::UintTy::U16), + ast::UintTy::U32 => uint(chalk_ir::UintTy::U32), + ast::UintTy::U64 => uint(chalk_ir::UintTy::U64), + ast::UintTy::U128 => uint(chalk_ir::UintTy::U128), + }, + }), + }) } fn fn_def_datum( @@ -316,7 +338,11 @@ impl<'tcx> chalk_solve::RustIrDatabase<RustInterner<'tcx>> for RustIrDatabase<'t let self_ty = self_ty.fold_with(&mut regions_substitutor); let lowered_ty = self_ty.lower_into(&self.interner); - parameters[0].assert_ty_ref(&self.interner).could_match(&self.interner, &lowered_ty) + parameters[0].assert_ty_ref(&self.interner).could_match( + &self.interner, + self.unification_database(), + &lowered_ty, + ) }); let impls = matched_impls.map(chalk_ir::ImplId).collect(); @@ -541,6 +567,7 @@ impl<'tcx> chalk_solve::RustIrDatabase<RustInterner<'tcx>> for RustIrDatabase<'t Unsize => lang_items.unsize_trait(), Unpin => lang_items.unpin_trait(), CoerceUnsized => lang_items.coerce_unsized_trait(), + DiscriminantKind => lang_items.discriminant_kind_trait(), }; def_id.map(chalk_ir::TraitId) } @@ -586,7 +613,7 @@ impl<'tcx> chalk_solve::RustIrDatabase<RustInterner<'tcx>> for RustIrDatabase<'t let sig = &substs.as_slice(&self.interner)[substs.len(&self.interner) - 2]; match sig.assert_ty_ref(&self.interner).kind(&self.interner) { chalk_ir::TyKind::Function(f) => { - let substitution = f.substitution.as_slice(&self.interner); + let substitution = f.substitution.0.as_slice(&self.interner); let return_type = substitution.last().unwrap().assert_ty_ref(&self.interner).clone(); // Closure arguments are tupled @@ -644,6 +671,51 @@ impl<'tcx> chalk_solve::RustIrDatabase<RustInterner<'tcx>> for RustIrDatabase<'t ) -> Arc<chalk_solve::rust_ir::GeneratorWitnessDatum<RustInterner<'tcx>>> { unimplemented!() } + + fn unification_database(&self) -> &dyn chalk_ir::UnificationDatabase<RustInterner<'tcx>> { + self + } + + fn discriminant_type( + &self, + _: chalk_ir::Ty<RustInterner<'tcx>>, + ) -> chalk_ir::Ty<RustInterner<'tcx>> { + unimplemented!() + } +} + +impl<'tcx> chalk_ir::UnificationDatabase<RustInterner<'tcx>> for RustIrDatabase<'tcx> { + fn fn_def_variance( + &self, + def_id: chalk_ir::FnDefId<RustInterner<'tcx>>, + ) -> chalk_ir::Variances<RustInterner<'tcx>> { + let variances = self.interner.tcx.variances_of(def_id.0); + chalk_ir::Variances::from( + &self.interner, + variances.iter().map(|v| match v { + ty::Variance::Invariant => chalk_ir::Variance::Invariant, + ty::Variance::Covariant => chalk_ir::Variance::Covariant, + ty::Variance::Contravariant => chalk_ir::Variance::Contravariant, + ty::Variance::Bivariant => unimplemented!(), + }), + ) + } + + fn adt_variance( + &self, + def_id: chalk_ir::AdtId<RustInterner<'tcx>>, + ) -> chalk_ir::Variances<RustInterner<'tcx>> { + let variances = self.interner.tcx.variances_of(def_id.0.did); + chalk_ir::Variances::from( + &self.interner, + variances.iter().map(|v| match v { + ty::Variance::Invariant => chalk_ir::Variance::Invariant, + ty::Variance::Covariant => chalk_ir::Variance::Covariant, + ty::Variance::Contravariant => chalk_ir::Variance::Contravariant, + ty::Variance::Bivariant => unimplemented!(), + }), + ) + } } /// Creates a `InternalSubsts` that maps each generic parameter to a higher-ranked diff --git a/compiler/rustc_traits/src/chalk/lowering.rs b/compiler/rustc_traits/src/chalk/lowering.rs index 2a1a3f57e23..7d3589c4b6b 100644 --- a/compiler/rustc_traits/src/chalk/lowering.rs +++ b/compiler/rustc_traits/src/chalk/lowering.rs @@ -287,12 +287,12 @@ impl<'tcx> LowerInto<'tcx, chalk_ir::Ty<RustInterner<'tcx>>> for Ty<'tcx> { chalk_ir::TyKind::Function(chalk_ir::FnPointer { num_binders: binders.len(interner), sig: sig.lower_into(interner), - substitution: chalk_ir::Substitution::from_iter( + substitution: chalk_ir::FnSubst(chalk_ir::Substitution::from_iter( interner, inputs_and_outputs.iter().map(|ty| { chalk_ir::GenericArgData::Ty(ty.lower_into(interner)).intern(interner) }), - ), + )), }) } ty::Dynamic(predicates, region) => chalk_ir::TyKind::Dyn(chalk_ir::DynTy { @@ -478,6 +478,10 @@ impl<'tcx> LowerInto<'tcx, Region<'tcx>> for &chalk_ir::Lifetime<RustInterner<'t } chalk_ir::LifetimeData::Static => ty::RegionKind::ReStatic, chalk_ir::LifetimeData::Phantom(_, _) => unimplemented!(), + chalk_ir::LifetimeData::Empty(ui) => { + ty::RegionKind::ReEmpty(ty::UniverseIndex::from_usize(ui.counter)) + } + chalk_ir::LifetimeData::Erased => ty::RegionKind::ReErased, }; interner.tcx.mk_region(kind) } diff --git a/compiler/rustc_traits/src/chalk/mod.rs b/compiler/rustc_traits/src/chalk/mod.rs index bd2f87f70a2..240807d72e4 100644 --- a/compiler/rustc_traits/src/chalk/mod.rs +++ b/compiler/rustc_traits/src/chalk/mod.rs @@ -97,6 +97,7 @@ crate fn evaluate_goal<'tcx>( use chalk_solve::Solver; let mut solver = chalk_engine::solve::SLGSolver::new(32, None); let db = ChalkRustIrDatabase { interner, reempty_placeholder }; + //dbg!("evaluate_goal_pre", &obligation, &lowered_goal); let solution = solver.solve(&db, &lowered_goal); debug!(?obligation, ?solution, "evaluate goal"); @@ -105,14 +106,40 @@ crate fn evaluate_goal<'tcx>( // really need this and so it's really minimal. // Right now, we also treat a `Unique` solution the same as // `Ambig(Definite)`. This really isn't right. - let make_solution = |subst: chalk_ir::Substitution<_>| { + let make_solution = |subst: chalk_ir::Substitution<_>, + binders: chalk_ir::CanonicalVarKinds<_>| { + use rustc_middle::infer::canonical::CanonicalVarInfo; + let mut var_values: IndexVec<BoundVar, GenericArg<'tcx>> = IndexVec::new(); subst.as_slice(&interner).iter().for_each(|p| { var_values.push(p.lower_into(&interner)); }); + let variables: Vec<_> = binders + .iter(&interner) + .map(|var| { + let kind = match var.kind { + chalk_ir::VariableKind::Ty(ty_kind) => CanonicalVarKind::Ty(match ty_kind { + chalk_ir::TyVariableKind::General => CanonicalTyVarKind::General( + ty::UniverseIndex::from_usize(var.skip_kind().counter), + ), + chalk_ir::TyVariableKind::Integer => CanonicalTyVarKind::Int, + chalk_ir::TyVariableKind::Float => CanonicalTyVarKind::Float, + }), + chalk_ir::VariableKind::Lifetime => CanonicalVarKind::Region( + ty::UniverseIndex::from_usize(var.skip_kind().counter), + ), + chalk_ir::VariableKind::Const(_) => CanonicalVarKind::Const( + ty::UniverseIndex::from_usize(var.skip_kind().counter), + ), + }; + CanonicalVarInfo { kind } + }) + .collect(); + let max_universe = + binders.iter(&interner).map(|v| v.skip_kind().counter).max().unwrap_or(0); let sol = Canonical { - max_universe: ty::UniverseIndex::from_usize(0), - variables: obligation.variables.clone(), + max_universe: ty::UniverseIndex::from_usize(max_universe), + variables: tcx.intern_canonical_var_infos(&variables), value: QueryResponse { var_values: CanonicalVarValues { var_values }, region_constraints: QueryRegionConstraints::default(), @@ -126,11 +153,13 @@ crate fn evaluate_goal<'tcx>( .map(|s| match s { Solution::Unique(subst) => { // FIXME(chalk): handle constraints - make_solution(subst.value.subst) + make_solution(subst.value.subst, subst.binders) } Solution::Ambig(guidance) => { match guidance { - chalk_solve::Guidance::Definite(subst) => make_solution(subst.value), + chalk_solve::Guidance::Definite(subst) => { + make_solution(subst.value, subst.binders) + } chalk_solve::Guidance::Suggested(_) => unimplemented!(), chalk_solve::Guidance::Unknown => { // chalk_fulfill doesn't use the var_values here, so |