schema {
query: RootSchemaQuery
}
directive @filter(op: String!, value: [String!]) on FIELD | INLINE_FRAGMENT
directive @tag(name: String) on FIELD
directive @output(name: String) on FIELD
directive @optional on FIELD
directive @recurse(depth: Int!) on FIELD
directive @fold on FIELD
type RootSchemaQuery {
Crate: Crate!
CrateDiff: CrateDiff!
}
type CrateDiff {
current: Crate!
baseline: Crate
}
"""
https://docs.rs/rustdoc-types/0.11.0/rustdoc_types/struct.Crate.html
"""
type Crate {
root: String!
crate_version: String
includes_private: Boolean!
format_version: Int!
"""
The top-level module of the crate, in which everything else in the crate is contained.
"""
root_module: Module!
item: [Item!]
}
"""
https://docs.rs/rustdoc-types/0.11.0/rustdoc_types/struct.Item.html
https://docs.rs/rustdoc-types/0.11.0/rustdoc_types/enum.ItemEnum.html
"""
interface Item {
id: String!
crate_id: Int!
name: String
docs: String
"""
A list of all the attributes applied to this item.
The attributes are also available through the `attribute` edge,
which makes certain operations easier.
"""
attrs: [String!]!
"""
This item is hidden in documentation.
"""
doc_hidden: Boolean!
"""
This item is deprecated.
"""
deprecated: Boolean!
"""
Whether this item is eligible to be in the public API. This is true if both:
- The item is public, either explicitly (`pub`) or implicitly (like enum variants).
- The item is visible in documentation, or is not visible but is deprecated,
since deprecated items are assumed to have been part of the public API in the past.
Being eligible to be part of the public API *does not* make an item public API!
An item that is not eligible by itself cannot be part of the public API,
but eligible items might not be public API -- for example, pub-in-priv items
(public items in a private module) are eligible but not public API. Another example
would be a public item that is only reachable via modules that are both
`#[doc(hidden)]` and not deprecated.
To check whether an item is part of the public API:
- For items that are legal in a `use` import statement, use the `importable_path` edge and the
path's `public_api` property.
- For all other items (e.g. struct fields), first check whether that parent item is public API
as above, and then check whether the item itself is `public_api_eligible`.
"""
public_api_eligible: Boolean!
# stringified version of the visibility struct field
visibility_limit: String!
attribute: [Attribute!]
span: Span
}
"""
https://docs.rs/rustdoc-types/0.11.0/rustdoc_types/struct.Item.html
https://docs.rs/rustdoc-types/0.16.0/rustdoc_types/struct.Module.html
"""
type Module implements Item & Importable {
# properties from Item
id: String!
crate_id: Int!
name: String
docs: String
attrs: [String!]!
"""
This item is hidden in documentation.
"""
doc_hidden: Boolean!
"""
This item is deprecated.
"""
deprecated: Boolean!
"""
Whether this item is eligible to be in the public API. This is true if both:
- The item is public, either explicitly (`pub`) or implicitly (like enum variants).
- The item is visible in documentation, or is not visible but is deprecated,
since deprecated items are assumed to have been part of the public API in the past.
Being eligible to be part of the public API *does not* make an item public API!
An item that is not eligible by itself cannot be part of the public API,
but eligible items might not be public API -- for example, pub-in-priv items
(public items in a private module) are eligible but not public API. Another example
would be a public item that is only reachable via modules that are both
`#[doc(hidden)]` and not deprecated.
To check whether an item is part of the public API:
- For items that are legal in a `use` import statement, use the `importable_path` edge and the
path's `public_api` property.
- For all other items (e.g. struct fields), first check whether that parent item is public API
as above, and then check whether the item itself is `public_api_eligible`.
"""
public_api_eligible: Boolean!
visibility_limit: String!
# own properties
is_stripped: Boolean!
# edges from Item
span: Span
attribute: [Attribute!]
# edges from Importable
importable_path: [ImportablePath!]
canonical_path: Path
# own edges
item: [Item!]!
}
"""
https://docs.rs/rustdoc-types/0.11.0/rustdoc_types/struct.Item.html
https://docs.rs/rustdoc-types/0.11.0/rustdoc_types/enum.ItemEnum.html
https://docs.rs/rustdoc-types/0.11.0/rustdoc_types/struct.Struct.html
"""
type Struct implements Item & Importable & ImplOwner {
# properties from Item
id: String!
crate_id: Int!
name: String
docs: String
attrs: [String!]!
"""
This item is hidden in documentation.
"""
doc_hidden: Boolean!
"""
This item is deprecated.
"""
deprecated: Boolean!
"""
Whether this item is eligible to be in the public API. This is true if both:
- The item is public, either explicitly (`pub`) or implicitly (like enum variants).
- The item is visible in documentation, or is not visible but is deprecated,
since deprecated items are assumed to have been part of the public API in the past.
Being eligible to be part of the public API *does not* make an item public API!
An item that is not eligible by itself cannot be part of the public API,
but eligible items might not be public API -- for example, pub-in-priv items
(public items in a private module) are eligible but not public API. Another example
would be a public item that is only reachable via modules that are both
`#[doc(hidden)]` and not deprecated.
To check whether an item is part of the public API:
- For items that are legal in a `use` import statement, use the `importable_path` edge and the
path's `public_api` property.
- For all other items (e.g. struct fields), first check whether that parent item is public API
as above, and then check whether the item itself is `public_api_eligible`.
"""
public_api_eligible: Boolean!
visibility_limit: String!
# own properties
struct_type: String!
fields_stripped: Boolean!
# edges from Item
span: Span
attribute: [Attribute!]
# edges from Importable
importable_path: [ImportablePath!]
canonical_path: Path
# edges from ImplOwner
"""
Any impl for this type.
All impl kinds are included:
- inherent impls: `impl Foo`
- explicit trait implementations: `impl Bar for Foo`
- blanket implementations: `impl<T> Bar for T`
"""
impl: [Impl!]
"""
Only inherent impls: implementations of the type itself (`impl Foo`).
The impls pointed to here are guaranteed to have no `trait` and no `blanket` edges.
This edge is just a convenience to simplify query-writing,
so we don't have to keep writing "@fold @transform(...) @filter(...)" chains
over the `trait` and `blanket` edges.
When Trustfall supports macro edges, this should just become a macro edge.
"""
inherent_impl: [Impl!]
# own edges
field: [StructField!]
}
"""
https://docs.rs/rustdoc-types/0.11.0/rustdoc_types/struct.Item.html
https://docs.rs/rustdoc-types/0.11.0/rustdoc_types/enum.ItemEnum.html
https://docs.rs/rustdoc-types/0.11.0/rustdoc_types/enum.Type.html
"""
type StructField implements Item {
# properties from Item
id: String!
crate_id: Int!
name: String
docs: String
attrs: [String!]!
"""
This item is hidden in documentation.
"""
doc_hidden: Boolean!
"""
This item is deprecated.
"""
deprecated: Boolean!
"""
Whether this item is eligible to be in the public API. This is true if both:
- The item is public, either explicitly (`pub`) or implicitly (like enum variants).
- The item is visible in documentation, or is not visible but is deprecated,
since deprecated items are assumed to have been part of the public API in the past.
Being eligible to be part of the public API *does not* make an item public API!
An item that is not eligible by itself cannot be part of the public API,
but eligible items might not be public API -- for example, pub-in-priv items
(public items in a private module) are eligible but not public API. Another example
would be a public item that is only reachable via modules that are both
`#[doc(hidden)]` and not deprecated.
To check whether an item is part of the public API:
- For items that are legal in a `use` import statement, use the `importable_path` edge and the
path's `public_api` property.
- For all other items (e.g. struct fields), first check whether that parent item is public API
as above, and then check whether the item itself is `public_api_eligible`.
"""
public_api_eligible: Boolean!
visibility_limit: String!
# edges from Item
span: Span
attribute: [Attribute!]
# own edges
raw_type: RawType
}
"""
https://docs.rs/rustdoc-types/0.11.0/rustdoc_types/struct.Item.html
https://docs.rs/rustdoc-types/0.11.0/rustdoc_types/enum.ItemEnum.html
https://docs.rs/rustdoc-types/0.11.0/rustdoc_types/struct.Enum.html
"""
type Enum implements Item & Importable & ImplOwner {
# properties from Item
id: String!
crate_id: Int!
name: String
docs: String
attrs: [String!]!
"""
This item is hidden in documentation.
"""
doc_hidden: Boolean!
"""
This item is deprecated.
"""
deprecated: Boolean!
"""
Whether this item is eligible to be in the public API. This is true if both:
- The item is public, either explicitly (`pub`) or implicitly (like enum variants).
- The item is visible in documentation, or is not visible but is deprecated,
since deprecated items are assumed to have been part of the public API in the past.
Being eligible to be part of the public API *does not* make an item public API!
An item that is not eligible by itself cannot be part of the public API,
but eligible items might not be public API -- for example, pub-in-priv items
(public items in a private module) are eligible but not public API. Another example
would be a public item that is only reachable via modules that are both
`#[doc(hidden)]` and not deprecated.
To check whether an item is part of the public API:
- For items that are legal in a `use` import statement, use the `importable_path` edge and the
path's `public_api` property.
- For all other items (e.g. struct fields), first check whether that parent item is public API
as above, and then check whether the item itself is `public_api_eligible`.
"""
public_api_eligible: Boolean!
visibility_limit: String!
# own properties
variants_stripped: Boolean!
# edges from Item
span: Span
attribute: [Attribute!]
# edges from Importable
importable_path: [ImportablePath!]
canonical_path: Path
# edges from ImplOwner
"""
Any impl for this type.
All impl kinds are included:
- inherent impls: `impl Foo`
- explicit trait implementations: `impl Bar for Foo`
- blanket implementations: `impl<T> Bar for T`
"""
impl: [Impl!]
"""
Only inherent impls: implementations of the type itself (`impl Foo`).
The impls pointed to here are guaranteed to have no `trait` and no `blanket` edges.
This edge is just a convenience to simplify query-writing,
so we don't have to keep writing "@fold @transform(...) @filter(...)" chains
over the `trait` and `blanket` edges.
When Trustfall supports macro edges, this should just become a macro edge.
"""
inherent_impl: [Impl!]
# own edges
variant: [Variant!]
}
"""
https://docs.rs/rustdoc-types/0.11.0/rustdoc_types/struct.Item.html
https://docs.rs/rustdoc-types/0.11.0/rustdoc_types/enum.ItemEnum.html
https://docs.rs/rustdoc-types/0.11.0/rustdoc_types/enum.Variant.html
"""
interface Variant implements Item {
# properties from Item
id: String!
crate_id: Int!
name: String
docs: String
attrs: [String!]!
"""
This item is hidden in documentation.
"""
doc_hidden: Boolean!
"""
This item is deprecated.
"""
deprecated: Boolean!
"""
Whether this item is eligible to be in the public API. This is true if both:
- The item is public, either explicitly (`pub`) or implicitly (like enum variants).
- The item is visible in documentation, or is not visible but is deprecated,
since deprecated items are assumed to have been part of the public API in the past.
Being eligible to be part of the public API *does not* make an item public API!
An item that is not eligible by itself cannot be part of the public API,
but eligible items might not be public API -- for example, pub-in-priv items
(public items in a private module) are eligible but not public API. Another example
would be a public item that is only reachable via modules that are both
`#[doc(hidden)]` and not deprecated.
To check whether an item is part of the public API:
- For items that are legal in a `use` import statement, use the `importable_path` edge and the
path's `public_api` property.
- For all other items (e.g. struct fields), first check whether that parent item is public API
as above, and then check whether the item itself is `public_api_eligible`.
"""
public_api_eligible: Boolean!
visibility_limit: String!
# edges from Item
span: Span
attribute: [Attribute!]
# own edges
field: [StructField!]
}
"""
https://docs.rs/rustdoc-types/0.11.0/rustdoc_types/struct.Item.html
https://docs.rs/rustdoc-types/0.11.0/rustdoc_types/enum.ItemEnum.html
https://docs.rs/rustdoc-types/0.11.0/rustdoc_types/enum.Variant.html
"""
type PlainVariant implements Item & Variant {
# properties from Item
id: String!
crate_id: Int!
name: String
docs: String
attrs: [String!]!
"""
This item is hidden in documentation.
"""
doc_hidden: Boolean!
"""
This item is deprecated.
"""
deprecated: Boolean!
"""
Whether this item is eligible to be in the public API. This is true if both:
- The item is public, either explicitly (`pub`) or implicitly (like enum variants).
- The item is visible in documentation, or is not visible but is deprecated,
since deprecated items are assumed to have been part of the public API in the past.
Being eligible to be part of the public API *does not* make an item public API!
An item that is not eligible by itself cannot be part of the public API,
but eligible items might not be public API -- for example, pub-in-priv items
(public items in a private module) are eligible but not public API. Another example
would be a public item that is only reachable via modules that are both
`#[doc(hidden)]` and not deprecated.
To check whether an item is part of the public API:
- For items that are legal in a `use` import statement, use the `importable_path` edge and the
path's `public_api` property.
- For all other items (e.g. struct fields), first check whether that parent item is public API
as above, and then check whether the item itself is `public_api_eligible`.
"""
public_api_eligible: Boolean!
visibility_limit: String!
# edges from Item
span: Span
attribute: [Attribute!]
# edges from Variant
field: [StructField!]
}
"""
https://docs.rs/rustdoc-types/0.11.0/rustdoc_types/struct.Item.html
https://docs.rs/rustdoc-types/0.11.0/rustdoc_types/enum.ItemEnum.html
https://docs.rs/rustdoc-types/0.11.0/rustdoc_types/enum.Variant.html
"""
type TupleVariant implements Item & Variant {
# properties from Item
id: String!
crate_id: Int!
name: String
docs: String
attrs: [String!]!
"""
This item is hidden in documentation.
"""
doc_hidden: Boolean!
"""
This item is deprecated.
"""
deprecated: Boolean!
"""
Whether this item is eligible to be in the public API. This is true if both:
- The item is public, either explicitly (`pub`) or implicitly (like enum variants).
- The item is visible in documentation, or is not visible but is deprecated,
since deprecated items are assumed to have been part of the public API in the past.
Being eligible to be part of the public API *does not* make an item public API!
An item that is not eligible by itself cannot be part of the public API,
but eligible items might not be public API -- for example, pub-in-priv items
(public items in a private module) are eligible but not public API. Another example
would be a public item that is only reachable via modules that are both
`#[doc(hidden)]` and not deprecated.
To check whether an item is part of the public API:
- For items that are legal in a `use` import statement, use the `importable_path` edge and the
path's `public_api` property.
- For all other items (e.g. struct fields), first check whether that parent item is public API
as above, and then check whether the item itself is `public_api_eligible`.
"""
public_api_eligible: Boolean!
visibility_limit: String!
# edges from Item
span: Span
attribute: [Attribute!]
# edges from Variant
field: [StructField!]
}
"""
https://docs.rs/rustdoc-types/0.11.0/rustdoc_types/struct.Item.html
https://docs.rs/rustdoc-types/0.11.0/rustdoc_types/enum.ItemEnum.html
https://docs.rs/rustdoc-types/0.11.0/rustdoc_types/enum.Variant.html
"""
type StructVariant implements Item & Variant {
# properties from Item
id: String!
crate_id: Int!
name: String
docs: String
attrs: [String!]!
"""
This item is hidden in documentation.
"""
doc_hidden: Boolean!
"""
This item is deprecated.
"""
deprecated: Boolean!
"""
Whether this item is eligible to be in the public API. This is true if both:
- The item is public, either explicitly (`pub`) or implicitly (like enum variants).
- The item is visible in documentation, or is not visible but is deprecated,
since deprecated items are assumed to have been part of the public API in the past.
Being eligible to be part of the public API *does not* make an item public API!
An item that is not eligible by itself cannot be part of the public API,
but eligible items might not be public API -- for example, pub-in-priv items
(public items in a private module) are eligible but not public API. Another example
would be a public item that is only reachable via modules that are both
`#[doc(hidden)]` and not deprecated.
To check whether an item is part of the public API:
- For items that are legal in a `use` import statement, use the `importable_path` edge and the
path's `public_api` property.
- For all other items (e.g. struct fields), first check whether that parent item is public API
as above, and then check whether the item itself is `public_api_eligible`.
"""
public_api_eligible: Boolean!
visibility_limit: String!
# edges from Item
span: Span
attribute: [Attribute!]
# edges from Variant
field: [StructField!]
}
"""
https://docs.rs/rustdoc-types/0.11.0/rustdoc_types/struct.Item.html
https://docs.rs/rustdoc-types/0.11.0/rustdoc_types/enum.ItemEnum.html
https://docs.rs/rustdoc-types/0.11.0/rustdoc_types/struct.Union.html
"""
type Union implements Item & Importable & ImplOwner {
# properties from Item
id: String!
crate_id: Int!
name: String
docs: String
attrs: [String!]!
"""
This item is hidden in documentation.
"""
doc_hidden: Boolean!
"""
This item is deprecated.
"""
deprecated: Boolean!
"""
Whether this item is eligible to be in the public API. This is true if both:
- The item is public, either explicitly (`pub`) or implicitly (like enum variants).
- The item is visible in documentation, or is not visible but is deprecated,
since deprecated items are assumed to have been part of the public API in the past.
Being eligible to be part of the public API *does not* make an item public API!
An item that is not eligible by itself cannot be part of the public API,
but eligible items might not be public API -- for example, pub-in-priv items
(public items in a private module) are eligible but not public API. Another example
would be a public item that is only reachable via modules that are both
`#[doc(hidden)]` and not deprecated.
To check whether an item is part of the public API:
- For items that are legal in a `use` import statement, use the `importable_path` edge and the
path's `public_api` property.
- For all other items (e.g. struct fields), first check whether that parent item is public API
as above, and then check whether the item itself is `public_api_eligible`.
"""
public_api_eligible: Boolean!
visibility_limit: String!
# own properties
fields_stripped: Boolean!
# edges from Item
span: Span
attribute: [Attribute!]
# edges from Importable
importable_path: [ImportablePath!]
canonical_path: Path
# edges from ImplOwner
"""
Any impl for this type.
All impl kinds are included:
- inherent impls: `impl Foo`
- explicit trait implementations: `impl Bar for Foo`
- blanket implementations: `impl<T> Bar for T`
"""
impl: [Impl!]
"""
Only inherent impls: implementations of the type itself (`impl Foo`).
The impls pointed to here are guaranteed to have no `trait` and no `blanket` edges.
This edge is just a convenience to simplify query-writing,
so we don't have to keep writing "@fold @transform(...) @filter(...)" chains
over the `trait` and `blanket` edges.
When Trustfall supports macro edges, this should just become a macro edge.
"""
inherent_impl: [Impl!]
# own edges
field: [StructField!]
}
"""
https://docs.rs/rustdoc-types/0.11.0/rustdoc_types/struct.Span.html
"""
type Span {
filename: String!
begin_line: Int!
begin_column: Int!
end_line: Int!
end_column: Int!
}
"""
An item that can be imported, through one or more paths.
"""
interface Importable {
importable_path: [ImportablePath!]
canonical_path: Path
}
"""
An item that can have impl blocks, like a struct or enum.
"""
interface ImplOwner implements Item & Importable {
# properties from Item
id: String!
crate_id: Int!
name: String
docs: String
attrs: [String!]!
"""
This item is hidden in documentation.
"""
doc_hidden: Boolean!
"""
This item is deprecated.
"""
deprecated: Boolean!
"""
Whether this item is eligible to be in the public API. This is true if both:
- The item is public, either explicitly (`pub`) or implicitly (like enum variants).
- The item is visible in documentation, or is not visible but is deprecated,
since deprecated items are assumed to have been part of the public API in the past.
Being eligible to be part of the public API *does not* make an item public API!
An item that is not eligible by itself cannot be part of the public API,
but eligible items might not be public API -- for example, pub-in-priv items
(public items in a private module) are eligible but not public API. Another example
would be a public item that is only reachable via modules that are both
`#[doc(hidden)]` and not deprecated.
To check whether an item is part of the public API:
- For items that are legal in a `use` import statement, use the `importable_path` edge and the
path's `public_api` property.
- For all other items (e.g. struct fields), first check whether that parent item is public API
as above, and then check whether the item itself is `public_api_eligible`.
"""
public_api_eligible: Boolean!
visibility_limit: String!
# edges from Item
span: Span
attribute: [Attribute!]
# edges from Importable
importable_path: [ImportablePath!]
canonical_path: Path
# own edges
"""
Any impl for this type.
All impl kinds are included:
- inherent impls: `impl Foo`
- explicit trait implementations: `impl Bar for Foo`
- blanket implementations: `impl<T> Bar for T`
"""
impl: [Impl!]
"""
Only inherent impls: implementations of the type itself (`impl Foo`).
The impls pointed to here are guaranteed to have no `trait` and no `blanket` edges.
This edge is just a convenience to simplify query-writing,
so we don't have to keep writing "@fold @transform(...) @filter(...)" chains
over the `trait` and `blanket` edges.
When Trustfall supports macro edges, this should just become a macro edge.
"""
inherent_impl: [Impl!]
}
"""
https://docs.rs/rustdoc-types/0.11.0/rustdoc_types/struct.Item.html
https://docs.rs/rustdoc-types/0.11.0/rustdoc_types/enum.ItemEnum.html
https://docs.rs/rustdoc-types/latest/rustdoc_types/struct.Impl.html
"""
type Impl implements Item {
# properties from Item
id: String!
crate_id: Int!
name: String
docs: String
attrs: [String!]!
"""
This item is hidden in documentation.
"""
doc_hidden: Boolean!
"""
This item is deprecated.
"""
deprecated: Boolean!
"""
Whether this item is eligible to be in the public API. This is true if both:
- The item is public, either explicitly (`pub`) or implicitly (like enum variants).
- The item is visible in documentation, or is not visible but is deprecated,
since deprecated items are assumed to have been part of the public API in the past.
Being eligible to be part of the public API *does not* make an item public API!
An item that is not eligible by itself cannot be part of the public API,
but eligible items might not be public API -- for example, pub-in-priv items
(public items in a private module) are eligible but not public API. Another example
would be a public item that is only reachable via modules that are both
`#[doc(hidden)]` and not deprecated.
To check whether an item is part of the public API:
- For items that are legal in a `use` import statement, use the `importable_path` edge and the
path's `public_api` property.
- For all other items (e.g. struct fields), first check whether that parent item is public API
as above, and then check whether the item itself is `public_api_eligible`.
"""
public_api_eligible: Boolean!
# stringified version of the visibility struct field
visibility_limit: String!
# own properties
unsafe: Boolean!
negative: Boolean!
synthetic: Boolean!
# edges from Item
span: Span
attribute: [Attribute!]
# own edges
"""
The trait being implemented. Inherent impls don't have a trait.
"""
implemented_trait: ImplementedTrait
# """
# The generic type across which the blanket trait implementation is made.
# TODO: implement me
# """
# blanket: GenericType
"""
Methods defined in this impl.
"""
method: [Method!]
"""
Constants associated with this type that are defined in this impl.
"""
associated_constant: [AssociatedConstant!]
}
"""
https://docs.rs/rustdoc-types/0.11.0/rustdoc_types/struct.Item.html
https://docs.rs/rustdoc-types/0.11.0/rustdoc_types/enum.ItemEnum.html
https://docs.rs/rustdoc-types/latest/rustdoc_types/struct.Trait.html
"""
type Trait implements Item & Importable {
# properties from Item
id: String!
crate_id: Int!
name: String
docs: String
attrs: [String!]!
"""
This item is hidden in documentation.
"""
doc_hidden: Boolean!
"""
This item is deprecated.
"""
deprecated: Boolean!
"""
Whether this item is eligible to be in the public API. This is true if both:
- The item is public, either explicitly (`pub`) or implicitly (like enum variants).
- The item is visible in documentation, or is not visible but is deprecated,
since deprecated items are assumed to have been part of the public API in the past.
Being eligible to be part of the public API *does not* make an item public API!
An item that is not eligible by itself cannot be part of the public API,
but eligible items might not be public API -- for example, pub-in-priv items
(public items in a private module) are eligible but not public API. Another example
would be a public item that is only reachable via modules that are both
`#[doc(hidden)]` and not deprecated.
To check whether an item is part of the public API:
- For items that are legal in a `use` import statement, use the `importable_path` edge and the
path's `public_api` property.
- For all other items (e.g. struct fields), first check whether that parent item is public API
as above, and then check whether the item itself is `public_api_eligible`.
"""
public_api_eligible: Boolean!
visibility_limit: String!
# own properties
unsafe: Boolean!
object_safe: Boolean!
# edges from Item
span: Span
attribute: [Attribute!]
# edges from Importable
importable_path: [ImportablePath!]
canonical_path: Path
# own edges
"""
Methods defined in this trait.
"""
method: [Method!]
"""
Traits whose implementation is a prerequisite for implementing this trait.
"""
supertrait: [ImplementedTrait!]
"""
Types associated with the implementation of this trait.
For example: in the `Iterator` trait, `Iterator::Item` is an associated type.
"""
associated_type: [AssociatedType!]
"""
Constants associated with this type that are defined in this impl.
"""
associated_constant: [AssociatedConstant!]
}
"""
A possible way that an item could be imported.
"""
type ImportablePath {
"""
The visibility restriction on this importable path.
For example: "public"
"""
visibility_limit: String!
"""
This path is hidden in documentation.
"""
doc_hidden: Boolean!
"""
This path is deprecated.
"""
deprecated: Boolean!
"""
This path should be treated as public API. This is true if either:
- The path is visible in documentation.
- The path is not visible and is deprecated,
since deprecated paths are assumed to have been part of the public API in the past.
"""
public_api: Boolean!
"""
The path from which the item can be imported.
For example: ["foo", "bar", "Baz"] for a type importable as foo::bar::Baz
"""
path: [String!]!
}
"""
The fully-qualified path of an item including the full sequence of modules in which it is found.
For example, consider a struct `Quux` in `foo/bar/mod.rs`. Its canonical path is `"foo::bar::Quux"`,
even if `foo/mod.rs` might have a line like `pub use bar::Quux;`. The re-export is visible through
the struct's ImportablePath neighbors.
"""
type Path {
path: [String!]!
}
"""
A function-like entity, like a function, function pointer, or method.
Combines:
https://docs.rs/rustdoc-types/0.11.0/rustdoc_types/struct.Header.html
https://docs.rs/rustdoc-types/0.11.0/rustdoc_types/struct.FnDecl.html
"""
interface FunctionLike {
const: Boolean!
unsafe: Boolean!
async: Boolean!
# own edges
parameter: [FunctionParameter!]
abi: FunctionAbi!
}
"""
A function parameter.
https://docs.rs/rustdoc-types/0.11.0/rustdoc_types/struct.FnDecl.html
"""
type FunctionParameter {
name: String!
}
"""
The ABI of a function, method, or function pointer.
It defines the calling convention for those functions, including whether unwinding across
the call boundary is supported. More info: https://rust-lang.github.io/rfcs/2945-c-unwind-abi.html
The list of supported ABIs is here:
https://github.com/rust-lang/rust/blob/557359f92512ca88b62a602ebda291f17a953002/compiler/rustc_target/src/spec/abi.rs#L74-L110
Backed by:
https://docs.rs/rustdoc-types/latest/rustdoc_types/enum.Abi.html
"""
type FunctionAbi {
"""
The name of the ABI, with any `"-unwind"` modifier stripped.
To get the ABI name directly as it would appear in a Rust source file,
use the `raw_name` property instead.
For example, a function defined as `extern "C-unwind" fn example()` would
have `name = "C"` and `raw_name = "C-unwind"`.
Functions with no specified ABI by default have an ABI named `"Rust"`.
"""
name: String!
"""
The raw name of the ABI, as it would appear in a Rust source file.
For example: "C-unwind" or "thiscall-unwind"
Functions with no specified ABI by default have an ABI named `"Rust"`.
"""
raw_name: String!
"""
Whether unwinding across this call is supported.
If encountering an unknown ABI, this value will be `null` due to unknown unwind semantics.
Unwind ability is specified in rustc here:
https://github.com/rust-lang/rust/blob/557359f92512ca88b62a602ebda291f17a953002/compiler/rustc_middle/src/ty/layout.rs#L1422-L1488
More info: https://rust-lang.github.io/rfcs/2945-c-unwind-abi.html
"""
unwind: Boolean
}
"""
https://docs.rs/rustdoc-types/0.11.0/rustdoc_types/struct.Item.html
https://docs.rs/rustdoc-types/0.11.0/rustdoc_types/enum.ItemEnum.html
https://docs.rs/rustdoc-types/0.11.0/rustdoc_types/struct.Function.html
"""
type Function implements Item & FunctionLike & Importable {
# properties from Item
id: String!
crate_id: Int!
name: String
docs: String
attrs: [String!]!
"""
This item is hidden in documentation.
"""
doc_hidden: Boolean!
"""
This item is deprecated.
"""
deprecated: Boolean!
"""
Whether this item is eligible to be in the public API. This is true if both:
- The item is public, either explicitly (`pub`) or implicitly (like enum variants).
- The item is visible in documentation, or is not visible but is deprecated,
since deprecated items are assumed to have been part of the public API in the past.
Being eligible to be part of the public API *does not* make an item public API!
An item that is not eligible by itself cannot be part of the public API,
but eligible items might not be public API -- for example, pub-in-priv items
(public items in a private module) are eligible but not public API. Another example
would be a public item that is only reachable via modules that are both
`#[doc(hidden)]` and not deprecated.
To check whether an item is part of the public API:
- For items that are legal in a `use` import statement, use the `importable_path` edge and the
path's `public_api` property.
- For all other items (e.g. struct fields), first check whether that parent item is public API
as above, and then check whether the item itself is `public_api_eligible`.
"""
public_api_eligible: Boolean!
visibility_limit: String!
# properties from FunctionLike
const: Boolean!
unsafe: Boolean!
async: Boolean!
# own properties
"""
The unmangled or explicitly-specified export name of this item, if any.
Export names are defined using the `#[export_name]` or `#[no_mangle]` attributes.
For example:
- The following function has `export_name = "example"`:
```rust
#[no_mangle]
extern "C" fn example() {}
```
- The following function has `export_name = "other"`:
```rust
#[export_name = "other"]
extern "C" fn example() {}
```
More info:
https://doc.rust-lang.org/reference/abi.html#the-no_mangle-attribute
https://doc.rust-lang.org/reference/abi.html#the-export_name-attribute
"""
export_name: String
# edges from Item
span: Span
attribute: [Attribute!]
# edges from FunctionLike
parameter: [FunctionParameter!]
abi: FunctionAbi!
# edges from Importable
importable_path: [ImportablePath!]
canonical_path: Path
}
"""
https://docs.rs/rustdoc-types/0.11.0/rustdoc_types/struct.Item.html
https://docs.rs/rustdoc-types/0.11.0/rustdoc_types/enum.ItemEnum.html
https://docs.rs/rustdoc-types/0.11.0/rustdoc_types/struct.Method.html
"""
type Method implements Item & FunctionLike {
# properties from Item
id: String!
crate_id: Int!
name: String
docs: String
attrs: [String!]!
"""
This item is hidden in documentation.
"""
doc_hidden: Boolean!
"""
This item is deprecated.
"""
deprecated: Boolean!
"""
Whether this item is eligible to be in the public API. This is true if both:
- The item is public, either explicitly (`pub`) or implicitly (like enum variants).
- The item is visible in documentation, or is not visible but is deprecated,
since deprecated items are assumed to have been part of the public API in the past.
Being eligible to be part of the public API *does not* make an item public API!
An item that is not eligible by itself cannot be part of the public API,
but eligible items might not be public API -- for example, pub-in-priv items
(public items in a private module) are eligible but not public API. Another example
would be a public item that is only reachable via modules that are both
`#[doc(hidden)]` and not deprecated.
To check whether an item is part of the public API:
- For items that are legal in a `use` import statement, use the `importable_path` edge and the
path's `public_api` property.
- For all other items (e.g. struct fields), first check whether that parent item is public API
as above, and then check whether the item itself is `public_api_eligible`.
"""
public_api_eligible: Boolean!
visibility_limit: String!
# properties from FunctionLike
const: Boolean!
unsafe: Boolean!
async: Boolean!
# edge from Item
span: Span
attribute: [Attribute!]
# edges from FunctionLike
parameter: [FunctionParameter!]
abi: FunctionAbi!
}
"""
Common supertype of `Constant` and `Static`.
https://docs.rs/rustdoc-types/0.11.0/rustdoc_types/struct.Item.html
https://docs.rs/rustdoc-types/0.11.0/rustdoc_types/enum.ItemEnum.html
"""
interface GlobalValue implements Item & Importable {
# properties from Item
id: String!
crate_id: Int!
name: String
docs: String
attrs: [String!]!
"""
This item is hidden in documentation.
"""
doc_hidden: Boolean!
"""
This item is deprecated.
"""
deprecated: Boolean!
"""
Whether this item is eligible to be in the public API. This is true if both:
- The item is public, either explicitly (`pub`) or implicitly (like enum variants).
- The item is visible in documentation, or is not visible but is deprecated,
since deprecated items are assumed to have been part of the public API in the past.
Being eligible to be part of the public API *does not* make an item public API!
An item that is not eligible by itself cannot be part of the public API,
but eligible items might not be public API -- for example, pub-in-priv items
(public items in a private module) are eligible but not public API. Another example
would be a public item that is only reachable via modules that are both
`#[doc(hidden)]` and not deprecated.
To check whether an item is part of the public API:
- For items that are legal in a `use` import statement, use the `importable_path` edge and the
path's `public_api` property.
- For all other items (e.g. struct fields), first check whether that parent item is public API
as above, and then check whether the item itself is `public_api_eligible`.
"""
public_api_eligible: Boolean!
visibility_limit: String!
# edges from Item
span: Span
attribute: [Attribute!]
# edges from Importable
importable_path: [ImportablePath!]
canonical_path: Path
}
"""
https://docs.rs/rustdoc-types/0.11.0/rustdoc_types/struct.Item.html
https://docs.rs/rustdoc-types/0.11.0/rustdoc_types/enum.ItemEnum.html
https://docs.rs/rustdoc-types/latest/rustdoc_types/struct.Constant.html
"""
type Constant implements Item & Importable & GlobalValue {
# properties from Item
id: String!
crate_id: Int!
name: String
docs: String
attrs: [String!]!
"""
This item is hidden in documentation.
"""
doc_hidden: Boolean!
"""
This item is deprecated.
"""
deprecated: Boolean!
"""
Whether this item is eligible to be in the public API. This is true if both:
- The item is public, either explicitly (`pub`) or implicitly (like enum variants).
- The item is visible in documentation, or is not visible but is deprecated,
since deprecated items are assumed to have been part of the public API in the past.
Being eligible to be part of the public API *does not* make an item public API!
An item that is not eligible by itself cannot be part of the public API,
but eligible items might not be public API -- for example, pub-in-priv items
(public items in a private module) are eligible but not public API. Another example
would be a public item that is only reachable via modules that are both
`#[doc(hidden)]` and not deprecated.
To check whether an item is part of the public API:
- For items that are legal in a `use` import statement, use the `importable_path` edge and the
path's `public_api` property.
- For all other items (e.g. struct fields), first check whether that parent item is public API
as above, and then check whether the item itself is `public_api_eligible`.
"""
public_api_eligible: Boolean!
visibility_limit: String!
# properties for Constant
"""
The expression of the constant, if any, as a Rust literal or `"_"`. For example:
```rust
// // expr
const MIN : usize = 16 ; // 16
const MIN_SIZE: usize = MIN ; // "MIN", referring to the other constant's name
const LOG_AS : &str = "batch" ; // "\"batch\"", including escaped quotes
const YEAR : Years = Years(42); // "_"
const EXPR_2_2: i32 = 2 + 2 ; // "_"
const FN_FIVE : i32 = five() ; // "_"
const fn five() -> i32 { 5 };
struct Years(i32);
```
If the constant is set:
- to be equal to another constant, `expr` holds the name of that other constant.
- by evaluating a `const` expression, such as `2 + 2` or a `const fn` call, `expr` is `"_"` instead of including the full expression.
"""
expr: String
"""
The value of the constant, if any, as a Rust literal. For example:
```rust
// // value
const MIN : usize = 16 ; // "16usize"
const MIN_SIZE: usize = MIN ; // "16usize"
const LOG_AS : &str = "batch" ; // None
const YEAR : Years = Years(42); // None
const EXPR_2_2: i32 = 2 + 2 ; // "4i32"
const FN_FIVE : i32 = five() ; // "5i32"
const fn five() -> i32 { 5 };
struct Years(i32);
```
If the constant is set:
- to be equal to another constant, `value` holds the value of that other constant.
- by evaluating a `const` expression, such as `2 + 2` or a `const fn` call, `value` is evaluated
"""
value: String
"""
The literal flag of the constant. For example:
```rust
// // is_literal
const MIN : usize = 16 ; // true
const MIN_SIZE: usize = MIN ; // false
const LOG_AS : &str = "batch" ; // true
const YEAR : Years = Years(42); // false
const EXPR_2_2: i32 = 2 + 2 ; // false
const FN_FIVE : i32 = five() ; // false
const fn five() -> i32 { 5 };
struct Years(i32);
```
"""
is_literal: Boolean
# edges from Item
span: Span
attribute: [Attribute!]
# edges from Importable
importable_path: [ImportablePath!]
canonical_path: Path
}
"""
https://docs.rs/rustdoc-types/0.11.0/rustdoc_types/struct.Item.html
https://docs.rs/rustdoc-types/0.11.0/rustdoc_types/enum.ItemEnum.html
https://docs.rs/rustdoc-types/latest/rustdoc_types/struct.Static.html
"""
type Static implements Item & Importable & GlobalValue {
# properties from Item
id: String!
crate_id: Int!
name: String
docs: String
attrs: [String!]!
"""
This item is hidden in documentation.
"""
doc_hidden: Boolean!
"""
This item is deprecated.
"""
deprecated: Boolean!
"""
Whether this item is eligible to be in the public API. This is true if both:
- The item is public, either explicitly (`pub`) or implicitly (like enum variants).
- The item is visible in documentation, or is not visible but is deprecated,
since deprecated items are assumed to have been part of the public API in the past.
Being eligible to be part of the public API *does not* make an item public API!
An item that is not eligible by itself cannot be part of the public API,
but eligible items might not be public API -- for example, pub-in-priv items
(public items in a private module) are eligible but not public API. Another example
would be a public item that is only reachable via modules that are both
`#[doc(hidden)]` and not deprecated.
To check whether an item is part of the public API:
- For items that are legal in a `use` import statement, use the `importable_path` edge and the
path's `public_api` property.
- For all other items (e.g. struct fields), first check whether that parent item is public API
as above, and then check whether the item itself is `public_api_eligible`.
"""
public_api_eligible: Boolean!
visibility_limit: String!
# own properties
mutable: Boolean!
# edges from Item
span: Span
attribute: [Attribute!]
# edges from Importable
importable_path: [ImportablePath!]
canonical_path: Path
}
"""
A specific attribute applied to an Item.
"""
type Attribute {
"""
String representation of the attribute as it is found in the code.
For example: `#[non_exhaustive]`
"""
raw_attribute: String!
"""
True for an inner attribute (starting with `#![`), and false for an
outer one (starting with `#[`).
For example: false for `#[non_exhaustive]`
"""
is_inner: Boolean!
# edges
# Edge to parsed content of the attribute
content: AttributeMetaItem!
}
"""
A single meta item used by a specific attribute
(see https://doc.rust-lang.org/reference/attributes.html#meta-item-attribute-syntax).
"""
type AttributeMetaItem {
"""
The entire meta item represented as a string as it is found in the code.
For example: `"derive(Debug, Clone)"`
"""
raw_item: String!
"""
SimplePath of the meta item.
For example: `"derive"` for `derive(Debug, Clone)`,
`"must_use"` for `must_use = "example_message"`
"""
base: String!
"""
Assigned item if the meta item is in the form `SimplePath = AssignedItem`.
For example: `"\"example_message\""` for `must_use = "example_message"`
"""
assigned_item: String
# edges
"""
Inner meta items if the meta item is in the form `SimplePath(MetaSeq)`.
For example: `[AttributeMetaItem::new("Debug"), AttributeMetaItem::new("Clone")]`
for `derive(Debug, Clone)`
"""
argument: [AttributeMetaItem!]
}
"""
The trait that is being implemented in an impl block.
In `impl Foo<u64> for Bar`, this is the `Foo<u64>` part.
"""
type ImplementedTrait {
name: String!
# own edges
"""
In `impl Foo<u64> for Bar`, this refers to `trait Foo<T>`.
"""
trait: Trait
}
"""
https://docs.rs/rustdoc-types/0.11.0/rustdoc_types/struct.Item.html
https://docs.rs/rustdoc-types/latest/rustdoc_types/enum.ItemEnum.html#variant.AssocType
"""
type AssociatedType implements Item {
# properties from Item
id: String!
crate_id: Int!
"""
The name of the associated type.
For example:
```rust
trait Iterator {
type Item; // `"Item"` is the name of the associated type
}
```
"""
name: String
docs: String
attrs: [String!]!
"""
This item is hidden in documentation.
"""
doc_hidden: Boolean!
"""
This item is deprecated.
"""
deprecated: Boolean!
"""
Whether this item is eligible to be in the public API. This is true if both:
- The item is public, either explicitly (`pub`) or implicitly (like enum variants).
- The item is visible in documentation, or is not visible but is deprecated,
since deprecated items are assumed to have been part of the public API in the past.
Being eligible to be part of the public API *does not* make an item public API!
An item that is not eligible by itself cannot be part of the public API,
but eligible items might not be public API -- for example, pub-in-priv items
(public items in a private module) are eligible but not public API. Another example
would be a public item that is only reachable via modules that are both
`#[doc(hidden)]` and not deprecated.
To check whether an item is part of the public API:
- For items that are legal in a `use` import statement, use the `importable_path` edge and the
path's `public_api` property.
- For all other items (e.g. struct fields), first check whether that parent item is public API
as above, and then check whether the item itself is `public_api_eligible`.
"""
public_api_eligible: Boolean!
visibility_limit: String!
# properties for AssociatedType
"""
Whether the type is defined to have a default value.
For example:
```rust
trait IntIterator {
type Item = i64; // by default, the associated type is `i64` so this property is `true`.
}
```
Associated type defaults are currently unstable: https://github.com/rust-lang/rust/issues/29661
"""
has_default: Boolean!
# edges from Item
span: Span
attribute: [Attribute!]
}
"""
https://docs.rs/rustdoc-types/0.11.0/rustdoc_types/struct.Item.html
https://docs.rs/rustdoc-types/latest/rustdoc_types/enum.ItemEnum.html#variant.AssocConst
"""
type AssociatedConstant implements Item {
# properties from Item
id: String!
crate_id: Int!
"""
The name of the associated constant.
For example:
```rust
trait BatchIterator {
const SIZE: usize; // `"SIZE"` is the name of the associated constant
}
```
"""
name: String
docs: String
attrs: [String!]!
"""
This item is hidden in documentation.
"""
doc_hidden: Boolean!
"""
This item is deprecated.
"""
deprecated: Boolean!
"""
Whether this item is eligible to be in the public API. This is true if both:
- The item is public, either explicitly (`pub`) or implicitly (like enum variants).
- The item is visible in documentation, or is not visible but is deprecated,
since deprecated items are assumed to have been part of the public API in the past.
Being eligible to be part of the public API *does not* make an item public API!
An item that is not eligible by itself cannot be part of the public API,
but eligible items might not be public API -- for example, pub-in-priv items
(public items in a private module) are eligible but not public API. Another example
would be a public item that is only reachable via modules that are both
`#[doc(hidden)]` and not deprecated.
To check whether an item is part of the public API:
- For items that are legal in a `use` import statement, use the `importable_path` edge and the
path's `public_api` property.
- For all other items (e.g. struct fields), first check whether that parent item is public API
as above, and then check whether the item itself is `public_api_eligible`.
"""
public_api_eligible: Boolean!
visibility_limit: String!
# properties for AssociatedConstant
"""
The default value of the constant, if any, as a Rust literal, expression, or `"_"`.
For example:
```rust
const fn five() -> i32 { 5 };
struct Years(i32);
trait MyTrait<const MIN: usize> { // rustdocs default field
const NUM : i32 = 16 ; // 16
const MIN_SIZE: usize = MIN ; // "MIN", referring to the other constant's name
const LOG_AS : &'static str = "batch" ; // "\"batch\"", including escaped quotes
const EXPR2_2 : i32 = 2+2 ; // "_"
const FN_FIVE : i32 = five() ; // "_"
const YEAR : Years = Years(42); // "_"
}
```
If the associated constant is on a type's inherent impl, `default` is always required to be set.
If the associated constant is set:
- to be equal to another constant, `default` holds the name of that other constant.
- by evaluating a `const` expression, such as `2 + 2` or a `const fn` call,
`default` is `"_"` instead of evaluating the constant value or including the full expression.
"""
default: String
# edges from Item
span: Span
attribute: [Attribute!]
}
"""
A type represented in the "raw" rustdoc JSON representation.
Copiously detailed, but not the easiest to use due to its complexity.
This interface is a temporary, perma-unstable type intended to be used
only until the rustdoc JSON format is stabilized and until subsequently
we are able to design a better, more permanent representation for
Rust types in this schema.
https://docs.rs/rustdoc-types/latest/rustdoc_types/enum.Type.html
"""
interface RawType {
name: String!
}
"""
Represents a struct, enum, or trait.
https://docs.rs/rustdoc-types/latest/rustdoc_types/enum.Type.html#variant.ResolvedPath
"""
type ResolvedPathType implements RawType {
"""
The fully-qualified canonical name of the type.
For example: "core::marker::PhantomData" or "std::marker::PhantomData"
"""
name: String!
}