1 use crate::ty
::subst
::{GenericArg, Subst}
;
2 use crate::ty
::{self, DefIdTree, Ty, TyCtxt}
;
4 use rustc_data_structures
::fx
::FxHashSet
;
5 use rustc_data_structures
::sso
::SsoHashSet
;
6 use rustc_hir
::def_id
::{CrateNum, DefId}
;
7 use rustc_hir
::definitions
::{DefPathData, DisambiguatedDefPathData}
;
9 // `pretty` is a separate module only for organization.
11 pub use self::pretty
::*;
13 // FIXME(eddyb) false positive, the lifetime parameters are used with `P: Printer<...>`.
14 #[allow(unused_lifetimes)]
15 pub trait Print
<'tcx
, P
> {
19 fn print(&self, cx
: P
) -> Result
<Self::Output
, Self::Error
>;
22 /// Interface for outputting user-facing "type-system entities"
23 /// (paths, types, lifetimes, constants, etc.) as a side-effect
24 /// (e.g. formatting, like `PrettyPrinter` implementors do) or by
25 /// constructing some alternative representation (e.g. an AST),
26 /// which the associated types allow passing through the methods.
28 /// For pretty-printing/formatting in particular, see `PrettyPrinter`.
30 // FIXME(eddyb) find a better name; this is more general than "printing".
31 pub trait Printer
<'tcx
>: Sized
{
40 fn tcx
<'a
>(&'a
self) -> TyCtxt
<'tcx
>;
45 substs
: &'tcx
[GenericArg
<'tcx
>],
46 ) -> Result
<Self::Path
, Self::Error
> {
47 self.default_print_def_path(def_id
, substs
)
53 substs
: &'tcx
[GenericArg
<'tcx
>],
55 trait_ref
: Option
<ty
::TraitRef
<'tcx
>>,
56 ) -> Result
<Self::Path
, Self::Error
> {
57 self.default_print_impl_path(impl_def_id
, substs
, self_ty
, trait_ref
)
60 fn print_region(self, region
: ty
::Region
<'tcx
>) -> Result
<Self::Region
, Self::Error
>;
62 fn print_type(self, ty
: Ty
<'tcx
>) -> Result
<Self::Type
, Self::Error
>;
64 fn print_dyn_existential(
66 predicates
: &'tcx ty
::List
<ty
::Binder
<'tcx
, ty
::ExistentialPredicate
<'tcx
>>>,
67 ) -> Result
<Self::DynExistential
, Self::Error
>;
69 fn print_const(self, ct
: ty
::Const
<'tcx
>) -> Result
<Self::Const
, Self::Error
>;
71 fn path_crate(self, cnum
: CrateNum
) -> Result
<Self::Path
, Self::Error
>;
76 trait_ref
: Option
<ty
::TraitRef
<'tcx
>>,
77 ) -> Result
<Self::Path
, Self::Error
>;
81 print_prefix
: impl FnOnce(Self) -> Result
<Self::Path
, Self::Error
>,
82 disambiguated_data
: &DisambiguatedDefPathData
,
84 trait_ref
: Option
<ty
::TraitRef
<'tcx
>>,
85 ) -> Result
<Self::Path
, Self::Error
>;
89 print_prefix
: impl FnOnce(Self) -> Result
<Self::Path
, Self::Error
>,
90 disambiguated_data
: &DisambiguatedDefPathData
,
91 ) -> Result
<Self::Path
, Self::Error
>;
95 print_prefix
: impl FnOnce(Self) -> Result
<Self::Path
, Self::Error
>,
96 args
: &[GenericArg
<'tcx
>],
97 ) -> Result
<Self::Path
, Self::Error
>;
99 // Defaults (should not be overridden):
101 #[instrument(skip(self), level = "debug")]
102 fn default_print_def_path(
105 substs
: &'tcx
[GenericArg
<'tcx
>],
106 ) -> Result
<Self::Path
, Self::Error
> {
107 let key
= self.tcx().def_key(def_id
);
110 match key
.disambiguated_data
.data
{
111 DefPathData
::CrateRoot
=> {
112 assert
!(key
.parent
.is_none());
113 self.path_crate(def_id
.krate
)
116 DefPathData
::Impl
=> {
117 let generics
= self.tcx().generics_of(def_id
);
118 let self_ty
= self.tcx().bound_type_of(def_id
);
119 let impl_trait_ref
= self.tcx().bound_impl_trait_ref(def_id
);
120 let (self_ty
, impl_trait_ref
) = if substs
.len() >= generics
.count() {
122 self_ty
.subst(self.tcx(), substs
),
123 impl_trait_ref
.map(|i
| i
.subst(self.tcx(), substs
)),
126 (self_ty
.0, impl_trait_ref
.map(|i
| i
.0))
128 self.print_impl_path(def_id
, substs
, self_ty
, impl_trait_ref
)
132 let parent_def_id
= DefId { index: key.parent.unwrap(), ..def_id }
;
134 let mut parent_substs
= substs
;
135 let mut trait_qualify_parent
= false;
136 if !substs
.is_empty() {
137 let generics
= self.tcx().generics_of(def_id
);
138 parent_substs
= &substs
[..generics
.parent_count
.min(substs
.len())];
140 match key
.disambiguated_data
.data
{
141 // Closures' own generics are only captures, don't print them.
142 DefPathData
::ClosureExpr
=> {}
143 // This covers both `DefKind::AnonConst` and `DefKind::InlineConst`.
144 // Anon consts doesn't have their own generics, and inline consts' own
145 // generics are their inferred types, so don't print them.
146 DefPathData
::AnonConst
=> {}
148 // If we have any generic arguments to print, we do that
149 // on top of the same path, but without its own generics.
151 if !generics
.params
.is_empty() && substs
.len() >= generics
.count() {
152 let args
= generics
.own_substs_no_defaults(self.tcx(), substs
);
153 return self.path_generic_args(
154 |cx
| cx
.print_def_path(def_id
, parent_substs
),
161 // FIXME(eddyb) try to move this into the parent's printing
162 // logic, instead of doing it when printing the child.
163 trait_qualify_parent
= generics
.has_self
164 && generics
.parent
== Some(parent_def_id
)
165 && parent_substs
.len() == generics
.parent_count
166 && self.tcx().generics_of(parent_def_id
).parent_count
== 0;
171 if trait_qualify_parent
{
172 let trait_ref
= ty
::TraitRef
::new(
174 cx
.tcx().intern_substs(parent_substs
),
176 cx
.path_qualified(trait_ref
.self_ty(), Some(trait_ref
))
178 cx
.print_def_path(parent_def_id
, parent_substs
)
181 &key
.disambiguated_data
,
187 fn default_print_impl_path(
190 _substs
: &'tcx
[GenericArg
<'tcx
>],
192 impl_trait_ref
: Option
<ty
::TraitRef
<'tcx
>>,
193 ) -> Result
<Self::Path
, Self::Error
> {
195 "default_print_impl_path: impl_def_id={:?}, self_ty={}, impl_trait_ref={:?}",
196 impl_def_id
, self_ty
, impl_trait_ref
199 let key
= self.tcx().def_key(impl_def_id
);
200 let parent_def_id
= DefId { index: key.parent.unwrap(), ..impl_def_id }
;
202 // Decide whether to print the parent path for the impl.
203 // Logically, since impls are global, it's never needed, but
204 // users may find it useful. Currently, we omit the parent if
205 // the impl is either in the same module as the self-type or
207 let in_self_mod
= match characteristic_def_id_of_type(self_ty
) {
209 Some(ty_def_id
) => self.tcx().parent(ty_def_id
) == parent_def_id
,
211 let in_trait_mod
= match impl_trait_ref
{
213 Some(trait_ref
) => self.tcx().parent(trait_ref
.def_id
) == parent_def_id
,
216 if !in_self_mod
&& !in_trait_mod
{
217 // If the impl is not co-located with either self-type or
218 // trait-type, then fallback to a format that identifies
219 // the module more clearly.
220 self.path_append_impl(
221 |cx
| cx
.print_def_path(parent_def_id
, &[]),
222 &key
.disambiguated_data
,
227 // Otherwise, try to give a good form that would be valid language
228 // syntax. Preferably using associated item notation.
229 self.path_qualified(self_ty
, impl_trait_ref
)
234 /// As a heuristic, when we see an impl, if we see that the
235 /// 'self type' is a type defined in the same module as the impl,
236 /// we can omit including the path to the impl itself. This
237 /// function tries to find a "characteristic `DefId`" for a
238 /// type. It's just a heuristic so it makes some questionable
239 /// decisions and we may want to adjust it later.
241 /// Visited set is needed to avoid full iteration over
242 /// deeply nested tuples that have no DefId.
243 fn characteristic_def_id_of_type_cached
<'a
>(
245 visited
: &mut SsoHashSet
<Ty
<'a
>>,
248 ty
::Adt(adt_def
, _
) => Some(adt_def
.did()),
250 ty
::Dynamic(data
, ..) => data
.principal_def_id(),
252 ty
::Array(subty
, _
) | ty
::Slice(subty
) => {
253 characteristic_def_id_of_type_cached(subty
, visited
)
256 ty
::RawPtr(mt
) => characteristic_def_id_of_type_cached(mt
.ty
, visited
),
258 ty
::Ref(_
, ty
, _
) => characteristic_def_id_of_type_cached(ty
, visited
),
260 ty
::Tuple(ref tys
) => tys
.iter().find_map(|ty
| {
261 if visited
.insert(ty
) {
262 return characteristic_def_id_of_type_cached(ty
, visited
);
268 | ty
::Closure(def_id
, _
)
269 | ty
::Generator(def_id
, _
, _
)
270 | ty
::Foreign(def_id
) => Some(def_id
),
279 | ty
::Placeholder(..)
285 | ty
::GeneratorWitness(..)
287 | ty
::Float(_
) => None
,
290 pub fn characteristic_def_id_of_type(ty
: Ty
<'_
>) -> Option
<DefId
> {
291 characteristic_def_id_of_type_cached(ty
, &mut SsoHashSet
::new())
294 impl<'tcx
, P
: Printer
<'tcx
>> Print
<'tcx
, P
> for ty
::Region
<'tcx
> {
295 type Output
= P
::Region
;
296 type Error
= P
::Error
;
297 fn print(&self, cx
: P
) -> Result
<Self::Output
, Self::Error
> {
298 cx
.print_region(*self)
302 impl<'tcx
, P
: Printer
<'tcx
>> Print
<'tcx
, P
> for Ty
<'tcx
> {
303 type Output
= P
::Type
;
304 type Error
= P
::Error
;
306 fn print(&self, cx
: P
) -> Result
<Self::Output
, Self::Error
> {
311 impl<'tcx
, P
: Printer
<'tcx
>> Print
<'tcx
, P
>
312 for &'tcx ty
::List
<ty
::Binder
<'tcx
, ty
::ExistentialPredicate
<'tcx
>>>
314 type Output
= P
::DynExistential
;
315 type Error
= P
::Error
;
316 fn print(&self, cx
: P
) -> Result
<Self::Output
, Self::Error
> {
317 cx
.print_dyn_existential(self)
321 impl<'tcx
, P
: Printer
<'tcx
>> Print
<'tcx
, P
> for ty
::Const
<'tcx
> {
322 type Output
= P
::Const
;
323 type Error
= P
::Error
;
324 fn print(&self, cx
: P
) -> Result
<Self::Output
, Self::Error
> {
325 cx
.print_const(*self)