1 //! These from impls are used to create the JSON types which get serialized. They're very close to
2 //! the `clean` types but with some fields removed or stringified to simplify the output and not
3 //! expose unstable compiler internals.
5 #![allow(rustc::default_hash_types)]
7 use std
::convert
::From
;
11 use rustc_hir
::{def::CtorKind, def_id::DefId}
;
12 use rustc_middle
::ty
::TyCtxt
;
13 use rustc_span
::def_id
::CRATE_DEF_INDEX
;
16 use rustdoc_json_types
::*;
18 use crate::clean
::utils
::print_const_expr
;
19 use crate::clean
::{self, ItemId}
;
20 use crate::formats
::item_type
::ItemType
;
21 use crate::json
::JsonRenderer
;
22 use std
::collections
::HashSet
;
24 impl JsonRenderer
<'_
> {
25 pub(super) fn convert_item(&self, item
: clean
::Item
) -> Option
<Item
> {
26 let deprecation
= item
.deprecation(self.tcx
);
33 .map(|clean
::ItemLink { link, did, .. }
| (link
.clone(), from_item_id((*did
).into())))
35 let docs
= item
.attrs
.collapsed_doc_value();
40 .map(rustc_ast_pretty
::pprust
::attribute_to_string
)
42 let span
= item
.span(self.tcx
);
43 let clean
::Item { name, attrs: _, kind: _, visibility, def_id, cfg: _ }
= item
;
44 let inner
= match *item
.kind
{
45 clean
::StrippedItem(_
) => return None
,
46 _
=> from_clean_item(item
, self.tcx
),
49 id
: from_item_id(def_id
),
50 crate_id
: def_id
.krate().as_u32(),
51 name
: name
.map(|sym
| sym
.to_string()),
52 span
: self.convert_span(span
),
53 visibility
: self.convert_visibility(visibility
),
56 deprecation
: deprecation
.map(from_deprecation
),
62 fn convert_span(&self, span
: clean
::Span
) -> Option
<Span
> {
63 match span
.filename(self.sess()) {
64 rustc_span
::FileName
::Real(name
) => {
65 if let Some(local_path
) = name
.into_local_path() {
66 let hi
= span
.hi(self.sess());
67 let lo
= span
.lo(self.sess());
70 begin
: (lo
.line
, lo
.col
.to_usize()),
71 end
: (hi
.line
, hi
.col
.to_usize()),
81 fn convert_visibility(&self, v
: clean
::Visibility
) -> Visibility
{
82 use clean
::Visibility
::*;
84 Public
=> Visibility
::Public
,
85 Inherited
=> Visibility
::Default
,
86 Restricted(did
) if did
.index
== CRATE_DEF_INDEX
=> Visibility
::Crate
,
87 Restricted(did
) => Visibility
::Restricted
{
88 parent
: from_item_id(did
.into()),
89 path
: self.tcx
.def_path(did
).to_string_no_crate_verbose(),
95 crate trait FromWithTcx
<T
> {
96 fn from_tcx(f
: T
, tcx
: TyCtxt
<'_
>) -> Self;
99 crate trait IntoWithTcx
<T
> {
100 fn into_tcx(self, tcx
: TyCtxt
<'_
>) -> T
;
103 impl<T
, U
> IntoWithTcx
<U
> for T
107 fn into_tcx(self, tcx
: TyCtxt
<'_
>) -> U
{
108 U
::from_tcx(self, tcx
)
112 crate fn from_deprecation(deprecation
: rustc_attr
::Deprecation
) -> Deprecation
{
114 let rustc_attr
::Deprecation { since, note, is_since_rustc_version: _, suggestion: _ }
= deprecation
;
115 Deprecation { since: since.map(|s| s.to_string()), note: note.map(|s| s.to_string()) }
118 impl FromWithTcx
<clean
::GenericArgs
> for GenericArgs
{
119 fn from_tcx(args
: clean
::GenericArgs
, tcx
: TyCtxt
<'_
>) -> Self {
120 use clean
::GenericArgs
::*;
122 AngleBracketed { args, bindings }
=> GenericArgs
::AngleBracketed
{
123 args
: args
.into_iter().map(|a
| a
.into_tcx(tcx
)).collect(),
124 bindings
: bindings
.into_iter().map(|a
| a
.into_tcx(tcx
)).collect(),
126 Parenthesized { inputs, output }
=> GenericArgs
::Parenthesized
{
127 inputs
: inputs
.into_iter().map(|a
| a
.into_tcx(tcx
)).collect(),
128 output
: output
.map(|a
| (*a
).into_tcx(tcx
)),
134 impl FromWithTcx
<clean
::GenericArg
> for GenericArg
{
135 fn from_tcx(arg
: clean
::GenericArg
, tcx
: TyCtxt
<'_
>) -> Self {
136 use clean
::GenericArg
::*;
138 Lifetime(l
) => GenericArg
::Lifetime(l
.0.to_string()),
139 Type(t
) => GenericArg
::Type(t
.into_tcx(tcx
)),
140 Const(box c
) => GenericArg
::Const(c
.into_tcx(tcx
)),
141 Infer
=> GenericArg
::Infer
,
146 impl FromWithTcx
<clean
::Constant
> for Constant
{
147 fn from_tcx(constant
: clean
::Constant
, tcx
: TyCtxt
<'_
>) -> Self {
148 let expr
= constant
.expr(tcx
);
149 let value
= constant
.value(tcx
);
150 let is_literal
= constant
.is_literal(tcx
);
151 Constant { type_: constant.type_.into_tcx(tcx), expr, value, is_literal }
155 impl FromWithTcx
<clean
::TypeBinding
> for TypeBinding
{
156 fn from_tcx(binding
: clean
::TypeBinding
, tcx
: TyCtxt
<'_
>) -> Self {
157 TypeBinding { name: binding.name.to_string(), binding: binding.kind.into_tcx(tcx) }
161 impl FromWithTcx
<clean
::TypeBindingKind
> for TypeBindingKind
{
162 fn from_tcx(kind
: clean
::TypeBindingKind
, tcx
: TyCtxt
<'_
>) -> Self {
163 use clean
::TypeBindingKind
::*;
165 Equality { ty }
=> TypeBindingKind
::Equality(ty
.into_tcx(tcx
)),
166 Constraint { bounds }
=> {
167 TypeBindingKind
::Constraint(bounds
.into_iter().map(|a
| a
.into_tcx(tcx
)).collect())
173 crate fn from_item_id(did
: ItemId
) -> Id
{
174 struct DisplayDefId(DefId
);
176 impl fmt
::Display
for DisplayDefId
{
177 fn fmt(&self, f
: &mut fmt
::Formatter
<'_
>) -> fmt
::Result
{
178 write
!(f
, "{}:{}", self.0.krate
.as_u32(), u32::from(self.0.index
))
183 ItemId
::DefId(did
) => Id(format
!("{}", DisplayDefId(did
))),
184 ItemId
::Blanket { for_, impl_id }
=> {
185 Id(format
!("b:{}-{}", DisplayDefId(impl_id
), DisplayDefId(for_
)))
187 ItemId
::Auto { for_, trait_ }
=> {
188 Id(format
!("a:{}-{}", DisplayDefId(trait_
), DisplayDefId(for_
)))
190 ItemId
::Primitive(ty
, krate
) => Id(format
!("p:{}:{}", krate
.as_u32(), ty
.as_sym())),
194 fn from_clean_item(item
: clean
::Item
, tcx
: TyCtxt
<'_
>) -> ItemEnum
{
195 use clean
::ItemKind
::*;
196 let name
= item
.name
;
197 let is_crate
= item
.is_crate();
199 ModuleItem(m
) => ItemEnum
::Module(Module { is_crate, items: ids(m.items) }
),
200 ImportItem(i
) => ItemEnum
::Import(i
.into_tcx(tcx
)),
201 StructItem(s
) => ItemEnum
::Struct(s
.into_tcx(tcx
)),
202 UnionItem(u
) => ItemEnum
::Union(u
.into_tcx(tcx
)),
203 StructFieldItem(f
) => ItemEnum
::StructField(f
.into_tcx(tcx
)),
204 EnumItem(e
) => ItemEnum
::Enum(e
.into_tcx(tcx
)),
205 VariantItem(v
) => ItemEnum
::Variant(v
.into_tcx(tcx
)),
206 FunctionItem(f
) => ItemEnum
::Function(f
.into_tcx(tcx
)),
207 ForeignFunctionItem(f
) => ItemEnum
::Function(f
.into_tcx(tcx
)),
208 TraitItem(t
) => ItemEnum
::Trait(t
.into_tcx(tcx
)),
209 TraitAliasItem(t
) => ItemEnum
::TraitAlias(t
.into_tcx(tcx
)),
210 MethodItem(m
, _
) => ItemEnum
::Method(from_function_method(m
, true, tcx
)),
211 TyMethodItem(m
) => ItemEnum
::Method(from_function_method(m
, false, tcx
)),
212 ImplItem(i
) => ItemEnum
::Impl(i
.into_tcx(tcx
)),
213 StaticItem(s
) => ItemEnum
::Static(s
.into_tcx(tcx
)),
214 ForeignStaticItem(s
) => ItemEnum
::Static(s
.into_tcx(tcx
)),
215 ForeignTypeItem
=> ItemEnum
::ForeignType
,
216 TypedefItem(t
, _
) => ItemEnum
::Typedef(t
.into_tcx(tcx
)),
217 OpaqueTyItem(t
) => ItemEnum
::OpaqueTy(t
.into_tcx(tcx
)),
218 ConstantItem(c
) => ItemEnum
::Constant(c
.into_tcx(tcx
)),
219 MacroItem(m
) => ItemEnum
::Macro(m
.source
),
220 ProcMacroItem(m
) => ItemEnum
::ProcMacro(m
.into_tcx(tcx
)),
221 PrimitiveItem(p
) => ItemEnum
::PrimitiveType(p
.as_sym().to_string()),
222 AssocConstItem(t
, s
) => ItemEnum
::AssocConst { type_: t.into_tcx(tcx), default: s }
,
223 AssocTypeItem(g
, t
) => ItemEnum
::AssocType
{
224 bounds
: g
.into_iter().map(|x
| x
.into_tcx(tcx
)).collect(),
225 default: t
.map(|x
| x
.into_tcx(tcx
)),
227 // `convert_item` early returns `None` for striped items
228 StrippedItem(_
) => unreachable
!(),
230 panic
!("{:?} is not supported for JSON output", item
)
232 ExternCrateItem { ref src }
=> ItemEnum
::ExternCrate
{
233 name
: name
.as_ref().unwrap().to_string(),
234 rename
: src
.map(|x
| x
.to_string()),
239 impl FromWithTcx
<clean
::Struct
> for Struct
{
240 fn from_tcx(struct_
: clean
::Struct
, tcx
: TyCtxt
<'_
>) -> Self {
241 let clean
::Struct { struct_type, generics, fields, fields_stripped }
= struct_
;
243 struct_type
: from_ctor_kind(struct_type
),
244 generics
: generics
.into_tcx(tcx
),
247 impls
: Vec
::new(), // Added in JsonRenderer::item
252 impl FromWithTcx
<clean
::Union
> for Union
{
253 fn from_tcx(struct_
: clean
::Union
, tcx
: TyCtxt
<'_
>) -> Self {
254 let clean
::Union { generics, fields, fields_stripped }
= struct_
;
256 generics
: generics
.into_tcx(tcx
),
259 impls
: Vec
::new(), // Added in JsonRenderer::item
264 crate fn from_ctor_kind(struct_type
: CtorKind
) -> StructType
{
266 CtorKind
::Fictive
=> StructType
::Plain
,
267 CtorKind
::Fn
=> StructType
::Tuple
,
268 CtorKind
::Const
=> StructType
::Unit
,
272 crate fn from_fn_header(header
: &rustc_hir
::FnHeader
) -> HashSet
<Qualifiers
> {
273 let mut v
= HashSet
::new();
275 if let rustc_hir
::Unsafety
::Unsafe
= header
.unsafety
{
276 v
.insert(Qualifiers
::Unsafe
);
279 if let rustc_hir
::IsAsync
::Async
= header
.asyncness
{
280 v
.insert(Qualifiers
::Async
);
283 if let rustc_hir
::Constness
::Const
= header
.constness
{
284 v
.insert(Qualifiers
::Const
);
290 impl FromWithTcx
<clean
::Function
> for Function
{
291 fn from_tcx(function
: clean
::Function
, tcx
: TyCtxt
<'_
>) -> Self {
292 let clean
::Function { decl, generics, header }
= function
;
294 decl
: decl
.into_tcx(tcx
),
295 generics
: generics
.into_tcx(tcx
),
296 header
: from_fn_header(&header
),
297 abi
: header
.abi
.to_string(),
302 impl FromWithTcx
<clean
::Generics
> for Generics
{
303 fn from_tcx(generics
: clean
::Generics
, tcx
: TyCtxt
<'_
>) -> Self {
305 params
: generics
.params
.into_iter().map(|x
| x
.into_tcx(tcx
)).collect(),
306 where_predicates
: generics
309 .map(|x
| x
.into_tcx(tcx
))
315 impl FromWithTcx
<clean
::GenericParamDef
> for GenericParamDef
{
316 fn from_tcx(generic_param
: clean
::GenericParamDef
, tcx
: TyCtxt
<'_
>) -> Self {
318 name
: generic_param
.name
.to_string(),
319 kind
: generic_param
.kind
.into_tcx(tcx
),
324 impl FromWithTcx
<clean
::GenericParamDefKind
> for GenericParamDefKind
{
325 fn from_tcx(kind
: clean
::GenericParamDefKind
, tcx
: TyCtxt
<'_
>) -> Self {
326 use clean
::GenericParamDefKind
::*;
328 Lifetime { outlives }
=> GenericParamDefKind
::Lifetime
{
329 outlives
: outlives
.into_iter().map(|lt
| lt
.0.to_string()).collect(),
331 Type { did: _, bounds, default, synthetic: _ }
=> GenericParamDefKind
::Type
{
332 bounds
: bounds
.into_iter().map(|x
| x
.into_tcx(tcx
)).collect(),
333 default: default.map(|x
| x
.into_tcx(tcx
)),
335 Const { did: _, ty, default }
=> {
336 GenericParamDefKind
::Const { ty: ty.into_tcx(tcx), default }
342 impl FromWithTcx
<clean
::WherePredicate
> for WherePredicate
{
343 fn from_tcx(predicate
: clean
::WherePredicate
, tcx
: TyCtxt
<'_
>) -> Self {
344 use clean
::WherePredicate
::*;
346 BoundPredicate { ty, bounds, .. }
=> WherePredicate
::BoundPredicate
{
347 ty
: ty
.into_tcx(tcx
),
348 bounds
: bounds
.into_iter().map(|x
| x
.into_tcx(tcx
)).collect(),
349 // FIXME: add `bound_params` to rustdoc-json-params?
351 RegionPredicate { lifetime, bounds }
=> WherePredicate
::RegionPredicate
{
352 lifetime
: lifetime
.0.to_string(),
353 bounds
: bounds
.into_iter().map(|x
| x
.into_tcx(tcx
)).collect(),
355 EqPredicate { lhs, rhs }
=> {
356 WherePredicate
::EqPredicate { lhs: lhs.into_tcx(tcx), rhs: rhs.into_tcx(tcx) }
362 impl FromWithTcx
<clean
::GenericBound
> for GenericBound
{
363 fn from_tcx(bound
: clean
::GenericBound
, tcx
: TyCtxt
<'_
>) -> Self {
364 use clean
::GenericBound
::*;
366 TraitBound(clean
::PolyTrait { trait_, generic_params }
, modifier
) => {
367 // FIXME: should `trait_` be a clean::Path equivalent in JSON?
369 clean
::ResolvedPath { did: trait_.def_id(), path: trait_ }
.into_tcx(tcx
);
370 GenericBound
::TraitBound
{
372 generic_params
: generic_params
.into_iter().map(|x
| x
.into_tcx(tcx
)).collect(),
373 modifier
: from_trait_bound_modifier(modifier
),
376 Outlives(lifetime
) => GenericBound
::Outlives(lifetime
.0.to_string()),
381 crate fn from_trait_bound_modifier(modifier
: rustc_hir
::TraitBoundModifier
) -> TraitBoundModifier
{
382 use rustc_hir
::TraitBoundModifier
::*;
384 None
=> TraitBoundModifier
::None
,
385 Maybe
=> TraitBoundModifier
::Maybe
,
386 MaybeConst
=> TraitBoundModifier
::MaybeConst
,
390 impl FromWithTcx
<clean
::Type
> for Type
{
391 fn from_tcx(ty
: clean
::Type
, tcx
: TyCtxt
<'_
>) -> Self {
394 ResolvedPath { path, did }
=> Type
::ResolvedPath
{
395 name
: path
.whole_name(),
396 id
: from_item_id(did
.into()),
397 args
: path
.segments
.last().map(|args
| Box
::new(args
.clone().args
.into_tcx(tcx
))),
398 param_names
: Vec
::new(),
400 DynTrait(mut bounds
, lt
) => {
401 let first_trait
= bounds
.remove(0).trait_
;
404 name
: first_trait
.whole_name(),
405 id
: from_item_id(first_trait
.def_id().into()),
409 .map(|args
| Box
::new(args
.clone().args
.into_tcx(tcx
))),
413 clean
::GenericBound
::TraitBound(t
, rustc_hir
::TraitBoundModifier
::None
)
415 .chain(lt
.into_iter().map(|lt
| clean
::GenericBound
::Outlives(lt
)))
416 .map(|bound
| bound
.into_tcx(tcx
))
420 Generic(s
) => Type
::Generic(s
.to_string()),
421 Primitive(p
) => Type
::Primitive(p
.as_sym().to_string()),
422 BareFunction(f
) => Type
::FunctionPointer(Box
::new((*f
).into_tcx(tcx
))),
423 Tuple(t
) => Type
::Tuple(t
.into_iter().map(|x
| x
.into_tcx(tcx
)).collect()),
424 Slice(t
) => Type
::Slice(Box
::new((*t
).into_tcx(tcx
))),
425 Array(t
, s
) => Type
::Array { type_: Box::new((*t).into_tcx(tcx)), len: s }
,
426 ImplTrait(g
) => Type
::ImplTrait(g
.into_iter().map(|x
| x
.into_tcx(tcx
)).collect()),
427 Infer
=> Type
::Infer
,
428 RawPointer(mutability
, type_
) => Type
::RawPointer
{
429 mutable
: mutability
== ast
::Mutability
::Mut
,
430 type_
: Box
::new((*type_
).into_tcx(tcx
)),
432 BorrowedRef { lifetime, mutability, type_ }
=> Type
::BorrowedRef
{
433 lifetime
: lifetime
.map(|l
| l
.0.to_string()),
434 mutable
: mutability
== ast
::Mutability
::Mut
,
435 type_
: Box
::new((*type_
).into_tcx(tcx
)),
437 QPath { name, self_type, trait_, .. }
=> {
438 // FIXME: should `trait_` be a clean::Path equivalent in JSON?
439 let trait_
= ResolvedPath { did: trait_.def_id(), path: trait_ }
.into_tcx(tcx
);
440 Type
::QualifiedPath
{
441 name
: name
.to_string(),
442 self_type
: Box
::new((*self_type
).into_tcx(tcx
)),
443 trait_
: Box
::new(trait_
),
450 impl FromWithTcx
<clean
::BareFunctionDecl
> for FunctionPointer
{
451 fn from_tcx(bare_decl
: clean
::BareFunctionDecl
, tcx
: TyCtxt
<'_
>) -> Self {
452 let clean
::BareFunctionDecl { unsafety, generic_params, decl, abi }
= bare_decl
;
454 header
: if let rustc_hir
::Unsafety
::Unsafe
= unsafety
{
455 let mut hs
= HashSet
::new();
456 hs
.insert(Qualifiers
::Unsafe
);
461 generic_params
: generic_params
.into_iter().map(|x
| x
.into_tcx(tcx
)).collect(),
462 decl
: decl
.into_tcx(tcx
),
463 abi
: abi
.to_string(),
468 impl FromWithTcx
<clean
::FnDecl
> for FnDecl
{
469 fn from_tcx(decl
: clean
::FnDecl
, tcx
: TyCtxt
<'_
>) -> Self {
470 let clean
::FnDecl { inputs, output, c_variadic }
= decl
;
475 .map(|arg
| (arg
.name
.to_string(), arg
.type_
.into_tcx(tcx
)))
477 output
: match output
{
478 clean
::FnRetTy
::Return(t
) => Some(t
.into_tcx(tcx
)),
479 clean
::FnRetTy
::DefaultReturn
=> None
,
486 impl FromWithTcx
<clean
::Trait
> for Trait
{
487 fn from_tcx(trait_
: clean
::Trait
, tcx
: TyCtxt
<'_
>) -> Self {
488 let clean
::Trait { unsafety, items, generics, bounds, is_auto }
= trait_
;
491 is_unsafe
: unsafety
== rustc_hir
::Unsafety
::Unsafe
,
493 generics
: generics
.into_tcx(tcx
),
494 bounds
: bounds
.into_iter().map(|x
| x
.into_tcx(tcx
)).collect(),
495 implementors
: Vec
::new(), // Added in JsonRenderer::item
500 impl FromWithTcx
<clean
::Impl
> for Impl
{
501 fn from_tcx(impl_
: clean
::Impl
, tcx
: TyCtxt
<'_
>) -> Self {
502 let provided_trait_methods
= impl_
.provided_trait_methods(tcx
);
514 // FIXME: should `trait_` be a clean::Path equivalent in JSON?
515 let trait_
= trait_
.map(|path
| {
516 let did
= path
.def_id();
517 clean
::ResolvedPath { path, did }
.into_tcx(tcx
)
520 is_unsafe
: unsafety
== rustc_hir
::Unsafety
::Unsafe
,
521 generics
: generics
.into_tcx(tcx
),
522 provided_trait_methods
: provided_trait_methods
524 .map(|x
| x
.to_string())
527 for_
: for_
.into_tcx(tcx
),
529 negative
: negative_polarity
,
531 blanket_impl
: blanket_impl
.map(|x
| (*x
).into_tcx(tcx
)),
536 crate fn from_function_method(
537 function
: clean
::Function
,
541 let clean
::Function { header, decl, generics }
= function
;
543 decl
: decl
.into_tcx(tcx
),
544 generics
: generics
.into_tcx(tcx
),
545 header
: from_fn_header(&header
),
546 abi
: header
.abi
.to_string(),
551 impl FromWithTcx
<clean
::Enum
> for Enum
{
552 fn from_tcx(enum_
: clean
::Enum
, tcx
: TyCtxt
<'_
>) -> Self {
553 let clean
::Enum { variants, generics, variants_stripped }
= enum_
;
555 generics
: generics
.into_tcx(tcx
),
557 variants
: ids(variants
),
558 impls
: Vec
::new(), // Added in JsonRenderer::item
563 impl FromWithTcx
<clean
::VariantStruct
> for Struct
{
564 fn from_tcx(struct_
: clean
::VariantStruct
, _tcx
: TyCtxt
<'_
>) -> Self {
565 let clean
::VariantStruct { struct_type, fields, fields_stripped }
= struct_
;
567 struct_type
: from_ctor_kind(struct_type
),
568 generics
: Default
::default(),
576 impl FromWithTcx
<clean
::Variant
> for Variant
{
577 fn from_tcx(variant
: clean
::Variant
, tcx
: TyCtxt
<'_
>) -> Self {
578 use clean
::Variant
::*;
580 CLike
=> Variant
::Plain
,
581 Tuple(fields
) => Variant
::Tuple(
585 if let clean
::StructFieldItem(ty
) = *f
.kind
{
593 Struct(s
) => Variant
::Struct(ids(s
.fields
)),
598 impl FromWithTcx
<clean
::Import
> for Import
{
599 fn from_tcx(import
: clean
::Import
, _tcx
: TyCtxt
<'_
>) -> Self {
600 use clean
::ImportKind
::*;
602 Simple(s
) => Import
{
603 source
: import
.source
.path
.whole_name(),
605 id
: import
.source
.did
.map(ItemId
::from
).map(from_item_id
),
609 source
: import
.source
.path
.whole_name(),
610 name
: import
.source
.path
.last_name().to_string(),
611 id
: import
.source
.did
.map(ItemId
::from
).map(from_item_id
),
618 impl FromWithTcx
<clean
::ProcMacro
> for ProcMacro
{
619 fn from_tcx(mac
: clean
::ProcMacro
, _tcx
: TyCtxt
<'_
>) -> Self {
621 kind
: from_macro_kind(mac
.kind
),
622 helpers
: mac
.helpers
.iter().map(|x
| x
.to_string()).collect(),
627 crate fn from_macro_kind(kind
: rustc_span
::hygiene
::MacroKind
) -> MacroKind
{
628 use rustc_span
::hygiene
::MacroKind
::*;
630 Bang
=> MacroKind
::Bang
,
631 Attr
=> MacroKind
::Attr
,
632 Derive
=> MacroKind
::Derive
,
636 impl FromWithTcx
<clean
::Typedef
> for Typedef
{
637 fn from_tcx(typedef
: clean
::Typedef
, tcx
: TyCtxt
<'_
>) -> Self {
638 let clean
::Typedef { type_, generics, item_type: _ }
= typedef
;
639 Typedef { type_: type_.into_tcx(tcx), generics: generics.into_tcx(tcx) }
643 impl FromWithTcx
<clean
::OpaqueTy
> for OpaqueTy
{
644 fn from_tcx(opaque
: clean
::OpaqueTy
, tcx
: TyCtxt
<'_
>) -> Self {
646 bounds
: opaque
.bounds
.into_iter().map(|x
| x
.into_tcx(tcx
)).collect(),
647 generics
: opaque
.generics
.into_tcx(tcx
),
652 impl FromWithTcx
<clean
::Static
> for Static
{
653 fn from_tcx(stat
: clean
::Static
, tcx
: TyCtxt
<'_
>) -> Self {
655 type_
: stat
.type_
.into_tcx(tcx
),
656 mutable
: stat
.mutability
== ast
::Mutability
::Mut
,
657 expr
: stat
.expr
.map(|e
| print_const_expr(tcx
, e
)).unwrap_or_default(),
662 impl FromWithTcx
<clean
::TraitAlias
> for TraitAlias
{
663 fn from_tcx(alias
: clean
::TraitAlias
, tcx
: TyCtxt
<'_
>) -> Self {
665 generics
: alias
.generics
.into_tcx(tcx
),
666 params
: alias
.bounds
.into_iter().map(|x
| x
.into_tcx(tcx
)).collect(),
671 impl FromWithTcx
<ItemType
> for ItemKind
{
672 fn from_tcx(kind
: ItemType
, _tcx
: TyCtxt
<'_
>) -> Self {
675 Module
=> ItemKind
::Module
,
676 ExternCrate
=> ItemKind
::ExternCrate
,
677 Import
=> ItemKind
::Import
,
678 Struct
=> ItemKind
::Struct
,
679 Union
=> ItemKind
::Union
,
680 Enum
=> ItemKind
::Enum
,
681 Function
=> ItemKind
::Function
,
682 Typedef
=> ItemKind
::Typedef
,
683 OpaqueTy
=> ItemKind
::OpaqueTy
,
684 Static
=> ItemKind
::Static
,
685 Constant
=> ItemKind
::Constant
,
686 Trait
=> ItemKind
::Trait
,
687 Impl
=> ItemKind
::Impl
,
688 TyMethod
| Method
=> ItemKind
::Method
,
689 StructField
=> ItemKind
::StructField
,
690 Variant
=> ItemKind
::Variant
,
691 Macro
=> ItemKind
::Macro
,
692 Primitive
=> ItemKind
::Primitive
,
693 AssocConst
=> ItemKind
::AssocConst
,
694 AssocType
=> ItemKind
::AssocType
,
695 ForeignType
=> ItemKind
::ForeignType
,
696 Keyword
=> ItemKind
::Keyword
,
697 TraitAlias
=> ItemKind
::TraitAlias
,
698 ProcAttribute
=> ItemKind
::ProcAttribute
,
699 ProcDerive
=> ItemKind
::ProcDerive
,
704 fn ids(items
: impl IntoIterator
<Item
= clean
::Item
>) -> Vec
<Id
> {
705 items
.into_iter().filter(|x
| !x
.is_stripped()).map(|i
| from_item_id(i
.def_id
)).collect()