summaryrefslogtreecommitdiffstats
path: root/compiler/rustc_middle/src/ty/structural_impls.rs
diff options
context:
space:
mode:
Diffstat (limited to 'compiler/rustc_middle/src/ty/structural_impls.rs')
-rw-r--r--compiler/rustc_middle/src/ty/structural_impls.rs142
1 files changed, 106 insertions, 36 deletions
diff --git a/compiler/rustc_middle/src/ty/structural_impls.rs b/compiler/rustc_middle/src/ty/structural_impls.rs
index 16cb6c910..7220d133f 100644
--- a/compiler/rustc_middle/src/ty/structural_impls.rs
+++ b/compiler/rustc_middle/src/ty/structural_impls.rs
@@ -11,6 +11,7 @@ use crate::ty::{self, AliasTy, InferConst, Lift, Term, TermKind, Ty, TyCtxt};
use rustc_hir::def::Namespace;
use rustc_index::{Idx, IndexVec};
use rustc_target::abi::TyAndLayout;
+use rustc_type_ir::ConstKind;
use std::fmt;
use std::ops::ControlFlow;
@@ -88,7 +89,35 @@ impl fmt::Debug for ty::FreeRegion {
impl<'tcx> fmt::Debug for ty::FnSig<'tcx> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
- write!(f, "({:?}; c_variadic: {})->{:?}", self.inputs(), self.c_variadic, self.output())
+ let ty::FnSig { inputs_and_output: _, c_variadic, unsafety, abi } = self;
+
+ write!(f, "{}", unsafety.prefix_str())?;
+ match abi {
+ rustc_target::spec::abi::Abi::Rust => (),
+ abi => write!(f, "extern \"{abi:?}\" ")?,
+ };
+
+ write!(f, "fn(")?;
+ let inputs = self.inputs();
+ match inputs.len() {
+ 0 if *c_variadic => write!(f, "...)")?,
+ 0 => write!(f, ")")?,
+ _ => {
+ for ty in &self.inputs()[0..(self.inputs().len() - 1)] {
+ write!(f, "{ty:?}, ")?;
+ }
+ write!(f, "{:?}", self.inputs().last().unwrap())?;
+ if *c_variadic {
+ write!(f, "...")?;
+ }
+ write!(f, ")")?;
+ }
+ }
+
+ match self.output().kind() {
+ ty::Tuple(list) if list.is_empty() => Ok(()),
+ _ => write!(f, " -> {:?}", self.output()),
+ }
}
}
@@ -145,12 +174,22 @@ impl<'tcx> fmt::Debug for ty::Predicate<'tcx> {
impl<'tcx> fmt::Debug for ty::Clause<'tcx> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ write!(f, "{:?}", self.kind())
+ }
+}
+
+impl<'tcx> fmt::Debug for ty::ClauseKind<'tcx> {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match *self {
- ty::Clause::ConstArgHasType(ct, ty) => write!(f, "ConstArgHasType({ct:?}, {ty:?})"),
- ty::Clause::Trait(ref a) => a.fmt(f),
- ty::Clause::RegionOutlives(ref pair) => pair.fmt(f),
- ty::Clause::TypeOutlives(ref pair) => pair.fmt(f),
- ty::Clause::Projection(ref pair) => pair.fmt(f),
+ ty::ClauseKind::ConstArgHasType(ct, ty) => write!(f, "ConstArgHasType({ct:?}, {ty:?})"),
+ ty::ClauseKind::Trait(ref a) => a.fmt(f),
+ ty::ClauseKind::RegionOutlives(ref pair) => pair.fmt(f),
+ ty::ClauseKind::TypeOutlives(ref pair) => pair.fmt(f),
+ ty::ClauseKind::Projection(ref pair) => pair.fmt(f),
+ ty::ClauseKind::WellFormed(ref data) => write!(f, "WellFormed({:?})", data),
+ ty::ClauseKind::ConstEvaluatable(ct) => {
+ write!(f, "ConstEvaluatable({ct:?})")
+ }
}
}
}
@@ -161,20 +200,13 @@ impl<'tcx> fmt::Debug for ty::PredicateKind<'tcx> {
ty::PredicateKind::Clause(ref a) => a.fmt(f),
ty::PredicateKind::Subtype(ref pair) => pair.fmt(f),
ty::PredicateKind::Coerce(ref pair) => pair.fmt(f),
- ty::PredicateKind::WellFormed(data) => write!(f, "WellFormed({:?})", data),
ty::PredicateKind::ObjectSafe(trait_def_id) => {
write!(f, "ObjectSafe({:?})", trait_def_id)
}
ty::PredicateKind::ClosureKind(closure_def_id, closure_substs, kind) => {
write!(f, "ClosureKind({:?}, {:?}, {:?})", closure_def_id, closure_substs, kind)
}
- ty::PredicateKind::ConstEvaluatable(ct) => {
- write!(f, "ConstEvaluatable({ct:?})")
- }
ty::PredicateKind::ConstEquate(c1, c2) => write!(f, "ConstEquate({:?}, {:?})", c1, c2),
- ty::PredicateKind::TypeWellFormedFromEnv(ty) => {
- write!(f, "TypeWellFormedFromEnv({:?})", ty)
- }
ty::PredicateKind::Ambiguous => write!(f, "Ambiguous"),
ty::PredicateKind::AliasRelate(t1, t2, dir) => {
write!(f, "AliasRelate({t1:?}, {dir:?}, {t2:?})")
@@ -210,22 +242,21 @@ impl<'tcx> fmt::Debug for ty::Const<'tcx> {
}
}
-impl<'tcx> fmt::Debug for ty::ConstKind<'tcx> {
- fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
- use ty::ConstKind::*;
- match self {
- Param(param) => write!(f, "{param:?}"),
- Infer(var) => write!(f, "{var:?}"),
- Bound(debruijn, var) => ty::print::debug_bound_var(f, *debruijn, *var),
- Placeholder(placeholder) => {
- ty::print::debug_placeholder_var(f, placeholder.universe, placeholder.bound)
- }
- Unevaluated(uv) => {
- f.debug_tuple("Unevaluated").field(&uv.substs).field(&uv.def).finish()
- }
- Value(valtree) => write!(f, "{valtree:?}"),
- Error(_) => write!(f, "[const error]"),
- Expr(expr) => write!(f, "{expr:?}"),
+impl fmt::Debug for ty::BoundTy {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ match self.kind {
+ ty::BoundTyKind::Anon => write!(f, "{:?}", self.var),
+ ty::BoundTyKind::Param(_, sym) => write!(f, "{sym:?}"),
+ }
+ }
+}
+
+impl<T: fmt::Debug> fmt::Debug for ty::Placeholder<T> {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ if self.universe == ty::UniverseIndex::ROOT {
+ write!(f, "!{:?}", self.bound)
+ } else {
+ write!(f, "!{}_{:?}", self.universe.index(), self.bound)
}
}
}
@@ -294,13 +325,14 @@ TrivialTypeTraversalAndLiftImpls! {
crate::ty::AliasRelationDirection,
crate::ty::Placeholder<crate::ty::BoundRegion>,
crate::ty::Placeholder<crate::ty::BoundTy>,
+ crate::ty::Placeholder<ty::BoundVar>,
crate::ty::ClosureKind,
crate::ty::FreeRegion,
crate::ty::InferTy,
crate::ty::IntVarValue,
crate::ty::ParamConst,
crate::ty::ParamTy,
- crate::ty::adjustment::PointerCast,
+ crate::ty::adjustment::PointerCoercion,
crate::ty::RegionVid,
crate::ty::UniverseIndex,
crate::ty::Variance,
@@ -310,7 +342,6 @@ TrivialTypeTraversalAndLiftImpls! {
interpret::Scalar,
rustc_target::abi::Size,
ty::BoundVar,
- ty::Placeholder<ty::BoundVar>,
}
TrivialTypeTraversalAndLiftImpls! {
@@ -609,12 +640,28 @@ impl<'tcx> TypeFoldable<TyCtxt<'tcx>> for ty::Predicate<'tcx> {
}
}
+// FIXME(clause): This is wonky
+impl<'tcx> TypeFoldable<TyCtxt<'tcx>> for ty::Clause<'tcx> {
+ fn try_fold_with<F: FallibleTypeFolder<TyCtxt<'tcx>>>(
+ self,
+ folder: &mut F,
+ ) -> Result<Self, F::Error> {
+ Ok(folder.try_fold_predicate(self.as_predicate())?.expect_clause())
+ }
+}
+
impl<'tcx> TypeVisitable<TyCtxt<'tcx>> for ty::Predicate<'tcx> {
fn visit_with<V: TypeVisitor<TyCtxt<'tcx>>>(&self, visitor: &mut V) -> ControlFlow<V::BreakTy> {
visitor.visit_predicate(*self)
}
}
+impl<'tcx> TypeVisitable<TyCtxt<'tcx>> for ty::Clause<'tcx> {
+ fn visit_with<V: TypeVisitor<TyCtxt<'tcx>>>(&self, visitor: &mut V) -> ControlFlow<V::BreakTy> {
+ visitor.visit_predicate(self.as_predicate())
+ }
+}
+
impl<'tcx> TypeSuperFoldable<TyCtxt<'tcx>> for ty::Predicate<'tcx> {
fn try_super_fold_with<F: FallibleTypeFolder<TyCtxt<'tcx>>>(
self,
@@ -634,12 +681,12 @@ impl<'tcx> TypeSuperVisitable<TyCtxt<'tcx>> for ty::Predicate<'tcx> {
}
}
-impl<'tcx> TypeFoldable<TyCtxt<'tcx>> for &'tcx ty::List<ty::Predicate<'tcx>> {
+impl<'tcx> TypeFoldable<TyCtxt<'tcx>> for &'tcx ty::List<ty::Clause<'tcx>> {
fn try_fold_with<F: FallibleTypeFolder<TyCtxt<'tcx>>>(
self,
folder: &mut F,
) -> Result<Self, F::Error> {
- ty::util::fold_list(self, folder, |tcx, v| tcx.mk_predicates(v))
+ ty::util::fold_list(self, folder, |tcx, v| tcx.mk_clauses(v))
}
}
@@ -664,9 +711,20 @@ impl<'tcx> TypeSuperFoldable<TyCtxt<'tcx>> for ty::Const<'tcx> {
folder: &mut F,
) -> Result<Self, F::Error> {
let ty = self.ty().try_fold_with(folder)?;
- let kind = self.kind().try_fold_with(folder)?;
+ let kind = match self.kind() {
+ ConstKind::Param(p) => ConstKind::Param(p.try_fold_with(folder)?),
+ ConstKind::Infer(i) => ConstKind::Infer(i.try_fold_with(folder)?),
+ ConstKind::Bound(d, b) => {
+ ConstKind::Bound(d.try_fold_with(folder)?, b.try_fold_with(folder)?)
+ }
+ ConstKind::Placeholder(p) => ConstKind::Placeholder(p.try_fold_with(folder)?),
+ ConstKind::Unevaluated(uv) => ConstKind::Unevaluated(uv.try_fold_with(folder)?),
+ ConstKind::Value(v) => ConstKind::Value(v.try_fold_with(folder)?),
+ ConstKind::Error(e) => ConstKind::Error(e.try_fold_with(folder)?),
+ ConstKind::Expr(e) => ConstKind::Expr(e.try_fold_with(folder)?),
+ };
if ty != self.ty() || kind != self.kind() {
- Ok(folder.interner().mk_const(kind, ty))
+ Ok(folder.interner().mk_ct_from_kind(kind, ty))
} else {
Ok(self)
}
@@ -679,7 +737,19 @@ impl<'tcx> TypeSuperVisitable<TyCtxt<'tcx>> for ty::Const<'tcx> {
visitor: &mut V,
) -> ControlFlow<V::BreakTy> {
self.ty().visit_with(visitor)?;
- self.kind().visit_with(visitor)
+ match self.kind() {
+ ConstKind::Param(p) => p.visit_with(visitor),
+ ConstKind::Infer(i) => i.visit_with(visitor),
+ ConstKind::Bound(d, b) => {
+ d.visit_with(visitor)?;
+ b.visit_with(visitor)
+ }
+ ConstKind::Placeholder(p) => p.visit_with(visitor),
+ ConstKind::Unevaluated(uv) => uv.visit_with(visitor),
+ ConstKind::Value(v) => v.visit_with(visitor),
+ ConstKind::Error(e) => e.visit_with(visitor),
+ ConstKind::Expr(e) => e.visit_with(visitor),
+ }
}
}
generated by cgit v1.2.3 (git 2.39.1) at 2024-10-01 21:14:27 +0000