src/rustdoc-json-types/lib.rs

   1 //! Rustdoc's JSON output interface
   2 //!
   3 //! These types are the public API exposed through the `--output-format json` flag. The [`Crate`]
   4 //! struct is the root of the JSON blob and all other items are contained within.
   5
   6 use std::collections::HashMap;
   7 use std::path::PathBuf;
   8
   9 use serde::{Deserialize, Serialize};
  10
  11 /// rustdoc format-version.
  12 pub const FORMAT_VERSION: u32 = 19;
  13
  14 /// A `Crate` is the root of the emitted JSON blob. It contains all type/documentation information
  15 /// about the language items in the local crate, as well as info about external items to allow
  16 /// tools to find or link to them.
  17 #[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
  18 pub struct Crate {
  19     /// The id of the root [`Module`] item of the local crate.
  20     pub root: Id,
  21     /// The version string given to `--crate-version`, if any.
  22     pub crate_version: Option<String>,
  23     /// Whether or not the output includes private items.
  24     pub includes_private: bool,
  25     /// A collection of all items in the local crate as well as some external traits and their
  26     /// items that are referenced locally.
  27     pub index: HashMap<Id, Item>,
  28     /// Maps IDs to fully qualified paths and other info helpful for generating links.
  29     pub paths: HashMap<Id, ItemSummary>,
  30     /// Maps `crate_id` of items to a crate name and html_root_url if it exists.
  31     pub external_crates: HashMap<u32, ExternalCrate>,
  32     /// A single version number to be used in the future when making backwards incompatible changes
  33     /// to the JSON output.
  34     pub format_version: u32,
  35 }
  36
  37 #[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
  38 pub struct ExternalCrate {
  39     pub name: String,
  40     pub html_root_url: Option<String>,
  41 }
  42
  43 /// For external (not defined in the local crate) items, you don't get the same level of
  44 /// information. This struct should contain enough to generate a link/reference to the item in
  45 /// question, or can be used by a tool that takes the json output of multiple crates to find
  46 /// the actual item definition with all the relevant info.
  47 #[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
  48 pub struct ItemSummary {
  49     /// Can be used to look up the name and html_root_url of the crate this item came from in the
  50     /// `external_crates` map.
  51     pub crate_id: u32,
  52     /// The list of path components for the fully qualified path of this item (e.g.
  53     /// `["std", "io", "lazy", "Lazy"]` for `std::io::lazy::Lazy`).
  54     pub path: Vec<String>,
  55     /// Whether this item is a struct, trait, macro, etc.
  56     pub kind: ItemKind,
  57 }
  58
  59 #[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
  60 pub struct Item {
  61     /// The unique identifier of this item. Can be used to find this item in various mappings.
  62     pub id: Id,
  63     /// This can be used as a key to the `external_crates` map of [`Crate`] to see which crate
  64     /// this item came from.
  65     pub crate_id: u32,
  66     /// Some items such as impls don't have names.
  67     pub name: Option<String>,
  68     /// The source location of this item (absent if it came from a macro expansion or inline
  69     /// assembly).
  70     pub span: Option<Span>,
  71     /// By default all documented items are public, but you can tell rustdoc to output private items
  72     /// so this field is needed to differentiate.
  73     pub visibility: Visibility,
  74     /// The full markdown docstring of this item. Absent if there is no documentation at all,
  75     /// Some("") if there is some documentation but it is empty (EG `#[doc = ""]`).
  76     pub docs: Option<String>,
  77     /// This mapping resolves [intra-doc links](https://github.com/rust-lang/rfcs/blob/master/text/1946-intra-rustdoc-links.md) from the docstring to their IDs
  78     pub links: HashMap<String, Id>,
  79     /// Stringified versions of the attributes on this item (e.g. `"#[inline]"`)
  80     pub attrs: Vec<String>,
  81     pub deprecation: Option<Deprecation>,
  82     #[serde(flatten)]
  83     pub inner: ItemEnum,
  84 }
  85
  86 #[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
  87 pub struct Span {
  88     /// The path to the source file for this span relative to the path `rustdoc` was invoked with.
  89     pub filename: PathBuf,
  90     /// Zero indexed Line and Column of the first character of the `Span`
  91     pub begin: (usize, usize),
  92     /// Zero indexed Line and Column of the last character of the `Span`
  93     pub end: (usize, usize),
  94 }
  95
  96 #[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
  97 pub struct Deprecation {
  98     pub since: Option<String>,
  99     pub note: Option<String>,
 100 }
 101
 102 #[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
 103 #[serde(rename_all = "snake_case")]
 104 pub enum Visibility {
 105     Public,
 106     /// For the most part items are private by default. The exceptions are associated items of
 107     /// public traits and variants of public enums.
 108     Default,
 109     Crate,
 110     /// For `pub(in path)` visibility. `parent` is the module it's restricted to and `path` is how
 111     /// that module was referenced (like `"super::super"` or `"crate::foo::bar"`).
 112     Restricted {
 113         parent: Id,
 114         path: String,
 115     },
 116 }
 117
 118 #[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
 119 pub struct DynTrait {
 120     /// All the traits implemented. One of them is the vtable, and the rest must be auto traits.
 121     pub traits: Vec<PolyTrait>,
 122     /// The lifetime of the whole dyn object
 123     /// ```text
 124     /// dyn Debug + 'static
 125     ///             ^^^^^^^
 126     ///             |
 127     ///             this part
 128     /// ```
 129     pub lifetime: Option<String>,
 130 }
 131
 132 #[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
 133 /// A trait and potential HRTBs
 134 pub struct PolyTrait {
 135     #[serde(rename = "trait")]
 136     pub trait_: Path,
 137     /// Used for Higher-Rank Trait Bounds (HRTBs)
 138     /// ```text
 139     /// dyn for<'a> Fn() -> &'a i32"
 140     ///     ^^^^^^^
 141     ///       |
 142     ///       this part
 143     /// ```
 144     pub generic_params: Vec<GenericParamDef>,
 145 }
 146
 147 #[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
 148 #[serde(rename_all = "snake_case")]
 149 pub enum GenericArgs {
 150     /// <'a, 32, B: Copy, C = u32>
 151     AngleBracketed { args: Vec<GenericArg>, bindings: Vec<TypeBinding> },
 152     /// Fn(A, B) -> C
 153     Parenthesized { inputs: Vec<Type>, output: Option<Type> },
 154 }
 155
 156 #[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
 157 #[serde(rename_all = "snake_case")]
 158 pub enum GenericArg {
 159     Lifetime(String),
 160     Type(Type),
 161     Const(Constant),
 162     Infer,
 163 }
 164
 165 #[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
 166 pub struct Constant {
 167     #[serde(rename = "type")]
 168     pub type_: Type,
 169     pub expr: String,
 170     pub value: Option<String>,
 171     pub is_literal: bool,
 172 }
 173
 174 #[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
 175 pub struct TypeBinding {
 176     pub name: String,
 177     pub args: GenericArgs,
 178     pub binding: TypeBindingKind,
 179 }
 180
 181 #[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
 182 #[serde(rename_all = "snake_case")]
 183 pub enum TypeBindingKind {
 184     Equality(Term),
 185     Constraint(Vec<GenericBound>),
 186 }
 187
 188 #[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
 189 pub struct Id(pub String);
 190
 191 #[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
 192 #[serde(rename_all = "snake_case")]
 193 pub enum ItemKind {
 194     Module,
 195     ExternCrate,
 196     Import,
 197     Struct,
 198     StructField,
 199     Union,
 200     Enum,
 201     Variant,
 202     Function,
 203     Typedef,
 204     OpaqueTy,
 205     Constant,
 206     Trait,
 207     TraitAlias,
 208     Method,
 209     Impl,
 210     Static,
 211     ForeignType,
 212     Macro,
 213     ProcAttribute,
 214     ProcDerive,
 215     AssocConst,
 216     AssocType,
 217     Primitive,
 218     Keyword,
 219 }
 220
 221 #[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
 222 #[serde(tag = "kind", content = "inner", rename_all = "snake_case")]
 223 pub enum ItemEnum {
 224     Module(Module),
 225     ExternCrate {
 226         name: String,
 227         rename: Option<String>,
 228     },
 229     Import(Import),
 230
 231     Union(Union),
 232     Struct(Struct),
 233     StructField(Type),
 234     Enum(Enum),
 235     Variant(Variant),
 236
 237     Function(Function),
 238
 239     Trait(Trait),
 240     TraitAlias(TraitAlias),
 241     Method(Method),
 242     Impl(Impl),
 243
 244     Typedef(Typedef),
 245     OpaqueTy(OpaqueTy),
 246     Constant(Constant),
 247
 248     Static(Static),
 249
 250     /// `type`s from an extern block
 251     ForeignType,
 252
 253     /// Declarative macro_rules! macro
 254     Macro(String),
 255     ProcMacro(ProcMacro),
 256
 257     PrimitiveType(String),
 258
 259     AssocConst {
 260         #[serde(rename = "type")]
 261         type_: Type,
 262         /// e.g. `const X: usize = 5;`
 263         default: Option<String>,
 264     },
 265     AssocType {
 266         generics: Generics,
 267         bounds: Vec<GenericBound>,
 268         /// e.g. `type X = usize;`
 269         default: Option<Type>,
 270     },
 271 }
 272
 273 #[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
 274 pub struct Module {
 275     pub is_crate: bool,
 276     pub items: Vec<Id>,
 277     /// If `true`, this module is not part of the public API, but it contains
 278     /// items that are re-exported as public API.
 279     pub is_stripped: bool,
 280 }
 281
 282 #[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
 283 pub struct Union {
 284     pub generics: Generics,
 285     pub fields_stripped: bool,
 286     pub fields: Vec<Id>,
 287     pub impls: Vec<Id>,
 288 }
 289
 290 #[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
 291 pub struct Struct {
 292     pub struct_type: StructType,
 293     pub generics: Generics,
 294     pub fields_stripped: bool,
 295     pub fields: Vec<Id>,
 296     pub impls: Vec<Id>,
 297 }
 298
 299 #[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
 300 pub struct Enum {
 301     pub generics: Generics,
 302     pub variants_stripped: bool,
 303     pub variants: Vec<Id>,
 304     pub impls: Vec<Id>,
 305 }
 306
 307 #[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
 308 #[serde(rename_all = "snake_case")]
 309 #[serde(tag = "variant_kind", content = "variant_inner")]
 310 pub enum Variant {
 311     Plain(Option<Discriminant>),
 312     Tuple(Vec<Type>),
 313     Struct(Vec<Id>),
 314 }
 315
 316 #[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
 317 pub struct Discriminant {
 318     /// The expression that produced the discriminant.
 319     ///
 320     /// Unlike `value`, this preserves the original formatting (eg suffixes,
 321     /// hexadecimal, and underscores), making it unsuitable to be machine
 322     /// interpreted.
 323     ///
 324     /// In some cases, when the value is to complex, this may be `"{ _ }"`.
 325     /// When this occurs is unstable, and may change without notice.
 326     pub expr: String,
 327     /// The numerical value of the discriminant. Stored as a string due to
 328     /// JSON's poor support for large integers, and the fact that it would need
 329     /// to store from [`i128::MIN`] to [`u128::MAX`].
 330     pub value: String,
 331 }
 332
 333 #[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
 334 #[serde(rename_all = "snake_case")]
 335 pub enum StructType {
 336     Plain,
 337     Tuple,
 338     Unit,
 339 }
 340
 341 #[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
 342 pub struct Header {
 343     #[serde(rename = "const")]
 344     pub const_: bool,
 345     #[serde(rename = "unsafe")]
 346     pub unsafe_: bool,
 347     #[serde(rename = "async")]
 348     pub async_: bool,
 349     pub abi: Abi,
 350 }
 351
 352 #[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
 353 pub enum Abi {
 354     // We only have a concrete listing here for stable ABI's because their are so many
 355     // See rustc_ast_passes::feature_gate::PostExpansionVisitor::check_abi for the list
 356     Rust,
 357     C { unwind: bool },
 358     Cdecl { unwind: bool },
 359     Stdcall { unwind: bool },
 360     Fastcall { unwind: bool },
 361     Aapcs { unwind: bool },
 362     Win64 { unwind: bool },
 363     SysV64 { unwind: bool },
 364     System { unwind: bool },
 365     Other(String),
 366 }
 367
 368 #[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
 369 pub struct Function {
 370     pub decl: FnDecl,
 371     pub generics: Generics,
 372     pub header: Header,
 373 }
 374
 375 #[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
 376 pub struct Method {
 377     pub decl: FnDecl,
 378     pub generics: Generics,
 379     pub header: Header,
 380     pub has_body: bool,
 381 }
 382
 383 #[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
 384 pub struct Generics {
 385     pub params: Vec<GenericParamDef>,
 386     pub where_predicates: Vec<WherePredicate>,
 387 }
 388
 389 #[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
 390 pub struct GenericParamDef {
 391     pub name: String,
 392     pub kind: GenericParamDefKind,
 393 }
 394
 395 #[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
 396 #[serde(rename_all = "snake_case")]
 397 pub enum GenericParamDefKind {
 398     Lifetime {
 399         outlives: Vec<String>,
 400     },
 401     Type {
 402         bounds: Vec<GenericBound>,
 403         default: Option<Type>,
 404         /// This is normally `false`, which means that this generic parameter is
 405         /// declared in the Rust source text.
 406         ///
 407         /// If it is `true`, this generic parameter has been introduced by the
 408         /// compiler behind the scenes.
 409         ///
 410         /// # Example
 411         ///
 412         /// Consider
 413         ///
 414         /// ```ignore (pseudo-rust)
 415         /// pub fn f(_: impl Trait) {}
 416         /// ```
 417         ///
 418         /// The compiler will transform this behind the scenes to
 419         ///
 420         /// ```ignore (pseudo-rust)
 421         /// pub fn f<impl Trait: Trait>(_: impl Trait) {}
 422         /// ```
 423         ///
 424         /// In this example, the generic parameter named `impl Trait` (and which
 425         /// is bound by `Trait`) is synthetic, because it was not originally in
 426         /// the Rust source text.
 427         synthetic: bool,
 428     },
 429     Const {
 430         #[serde(rename = "type")]
 431         type_: Type,
 432         default: Option<String>,
 433     },
 434 }
 435
 436 #[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
 437 #[serde(rename_all = "snake_case")]
 438 pub enum WherePredicate {
 439     BoundPredicate {
 440         #[serde(rename = "type")]
 441         type_: Type,
 442         bounds: Vec<GenericBound>,
 443         /// Used for Higher-Rank Trait Bounds (HRTBs)
 444         /// ```text
 445         /// where for<'a> &'a T: Iterator,"
 446         ///       ^^^^^^^
 447         ///       |
 448         ///       this part
 449         /// ```
 450         generic_params: Vec<GenericParamDef>,
 451     },
 452     RegionPredicate {
 453         lifetime: String,
 454         bounds: Vec<GenericBound>,
 455     },
 456     EqPredicate {
 457         lhs: Type,
 458         rhs: Term,
 459     },
 460 }
 461
 462 #[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
 463 #[serde(rename_all = "snake_case")]
 464 pub enum GenericBound {
 465     TraitBound {
 466         #[serde(rename = "trait")]
 467         trait_: Path,
 468         /// Used for Higher-Rank Trait Bounds (HRTBs)
 469         /// ```text
 470         /// where F: for<'a, 'b> Fn(&'a u8, &'b u8)
 471         ///          ^^^^^^^^^^^
 472         ///          |
 473         ///          this part
 474         /// ```
 475         generic_params: Vec<GenericParamDef>,
 476         modifier: TraitBoundModifier,
 477     },
 478     Outlives(String),
 479 }
 480
 481 #[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
 482 #[serde(rename_all = "snake_case")]
 483 pub enum TraitBoundModifier {
 484     None,
 485     Maybe,
 486     MaybeConst,
 487 }
 488
 489 #[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
 490 #[serde(rename_all = "snake_case")]
 491 pub enum Term {
 492     Type(Type),
 493     Constant(Constant),
 494 }
 495
 496 #[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
 497 #[serde(rename_all = "snake_case")]
 498 #[serde(tag = "kind", content = "inner")]
 499 pub enum Type {
 500     /// Structs, enums, and traits
 501     ResolvedPath(Path),
 502     DynTrait(DynTrait),
 503     /// Parameterized types
 504     Generic(String),
 505     /// Fixed-size numeric types (plus int/usize/float), char, arrays, slices, and tuples
 506     Primitive(String),
 507     /// `extern "ABI" fn`
 508     FunctionPointer(Box<FunctionPointer>),
 509     /// `(String, u32, Box<usize>)`
 510     Tuple(Vec<Type>),
 511     /// `[u32]`
 512     Slice(Box<Type>),
 513     /// [u32; 15]
 514     Array {
 515         #[serde(rename = "type")]
 516         type_: Box<Type>,
 517         len: String,
 518     },
 519     /// `impl TraitA + TraitB + ...`
 520     ImplTrait(Vec<GenericBound>),
 521     /// `_`
 522     Infer,
 523     /// `*mut u32`, `*u8`, etc.
 524     RawPointer {
 525         mutable: bool,
 526         #[serde(rename = "type")]
 527         type_: Box<Type>,
 528     },
 529     /// `&'a mut String`, `&str`, etc.
 530     BorrowedRef {
 531         lifetime: Option<String>,
 532         mutable: bool,
 533         #[serde(rename = "type")]
 534         type_: Box<Type>,
 535     },
 536     /// `<Type as Trait>::Name` or associated types like `T::Item` where `T: Iterator`
 537     QualifiedPath {
 538         name: String,
 539         args: Box<GenericArgs>,
 540         self_type: Box<Type>,
 541         #[serde(rename = "trait")]
 542         trait_: Path,
 543     },
 544 }
 545
 546 #[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
 547 pub struct Path {
 548     pub name: String,
 549     pub id: Id,
 550     /// Generic arguments to the type
 551     /// ```test
 552     /// std::borrow::Cow<'static, str>
 553     ///                 ^^^^^^^^^^^^^^
 554     ///                 |
 555     ///                 this part
 556     /// ```
 557     pub args: Option<Box<GenericArgs>>,
 558 }
 559
 560 #[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
 561 pub struct FunctionPointer {
 562     pub decl: FnDecl,
 563     /// Used for Higher-Rank Trait Bounds (HRTBs)
 564     /// ```text
 565     /// for<'c> fn(val: &'c i32) -> i32
 566     /// ^^^^^^^
 567     ///       |
 568     ///       this part
 569     /// ```
 570     pub generic_params: Vec<GenericParamDef>,
 571     pub header: Header,
 572 }
 573
 574 #[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
 575 pub struct FnDecl {
 576     pub inputs: Vec<(String, Type)>,
 577     pub output: Option<Type>,
 578     pub c_variadic: bool,
 579 }
 580
 581 #[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
 582 pub struct Trait {
 583     pub is_auto: bool,
 584     pub is_unsafe: bool,
 585     pub items: Vec<Id>,
 586     pub generics: Generics,
 587     pub bounds: Vec<GenericBound>,
 588     pub implementations: Vec<Id>,
 589 }
 590
 591 #[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
 592 pub struct TraitAlias {
 593     pub generics: Generics,
 594     pub params: Vec<GenericBound>,
 595 }
 596
 597 #[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
 598 pub struct Impl {
 599     pub is_unsafe: bool,
 600     pub generics: Generics,
 601     pub provided_trait_methods: Vec<String>,
 602     #[serde(rename = "trait")]
 603     pub trait_: Option<Path>,
 604     #[serde(rename = "for")]
 605     pub for_: Type,
 606     pub items: Vec<Id>,
 607     pub negative: bool,
 608     pub synthetic: bool,
 609     pub blanket_impl: Option<Type>,
 610 }
 611
 612 #[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
 613 #[serde(rename_all = "snake_case")]
 614 pub struct Import {
 615     /// The full path being imported.
 616     pub source: String,
 617     /// May be different from the last segment of `source` when renaming imports:
 618     /// `use source as name;`
 619     pub name: String,
 620     /// The ID of the item being imported. Will be `None` in case of re-exports of primitives:
 621     /// ```rust
 622     /// pub use i32 as my_i32;
 623     /// ```
 624     pub id: Option<Id>,
 625     /// Whether this import uses a glob: `use source::*;`
 626     pub glob: bool,
 627 }
 628
 629 #[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
 630 pub struct ProcMacro {
 631     pub kind: MacroKind,
 632     pub helpers: Vec<String>,
 633 }
 634
 635 #[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
 636 #[serde(rename_all = "snake_case")]
 637 pub enum MacroKind {
 638     /// A bang macro `foo!()`.
 639     Bang,
 640     /// An attribute macro `#[foo]`.
 641     Attr,
 642     /// A derive macro `#[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]`
 643     Derive,
 644 }
 645
 646 #[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
 647 pub struct Typedef {
 648     #[serde(rename = "type")]
 649     pub type_: Type,
 650     pub generics: Generics,
 651 }
 652
 653 #[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
 654 pub struct OpaqueTy {
 655     pub bounds: Vec<GenericBound>,
 656     pub generics: Generics,
 657 }
 658
 659 #[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
 660 pub struct Static {
 661     #[serde(rename = "type")]
 662     pub type_: Type,
 663     pub mutable: bool,
 664     pub expr: String,
 665 }
 666
 667 #[cfg(test)]
 668 mod tests;