1 use crate::ty
::GenericArg
;
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, LocalDefId}
;
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
::PolyExistentialPredicate
<'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().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
{
173 cx
.tcx().mk_trait_ref(parent_def_id
, parent_substs
.iter().copied());
174 cx
.path_qualified(trait_ref
.self_ty(), Some(trait_ref
))
176 cx
.print_def_path(parent_def_id
, parent_substs
)
179 &key
.disambiguated_data
,
185 fn default_print_impl_path(
188 _substs
: &'tcx
[GenericArg
<'tcx
>],
190 impl_trait_ref
: Option
<ty
::TraitRef
<'tcx
>>,
191 ) -> Result
<Self::Path
, Self::Error
> {
193 "default_print_impl_path: impl_def_id={:?}, self_ty={}, impl_trait_ref={:?}",
194 impl_def_id
, self_ty
, impl_trait_ref
197 let key
= self.tcx().def_key(impl_def_id
);
198 let parent_def_id
= DefId { index: key.parent.unwrap(), ..impl_def_id }
;
200 // Decide whether to print the parent path for the impl.
201 // Logically, since impls are global, it's never needed, but
202 // users may find it useful. Currently, we omit the parent if
203 // the impl is either in the same module as the self-type or
205 let in_self_mod
= match characteristic_def_id_of_type(self_ty
) {
207 Some(ty_def_id
) => self.tcx().parent(ty_def_id
) == parent_def_id
,
209 let in_trait_mod
= match impl_trait_ref
{
211 Some(trait_ref
) => self.tcx().parent(trait_ref
.def_id
) == parent_def_id
,
214 if !in_self_mod
&& !in_trait_mod
{
215 // If the impl is not co-located with either self-type or
216 // trait-type, then fallback to a format that identifies
217 // the module more clearly.
218 self.path_append_impl(
219 |cx
| cx
.print_def_path(parent_def_id
, &[]),
220 &key
.disambiguated_data
,
225 // Otherwise, try to give a good form that would be valid language
226 // syntax. Preferably using associated item notation.
227 self.path_qualified(self_ty
, impl_trait_ref
)
232 /// As a heuristic, when we see an impl, if we see that the
233 /// 'self type' is a type defined in the same module as the impl,
234 /// we can omit including the path to the impl itself. This
235 /// function tries to find a "characteristic `DefId`" for a
236 /// type. It's just a heuristic so it makes some questionable
237 /// decisions and we may want to adjust it later.
239 /// Visited set is needed to avoid full iteration over
240 /// deeply nested tuples that have no DefId.
241 fn characteristic_def_id_of_type_cached
<'a
>(
243 visited
: &mut SsoHashSet
<Ty
<'a
>>,
246 ty
::Adt(adt_def
, _
) => Some(adt_def
.did()),
248 ty
::Dynamic(data
, ..) => data
.principal_def_id(),
250 ty
::Array(subty
, _
) | ty
::Slice(subty
) => {
251 characteristic_def_id_of_type_cached(subty
, visited
)
254 ty
::RawPtr(mt
) => characteristic_def_id_of_type_cached(mt
.ty
, visited
),
256 ty
::Ref(_
, ty
, _
) => characteristic_def_id_of_type_cached(ty
, visited
),
258 ty
::Tuple(ref tys
) => tys
.iter().find_map(|ty
| {
259 if visited
.insert(ty
) {
260 return characteristic_def_id_of_type_cached(ty
, visited
);
266 | ty
::Closure(def_id
, _
)
267 | ty
::Generator(def_id
, _
, _
)
268 | ty
::Foreign(def_id
) => Some(def_id
),
277 | ty
::Placeholder(..)
282 | ty
::GeneratorWitness(..)
284 | ty
::Float(_
) => None
,
287 pub fn characteristic_def_id_of_type(ty
: Ty
<'_
>) -> Option
<DefId
> {
288 characteristic_def_id_of_type_cached(ty
, &mut SsoHashSet
::new())
291 impl<'tcx
, P
: Printer
<'tcx
>> Print
<'tcx
, P
> for ty
::Region
<'tcx
> {
292 type Output
= P
::Region
;
293 type Error
= P
::Error
;
294 fn print(&self, cx
: P
) -> Result
<Self::Output
, Self::Error
> {
295 cx
.print_region(*self)
299 impl<'tcx
, P
: Printer
<'tcx
>> Print
<'tcx
, P
> for Ty
<'tcx
> {
300 type Output
= P
::Type
;
301 type Error
= P
::Error
;
303 fn print(&self, cx
: P
) -> Result
<Self::Output
, Self::Error
> {
308 impl<'tcx
, P
: Printer
<'tcx
>> Print
<'tcx
, P
> for &'tcx ty
::List
<ty
::PolyExistentialPredicate
<'tcx
>> {
309 type Output
= P
::DynExistential
;
310 type Error
= P
::Error
;
311 fn print(&self, cx
: P
) -> Result
<Self::Output
, Self::Error
> {
312 cx
.print_dyn_existential(self)
316 impl<'tcx
, P
: Printer
<'tcx
>> Print
<'tcx
, P
> for ty
::Const
<'tcx
> {
317 type Output
= P
::Const
;
318 type Error
= P
::Error
;
319 fn print(&self, cx
: P
) -> Result
<Self::Output
, Self::Error
> {
320 cx
.print_const(*self)
324 // This is only used by query descriptions
325 pub fn describe_as_module(def_id
: LocalDefId
, tcx
: TyCtxt
<'_
>) -> String
{
326 if def_id
.is_top_level_module() {
327 "top-level module".to_string()
329 format
!("module `{}`", tcx
.def_path_str(def_id
.to_def_id()))