hir_ty/next_solver/
ir_print.rs

1//! Things related to IR printing in the next-trait-solver.
2
3use std::any::type_name_of_val;
4
5use rustc_type_ir::inherent::SliceLike;
6use rustc_type_ir::{self as ty, ir_print::IrPrint};
7
8use crate::db::HirDatabase;
9
10use super::SolverDefId;
11use super::interner::DbInterner;
12
13impl<'db> IrPrint<ty::AliasTy<Self>> for DbInterner<'db> {
14    fn print(t: &ty::AliasTy<Self>, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15        Self::print_debug(t, fmt)
16    }
17
18    fn print_debug(t: &ty::AliasTy<Self>, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19        salsa::with_attached_database(|db| match t.def_id {
20            SolverDefId::TypeAliasId(id) => fmt.write_str(&format!(
21                "AliasTy({:?}[{:?}])",
22                db.as_view::<dyn HirDatabase>().type_alias_signature(id).name.as_str(),
23                t.args
24            )),
25            SolverDefId::InternedOpaqueTyId(id) => {
26                fmt.write_str(&format!("AliasTy({:?}[{:?}])", id, t.args))
27            }
28            _ => panic!("Expected TypeAlias or OpaqueTy."),
29        })
30        .unwrap_or_else(|| fmt.write_str(&format!("AliasTy({:?}[{:?}])", t.def_id, t.args)))
31    }
32}
33
34impl<'db> IrPrint<ty::AliasTerm<Self>> for DbInterner<'db> {
35    fn print(t: &ty::AliasTerm<Self>, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
36        Self::print_debug(t, fmt)
37    }
38
39    fn print_debug(t: &ty::AliasTerm<Self>, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
40        salsa::with_attached_database(|db| match t.def_id {
41            SolverDefId::TypeAliasId(id) => fmt.write_str(&format!(
42                "AliasTerm({:?}[{:?}])",
43                db.as_view::<dyn HirDatabase>().type_alias_signature(id).name.as_str(),
44                t.args
45            )),
46            SolverDefId::InternedOpaqueTyId(id) => {
47                fmt.write_str(&format!("AliasTerm({:?}[{:?}])", id, t.args))
48            }
49            _ => panic!("Expected TypeAlias or OpaqueTy."),
50        })
51        .unwrap_or_else(|| fmt.write_str(&format!("AliasTerm({:?}[{:?}])", t.def_id, t.args)))
52    }
53}
54impl<'db> IrPrint<ty::TraitRef<Self>> for DbInterner<'db> {
55    fn print(t: &ty::TraitRef<Self>, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
56        Self::print_debug(t, fmt)
57    }
58
59    fn print_debug(t: &ty::TraitRef<Self>, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
60        salsa::with_attached_database(|db| {
61            let trait_ = t.def_id.0;
62            let self_ty = &t.args.as_slice()[0];
63            let trait_args = &t.args.as_slice()[1..];
64            if trait_args.is_empty() {
65                fmt.write_str(&format!(
66                    "{:?}: {}",
67                    self_ty,
68                    db.as_view::<dyn HirDatabase>().trait_signature(trait_).name.as_str()
69                ))
70            } else {
71                fmt.write_str(&format!(
72                    "{:?}: {}<{:?}>",
73                    self_ty,
74                    db.as_view::<dyn HirDatabase>().trait_signature(trait_).name.as_str(),
75                    trait_args
76                ))
77            }
78        })
79        .unwrap_or_else(|| fmt.write_str(&format!("TraitRef({:?}[{:?}])", t.def_id, t.args)))
80    }
81}
82impl<'db> IrPrint<ty::TraitPredicate<Self>> for DbInterner<'db> {
83    fn print(t: &ty::TraitPredicate<Self>, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
84        Self::print_debug(t, fmt)
85    }
86
87    fn print_debug(
88        t: &ty::TraitPredicate<Self>,
89        fmt: &mut std::fmt::Formatter<'_>,
90    ) -> std::fmt::Result {
91        fmt.write_str(&format!("TODO: {:?}", type_name_of_val(t)))
92    }
93}
94impl<'db> IrPrint<rustc_type_ir::HostEffectPredicate<Self>> for DbInterner<'db> {
95    fn print(
96        t: &rustc_type_ir::HostEffectPredicate<Self>,
97        fmt: &mut std::fmt::Formatter<'_>,
98    ) -> std::fmt::Result {
99        Self::print_debug(t, fmt)
100    }
101
102    fn print_debug(
103        t: &rustc_type_ir::HostEffectPredicate<Self>,
104        fmt: &mut std::fmt::Formatter<'_>,
105    ) -> std::fmt::Result {
106        fmt.write_str(&format!("TODO: {:?}", type_name_of_val(t)))
107    }
108}
109impl<'db> IrPrint<ty::ExistentialTraitRef<Self>> for DbInterner<'db> {
110    fn print(
111        t: &ty::ExistentialTraitRef<Self>,
112        fmt: &mut std::fmt::Formatter<'_>,
113    ) -> std::fmt::Result {
114        Self::print_debug(t, fmt)
115    }
116
117    fn print_debug(
118        t: &ty::ExistentialTraitRef<Self>,
119        fmt: &mut std::fmt::Formatter<'_>,
120    ) -> std::fmt::Result {
121        salsa::with_attached_database(|db| {
122            let trait_ = t.def_id.0;
123            fmt.write_str(&format!(
124                "ExistentialTraitRef({:?}[{:?}])",
125                db.as_view::<dyn HirDatabase>().trait_signature(trait_).name.as_str(),
126                t.args
127            ))
128        })
129        .unwrap_or_else(|| {
130            fmt.write_str(&format!("ExistentialTraitRef({:?}[{:?}])", t.def_id, t.args))
131        })
132    }
133}
134impl<'db> IrPrint<ty::ExistentialProjection<Self>> for DbInterner<'db> {
135    fn print(
136        t: &ty::ExistentialProjection<Self>,
137        fmt: &mut std::fmt::Formatter<'_>,
138    ) -> std::fmt::Result {
139        Self::print_debug(t, fmt)
140    }
141
142    fn print_debug(
143        t: &ty::ExistentialProjection<Self>,
144        fmt: &mut std::fmt::Formatter<'_>,
145    ) -> std::fmt::Result {
146        salsa::with_attached_database(|db| {
147            let id = match t.def_id {
148                SolverDefId::TypeAliasId(id) => id,
149                _ => panic!("Expected trait."),
150            };
151            fmt.write_str(&format!(
152                "ExistentialProjection(({:?}[{:?}]) -> {:?})",
153                db.as_view::<dyn HirDatabase>().type_alias_signature(id).name.as_str(),
154                t.args,
155                t.term
156            ))
157        })
158        .unwrap_or_else(|| {
159            fmt.write_str(&format!(
160                "ExistentialProjection(({:?}[{:?}]) -> {:?})",
161                t.def_id, t.args, t.term
162            ))
163        })
164    }
165}
166impl<'db> IrPrint<ty::ProjectionPredicate<Self>> for DbInterner<'db> {
167    fn print(
168        t: &ty::ProjectionPredicate<Self>,
169        fmt: &mut std::fmt::Formatter<'_>,
170    ) -> std::fmt::Result {
171        Self::print_debug(t, fmt)
172    }
173
174    fn print_debug(
175        t: &ty::ProjectionPredicate<Self>,
176        fmt: &mut std::fmt::Formatter<'_>,
177    ) -> std::fmt::Result {
178        salsa::with_attached_database(|db| {
179            let id = match t.projection_term.def_id {
180                SolverDefId::TypeAliasId(id) => id,
181                _ => panic!("Expected trait."),
182            };
183            fmt.write_str(&format!(
184                "ProjectionPredicate(({:?}[{:?}]) -> {:?})",
185                db.as_view::<dyn HirDatabase>().type_alias_signature(id).name.as_str(),
186                t.projection_term.args,
187                t.term
188            ))
189        })
190        .unwrap_or_else(|| {
191            fmt.write_str(&format!(
192                "ProjectionPredicate(({:?}[{:?}]) -> {:?})",
193                t.projection_term.def_id, t.projection_term.args, t.term
194            ))
195        })
196    }
197}
198impl<'db> IrPrint<ty::NormalizesTo<Self>> for DbInterner<'db> {
199    fn print(t: &ty::NormalizesTo<Self>, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
200        Self::print_debug(t, fmt)
201    }
202
203    fn print_debug(
204        t: &ty::NormalizesTo<Self>,
205        fmt: &mut std::fmt::Formatter<'_>,
206    ) -> std::fmt::Result {
207        fmt.write_str(&format!("TODO: {:?}", type_name_of_val(t)))
208    }
209}
210impl<'db> IrPrint<ty::SubtypePredicate<Self>> for DbInterner<'db> {
211    fn print(
212        t: &ty::SubtypePredicate<Self>,
213        fmt: &mut std::fmt::Formatter<'_>,
214    ) -> std::fmt::Result {
215        Self::print_debug(t, fmt)
216    }
217
218    fn print_debug(
219        t: &ty::SubtypePredicate<Self>,
220        fmt: &mut std::fmt::Formatter<'_>,
221    ) -> std::fmt::Result {
222        fmt.write_str(&format!("TODO: {:?}", type_name_of_val(t)))
223    }
224}
225impl<'db> IrPrint<ty::CoercePredicate<Self>> for DbInterner<'db> {
226    fn print(t: &ty::CoercePredicate<Self>, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
227        Self::print_debug(t, fmt)
228    }
229
230    fn print_debug(
231        t: &ty::CoercePredicate<Self>,
232        fmt: &mut std::fmt::Formatter<'_>,
233    ) -> std::fmt::Result {
234        fmt.write_str(&format!("TODO: {:?}", type_name_of_val(t)))
235    }
236}
237impl<'db> IrPrint<ty::FnSig<Self>> for DbInterner<'db> {
238    fn print(t: &ty::FnSig<Self>, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
239        Self::print_debug(t, fmt)
240    }
241
242    fn print_debug(t: &ty::FnSig<Self>, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
243        fmt.write_str(&format!("TODO: {:?}", type_name_of_val(t)))
244    }
245}
246
247impl<'db> IrPrint<rustc_type_ir::PatternKind<DbInterner<'db>>> for DbInterner<'db> {
248    fn print(
249        t: &rustc_type_ir::PatternKind<DbInterner<'db>>,
250        fmt: &mut std::fmt::Formatter<'_>,
251    ) -> std::fmt::Result {
252        Self::print_debug(t, fmt)
253    }
254
255    fn print_debug(
256        t: &rustc_type_ir::PatternKind<DbInterner<'db>>,
257        fmt: &mut std::fmt::Formatter<'_>,
258    ) -> std::fmt::Result {
259        fmt.write_str(&format!("TODO: {:?}", type_name_of_val(t)))
260    }
261}
hir_ty/next_solver/ir_print.rs

hir_ty/next_solver/
ir_print.rs
