Add json backend
Respond to comments and start adding tests
Fix re-exports and extern-crate
Add expected output tests
Add restricted paths
Format
Fix: associated methods missing in output
Ignore stripped items
Mark stripped items
removing them creates dangling references
Fix tests and update conversions
Don't panic if JSON backend fails to create a file
Fix attribute error in JSON testsuite
Move rustdoc-json to rustdoc/
This way it doesn't have to build rustc twice. Eventually it should
probably get its own suite, like rustdoc-js, but that can be fixed in a
follow-up.
Small cleanups
Don't prettify json before printing
This fully halves the size of the emitted JSON.
Add comments
[BREAKING CHANGE] rename version -> crate_version
[BREAKING CHANGE] rename source -> span
Use exhaustive matches
Don't qualify imports for DefId
Rename clean::{ItemEnum -> ItemKind}, clean::Item::{inner -> kind}
Fix Visibility conversion
clean::Visability was changed here:
https://github.com/rust-lang/rust/pull/77820/files#diff-df9f90aae0b7769e1eb6ea6f1d73c1c3f649e1ac48a20e169662a8930eb427beL1467-R1509
More churn catchup
Format
This commit is contained in:
Joseph Ryan
Nixon Enraght-Moony
parent
4cbda829c0
commit
66884e318f
@ -2281,7 +2281,7 @@ fn clean(&self, cx: &DocContext<'_>) -> Vec<Item> {
|
||||
name: None,
|
||||
attrs: self.attrs.clean(cx),
|
||||
source: self.span.clean(cx),
|
||||
def_id: DefId::local(CRATE_DEF_INDEX),
|
||||
def_id: cx.tcx.hir().local_def_id(self.id).to_def_id(),
|
||||
visibility: self.vis.clean(cx),
|
||||
stability: None,
|
||||
const_stability: None,
|
||||
|
||||
@ -337,6 +337,42 @@ pub fn from_def_id_and_parts(
|
||||
}
|
||||
|
||||
impl ItemKind {
|
||||
/// Some items contain others such as structs (for their fields) and Enums
|
||||
/// (for their variants). This method returns those contained items.
|
||||
crate fn inner_items(&self) -> impl Iterator<Item = &Item> {
|
||||
match self {
|
||||
StructItem(s) => s.fields.iter(),
|
||||
UnionItem(u) => u.fields.iter(),
|
||||
VariantItem(Variant { kind: VariantKind::Struct(v) }) => v.fields.iter(),
|
||||
EnumItem(e) => e.variants.iter(),
|
||||
TraitItem(t) => t.items.iter(),
|
||||
ImplItem(i) => i.items.iter(),
|
||||
ModuleItem(m) => m.items.iter(),
|
||||
ExternCrateItem(_, _)
|
||||
| ImportItem(_)
|
||||
| FunctionItem(_)
|
||||
| TypedefItem(_, _)
|
||||
| OpaqueTyItem(_)
|
||||
| StaticItem(_)
|
||||
| ConstantItem(_)
|
||||
| TraitAliasItem(_)
|
||||
| TyMethodItem(_)
|
||||
| MethodItem(_, _)
|
||||
| StructFieldItem(_)
|
||||
| VariantItem(_)
|
||||
| ForeignFunctionItem(_)
|
||||
| ForeignStaticItem(_)
|
||||
| ForeignTypeItem
|
||||
| MacroItem(_)
|
||||
| ProcMacroItem(_)
|
||||
| PrimitiveItem(_)
|
||||
| AssocConstItem(_, _)
|
||||
| AssocTypeItem(_, _)
|
||||
| StrippedItem(_)
|
||||
| KeywordItem(_) => [].iter(),
|
||||
}
|
||||
}
|
||||
|
||||
crate fn is_type_alias(&self) -> bool {
|
||||
match *self {
|
||||
ItemKind::TypedefItem(_, _) | ItemKind::AssocTypeItem(_, _) => true,
|
||||
@ -1613,6 +1649,11 @@ impl Path {
|
||||
crate fn last_name(&self) -> &str {
|
||||
self.segments.last().expect("segments were empty").name.as_str()
|
||||
}
|
||||
|
||||
crate fn whole_name(&self) -> String {
|
||||
String::from(if self.global { "::" } else { "" })
|
||||
+ &self.segments.iter().map(|s| s.name.clone()).collect::<Vec<_>>().join("::")
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, PartialEq, Eq, Debug, Hash)]
|
||||
|
||||
596
src/librustdoc/json/conversions.rs
Normal file
596
src/librustdoc/json/conversions.rs
Normal file
@ -0,0 +1,596 @@
|
||||
//! These from impls are used to create the JSON types which get serialized. They're very close to
|
||||
//! the `clean` types but with some fields removed or stringified to simplify the output and not
|
||||
//! expose unstable compiler internals.
|
||||
|
||||
use std::convert::From;
|
||||
|
||||
use rustc_ast::ast;
|
||||
use rustc_span::def_id::{DefId, CRATE_DEF_INDEX};
|
||||
|
||||
use crate::clean;
|
||||
use crate::doctree;
|
||||
use crate::formats::item_type::ItemType;
|
||||
use crate::json::types::*;
|
||||
|
||||
impl From<clean::Item> for Item {
|
||||
fn from(item: clean::Item) -> Self {
|
||||
let item_type = ItemType::from(&item);
|
||||
let clean::Item {
|
||||
source,
|
||||
name,
|
||||
attrs,
|
||||
kind: inner,
|
||||
visibility,
|
||||
def_id,
|
||||
stability: _,
|
||||
deprecation,
|
||||
} = item;
|
||||
Item {
|
||||
id: def_id.into(),
|
||||
crate_id: def_id.krate.as_u32(),
|
||||
name,
|
||||
stripped: match inner {
|
||||
clean::StrippedItem(_) => true,
|
||||
_ => false,
|
||||
},
|
||||
source: source.into(),
|
||||
visibility: visibility.into(),
|
||||
docs: attrs.collapsed_doc_value().unwrap_or_default(),
|
||||
links: attrs
|
||||
.links
|
||||
.into_iter()
|
||||
.filter_map(|clean::ItemLink { link, did, .. }| did.map(|did| (link, did.into())))
|
||||
.collect(),
|
||||
attrs: attrs
|
||||
.other_attrs
|
||||
.iter()
|
||||
.map(rustc_ast_pretty::pprust::attribute_to_string)
|
||||
.collect(),
|
||||
deprecation: deprecation.map(Into::into),
|
||||
kind: item_type.into(),
|
||||
inner: inner.into(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl From<clean::Span> for Option<Span> {
|
||||
fn from(span: clean::Span) -> Self {
|
||||
let clean::Span { loline, locol, hiline, hicol, .. } = span;
|
||||
match span.filename {
|
||||
rustc_span::FileName::Real(name) => Some(Span {
|
||||
filename: match name {
|
||||
rustc_span::RealFileName::Named(path) => path,
|
||||
rustc_span::RealFileName::Devirtualized { local_path, virtual_name: _ } => {
|
||||
local_path
|
||||
}
|
||||
},
|
||||
begin: (loline, locol),
|
||||
end: (hiline, hicol),
|
||||
}),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl From<clean::Deprecation> for Deprecation {
|
||||
fn from(deprecation: clean::Deprecation) -> Self {
|
||||
let clean::Deprecation { since, note, is_since_rustc_version: _ } = deprecation;
|
||||
Deprecation { since, note }
|
||||
}
|
||||
}
|
||||
|
||||
impl From<clean::Visibility> for Visibility {
|
||||
fn from(v: clean::Visibility) -> Self {
|
||||
use clean::Visibility::*;
|
||||
match v {
|
||||
Public => Visibility::Public,
|
||||
Inherited => Visibility::Default,
|
||||
Restricted(did, _) if did.index == CRATE_DEF_INDEX => Visibility::Crate,
|
||||
Restricted(did, path) => Visibility::Restricted {
|
||||
parent: did.into(),
|
||||
path: path.to_string_no_crate_verbose(),
|
||||
},
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl From<clean::GenericArgs> for GenericArgs {
|
||||
fn from(args: clean::GenericArgs) -> Self {
|
||||
use clean::GenericArgs::*;
|
||||
match args {
|
||||
AngleBracketed { args, bindings } => GenericArgs::AngleBracketed {
|
||||
args: args.into_iter().map(Into::into).collect(),
|
||||
bindings: bindings.into_iter().map(Into::into).collect(),
|
||||
},
|
||||
Parenthesized { inputs, output } => GenericArgs::Parenthesized {
|
||||
inputs: inputs.into_iter().map(Into::into).collect(),
|
||||
output: output.map(Into::into),
|
||||
},
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl From<clean::GenericArg> for GenericArg {
|
||||
fn from(arg: clean::GenericArg) -> Self {
|
||||
use clean::GenericArg::*;
|
||||
match arg {
|
||||
Lifetime(l) => GenericArg::Lifetime(l.0),
|
||||
Type(t) => GenericArg::Type(t.into()),
|
||||
Const(c) => GenericArg::Const(c.into()),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl From<clean::Constant> for Constant {
|
||||
fn from(constant: clean::Constant) -> Self {
|
||||
let clean::Constant { type_, expr, value, is_literal } = constant;
|
||||
Constant { type_: type_.into(), expr, value, is_literal }
|
||||
}
|
||||
}
|
||||
|
||||
impl From<clean::TypeBinding> for TypeBinding {
|
||||
fn from(binding: clean::TypeBinding) -> Self {
|
||||
TypeBinding { name: binding.name, binding: binding.kind.into() }
|
||||
}
|
||||
}
|
||||
|
||||
impl From<clean::TypeBindingKind> for TypeBindingKind {
|
||||
fn from(kind: clean::TypeBindingKind) -> Self {
|
||||
use clean::TypeBindingKind::*;
|
||||
match kind {
|
||||
Equality { ty } => TypeBindingKind::Equality(ty.into()),
|
||||
Constraint { bounds } => {
|
||||
TypeBindingKind::Constraint(bounds.into_iter().map(Into::into).collect())
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl From<DefId> for Id {
|
||||
fn from(did: DefId) -> Self {
|
||||
Id(format!("{}:{}", did.krate.as_u32(), u32::from(did.index)))
|
||||
}
|
||||
}
|
||||
|
||||
impl From<clean::ItemKind> for ItemEnum {
|
||||
fn from(item: clean::ItemKind) -> Self {
|
||||
use clean::ItemKind::*;
|
||||
match item {
|
||||
ModuleItem(m) => ItemEnum::ModuleItem(m.into()),
|
||||
ExternCrateItem(c, a) => ItemEnum::ExternCrateItem { name: c, rename: a },
|
||||
ImportItem(i) => ItemEnum::ImportItem(i.into()),
|
||||
StructItem(s) => ItemEnum::StructItem(s.into()),
|
||||
UnionItem(u) => ItemEnum::StructItem(u.into()),
|
||||
StructFieldItem(f) => ItemEnum::StructFieldItem(f.into()),
|
||||
EnumItem(e) => ItemEnum::EnumItem(e.into()),
|
||||
VariantItem(v) => ItemEnum::VariantItem(v.into()),
|
||||
FunctionItem(f) => ItemEnum::FunctionItem(f.into()),
|
||||
ForeignFunctionItem(f) => ItemEnum::FunctionItem(f.into()),
|
||||
TraitItem(t) => ItemEnum::TraitItem(t.into()),
|
||||
TraitAliasItem(t) => ItemEnum::TraitAliasItem(t.into()),
|
||||
MethodItem(m, _) => ItemEnum::MethodItem(m.into()),
|
||||
TyMethodItem(m) => ItemEnum::MethodItem(m.into()),
|
||||
ImplItem(i) => ItemEnum::ImplItem(i.into()),
|
||||
StaticItem(s) => ItemEnum::StaticItem(s.into()),
|
||||
ForeignStaticItem(s) => ItemEnum::StaticItem(s.into()),
|
||||
ForeignTypeItem => ItemEnum::ForeignTypeItem,
|
||||
TypedefItem(t, _) => ItemEnum::TypedefItem(t.into()),
|
||||
OpaqueTyItem(t) => ItemEnum::OpaqueTyItem(t.into()),
|
||||
ConstantItem(c) => ItemEnum::ConstantItem(c.into()),
|
||||
MacroItem(m) => ItemEnum::MacroItem(m.source),
|
||||
ProcMacroItem(m) => ItemEnum::ProcMacroItem(m.into()),
|
||||
AssocConstItem(t, s) => ItemEnum::AssocConstItem { type_: t.into(), default: s },
|
||||
AssocTypeItem(g, t) => ItemEnum::AssocTypeItem {
|
||||
bounds: g.into_iter().map(Into::into).collect(),
|
||||
default: t.map(Into::into),
|
||||
},
|
||||
StrippedItem(inner) => (*inner).into(),
|
||||
PrimitiveItem(_) | KeywordItem(_) => {
|
||||
panic!("{:?} is not supported for JSON output", item)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl From<clean::Module> for Module {
|
||||
fn from(module: clean::Module) -> Self {
|
||||
Module {
|
||||
is_crate: module.is_crate,
|
||||
items: module.items.into_iter().map(|i| i.def_id.into()).collect(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl From<clean::Struct> for Struct {
|
||||
fn from(struct_: clean::Struct) -> Self {
|
||||
let clean::Struct { struct_type, generics, fields, fields_stripped } = struct_;
|
||||
Struct {
|
||||
struct_type: struct_type.into(),
|
||||
generics: generics.into(),
|
||||
fields_stripped,
|
||||
fields: fields.into_iter().map(|i| i.def_id.into()).collect(),
|
||||
impls: Vec::new(), // Added in JsonRenderer::item
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl From<clean::Union> for Struct {
|
||||
fn from(struct_: clean::Union) -> Self {
|
||||
let clean::Union { struct_type, generics, fields, fields_stripped } = struct_;
|
||||
Struct {
|
||||
struct_type: struct_type.into(),
|
||||
generics: generics.into(),
|
||||
fields_stripped,
|
||||
fields: fields.into_iter().map(|i| i.def_id.into()).collect(),
|
||||
impls: Vec::new(), // Added in JsonRenderer::item
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl From<doctree::StructType> for StructType {
|
||||
fn from(struct_type: doctree::StructType) -> Self {
|
||||
use doctree::StructType::*;
|
||||
match struct_type {
|
||||
Plain => StructType::Plain,
|
||||
Tuple => StructType::Tuple,
|
||||
Unit => StructType::Unit,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn stringify_header(header: &rustc_hir::FnHeader) -> String {
|
||||
let mut s = String::from(header.unsafety.prefix_str());
|
||||
if header.asyncness == rustc_hir::IsAsync::Async {
|
||||
s.push_str("async ")
|
||||
}
|
||||
if header.constness == rustc_hir::Constness::Const {
|
||||
s.push_str("const ")
|
||||
}
|
||||
s
|
||||
}
|
||||
|
||||
impl From<clean::Function> for Function {
|
||||
fn from(function: clean::Function) -> Self {
|
||||
let clean::Function { decl, generics, header, all_types: _, ret_types: _ } = function;
|
||||
Function {
|
||||
decl: decl.into(),
|
||||
generics: generics.into(),
|
||||
header: stringify_header(&header),
|
||||
abi: header.abi.to_string(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl From<clean::Generics> for Generics {
|
||||
fn from(generics: clean::Generics) -> Self {
|
||||
Generics {
|
||||
params: generics.params.into_iter().map(Into::into).collect(),
|
||||
where_predicates: generics.where_predicates.into_iter().map(Into::into).collect(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl From<clean::GenericParamDef> for GenericParamDef {
|
||||
fn from(generic_param: clean::GenericParamDef) -> Self {
|
||||
GenericParamDef { name: generic_param.name, kind: generic_param.kind.into() }
|
||||
}
|
||||
}
|
||||
|
||||
impl From<clean::GenericParamDefKind> for GenericParamDefKind {
|
||||
fn from(kind: clean::GenericParamDefKind) -> Self {
|
||||
use clean::GenericParamDefKind::*;
|
||||
match kind {
|
||||
Lifetime => GenericParamDefKind::Lifetime,
|
||||
Type { did: _, bounds, default, synthetic: _ } => GenericParamDefKind::Type {
|
||||
bounds: bounds.into_iter().map(Into::into).collect(),
|
||||
default: default.map(Into::into),
|
||||
},
|
||||
Const { did: _, ty } => GenericParamDefKind::Const(ty.into()),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl From<clean::WherePredicate> for WherePredicate {
|
||||
fn from(predicate: clean::WherePredicate) -> Self {
|
||||
use clean::WherePredicate::*;
|
||||
match predicate {
|
||||
BoundPredicate { ty, bounds } => WherePredicate::BoundPredicate {
|
||||
ty: ty.into(),
|
||||
bounds: bounds.into_iter().map(Into::into).collect(),
|
||||
},
|
||||
RegionPredicate { lifetime, bounds } => WherePredicate::RegionPredicate {
|
||||
lifetime: lifetime.0,
|
||||
bounds: bounds.into_iter().map(Into::into).collect(),
|
||||
},
|
||||
EqPredicate { lhs, rhs } => {
|
||||
WherePredicate::EqPredicate { lhs: lhs.into(), rhs: rhs.into() }
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl From<clean::GenericBound> for GenericBound {
|
||||
fn from(bound: clean::GenericBound) -> Self {
|
||||
use clean::GenericBound::*;
|
||||
match bound {
|
||||
TraitBound(clean::PolyTrait { trait_, generic_params }, modifier) => {
|
||||
GenericBound::TraitBound {
|
||||
trait_: trait_.into(),
|
||||
generic_params: generic_params.into_iter().map(Into::into).collect(),
|
||||
modifier: modifier.into(),
|
||||
}
|
||||
}
|
||||
Outlives(lifetime) => GenericBound::Outlives(lifetime.0),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl From<rustc_hir::TraitBoundModifier> for TraitBoundModifier {
|
||||
fn from(modifier: rustc_hir::TraitBoundModifier) -> Self {
|
||||
use rustc_hir::TraitBoundModifier::*;
|
||||
match modifier {
|
||||
None => TraitBoundModifier::None,
|
||||
Maybe => TraitBoundModifier::Maybe,
|
||||
MaybeConst => TraitBoundModifier::MaybeConst,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl From<clean::Type> for Type {
|
||||
fn from(ty: clean::Type) -> Self {
|
||||
use clean::Type::*;
|
||||
match ty {
|
||||
ResolvedPath { path, param_names, did, is_generic: _ } => Type::ResolvedPath {
|
||||
name: path.whole_name(),
|
||||
id: did.into(),
|
||||
args: path.segments.last().map(|args| Box::new(args.clone().args.into())),
|
||||
param_names: param_names
|
||||
.map(|v| v.into_iter().map(Into::into).collect())
|
||||
.unwrap_or_default(),
|
||||
},
|
||||
Generic(s) => Type::Generic(s),
|
||||
Primitive(p) => Type::Primitive(p.as_str().to_string()),
|
||||
BareFunction(f) => Type::FunctionPointer(Box::new((*f).into())),
|
||||
Tuple(t) => Type::Tuple(t.into_iter().map(Into::into).collect()),
|
||||
Slice(t) => Type::Slice(Box::new((*t).into())),
|
||||
Array(t, s) => Type::Array { type_: Box::new((*t).into()), len: s },
|
||||
ImplTrait(g) => Type::ImplTrait(g.into_iter().map(Into::into).collect()),
|
||||
Never => Type::Never,
|
||||
Infer => Type::Infer,
|
||||
RawPointer(mutability, type_) => Type::RawPointer {
|
||||
mutable: mutability == ast::Mutability::Mut,
|
||||
type_: Box::new((*type_).into()),
|
||||
},
|
||||
BorrowedRef { lifetime, mutability, type_ } => Type::BorrowedRef {
|
||||
lifetime: lifetime.map(|l| l.0),
|
||||
mutable: mutability == ast::Mutability::Mut,
|
||||
type_: Box::new((*type_).into()),
|
||||
},
|
||||
QPath { name, self_type, trait_ } => Type::QualifiedPath {
|
||||
name,
|
||||
self_type: Box::new((*self_type).into()),
|
||||
trait_: Box::new((*trait_).into()),
|
||||
},
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl From<clean::BareFunctionDecl> for FunctionPointer {
|
||||
fn from(bare_decl: clean::BareFunctionDecl) -> Self {
|
||||
let clean::BareFunctionDecl { unsafety, generic_params, decl, abi } = bare_decl;
|
||||
FunctionPointer {
|
||||
is_unsafe: unsafety == rustc_hir::Unsafety::Unsafe,
|
||||
generic_params: generic_params.into_iter().map(Into::into).collect(),
|
||||
decl: decl.into(),
|
||||
abi: abi.to_string(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl From<clean::FnDecl> for FnDecl {
|
||||
fn from(decl: clean::FnDecl) -> Self {
|
||||
let clean::FnDecl { inputs, output, c_variadic, attrs: _ } = decl;
|
||||
FnDecl {
|
||||
inputs: inputs.values.into_iter().map(|arg| (arg.name, arg.type_.into())).collect(),
|
||||
output: match output {
|
||||
clean::FnRetTy::Return(t) => Some(t.into()),
|
||||
clean::FnRetTy::DefaultReturn => None,
|
||||
},
|
||||
c_variadic,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl From<clean::Trait> for Trait {
|
||||
fn from(trait_: clean::Trait) -> Self {
|
||||
let clean::Trait { unsafety, items, generics, bounds, is_spotlight: _, is_auto } = trait_;
|
||||
Trait {
|
||||
is_auto,
|
||||
is_unsafe: unsafety == rustc_hir::Unsafety::Unsafe,
|
||||
items: items.into_iter().map(|i| i.def_id.into()).collect(),
|
||||
generics: generics.into(),
|
||||
bounds: bounds.into_iter().map(Into::into).collect(),
|
||||
implementors: Vec::new(), // Added in JsonRenderer::item
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl From<clean::Impl> for Impl {
|
||||
fn from(impl_: clean::Impl) -> Self {
|
||||
let clean::Impl {
|
||||
unsafety,
|
||||
generics,
|
||||
provided_trait_methods,
|
||||
trait_,
|
||||
for_,
|
||||
items,
|
||||
polarity,
|
||||
synthetic,
|
||||
blanket_impl,
|
||||
} = impl_;
|
||||
Impl {
|
||||
is_unsafe: unsafety == rustc_hir::Unsafety::Unsafe,
|
||||
generics: generics.into(),
|
||||
provided_trait_methods: provided_trait_methods.into_iter().collect(),
|
||||
trait_: trait_.map(Into::into),
|
||||
for_: for_.into(),
|
||||
items: items.into_iter().map(|i| i.def_id.into()).collect(),
|
||||
negative: polarity == Some(clean::ImplPolarity::Negative),
|
||||
synthetic,
|
||||
blanket_impl: blanket_impl.map(Into::into),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl From<clean::Function> for Method {
|
||||
fn from(function: clean::Function) -> Self {
|
||||
let clean::Function { header, decl, generics, all_types: _, ret_types: _ } = function;
|
||||
Method {
|
||||
decl: decl.into(),
|
||||
generics: generics.into(),
|
||||
header: stringify_header(&header),
|
||||
has_body: true,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl From<clean::Enum> for Enum {
|
||||
fn from(enum_: clean::Enum) -> Self {
|
||||
let clean::Enum { variants, generics, variants_stripped } = enum_;
|
||||
Enum {
|
||||
generics: generics.into(),
|
||||
variants_stripped,
|
||||
variants: variants.into_iter().map(|i| i.def_id.into()).collect(),
|
||||
impls: Vec::new(), // Added in JsonRenderer::item
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl From<clean::VariantStruct> for Struct {
|
||||
fn from(struct_: clean::VariantStruct) -> Self {
|
||||
let clean::VariantStruct { struct_type, fields, fields_stripped } = struct_;
|
||||
Struct {
|
||||
struct_type: struct_type.into(),
|
||||
generics: Default::default(),
|
||||
fields_stripped,
|
||||
fields: fields.into_iter().map(|i| i.def_id.into()).collect(),
|
||||
impls: Vec::new(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl From<clean::Variant> for Variant {
|
||||
fn from(variant: clean::Variant) -> Self {
|
||||
use clean::VariantKind::*;
|
||||
match variant.kind {
|
||||
CLike => Variant::Plain,
|
||||
Tuple(t) => Variant::Tuple(t.into_iter().map(Into::into).collect()),
|
||||
Struct(s) => Variant::Struct(s.fields.into_iter().map(|i| i.def_id.into()).collect()),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl From<clean::Import> for Import {
|
||||
fn from(import: clean::Import) -> Self {
|
||||
use clean::ImportKind::*;
|
||||
match import.kind {
|
||||
Simple(s) => Import {
|
||||
span: import.source.path.whole_name(),
|
||||
name: s,
|
||||
id: import.source.did.map(Into::into),
|
||||
glob: false,
|
||||
},
|
||||
Glob => Import {
|
||||
span: import.source.path.whole_name(),
|
||||
name: import.source.path.last_name().to_string(),
|
||||
id: import.source.did.map(Into::into),
|
||||
glob: true,
|
||||
},
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl From<clean::ProcMacro> for ProcMacro {
|
||||
fn from(mac: clean::ProcMacro) -> Self {
|
||||
ProcMacro { kind: mac.kind.into(), helpers: mac.helpers }
|
||||
}
|
||||
}
|
||||
|
||||
impl From<rustc_span::hygiene::MacroKind> for MacroKind {
|
||||
fn from(kind: rustc_span::hygiene::MacroKind) -> Self {
|
||||
use rustc_span::hygiene::MacroKind::*;
|
||||
match kind {
|
||||
Bang => MacroKind::Bang,
|
||||
Attr => MacroKind::Attr,
|
||||
Derive => MacroKind::Derive,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl From<clean::Typedef> for Typedef {
|
||||
fn from(typedef: clean::Typedef) -> Self {
|
||||
let clean::Typedef { type_, generics, item_type: _ } = typedef;
|
||||
Typedef { type_: type_.into(), generics: generics.into() }
|
||||
}
|
||||
}
|
||||
|
||||
impl From<clean::OpaqueTy> for OpaqueTy {
|
||||
fn from(opaque: clean::OpaqueTy) -> Self {
|
||||
OpaqueTy {
|
||||
bounds: opaque.bounds.into_iter().map(Into::into).collect(),
|
||||
generics: opaque.generics.into(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl From<clean::Static> for Static {
|
||||
fn from(stat: clean::Static) -> Self {
|
||||
Static {
|
||||
type_: stat.type_.into(),
|
||||
mutable: stat.mutability == ast::Mutability::Mut,
|
||||
expr: stat.expr,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl From<clean::TraitAlias> for TraitAlias {
|
||||
fn from(alias: clean::TraitAlias) -> Self {
|
||||
TraitAlias {
|
||||
generics: alias.generics.into(),
|
||||
params: alias.bounds.into_iter().map(Into::into).collect(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl From<ItemType> for ItemKind {
|
||||
fn from(kind: ItemType) -> Self {
|
||||
use ItemType::*;
|
||||
match kind {
|
||||
Module => ItemKind::Module,
|
||||
ExternCrate => ItemKind::ExternCrate,
|
||||
Import => ItemKind::Import,
|
||||
Struct => ItemKind::Struct,
|
||||
Union => ItemKind::Union,
|
||||
Enum => ItemKind::Enum,
|
||||
Function => ItemKind::Function,
|
||||
Typedef => ItemKind::Typedef,
|
||||
OpaqueTy => ItemKind::OpaqueTy,
|
||||
Static => ItemKind::Static,
|
||||
Constant => ItemKind::Constant,
|
||||
Trait => ItemKind::Trait,
|
||||
Impl => ItemKind::Impl,
|
||||
TyMethod | Method => ItemKind::Method,
|
||||
StructField => ItemKind::StructField,
|
||||
Variant => ItemKind::Variant,
|
||||
Macro => ItemKind::Macro,
|
||||
Primitive => ItemKind::Primitive,
|
||||
AssocConst => ItemKind::AssocConst,
|
||||
AssocType => ItemKind::AssocType,
|
||||
ForeignType => ItemKind::ForeignType,
|
||||
Keyword => ItemKind::Keyword,
|
||||
TraitAlias => ItemKind::TraitAlias,
|
||||
ProcAttribute => ItemKind::ProcAttribute,
|
||||
ProcDerive => ItemKind::ProcDerive,
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,47 +1,238 @@
|
||||
//! Rustdoc's JSON backend
|
||||
//!
|
||||
//! This module contains the logic for rendering a crate as JSON rather than the normal static HTML
|
||||
//! output. See [the RFC](https://github.com/rust-lang/rfcs/pull/2963) and the [`types`] module
|
||||
//! docs for usage and details.
|
||||
|
||||
mod conversions;
|
||||
pub mod types;
|
||||
|
||||
use std::cell::RefCell;
|
||||
use std::fs::File;
|
||||
use std::path::PathBuf;
|
||||
use std::rc::Rc;
|
||||
|
||||
use rustc_data_structures::fx::FxHashMap;
|
||||
use rustc_span::edition::Edition;
|
||||
|
||||
use crate::clean;
|
||||
use crate::config::{RenderInfo, RenderOptions};
|
||||
use crate::error::Error;
|
||||
use crate::formats::cache::Cache;
|
||||
use crate::formats::FormatRenderer;
|
||||
|
||||
use rustc_span::edition::Edition;
|
||||
use crate::html::render::cache::ExternalLocation;
|
||||
|
||||
#[derive(Clone)]
|
||||
crate struct JsonRenderer {}
|
||||
crate struct JsonRenderer {
|
||||
/// A mapping of IDs that contains all local items for this crate which gets output as a top
|
||||
/// level field of the JSON blob.
|
||||
index: Rc<RefCell<FxHashMap<types::Id, types::Item>>>,
|
||||
/// The directory where the blob will be written to.
|
||||
out_path: PathBuf,
|
||||
}
|
||||
|
||||
impl JsonRenderer {
|
||||
fn get_trait_implementors(
|
||||
&mut self,
|
||||
id: rustc_span::def_id::DefId,
|
||||
cache: &Cache,
|
||||
) -> Vec<types::Id> {
|
||||
cache
|
||||
.implementors
|
||||
.get(&id)
|
||||
.map(|implementors| {
|
||||
implementors
|
||||
.iter()
|
||||
.map(|i| {
|
||||
let item = &i.impl_item;
|
||||
self.item(item.clone(), cache).unwrap();
|
||||
item.def_id.into()
|
||||
})
|
||||
.collect()
|
||||
})
|
||||
.unwrap_or_default()
|
||||
}
|
||||
|
||||
fn get_impls(&mut self, id: rustc_span::def_id::DefId, cache: &Cache) -> Vec<types::Id> {
|
||||
cache
|
||||
.impls
|
||||
.get(&id)
|
||||
.map(|impls| {
|
||||
impls
|
||||
.iter()
|
||||
.filter_map(|i| {
|
||||
let item = &i.impl_item;
|
||||
if item.def_id.is_local() {
|
||||
self.item(item.clone(), cache).unwrap();
|
||||
Some(item.def_id.into())
|
||||
} else {
|
||||
None
|
||||
}
|
||||
})
|
||||
.collect()
|
||||
})
|
||||
.unwrap_or_default()
|
||||
}
|
||||
|
||||
fn get_trait_items(&mut self, cache: &Cache) -> Vec<(types::Id, types::Item)> {
|
||||
cache
|
||||
.traits
|
||||
.iter()
|
||||
.filter_map(|(&id, trait_item)| {
|
||||
// only need to synthesize items for external traits
|
||||
if !id.is_local() {
|
||||
trait_item.items.clone().into_iter().for_each(|i| self.item(i, cache).unwrap());
|
||||
Some((
|
||||
id.into(),
|
||||
types::Item {
|
||||
id: id.into(),
|
||||
crate_id: id.krate.as_u32(),
|
||||
name: cache
|
||||
.paths
|
||||
.get(&id)
|
||||
.unwrap_or_else(|| {
|
||||
cache
|
||||
.external_paths
|
||||
.get(&id)
|
||||
.expect("Trait should either be in local or external paths")
|
||||
})
|
||||
.0
|
||||
.last()
|
||||
.map(Clone::clone),
|
||||
stripped: false,
|
||||
visibility: types::Visibility::Public,
|
||||
kind: types::ItemKind::Trait,
|
||||
inner: types::ItemEnum::TraitItem(trait_item.clone().into()),
|
||||
source: None,
|
||||
docs: Default::default(),
|
||||
links: Default::default(),
|
||||
attrs: Default::default(),
|
||||
deprecation: Default::default(),
|
||||
},
|
||||
))
|
||||
} else {
|
||||
None
|
||||
}
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
}
|
||||
|
||||
impl FormatRenderer for JsonRenderer {
|
||||
fn init(
|
||||
_krate: clean::Crate,
|
||||
_options: RenderOptions,
|
||||
krate: clean::Crate,
|
||||
options: RenderOptions,
|
||||
_render_info: RenderInfo,
|
||||
_edition: Edition,
|
||||
_cache: &mut Cache,
|
||||
) -> Result<(Self, clean::Crate), Error> {
|
||||
unimplemented!()
|
||||
debug!("Initializing json renderer");
|
||||
Ok((
|
||||
JsonRenderer {
|
||||
index: Rc::new(RefCell::new(FxHashMap::default())),
|
||||
out_path: options.output,
|
||||
},
|
||||
krate,
|
||||
))
|
||||
}
|
||||
|
||||
fn item(&mut self, _item: clean::Item, _cache: &Cache) -> Result<(), Error> {
|
||||
unimplemented!()
|
||||
/// Inserts an item into the index. This should be used rather than directly calling insert on
|
||||
/// the hashmap because certain items (traits and types) need to have their mappings for trait
|
||||
/// implementations filled out before they're inserted.
|
||||
fn item(&mut self, item: clean::Item, cache: &Cache) -> Result<(), Error> {
|
||||
// Flatten items that recursively store other items
|
||||
item.kind.inner_items().for_each(|i| self.item(i.clone(), cache).unwrap());
|
||||
|
||||
let id = item.def_id;
|
||||
let mut new_item: types::Item = item.into();
|
||||
if let types::ItemEnum::TraitItem(ref mut t) = new_item.inner {
|
||||
t.implementors = self.get_trait_implementors(id, cache)
|
||||
} else if let types::ItemEnum::StructItem(ref mut s) = new_item.inner {
|
||||
s.impls = self.get_impls(id, cache)
|
||||
} else if let types::ItemEnum::EnumItem(ref mut e) = new_item.inner {
|
||||
e.impls = self.get_impls(id, cache)
|
||||
}
|
||||
|
||||
self.index.borrow_mut().insert(id.into(), new_item);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn mod_item_in(
|
||||
&mut self,
|
||||
_item: &clean::Item,
|
||||
_item_name: &str,
|
||||
_cache: &Cache,
|
||||
item: &clean::Item,
|
||||
_module_name: &str,
|
||||
cache: &Cache,
|
||||
) -> Result<(), Error> {
|
||||
unimplemented!()
|
||||
use clean::types::ItemKind::*;
|
||||
if let ModuleItem(m) = &item.kind {
|
||||
for item in &m.items {
|
||||
match &item.kind {
|
||||
// These don't have names so they don't get added to the output by default
|
||||
ImportItem(_) => self.item(item.clone(), cache).unwrap(),
|
||||
ExternCrateItem(_, _) => self.item(item.clone(), cache).unwrap(),
|
||||
ImplItem(i) => {
|
||||
i.items.iter().for_each(|i| self.item(i.clone(), cache).unwrap())
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
}
|
||||
self.item(item.clone(), cache).unwrap();
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn mod_item_out(&mut self, _item_name: &str) -> Result<(), Error> {
|
||||
unimplemented!()
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn after_krate(&mut self, _krate: &clean::Crate, _cache: &Cache) -> Result<(), Error> {
|
||||
unimplemented!()
|
||||
fn after_krate(&mut self, krate: &clean::Crate, cache: &Cache) -> Result<(), Error> {
|
||||
debug!("Done with crate");
|
||||
let mut index = (*self.index).clone().into_inner();
|
||||
index.extend(self.get_trait_items(cache));
|
||||
let output = types::Crate {
|
||||
root: types::Id(String::from("0:0")),
|
||||
crate_version: krate.version.clone(),
|
||||
includes_private: cache.document_private,
|
||||
index,
|
||||
paths: cache
|
||||
.paths
|
||||
.clone()
|
||||
.into_iter()
|
||||
.chain(cache.external_paths.clone().into_iter())
|
||||
.map(|(k, (path, kind))| {
|
||||
(
|
||||
k.into(),
|
||||
types::ItemSummary { crate_id: k.krate.as_u32(), path, kind: kind.into() },
|
||||
)
|
||||
})
|
||||
.collect(),
|
||||
external_crates: cache
|
||||
.extern_locations
|
||||
.iter()
|
||||
.map(|(k, v)| {
|
||||
(
|
||||
k.as_u32(),
|
||||
types::ExternalCrate {
|
||||
name: v.0.clone(),
|
||||
html_root_url: match &v.2 {
|
||||
ExternalLocation::Remote(s) => Some(s.clone()),
|
||||
_ => None,
|
||||
},
|
||||
},
|
||||
)
|
||||
})
|
||||
.collect(),
|
||||
format_version: 1,
|
||||
};
|
||||
let mut p = self.out_path.clone();
|
||||
p.push(output.index.get(&output.root).unwrap().name.clone().unwrap());
|
||||
p.set_extension("json");
|
||||
let file = File::create(&p).map_err(|error| Error { error: error.to_string(), file: p })?;
|
||||
serde_json::ser::to_writer(&file, &output).unwrap();
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn after_run(&mut self, _diag: &rustc_errors::Handler) -> Result<(), Error> {
|
||||
unimplemented!()
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
493
src/librustdoc/json/types.rs
Normal file
493
src/librustdoc/json/types.rs
Normal file
@ -0,0 +1,493 @@
|
||||
//! Rustdoc's JSON output interface
|
||||
//!
|
||||
//! These types are the public API exposed through the `--output-format json` flag. The [`Crate`]
|
||||
//! struct is the root of the JSON blob and all other items are contained within.
|
||||
|
||||
use std::path::PathBuf;
|
||||
|
||||
use rustc_data_structures::fx::FxHashMap;
|
||||
use serde::{Deserialize, Serialize};
|
||||
|
||||
/// A `Crate` is the root of the emitted JSON blob. It contains all type/documentation information
|
||||
/// about the language items in the local crate, as well as info about external items to allow
|
||||
/// tools to find or link to them.
|
||||
#[derive(Clone, Debug, Serialize, Deserialize)]
|
||||
pub struct Crate {
|
||||
/// The id of the root [`Module`] item of the local crate.
|
||||
pub root: Id,
|
||||
/// The version string given to `--crate-version`, if any.
|
||||
pub crate_version: Option<String>,
|
||||
/// Whether or not the output includes private items.
|
||||
pub includes_private: bool,
|
||||
/// A collection of all items in the local crate as well as some external traits and their
|
||||
/// items that are referenced locally.
|
||||
pub index: FxHashMap<Id, Item>,
|
||||
/// Maps IDs to fully qualified paths and other info helpful for generating links.
|
||||
pub paths: FxHashMap<Id, ItemSummary>,
|
||||
/// Maps `crate_id` of items to a crate name and html_root_url if it exists.
|
||||
pub external_crates: FxHashMap<u32, ExternalCrate>,
|
||||
/// A single version number to be used in the future when making backwards incompatible changes
|
||||
/// to the JSON output.
|
||||
pub format_version: u32,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, Serialize, Deserialize)]
|
||||
pub struct ExternalCrate {
|
||||
pub name: String,
|
||||
pub html_root_url: Option<String>,
|
||||
}
|
||||
|
||||
/// For external (not defined in the local crate) items, you don't get the same level of
|
||||
/// information. This struct should contain enough to generate a link/reference to the item in
|
||||
/// question, or can be used by a tool that takes the json output of multiple crates to find
|
||||
/// the actual item definition with all the relevant info.
|
||||
#[derive(Clone, Debug, Serialize, Deserialize)]
|
||||
pub struct ItemSummary {
|
||||
/// Can be used to look up the name and html_root_url of the crate this item came from in the
|
||||
/// `external_crates` map.
|
||||
pub crate_id: u32,
|
||||
/// The list of path components for the fully qualified path of this item (e.g.
|
||||
/// `["std", "io", "lazy", "Lazy"]` for `std::io::lazy::Lazy`).
|
||||
pub path: Vec<String>,
|
||||
/// Whether this item is a struct, trait, macro, etc.
|
||||
pub kind: ItemKind,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, Serialize, Deserialize)]
|
||||
pub struct Item {
|
||||
/// The unique identifier of this item. Can be used to find this item in various mappings.
|
||||
pub id: Id,
|
||||
/// This can be used as a key to the `external_crates` map of [`Crate`] to see which crate
|
||||
/// this item came from.
|
||||
pub crate_id: u32,
|
||||
/// Some items such as impls don't have names.
|
||||
pub name: Option<String>,
|
||||
/// Whether this item is meant to be omitted from the generated documentation due to `#doc(hidden)`,
|
||||
/// because it is private, or because it was inlined.
|
||||
pub stripped: bool,
|
||||
/// The source location of this item (absent if it came from a macro expansion or inline
|
||||
/// assembly).
|
||||
pub source: Option<Span>,
|
||||
/// By default all documented items are public, but you can tell rustdoc to output private items
|
||||
/// so this field is needed to differentiate.
|
||||
pub visibility: Visibility,
|
||||
/// The full markdown docstring of this item.
|
||||
pub docs: String,
|
||||
/// 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
|
||||
pub links: FxHashMap<String, Id>,
|
||||
/// Stringified versions of the attributes on this item (e.g. `"#[inline]"`)
|
||||
pub attrs: Vec<String>,
|
||||
pub deprecation: Option<Deprecation>,
|
||||
pub kind: ItemKind,
|
||||
pub inner: ItemEnum,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, Serialize, Deserialize)]
|
||||
pub struct Span {
|
||||
/// The path to the source file for this span relative to the path `rustdoc` was invoked with.
|
||||
pub filename: PathBuf,
|
||||
/// Zero indexed Line and Column of the first character of the `Span`
|
||||
pub begin: (usize, usize),
|
||||
/// Zero indexed Line and Column of the last character of the `Span`
|
||||
pub end: (usize, usize),
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, Serialize, Deserialize)]
|
||||
pub struct Deprecation {
|
||||
pub since: Option<String>,
|
||||
pub note: Option<String>,
|
||||
}
|
||||
|
||||
#[serde(rename_all = "snake_case")]
|
||||
#[derive(Clone, Debug, Serialize, Deserialize)]
|
||||
pub enum Visibility {
|
||||
Public,
|
||||
/// For the most part items are private by default. The exceptions are associated items of
|
||||
/// public traits and variants of public enums.
|
||||
Default,
|
||||
Crate,
|
||||
/// For `pub(in path)` visibility. `parent` is the module it's restricted to and `path` is how
|
||||
/// that module was referenced (like `"super::super"` or `"crate::foo::bar"`).
|
||||
Restricted {
|
||||
parent: Id,
|
||||
path: String,
|
||||
},
|
||||
}
|
||||
|
||||
#[serde(rename_all = "snake_case")]
|
||||
#[derive(Clone, Debug, Serialize, Deserialize)]
|
||||
pub enum GenericArgs {
|
||||
/// <'a, 32, B: Copy, C = u32>
|
||||
AngleBracketed { args: Vec<GenericArg>, bindings: Vec<TypeBinding> },
|
||||
/// Fn(A, B) -> C
|
||||
Parenthesized { inputs: Vec<Type>, output: Option<Type> },
|
||||
}
|
||||
|
||||
#[serde(rename_all = "snake_case")]
|
||||
#[derive(Clone, Debug, Serialize, Deserialize)]
|
||||
pub enum GenericArg {
|
||||
Lifetime(String),
|
||||
Type(Type),
|
||||
Const(Constant),
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, Serialize, Deserialize)]
|
||||
pub struct Constant {
|
||||
#[serde(rename = "type")]
|
||||
pub type_: Type,
|
||||
pub expr: String,
|
||||
pub value: Option<String>,
|
||||
pub is_literal: bool,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, Serialize, Deserialize)]
|
||||
pub struct TypeBinding {
|
||||
pub name: String,
|
||||
pub binding: TypeBindingKind,
|
||||
}
|
||||
|
||||
#[serde(rename_all = "snake_case")]
|
||||
#[derive(Clone, Debug, Serialize, Deserialize)]
|
||||
pub enum TypeBindingKind {
|
||||
Equality(Type),
|
||||
Constraint(Vec<GenericBound>),
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
|
||||
pub struct Id(pub String);
|
||||
|
||||
#[serde(rename_all = "snake_case")]
|
||||
#[derive(Clone, Debug, Serialize, Deserialize)]
|
||||
pub enum ItemKind {
|
||||
Module,
|
||||
ExternCrate,
|
||||
Import,
|
||||
Struct,
|
||||
StructField,
|
||||
Union,
|
||||
Enum,
|
||||
Variant,
|
||||
Function,
|
||||
Typedef,
|
||||
OpaqueTy,
|
||||
Constant,
|
||||
Trait,
|
||||
TraitAlias,
|
||||
Method,
|
||||
Impl,
|
||||
Static,
|
||||
ForeignType,
|
||||
Macro,
|
||||
ProcAttribute,
|
||||
ProcDerive,
|
||||
AssocConst,
|
||||
AssocType,
|
||||
Primitive,
|
||||
Keyword,
|
||||
}
|
||||
|
||||
#[serde(untagged)]
|
||||
#[derive(Clone, Debug, Serialize, Deserialize)]
|
||||
pub enum ItemEnum {
|
||||
ModuleItem(Module),
|
||||
ExternCrateItem {
|
||||
name: String,
|
||||
rename: Option<String>,
|
||||
},
|
||||
ImportItem(Import),
|
||||
|
||||
StructItem(Struct),
|
||||
StructFieldItem(Type),
|
||||
EnumItem(Enum),
|
||||
VariantItem(Variant),
|
||||
|
||||
FunctionItem(Function),
|
||||
|
||||
TraitItem(Trait),
|
||||
TraitAliasItem(TraitAlias),
|
||||
MethodItem(Method),
|
||||
ImplItem(Impl),
|
||||
|
||||
TypedefItem(Typedef),
|
||||
OpaqueTyItem(OpaqueTy),
|
||||
ConstantItem(Constant),
|
||||
|
||||
StaticItem(Static),
|
||||
|
||||
/// `type`s from an extern block
|
||||
ForeignTypeItem,
|
||||
|
||||
/// Declarative macro_rules! macro
|
||||
MacroItem(String),
|
||||
ProcMacroItem(ProcMacro),
|
||||
|
||||
AssocConstItem {
|
||||
#[serde(rename = "type")]
|
||||
type_: Type,
|
||||
/// e.g. `const X: usize = 5;`
|
||||
default: Option<String>,
|
||||
},
|
||||
AssocTypeItem {
|
||||
bounds: Vec<GenericBound>,
|
||||
/// e.g. `type X = usize;`
|
||||
default: Option<Type>,
|
||||
},
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, Serialize, Deserialize)]
|
||||
pub struct Module {
|
||||
pub is_crate: bool,
|
||||
pub items: Vec<Id>,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, Serialize, Deserialize)]
|
||||
pub struct Struct {
|
||||
pub struct_type: StructType,
|
||||
pub generics: Generics,
|
||||
pub fields_stripped: bool,
|
||||
pub fields: Vec<Id>,
|
||||
pub impls: Vec<Id>,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, Serialize, Deserialize)]
|
||||
pub struct Enum {
|
||||
pub generics: Generics,
|
||||
pub variants_stripped: bool,
|
||||
pub variants: Vec<Id>,
|
||||
pub impls: Vec<Id>,
|
||||
}
|
||||
|
||||
#[serde(rename_all = "snake_case")]
|
||||
#[serde(tag = "variant_kind", content = "variant_inner")]
|
||||
#[derive(Clone, Debug, Serialize, Deserialize)]
|
||||
pub enum Variant {
|
||||
Plain,
|
||||
Tuple(Vec<Type>),
|
||||
Struct(Vec<Id>),
|
||||
}
|
||||
|
||||
#[serde(rename_all = "snake_case")]
|
||||
#[derive(Clone, Debug, Serialize, Deserialize)]
|
||||
pub enum StructType {
|
||||
Plain,
|
||||
Tuple,
|
||||
Unit,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, Serialize, Deserialize)]
|
||||
pub struct Function {
|
||||
pub decl: FnDecl,
|
||||
pub generics: Generics,
|
||||
pub header: String,
|
||||
pub abi: String,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, Serialize, Deserialize)]
|
||||
pub struct Method {
|
||||
pub decl: FnDecl,
|
||||
pub generics: Generics,
|
||||
pub header: String,
|
||||
pub has_body: bool,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, Default, Serialize, Deserialize)]
|
||||
pub struct Generics {
|
||||
pub params: Vec<GenericParamDef>,
|
||||
pub where_predicates: Vec<WherePredicate>,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, Serialize, Deserialize)]
|
||||
pub struct GenericParamDef {
|
||||
pub name: String,
|
||||
pub kind: GenericParamDefKind,
|
||||
}
|
||||
|
||||
#[serde(rename_all = "snake_case")]
|
||||
#[derive(Clone, Debug, Serialize, Deserialize)]
|
||||
pub enum GenericParamDefKind {
|
||||
Lifetime,
|
||||
Type { bounds: Vec<GenericBound>, default: Option<Type> },
|
||||
Const(Type),
|
||||
}
|
||||
|
||||
#[serde(rename_all = "snake_case")]
|
||||
#[derive(Clone, Debug, Serialize, Deserialize)]
|
||||
pub enum WherePredicate {
|
||||
BoundPredicate { ty: Type, bounds: Vec<GenericBound> },
|
||||
RegionPredicate { lifetime: String, bounds: Vec<GenericBound> },
|
||||
EqPredicate { lhs: Type, rhs: Type },
|
||||
}
|
||||
|
||||
#[serde(rename_all = "snake_case")]
|
||||
#[derive(Clone, Debug, Serialize, Deserialize)]
|
||||
pub enum GenericBound {
|
||||
TraitBound {
|
||||
#[serde(rename = "trait")]
|
||||
trait_: Type,
|
||||
/// Used for HRTBs
|
||||
generic_params: Vec<GenericParamDef>,
|
||||
modifier: TraitBoundModifier,
|
||||
},
|
||||
Outlives(String),
|
||||
}
|
||||
|
||||
#[serde(rename_all = "snake_case")]
|
||||
#[derive(Clone, Debug, Serialize, Deserialize)]
|
||||
pub enum TraitBoundModifier {
|
||||
None,
|
||||
Maybe,
|
||||
MaybeConst,
|
||||
}
|
||||
|
||||
#[serde(rename_all = "snake_case")]
|
||||
#[serde(tag = "kind", content = "inner")]
|
||||
#[derive(Clone, Debug, Serialize, Deserialize)]
|
||||
pub enum Type {
|
||||
/// Structs, enums, and traits
|
||||
ResolvedPath {
|
||||
name: String,
|
||||
id: Id,
|
||||
args: Option<Box<GenericArgs>>,
|
||||
param_names: Vec<GenericBound>,
|
||||
},
|
||||
/// Parameterized types
|
||||
Generic(String),
|
||||
/// Fixed-size numeric types (plus int/usize/float), char, arrays, slices, and tuples
|
||||
Primitive(String),
|
||||
/// `extern "ABI" fn`
|
||||
FunctionPointer(Box<FunctionPointer>),
|
||||
/// `(String, u32, Box<usize>)`
|
||||
Tuple(Vec<Type>),
|
||||
/// `[u32]`
|
||||
Slice(Box<Type>),
|
||||
/// [u32; 15]
|
||||
Array {
|
||||
#[serde(rename = "type")]
|
||||
type_: Box<Type>,
|
||||
len: String,
|
||||
},
|
||||
/// `impl TraitA + TraitB + ...`
|
||||
ImplTrait(Vec<GenericBound>),
|
||||
/// `!`
|
||||
Never,
|
||||
/// `_`
|
||||
Infer,
|
||||
/// `*mut u32`, `*u8`, etc.
|
||||
RawPointer {
|
||||
mutable: bool,
|
||||
#[serde(rename = "type")]
|
||||
type_: Box<Type>,
|
||||
},
|
||||
/// `&'a mut String`, `&str`, etc.
|
||||
BorrowedRef {
|
||||
lifetime: Option<String>,
|
||||
mutable: bool,
|
||||
#[serde(rename = "type")]
|
||||
type_: Box<Type>,
|
||||
},
|
||||
/// `<Type as Trait>::Name` or associated types like `T::Item` where `T: Iterator`
|
||||
QualifiedPath {
|
||||
name: String,
|
||||
self_type: Box<Type>,
|
||||
#[serde(rename = "trait")]
|
||||
trait_: Box<Type>,
|
||||
},
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, Serialize, Deserialize)]
|
||||
pub struct FunctionPointer {
|
||||
pub is_unsafe: bool,
|
||||
pub generic_params: Vec<GenericParamDef>,
|
||||
pub decl: FnDecl,
|
||||
pub abi: String,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, Serialize, Deserialize)]
|
||||
pub struct FnDecl {
|
||||
pub inputs: Vec<(String, Type)>,
|
||||
pub output: Option<Type>,
|
||||
pub c_variadic: bool,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, Serialize, Deserialize)]
|
||||
pub struct Trait {
|
||||
pub is_auto: bool,
|
||||
pub is_unsafe: bool,
|
||||
pub items: Vec<Id>,
|
||||
pub generics: Generics,
|
||||
pub bounds: Vec<GenericBound>,
|
||||
pub implementors: Vec<Id>,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, Serialize, Deserialize)]
|
||||
pub struct TraitAlias {
|
||||
pub generics: Generics,
|
||||
pub params: Vec<GenericBound>,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, Serialize, Deserialize)]
|
||||
pub struct Impl {
|
||||
pub is_unsafe: bool,
|
||||
pub generics: Generics,
|
||||
pub provided_trait_methods: Vec<String>,
|
||||
#[serde(rename = "trait")]
|
||||
pub trait_: Option<Type>,
|
||||
#[serde(rename = "for")]
|
||||
pub for_: Type,
|
||||
pub items: Vec<Id>,
|
||||
pub negative: bool,
|
||||
pub synthetic: bool,
|
||||
pub blanket_impl: Option<Type>,
|
||||
}
|
||||
|
||||
#[serde(rename_all = "snake_case")]
|
||||
#[derive(Clone, Debug, Serialize, Deserialize)]
|
||||
pub struct Import {
|
||||
/// The full path being imported.
|
||||
pub span: String,
|
||||
/// May be different from the last segment of `source` when renaming imports:
|
||||
/// `use source as name;`
|
||||
pub name: String,
|
||||
/// The ID of the item being imported.
|
||||
pub id: Option<Id>, // FIXME is this actually ever None?
|
||||
/// Whether this import uses a glob: `use source::*;`
|
||||
pub glob: bool,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, Serialize, Deserialize)]
|
||||
pub struct ProcMacro {
|
||||
pub kind: MacroKind,
|
||||
pub helpers: Vec<String>,
|
||||
}
|
||||
|
||||
#[serde(rename_all = "snake_case")]
|
||||
#[derive(Clone, Debug, Serialize, Deserialize)]
|
||||
pub enum MacroKind {
|
||||
/// A bang macro `foo!()`.
|
||||
Bang,
|
||||
/// An attribute macro `#[foo]`.
|
||||
Attr,
|
||||
/// A derive macro `#[derive(Foo)]`
|
||||
Derive,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, Serialize, Deserialize)]
|
||||
pub struct Typedef {
|
||||
#[serde(rename = "type")]
|
||||
pub type_: Type,
|
||||
pub generics: Generics,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, Serialize, Deserialize)]
|
||||
pub struct OpaqueTy {
|
||||
pub bounds: Vec<GenericBound>,
|
||||
pub generics: Generics,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, Serialize, Deserialize)]
|
||||
pub struct Static {
|
||||
#[serde(rename = "type")]
|
||||
pub type_: Type,
|
||||
pub mutable: bool,
|
||||
pub expr: String,
|
||||
}
|
||||
6
src/test/rustdoc/rustdoc-json/Makefile
Normal file
6
src/test/rustdoc/rustdoc-json/Makefile
Normal file
@ -0,0 +1,6 @@
|
||||
-include ../tools.mk
|
||||
|
||||
tests: *.rs
|
||||
$(RUSTDOC) $< -o $(TMPDIR) --output-format json
|
||||
$(PYTHON) check_missing_items.py $(TMPDIR)/$(basename $<).json
|
||||
$(PYTHON) compare.py $(basename $<).expected $(TMPDIR)/$(basename $<).json
|
||||
181
src/test/rustdoc/rustdoc-json/check_missing_items.py
Normal file
181
src/test/rustdoc/rustdoc-json/check_missing_items.py
Normal file
@ -0,0 +1,181 @@
|
||||
#!/usr/bin/env python
|
||||
|
||||
# This test ensures that every ID in the produced json actually resolves to an item either in
|
||||
# `index` or `paths`. It DOES NOT check that the structure of the produced json is actually in
|
||||
# any way correct, for example an empty map would pass.
|
||||
|
||||
import sys
|
||||
import json
|
||||
|
||||
crate = json.load(open(sys.argv[1]))
|
||||
|
||||
|
||||
def get_local_item(item_id):
|
||||
if item_id in crate["index"]:
|
||||
return crate["index"][item_id]
|
||||
print("Missing local ID:", item_id)
|
||||
sys.exit(1)
|
||||
|
||||
|
||||
# local IDs have to be in `index`, external ones can sometimes be in `index` but otherwise have
|
||||
# to be in `paths`
|
||||
def valid_id(item_id):
|
||||
return item_id in crate["index"] or item_id[0] != "0" and item_id in crate["paths"]
|
||||
|
||||
|
||||
def check_generics(generics):
|
||||
for param in generics["params"]:
|
||||
check_generic_param(param)
|
||||
for where_predicate in generics["where_predicates"]:
|
||||
if "bound_predicate" in where_predicate:
|
||||
pred = where_predicate["bound_predicate"]
|
||||
check_type(pred["ty"])
|
||||
for bound in pred["bounds"]:
|
||||
check_generic_bound(bound)
|
||||
elif "region_predicate" in where_predicate:
|
||||
pred = where_predicate["region_predicate"]
|
||||
for bound in pred["bounds"]:
|
||||
check_generic_bound(bound)
|
||||
elif "eq_predicate" in where_predicate:
|
||||
pred = where_predicate["eq_predicate"]
|
||||
check_type(pred["rhs"])
|
||||
check_type(pred["lhs"])
|
||||
|
||||
|
||||
def check_generic_param(param):
|
||||
if "type" in param["kind"]:
|
||||
ty = param["kind"]["type"]
|
||||
if ty["default"]:
|
||||
check_type(ty["default"])
|
||||
for bound in ty["bounds"]:
|
||||
check_generic_bound(bound)
|
||||
elif "const" in param["kind"]:
|
||||
check_type(param["kind"]["const"])
|
||||
|
||||
|
||||
def check_generic_bound(bound):
|
||||
if "trait_bound" in bound:
|
||||
for param in bound["trait_bound"]["generic_params"]:
|
||||
check_generic_param(param)
|
||||
check_type(bound["trait_bound"]["trait"])
|
||||
|
||||
|
||||
def check_decl(decl):
|
||||
for (_name, ty) in decl["inputs"]:
|
||||
check_type(ty)
|
||||
if decl["output"]:
|
||||
check_type(decl["output"])
|
||||
|
||||
|
||||
def check_type(ty):
|
||||
if ty["kind"] == "resolved_path":
|
||||
for bound in ty["inner"]["param_names"]:
|
||||
check_generic_bound(bound)
|
||||
args = ty["inner"]["args"]
|
||||
if args:
|
||||
if "angle_bracketed" in args:
|
||||
for arg in args["angle_bracketed"]["args"]:
|
||||
if "type" in arg:
|
||||
check_type(arg["type"])
|
||||
elif "const" in arg:
|
||||
check_type(arg["const"]["type"])
|
||||
for binding in args["angle_bracketed"]["bindings"]:
|
||||
if "equality" in binding["binding"]:
|
||||
check_type(binding["binding"]["equality"])
|
||||
elif "constraint" in binding["binding"]:
|
||||
for bound in binding["binding"]["constraint"]:
|
||||
check_generic_bound(bound)
|
||||
elif "parenthesized" in args:
|
||||
for ty in args["parenthesized"]["inputs"]:
|
||||
check_type(ty)
|
||||
if args["parenthesized"]["output"]:
|
||||
check_type(args["parenthesized"]["output"])
|
||||
if not valid_id(ty["inner"]["id"]):
|
||||
print("Type contained an invalid ID:", ty["inner"]["id"])
|
||||
sys.exit(1)
|
||||
elif ty["kind"] == "tuple":
|
||||
for ty in ty["inner"]:
|
||||
check_type(ty)
|
||||
elif ty["kind"] == "slice":
|
||||
check_type(ty["inner"])
|
||||
elif ty["kind"] == "impl_trait":
|
||||
for bound in ty["inner"]:
|
||||
check_generic_bound(bound)
|
||||
elif ty["kind"] in ("raw_pointer", "borrowed_ref", "array"):
|
||||
check_type(ty["inner"]["type"])
|
||||
elif ty["kind"] == "function_pointer":
|
||||
for param in ty["inner"]["generic_params"]:
|
||||
check_generic_param(param)
|
||||
check_decl(ty["inner"]["inner"])
|
||||
elif ty["kind"] == "qualified_path":
|
||||
check_type(ty["inner"]["self_type"])
|
||||
check_type(ty["inner"]["trait"])
|
||||
|
||||
|
||||
work_list = set([crate["root"]])
|
||||
visited = work_list.copy()
|
||||
|
||||
while work_list:
|
||||
current = work_list.pop()
|
||||
visited.add(current)
|
||||
item = get_local_item(current)
|
||||
# check intradoc links
|
||||
for (_name, link) in item["links"].items():
|
||||
if not valid_id(link):
|
||||
print("Intra-doc link contains invalid ID:", link)
|
||||
|
||||
# check all fields that reference types such as generics as well as nested items
|
||||
# (modules, structs, traits, and enums)
|
||||
if item["kind"] == "module":
|
||||
work_list |= set(item["inner"]["items"]) - visited
|
||||
elif item["kind"] == "struct":
|
||||
check_generics(item["inner"]["generics"])
|
||||
work_list |= (set(item["inner"]["fields"]) | set(item["inner"]["impls"])) - visited
|
||||
elif item["kind"] == "struct_field":
|
||||
check_type(item["inner"])
|
||||
elif item["kind"] == "enum":
|
||||
check_generics(item["inner"]["generics"])
|
||||
work_list |= (set(item["inner"]["variants"]) | set(item["inner"]["impls"])) - visited
|
||||
elif item["kind"] == "variant":
|
||||
if item["inner"]["variant_kind"] == "tuple":
|
||||
for ty in item["inner"]["variant_inner"]:
|
||||
check_type(ty)
|
||||
elif item["inner"]["variant_kind"] == "struct":
|
||||
work_list |= set(item["inner"]["variant_inner"]) - visited
|
||||
elif item["kind"] in ("function", "method"):
|
||||
check_generics(item["inner"]["generics"])
|
||||
check_decl(item["inner"]["decl"])
|
||||
elif item["kind"] in ("static", "constant", "assoc_const"):
|
||||
check_type(item["inner"]["type"])
|
||||
elif item["kind"] == "typedef":
|
||||
check_type(item["inner"]["type"])
|
||||
check_generics(item["inner"]["generics"])
|
||||
elif item["kind"] == "opaque_ty":
|
||||
check_generics(item["inner"]["generics"])
|
||||
for bound in item["inner"]["bounds"]:
|
||||
check_generic_bound(bound)
|
||||
elif item["kind"] == "trait_alias":
|
||||
check_generics(item["inner"]["params"])
|
||||
for bound in item["inner"]["bounds"]:
|
||||
check_generic_bound(bound)
|
||||
elif item["kind"] == "trait":
|
||||
check_generics(item["inner"]["generics"])
|
||||
for bound in item["inner"]["bounds"]:
|
||||
check_generic_bound(bound)
|
||||
work_list |= (set(item["inner"]["items"]) | set(item["inner"]["implementors"])) - visited
|
||||
elif item["kind"] == "impl":
|
||||
check_generics(item["inner"]["generics"])
|
||||
if item["inner"]["trait"]:
|
||||
check_type(item["inner"]["trait"])
|
||||
if item["inner"]["blanket_impl"]:
|
||||
check_type(item["inner"]["blanket_impl"])
|
||||
check_type(item["inner"]["for"])
|
||||
for assoc_item in item["inner"]["items"]:
|
||||
if not valid_id(assoc_item):
|
||||
print("Impl block referenced a missing ID:", assoc_item)
|
||||
sys.exit(1)
|
||||
elif item["kind"] == "assoc_type":
|
||||
for bound in item["inner"]["bounds"]:
|
||||
check_generic_bound(bound)
|
||||
if item["inner"]["default"]:
|
||||
check_type(item["inner"]["default"])
|
||||
107
src/test/rustdoc/rustdoc-json/compare.py
Normal file
107
src/test/rustdoc/rustdoc-json/compare.py
Normal file
@ -0,0 +1,107 @@
|
||||
#!/usr/bin/env python
|
||||
|
||||
# This script can check that an expected json blob is a subset of what actually gets produced.
|
||||
# The comparison is independent of the value of IDs (which are unstable) and instead uses their
|
||||
# relative ordering to check them against eachother by looking them up in their respective blob's
|
||||
# `index` or `paths` mappings. To add a new test run `rustdoc --output-format json -o . yourtest.rs`
|
||||
# and then create `yourtest.expected` by stripping unnecessary details from `yourtest.json`.
|
||||
|
||||
import copy
|
||||
import sys
|
||||
import json
|
||||
import types
|
||||
|
||||
# Used instead of the string ids when used as references.
|
||||
# Not used as keys in `index` or `paths`
|
||||
class ID(str):
|
||||
pass
|
||||
|
||||
|
||||
class SubsetException(Exception):
|
||||
def __init__(self, msg, trace):
|
||||
self.msg = msg
|
||||
self.trace = msg
|
||||
super().__init__("{}: {}".format(trace, msg))
|
||||
|
||||
|
||||
def check_subset(expected_main, actual_main):
|
||||
expected_index = expected_main["index"]
|
||||
expected_paths = expected_main["paths"]
|
||||
actual_index = actual_main["index"]
|
||||
actual_paths = actual_main["paths"]
|
||||
already_checked = set()
|
||||
|
||||
def _check_subset(expected, actual, trace):
|
||||
expected_type = type(expected)
|
||||
actual_type = type(actual)
|
||||
if expected_type is not actual_type:
|
||||
raise SubsetException(
|
||||
"expected type `{}`, got `{}`".format(expected_type, actual_type), trace
|
||||
)
|
||||
if expected_type in (str, int, bool) and expected != actual:
|
||||
raise SubsetException("expected `{}`, got: `{}`".format(expected, actual), trace)
|
||||
if expected_type is dict:
|
||||
for key in expected:
|
||||
if key not in actual:
|
||||
raise SubsetException("Key `{}` not found in output".format(key), trace)
|
||||
new_trace = copy.deepcopy(trace)
|
||||
new_trace.append(key)
|
||||
_check_subset(expected[key], actual[key], new_trace)
|
||||
elif expected_type is list:
|
||||
expected_elements = len(expected)
|
||||
actual_elements = len(actual)
|
||||
if expected_elements != actual_elements:
|
||||
raise SubsetException(
|
||||
"Found {} items, expected {}".format(expected_elements, actual_elements), trace
|
||||
)
|
||||
for expected, actual in zip(expected, actual):
|
||||
new_trace = copy.deepcopy(trace)
|
||||
new_trace.append(expected)
|
||||
_check_subset(expected, actual, new_trace)
|
||||
elif expected_type is ID and expected not in already_checked:
|
||||
already_checked.add(expected)
|
||||
_check_subset(expected_index.get(expected, {}), actual_index.get(actual, {}), trace)
|
||||
_check_subset(expected_paths.get(expected, {}), actual_paths.get(actual, {}), trace)
|
||||
|
||||
_check_subset(expected_main["root"], actual_main["root"], [])
|
||||
|
||||
|
||||
def rustdoc_object_hook(obj):
|
||||
# No need to convert paths, index and external_crates keys to ids, since
|
||||
# they are the target of resolution, and never a source itself.
|
||||
if "id" in obj and obj["id"]:
|
||||
obj["id"] = ID(obj["id"])
|
||||
if "root" in obj:
|
||||
obj["root"] = ID(obj["root"])
|
||||
if "items" in obj:
|
||||
obj["items"] = [ID(id) for id in obj["items"]]
|
||||
if "variants" in obj:
|
||||
obj["variants"] = [ID(id) for id in obj["variants"]]
|
||||
if "fields" in obj:
|
||||
obj["fields"] = [ID(id) for id in obj["fields"]]
|
||||
if "impls" in obj:
|
||||
obj["impls"] = [ID(id) for id in obj["impls"]]
|
||||
if "implementors" in obj:
|
||||
obj["implementors"] = [ID(id) for id in obj["implementors"]]
|
||||
if "links" in obj:
|
||||
obj["links"] = {s: ID(id) for s, id in obj["links"]}
|
||||
if "variant_kind" in obj and obj["variant_kind"] == "struct":
|
||||
obj["variant_inner"] = [ID(id) for id in obj["variant_inner"]]
|
||||
return obj
|
||||
|
||||
|
||||
def main(expected_fpath, actual_fpath):
|
||||
print("checking that {} is a logical subset of {}".format(expected_fpath, actual_fpath))
|
||||
with open(expected_fpath) as expected_file:
|
||||
expected_main = json.load(expected_file, object_hook=rustdoc_object_hook)
|
||||
with open(actual_fpath) as actual_file:
|
||||
actual_main = json.load(actual_file, object_hook=rustdoc_object_hook)
|
||||
check_subset(expected_main, actual_main)
|
||||
print("all checks passed")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
if len(sys.argv) < 3:
|
||||
print("Usage: `compare.py expected.json actual.json`")
|
||||
else:
|
||||
main(sys.argv[1], sys.argv[2])
|
||||
468
src/test/rustdoc/rustdoc-json/structs.expected
Normal file
468
src/test/rustdoc/rustdoc-json/structs.expected
Normal file
@ -0,0 +1,468 @@
|
||||
{
|
||||
"root": "0:0",
|
||||
"version": null,
|
||||
"includes_private": false,
|
||||
"index": {
|
||||
"0:9": {
|
||||
"crate_id": 0,
|
||||
"name": "Unit",
|
||||
"source": {
|
||||
"filename": "structs.rs",
|
||||
"begin": [
|
||||
7,
|
||||
0
|
||||
],
|
||||
"end": [
|
||||
7,
|
||||
16
|
||||
]
|
||||
},
|
||||
"visibility": "public",
|
||||
"docs": "",
|
||||
"links": {},
|
||||
"attrs": [],
|
||||
"deprecation": null,
|
||||
"kind": "struct",
|
||||
"inner": {
|
||||
"struct_type": "unit",
|
||||
"generics": {
|
||||
"params": [],
|
||||
"where_predicates": []
|
||||
},
|
||||
"fields_stripped": false,
|
||||
"fields": []
|
||||
}
|
||||
},
|
||||
"0:8": {
|
||||
"crate_id": 0,
|
||||
"name": "1",
|
||||
"source": {
|
||||
"filename": "structs.rs",
|
||||
"begin": [
|
||||
5,
|
||||
22
|
||||
],
|
||||
"end": [
|
||||
5,
|
||||
28
|
||||
]
|
||||
},
|
||||
"visibility": "default",
|
||||
"docs": "",
|
||||
"links": {},
|
||||
"attrs": [],
|
||||
"deprecation": null,
|
||||
"kind": "struct_field",
|
||||
"inner": {
|
||||
"kind": "resolved_path",
|
||||
"inner": {
|
||||
"name": "String",
|
||||
"id": "5:5035",
|
||||
"args": {
|
||||
"angle_bracketed": {
|
||||
"args": [],
|
||||
"bindings": []
|
||||
}
|
||||
},
|
||||
"param_names": []
|
||||
}
|
||||
}
|
||||
},
|
||||
"0:18": {
|
||||
"crate_id": 0,
|
||||
"name": "stuff",
|
||||
"source": {
|
||||
"filename": "structs.rs",
|
||||
"begin": [
|
||||
15,
|
||||
4
|
||||
],
|
||||
"end": [
|
||||
15,
|
||||
17
|
||||
]
|
||||
},
|
||||
"visibility": "default",
|
||||
"docs": "",
|
||||
"links": {},
|
||||
"attrs": [],
|
||||
"deprecation": null,
|
||||
"kind": "struct_field",
|
||||
"inner": {
|
||||
"kind": "resolved_path",
|
||||
"inner": {
|
||||
"name": "Vec",
|
||||
"id": "5:4322",
|
||||
"args": {
|
||||
"angle_bracketed": {
|
||||
"args": [
|
||||
{
|
||||
"type": {
|
||||
"kind": "generic",
|
||||
"inner": "T"
|
||||
}
|
||||
}
|
||||
],
|
||||
"bindings": []
|
||||
}
|
||||
},
|
||||
"param_names": []
|
||||
}
|
||||
}
|
||||
},
|
||||
"0:11": {
|
||||
"crate_id": 0,
|
||||
"name": "WithPrimitives",
|
||||
"source": {
|
||||
"filename": "structs.rs",
|
||||
"begin": [
|
||||
9,
|
||||
0
|
||||
],
|
||||
"end": [
|
||||
12,
|
||||
1
|
||||
]
|
||||
},
|
||||
"visibility": "public",
|
||||
"docs": "",
|
||||
"links": {},
|
||||
"attrs": [],
|
||||
"deprecation": null,
|
||||
"kind": "struct",
|
||||
"inner": {
|
||||
"struct_type": "plain",
|
||||
"generics": {
|
||||
"params": [
|
||||
{
|
||||
"name": "'a",
|
||||
"kind": "lifetime"
|
||||
}
|
||||
],
|
||||
"where_predicates": []
|
||||
},
|
||||
"fields_stripped": true,
|
||||
"fields": [
|
||||
"0:13",
|
||||
"0:14"
|
||||
]
|
||||
}
|
||||
},
|
||||
"0:14": {
|
||||
"crate_id": 0,
|
||||
"name": "s",
|
||||
"source": {
|
||||
"filename": "structs.rs",
|
||||
"begin": [
|
||||
11,
|
||||
4
|
||||
],
|
||||
"end": [
|
||||
11,
|
||||
14
|
||||
]
|
||||
},
|
||||
"visibility": "default",
|
||||
"docs": "",
|
||||
"links": {},
|
||||
"attrs": [],
|
||||
"deprecation": null,
|
||||
"kind": "struct_field",
|
||||
"inner": {
|
||||
"kind": "borrowed_ref",
|
||||
"inner": {
|
||||
"lifetime": "'a",
|
||||
"mutable": false,
|
||||
"type": {
|
||||
"kind": "primitive",
|
||||
"inner": "str"
|
||||
}
|
||||
}
|
||||
}
|
||||
},
|
||||
"0:19": {
|
||||
"crate_id": 0,
|
||||
"name": "things",
|
||||
"source": {
|
||||
"filename": "structs.rs",
|
||||
"begin": [
|
||||
16,
|
||||
4
|
||||
],
|
||||
"end": [
|
||||
16,
|
||||
25
|
||||
]
|
||||
},
|
||||
"visibility": "default",
|
||||
"docs": "",
|
||||
"links": {},
|
||||
"attrs": [],
|
||||
"deprecation": null,
|
||||
"kind": "struct_field",
|
||||
"inner": {
|
||||
"kind": "resolved_path",
|
||||
"inner": {
|
||||
"name": "HashMap",
|
||||
"id": "1:6600",
|
||||
"args": {
|
||||
"angle_bracketed": {
|
||||
"args": [
|
||||
{
|
||||
"type": {
|
||||
"kind": "generic",
|
||||
"inner": "U"
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": {
|
||||
"kind": "generic",
|
||||
"inner": "U"
|
||||
}
|
||||
}
|
||||
],
|
||||
"bindings": []
|
||||
}
|
||||
},
|
||||
"param_names": []
|
||||
}
|
||||
}
|
||||
},
|
||||
"0:15": {
|
||||
"crate_id": 0,
|
||||
"name": "WithGenerics",
|
||||
"source": {
|
||||
"filename": "structs.rs",
|
||||
"begin": [
|
||||
14,
|
||||
0
|
||||
],
|
||||
"end": [
|
||||
17,
|
||||
1
|
||||
]
|
||||
},
|
||||
"visibility": "public",
|
||||
"docs": "",
|
||||
"links": {},
|
||||
"attrs": [],
|
||||
"deprecation": null,
|
||||
"kind": "struct",
|
||||
"inner": {
|
||||
"struct_type": "plain",
|
||||
"generics": {
|
||||
"params": [
|
||||
{
|
||||
"name": "T",
|
||||
"kind": {
|
||||
"type": {
|
||||
"bounds": [],
|
||||
"default": null
|
||||
}
|
||||
}
|
||||
},
|
||||
{
|
||||
"name": "U",
|
||||
"kind": {
|
||||
"type": {
|
||||
"bounds": [],
|
||||
"default": null
|
||||
}
|
||||
}
|
||||
}
|
||||
],
|
||||
"where_predicates": []
|
||||
},
|
||||
"fields_stripped": true,
|
||||
"fields": [
|
||||
"0:18",
|
||||
"0:19"
|
||||
]
|
||||
}
|
||||
},
|
||||
"0:0": {
|
||||
"crate_id": 0,
|
||||
"name": "structs",
|
||||
"source": {
|
||||
"filename": "structs.rs",
|
||||
"begin": [
|
||||
1,
|
||||
0
|
||||
],
|
||||
"end": [
|
||||
17,
|
||||
1
|
||||
]
|
||||
},
|
||||
"visibility": "public",
|
||||
"docs": "",
|
||||
"links": {},
|
||||
"attrs": [],
|
||||
"deprecation": null,
|
||||
"kind": "module",
|
||||
"inner": {
|
||||
"is_crate": true,
|
||||
"items": [
|
||||
"0:4",
|
||||
"0:5",
|
||||
"0:9",
|
||||
"0:11",
|
||||
"0:15"
|
||||
]
|
||||
}
|
||||
},
|
||||
"0:13": {
|
||||
"crate_id": 0,
|
||||
"name": "num",
|
||||
"source": {
|
||||
"filename": "structs.rs",
|
||||
"begin": [
|
||||
10,
|
||||
4
|
||||
],
|
||||
"end": [
|
||||
10,
|
||||
12
|
||||
]
|
||||
},
|
||||
"visibility": "default",
|
||||
"docs": "",
|
||||
"links": {},
|
||||
"attrs": [],
|
||||
"deprecation": null,
|
||||
"kind": "struct_field",
|
||||
"inner": {
|
||||
"kind": "primitive",
|
||||
"inner": "u32"
|
||||
}
|
||||
},
|
||||
"0:5": {
|
||||
"crate_id": 0,
|
||||
"name": "Tuple",
|
||||
"source": {
|
||||
"filename": "structs.rs",
|
||||
"begin": [
|
||||
5,
|
||||
0
|
||||
],
|
||||
"end": [
|
||||
5,
|
||||
30
|
||||
]
|
||||
},
|
||||
"visibility": "public",
|
||||
"docs": "",
|
||||
"links": {},
|
||||
"attrs": [],
|
||||
"deprecation": null,
|
||||
"kind": "struct",
|
||||
"inner": {
|
||||
"struct_type": "tuple",
|
||||
"generics": {
|
||||
"params": [],
|
||||
"where_predicates": []
|
||||
},
|
||||
"fields_stripped": true,
|
||||
"fields": [
|
||||
"0:7",
|
||||
"0:8"
|
||||
]
|
||||
}
|
||||
},
|
||||
"0:4": {
|
||||
"crate_id": 0,
|
||||
"name": "PlainEmpty",
|
||||
"source": {
|
||||
"filename": "structs.rs",
|
||||
"begin": [
|
||||
3,
|
||||
0
|
||||
],
|
||||
"end": [
|
||||
3,
|
||||
24
|
||||
]
|
||||
},
|
||||
"visibility": "public",
|
||||
"docs": "",
|
||||
"links": {},
|
||||
"attrs": [],
|
||||
"deprecation": null,
|
||||
"kind": "struct",
|
||||
"inner": {
|
||||
"struct_type": "plain",
|
||||
"generics": {
|
||||
"params": [],
|
||||
"where_predicates": []
|
||||
},
|
||||
"fields_stripped": false,
|
||||
"fields": []
|
||||
}
|
||||
},
|
||||
"0:7": {
|
||||
"crate_id": 0,
|
||||
"name": "0",
|
||||
"source": {
|
||||
"filename": "structs.rs",
|
||||
"begin": [
|
||||
5,
|
||||
17
|
||||
],
|
||||
"end": [
|
||||
5,
|
||||
20
|
||||
]
|
||||
},
|
||||
"visibility": "default",
|
||||
"docs": "",
|
||||
"links": {},
|
||||
"attrs": [],
|
||||
"deprecation": null,
|
||||
"kind": "struct_field",
|
||||
"inner": {
|
||||
"kind": "primitive",
|
||||
"inner": "u32"
|
||||
}
|
||||
}
|
||||
},
|
||||
"paths": {
|
||||
"5:4322": {
|
||||
"crate_id": 5,
|
||||
"path": [
|
||||
"alloc",
|
||||
"vec",
|
||||
"Vec"
|
||||
],
|
||||
"kind": "struct"
|
||||
},
|
||||
"5:5035": {
|
||||
"crate_id": 5,
|
||||
"path": [
|
||||
"alloc",
|
||||
"string",
|
||||
"String"
|
||||
],
|
||||
"kind": "struct"
|
||||
},
|
||||
"1:6600": {
|
||||
"crate_id": 1,
|
||||
"path": [
|
||||
"std",
|
||||
"collections",
|
||||
"hash",
|
||||
"map",
|
||||
"HashMap"
|
||||
],
|
||||
"kind": "struct"
|
||||
}
|
||||
},
|
||||
"external_crates": {
|
||||
"1": {
|
||||
"name": "std"
|
||||
},
|
||||
"5": {
|
||||
"name": "alloc"
|
||||
}
|
||||
},
|
||||
"format_version": 1
|
||||
}
|
||||
17
src/test/rustdoc/rustdoc-json/structs.rs
Normal file
17
src/test/rustdoc/rustdoc-json/structs.rs
Normal file
@ -0,0 +1,17 @@
|
||||
use std::collections::HashMap;
|
||||
|
||||
pub struct PlainEmpty {}
|
||||
|
||||
pub struct Tuple(u32, String);
|
||||
|
||||
pub struct Unit;
|
||||
|
||||
pub struct WithPrimitives<'a> {
|
||||
num: u32,
|
||||
s: &'a str,
|
||||
}
|
||||
|
||||
pub struct WithGenerics<T, U> {
|
||||
stuff: Vec<T>,
|
||||
things: HashMap<U, U>,
|
||||
}
|
||||
Loading…
Reference in New Issue
Block a user