rustdoc_ext 0.1.1

Extension traits for rustdoc-types
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89

//! Extension traits for types in `rustdoc_types`.
//!
//! This crate provides utility traits that augment the types from our fork of `rustdoc-types`.
//! We keep these extensions separate to maintain `rustdoc_types` as close to upstream
//! as possible.

mod global_item_id;
pub use global_item_id::GlobalItemId;

use rustdoc_types::{ItemEnum, ItemKind};

/// Extension trait for `ItemEnum` to get a human-readable description of the item kind.
pub trait RustdocKindExt {
    /// Return a human-readable string description of this item's kind (e.g. "a function").
    fn kind(&self) -> &'static str;
}

impl RustdocKindExt for ItemEnum {
    fn kind(&self) -> &'static str {
        match self {
            ItemEnum::Module(_) => "a module",
            ItemEnum::ExternCrate { .. } => "an external crate",
            ItemEnum::Use(_) => "an import",
            ItemEnum::Union(_) => "a union",
            ItemEnum::Struct(_) => "a struct",
            ItemEnum::StructField(_) => "a struct field",
            ItemEnum::Enum(_) => "an enum",
            ItemEnum::Variant(_) => "an enum variant",
            ItemEnum::Function(func) => {
                if let Some((param, _)) = func.sig.inputs.first()
                    && param == "self"
                {
                    "a method"
                } else {
                    "a function"
                }
            }
            ItemEnum::Trait(_) => "a trait",
            ItemEnum::TraitAlias(_) => "a trait alias",
            ItemEnum::Impl(_) => "an impl block",
            ItemEnum::TypeAlias(_) => "a type alias",
            ItemEnum::Constant { .. } => "a constant",
            ItemEnum::Static(_) => "a static",
            ItemEnum::ExternType => "a foreign type",
            ItemEnum::Macro(_) => "a macro",
            ItemEnum::ProcMacro(_) => "a procedural macro",
            ItemEnum::Primitive(_) => "a primitive type",
            ItemEnum::AssocConst { .. } => "an associated constant",
            ItemEnum::AssocType { .. } => "an associated type",
        }
    }
}

/// Extension trait for `ItemKind` to get human-readable descriptions.
pub trait ItemKindExt {
    /// Return the plural form of this item kind (e.g. "functions", "structs").
    fn plural(&self) -> &'static str;
}

impl ItemKindExt for ItemKind {
    fn plural(&self) -> &'static str {
        match self {
            ItemKind::Module => "modules",
            ItemKind::ExternCrate => "extern crate declarations",
            ItemKind::Use => "use declarations",
            ItemKind::Struct => "structs",
            ItemKind::StructField => "struct fields",
            ItemKind::Union => "unions",
            ItemKind::Enum => "enums",
            ItemKind::Variant => "enum variants",
            ItemKind::Function => "functions",
            ItemKind::TypeAlias => "type aliases",
            ItemKind::Constant => "constants",
            ItemKind::Trait => "traits",
            ItemKind::TraitAlias => "trait aliases",
            ItemKind::Impl => "impl blocks",
            ItemKind::Static => "statics",
            ItemKind::ExternType => "extern types",
            ItemKind::Macro => "macros",
            ItemKind::ProcAttribute => "proc macro attributes",
            ItemKind::ProcDerive => "derive macros",
            ItemKind::AssocConst => "associated constants",
            ItemKind::AssocType => "associated types",
            ItemKind::Primitive => "primitive types",
            ItemKind::Keyword => "keywords",
            ItemKind::Attribute => "attributes",
        }
    }
}