Add an intital HIR and lowering step
This commit is contained in:
Nick Cameron
parent
cfd76b364c
commit
facdf2ebb1
160 changed files with 13917 additions and 4451 deletions
|
|
@ -13,7 +13,8 @@
|
|||
use std::collections::HashSet;
|
||||
|
||||
use syntax::ast;
|
||||
use syntax::attr::AttrMetaMethods;
|
||||
use rustc_front::attr::AttrMetaMethods;
|
||||
use rustc_front::hir;
|
||||
|
||||
use rustc::metadata::csearch;
|
||||
use rustc::metadata::decoder;
|
||||
|
|
@ -119,7 +120,7 @@ fn try_inline_def(cx: &DocContext, tcx: &ty::ctxt,
|
|||
name: Some(tcx.item_name(did).to_string()),
|
||||
attrs: load_attrs(cx, tcx, did),
|
||||
inner: inner,
|
||||
visibility: Some(ast::Public),
|
||||
visibility: Some(hir::Public),
|
||||
stability: stability::lookup(tcx, did).clean(cx),
|
||||
def_id: did,
|
||||
});
|
||||
|
|
@ -174,7 +175,7 @@ fn build_external_function(cx: &DocContext, tcx: &ty::ctxt, did: DefId) -> clean
|
|||
decl: decl,
|
||||
generics: (&t.generics, &predicates, subst::FnSpace).clean(cx),
|
||||
unsafety: style,
|
||||
constness: ast::Constness::NotConst,
|
||||
constness: hir::Constness::NotConst,
|
||||
abi: abi,
|
||||
}
|
||||
}
|
||||
|
|
@ -291,7 +292,7 @@ pub fn build_impl(cx: &DocContext,
|
|||
return ret.push(clean::Item {
|
||||
inner: clean::DefaultImplItem(clean::DefaultImpl {
|
||||
// FIXME: this should be decoded
|
||||
unsafety: ast::Unsafety::Normal,
|
||||
unsafety: hir::Unsafety::Normal,
|
||||
trait_: match associated_trait.as_ref().unwrap().clean(cx) {
|
||||
clean::TraitBound(polyt, _) => polyt.trait_,
|
||||
clean::RegionBound(..) => unreachable!(),
|
||||
|
|
@ -300,7 +301,7 @@ pub fn build_impl(cx: &DocContext,
|
|||
source: clean::Span::empty(),
|
||||
name: None,
|
||||
attrs: attrs,
|
||||
visibility: Some(ast::Inherited),
|
||||
visibility: Some(hir::Inherited),
|
||||
stability: stability::lookup(tcx, did).clean(cx),
|
||||
def_id: did,
|
||||
});
|
||||
|
|
@ -335,7 +336,7 @@ pub fn build_impl(cx: &DocContext,
|
|||
})
|
||||
}
|
||||
ty::MethodTraitItem(method) => {
|
||||
if method.vis != ast::Public && associated_trait.is_none() {
|
||||
if method.vis != hir::Public && associated_trait.is_none() {
|
||||
return None
|
||||
}
|
||||
if method.provided_source.is_some() {
|
||||
|
|
@ -348,7 +349,7 @@ pub fn build_impl(cx: &DocContext,
|
|||
}) => {
|
||||
clean::MethodItem(clean::Method {
|
||||
unsafety: unsafety,
|
||||
constness: ast::Constness::NotConst,
|
||||
constness: hir::Constness::NotConst,
|
||||
decl: decl,
|
||||
self_: self_,
|
||||
generics: generics,
|
||||
|
|
@ -396,7 +397,7 @@ pub fn build_impl(cx: &DocContext,
|
|||
}
|
||||
ret.push(clean::Item {
|
||||
inner: clean::ImplItem(clean::Impl {
|
||||
unsafety: ast::Unsafety::Normal, // FIXME: this should be decoded
|
||||
unsafety: hir::Unsafety::Normal, // FIXME: this should be decoded
|
||||
derived: clean::detect_derived(&attrs),
|
||||
trait_: trait_,
|
||||
for_: ty.ty.clean(cx),
|
||||
|
|
@ -407,7 +408,7 @@ pub fn build_impl(cx: &DocContext,
|
|||
source: clean::Span::empty(),
|
||||
name: None,
|
||||
attrs: attrs,
|
||||
visibility: Some(ast::Inherited),
|
||||
visibility: Some(hir::Inherited),
|
||||
stability: stability::lookup(tcx, did).clean(cx),
|
||||
def_id: did,
|
||||
});
|
||||
|
|
@ -447,7 +448,7 @@ fn build_module(cx: &DocContext, tcx: &ty::ctxt,
|
|||
decoder::DlDef(def::DefForeignMod(did)) => {
|
||||
fill_in(cx, tcx, did, items);
|
||||
}
|
||||
decoder::DlDef(def) if vis == ast::Public => {
|
||||
decoder::DlDef(def) if vis == hir::Public => {
|
||||
if !visited.insert(def) { return }
|
||||
match try_inline_def(cx, tcx, def) {
|
||||
Some(i) => items.extend(i),
|
||||
|
|
@ -466,7 +467,7 @@ fn build_module(cx: &DocContext, tcx: &ty::ctxt,
|
|||
fn build_const(cx: &DocContext, tcx: &ty::ctxt,
|
||||
did: DefId) -> clean::Constant {
|
||||
use rustc::middle::const_eval;
|
||||
use syntax::print::pprust;
|
||||
use rustc_front::print::pprust;
|
||||
|
||||
let expr = const_eval::lookup_const_by_id(tcx, did, None).unwrap_or_else(|| {
|
||||
panic!("expected lookup_const_by_id to succeed for {:?}", did);
|
||||
|
|
|
|||
|
|
@ -27,8 +27,6 @@ pub use self::FunctionRetTy::*;
|
|||
use syntax;
|
||||
use syntax::abi;
|
||||
use syntax::ast;
|
||||
use syntax::attr;
|
||||
use syntax::attr::{AttributeMethods, AttrMetaMethods};
|
||||
use syntax::codemap;
|
||||
use syntax::codemap::{DUMMY_SP, Pos, Spanned};
|
||||
use syntax::parse::token::{self, InternedString, special_idents};
|
||||
|
|
@ -44,6 +42,11 @@ use rustc::middle::subst::{self, ParamSpace, VecPerParamSpace};
|
|||
use rustc::middle::ty;
|
||||
use rustc::middle::stability;
|
||||
|
||||
use rustc_front::hir;
|
||||
use rustc_front::attr;
|
||||
use rustc_front::attr::{AttributeMethods, AttrMetaMethods};
|
||||
use rustc_front::lowering::unlower_attribute;
|
||||
|
||||
use std::collections::HashMap;
|
||||
use std::path::PathBuf;
|
||||
use std::rc::Rc;
|
||||
|
|
@ -140,7 +143,8 @@ impl<'a, 'tcx> Clean<Crate> for visit_ast::RustdocVisitor<'a, 'tcx> {
|
|||
|
||||
// Figure out the name of this crate
|
||||
let input = &cx.input;
|
||||
let name = link::find_crate_name(None, &self.attrs, input);
|
||||
let attrs: Vec<_> = self.attrs.iter().map(|a| unlower_attribute(a)).collect();
|
||||
let name = link::find_crate_name(None, &attrs, input);
|
||||
|
||||
// Clean the crate, translating the entire libsyntax AST to one that is
|
||||
// understood by rustdoc.
|
||||
|
|
@ -184,7 +188,7 @@ impl<'a, 'tcx> Clean<Crate> for visit_ast::RustdocVisitor<'a, 'tcx> {
|
|||
source: Span::empty(),
|
||||
name: Some(prim.to_url_str().to_string()),
|
||||
attrs: child.attrs.clone(),
|
||||
visibility: Some(ast::Public),
|
||||
visibility: Some(hir::Public),
|
||||
stability: None,
|
||||
def_id: DefId::local(prim.to_node_id()),
|
||||
inner: PrimitiveItem(prim),
|
||||
|
|
@ -433,21 +437,21 @@ pub enum Attribute {
|
|||
NameValue(String, String)
|
||||
}
|
||||
|
||||
impl Clean<Attribute> for ast::MetaItem {
|
||||
impl Clean<Attribute> for hir::MetaItem {
|
||||
fn clean(&self, cx: &DocContext) -> Attribute {
|
||||
match self.node {
|
||||
ast::MetaWord(ref s) => Word(s.to_string()),
|
||||
ast::MetaList(ref s, ref l) => {
|
||||
hir::MetaWord(ref s) => Word(s.to_string()),
|
||||
hir::MetaList(ref s, ref l) => {
|
||||
List(s.to_string(), l.clean(cx))
|
||||
}
|
||||
ast::MetaNameValue(ref s, ref v) => {
|
||||
hir::MetaNameValue(ref s, ref v) => {
|
||||
NameValue(s.to_string(), lit_to_string(v))
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl Clean<Attribute> for ast::Attribute {
|
||||
impl Clean<Attribute> for hir::Attribute {
|
||||
fn clean(&self, cx: &DocContext) -> Attribute {
|
||||
self.with_desugared_doc(|a| a.node.value.clean(cx))
|
||||
}
|
||||
|
|
@ -471,13 +475,13 @@ impl attr::AttrMetaMethods for Attribute {
|
|||
_ => None,
|
||||
}
|
||||
}
|
||||
fn meta_item_list<'a>(&'a self) -> Option<&'a [P<ast::MetaItem>]> { None }
|
||||
fn meta_item_list<'a>(&'a self) -> Option<&'a [P<hir::MetaItem>]> { None }
|
||||
fn span(&self) -> codemap::Span { unimplemented!() }
|
||||
}
|
||||
impl<'a> attr::AttrMetaMethods for &'a Attribute {
|
||||
fn name(&self) -> InternedString { (**self).name() }
|
||||
fn value_str(&self) -> Option<InternedString> { (**self).value_str() }
|
||||
fn meta_item_list(&self) -> Option<&[P<ast::MetaItem>]> { None }
|
||||
fn meta_item_list(&self) -> Option<&[P<hir::MetaItem>]> { None }
|
||||
fn span(&self) -> codemap::Span { unimplemented!() }
|
||||
}
|
||||
|
||||
|
|
@ -489,7 +493,7 @@ pub struct TyParam {
|
|||
pub default: Option<Type>,
|
||||
}
|
||||
|
||||
impl Clean<TyParam> for ast::TyParam {
|
||||
impl Clean<TyParam> for hir::TyParam {
|
||||
fn clean(&self, cx: &DocContext) -> TyParam {
|
||||
TyParam {
|
||||
name: self.ident.clean(cx),
|
||||
|
|
@ -516,12 +520,12 @@ impl<'tcx> Clean<TyParam> for ty::TypeParameterDef<'tcx> {
|
|||
#[derive(Clone, RustcEncodable, RustcDecodable, PartialEq, Debug)]
|
||||
pub enum TyParamBound {
|
||||
RegionBound(Lifetime),
|
||||
TraitBound(PolyTrait, ast::TraitBoundModifier)
|
||||
TraitBound(PolyTrait, hir::TraitBoundModifier)
|
||||
}
|
||||
|
||||
impl TyParamBound {
|
||||
fn maybe_sized(cx: &DocContext) -> TyParamBound {
|
||||
use syntax::ast::TraitBoundModifier as TBM;
|
||||
use rustc_front::hir::TraitBoundModifier as TBM;
|
||||
let mut sized_bound = ty::BoundSized.clean(cx);
|
||||
if let TyParamBound::TraitBound(_, ref mut tbm) = sized_bound {
|
||||
*tbm = TBM::Maybe
|
||||
|
|
@ -530,7 +534,7 @@ impl TyParamBound {
|
|||
}
|
||||
|
||||
fn is_sized_bound(&self, cx: &DocContext) -> bool {
|
||||
use syntax::ast::TraitBoundModifier as TBM;
|
||||
use rustc_front::hir::TraitBoundModifier as TBM;
|
||||
if let Some(tcx) = cx.tcx_opt() {
|
||||
let sized_did = match tcx.lang_items.sized_trait() {
|
||||
Some(did) => did,
|
||||
|
|
@ -548,11 +552,11 @@ impl TyParamBound {
|
|||
}
|
||||
}
|
||||
|
||||
impl Clean<TyParamBound> for ast::TyParamBound {
|
||||
impl Clean<TyParamBound> for hir::TyParamBound {
|
||||
fn clean(&self, cx: &DocContext) -> TyParamBound {
|
||||
match *self {
|
||||
ast::RegionTyParamBound(lt) => RegionBound(lt.clean(cx)),
|
||||
ast::TraitTyParamBound(ref t, modifier) => TraitBound(t.clean(cx), modifier),
|
||||
hir::RegionTyParamBound(lt) => RegionBound(lt.clean(cx)),
|
||||
hir::TraitTyParamBound(ref t, modifier) => TraitBound(t.clean(cx), modifier),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -666,7 +670,7 @@ impl Clean<TyParamBound> for ty::BuiltinBound {
|
|||
is_generic: false,
|
||||
},
|
||||
lifetimes: vec![]
|
||||
}, ast::TraitBoundModifier::None)
|
||||
}, hir::TraitBoundModifier::None)
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -712,7 +716,7 @@ impl<'tcx> Clean<TyParamBound> for ty::TraitRef<'tcx> {
|
|||
is_generic: false,
|
||||
},
|
||||
lifetimes: late_bounds
|
||||
}, ast::TraitBoundModifier::None)
|
||||
}, hir::TraitBoundModifier::None)
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -723,7 +727,7 @@ impl<'tcx> Clean<Option<Vec<TyParamBound>>> for subst::Substs<'tcx> {
|
|||
v.extend(self.types.iter().map(|t| TraitBound(PolyTrait {
|
||||
trait_: t.clean(cx),
|
||||
lifetimes: vec![]
|
||||
}, ast::TraitBoundModifier::None)));
|
||||
}, hir::TraitBoundModifier::None)));
|
||||
if !v.is_empty() {Some(v)} else {None}
|
||||
}
|
||||
}
|
||||
|
|
@ -743,13 +747,13 @@ impl Lifetime {
|
|||
}
|
||||
}
|
||||
|
||||
impl Clean<Lifetime> for ast::Lifetime {
|
||||
impl Clean<Lifetime> for hir::Lifetime {
|
||||
fn clean(&self, _: &DocContext) -> Lifetime {
|
||||
Lifetime(self.name.to_string())
|
||||
}
|
||||
}
|
||||
|
||||
impl Clean<Lifetime> for ast::LifetimeDef {
|
||||
impl Clean<Lifetime> for hir::LifetimeDef {
|
||||
fn clean(&self, _: &DocContext) -> Lifetime {
|
||||
Lifetime(self.lifetime.name.to_string())
|
||||
}
|
||||
|
|
@ -786,24 +790,24 @@ pub enum WherePredicate {
|
|||
EqPredicate { lhs: Type, rhs: Type }
|
||||
}
|
||||
|
||||
impl Clean<WherePredicate> for ast::WherePredicate {
|
||||
impl Clean<WherePredicate> for hir::WherePredicate {
|
||||
fn clean(&self, cx: &DocContext) -> WherePredicate {
|
||||
match *self {
|
||||
ast::WherePredicate::BoundPredicate(ref wbp) => {
|
||||
hir::WherePredicate::BoundPredicate(ref wbp) => {
|
||||
WherePredicate::BoundPredicate {
|
||||
ty: wbp.bounded_ty.clean(cx),
|
||||
bounds: wbp.bounds.clean(cx)
|
||||
}
|
||||
}
|
||||
|
||||
ast::WherePredicate::RegionPredicate(ref wrp) => {
|
||||
hir::WherePredicate::RegionPredicate(ref wrp) => {
|
||||
WherePredicate::RegionPredicate {
|
||||
lifetime: wrp.lifetime.clean(cx),
|
||||
bounds: wrp.bounds.clean(cx)
|
||||
}
|
||||
}
|
||||
|
||||
ast::WherePredicate::EqPredicate(_) => {
|
||||
hir::WherePredicate::EqPredicate(_) => {
|
||||
unimplemented!() // FIXME(#20041)
|
||||
}
|
||||
}
|
||||
|
|
@ -899,7 +903,7 @@ pub struct Generics {
|
|||
pub where_predicates: Vec<WherePredicate>
|
||||
}
|
||||
|
||||
impl Clean<Generics> for ast::Generics {
|
||||
impl Clean<Generics> for hir::Generics {
|
||||
fn clean(&self, cx: &DocContext) -> Generics {
|
||||
Generics {
|
||||
lifetimes: self.lifetimes.clean(cx),
|
||||
|
|
@ -982,17 +986,17 @@ impl<'a, 'tcx> Clean<Generics> for (&'a ty::Generics<'tcx>,
|
|||
pub struct Method {
|
||||
pub generics: Generics,
|
||||
pub self_: SelfTy,
|
||||
pub unsafety: ast::Unsafety,
|
||||
pub constness: ast::Constness,
|
||||
pub unsafety: hir::Unsafety,
|
||||
pub constness: hir::Constness,
|
||||
pub decl: FnDecl,
|
||||
pub abi: abi::Abi
|
||||
}
|
||||
|
||||
impl Clean<Method> for ast::MethodSig {
|
||||
impl Clean<Method> for hir::MethodSig {
|
||||
fn clean(&self, cx: &DocContext) -> Method {
|
||||
let all_inputs = &self.decl.inputs;
|
||||
let inputs = match self.explicit_self.node {
|
||||
ast::SelfStatic => &**all_inputs,
|
||||
hir::SelfStatic => &**all_inputs,
|
||||
_ => &all_inputs[1..]
|
||||
};
|
||||
let decl = FnDecl {
|
||||
|
|
@ -1016,17 +1020,17 @@ impl Clean<Method> for ast::MethodSig {
|
|||
|
||||
#[derive(Clone, RustcEncodable, RustcDecodable, Debug)]
|
||||
pub struct TyMethod {
|
||||
pub unsafety: ast::Unsafety,
|
||||
pub unsafety: hir::Unsafety,
|
||||
pub decl: FnDecl,
|
||||
pub generics: Generics,
|
||||
pub self_: SelfTy,
|
||||
pub abi: abi::Abi
|
||||
}
|
||||
|
||||
impl Clean<TyMethod> for ast::MethodSig {
|
||||
impl Clean<TyMethod> for hir::MethodSig {
|
||||
fn clean(&self, cx: &DocContext) -> TyMethod {
|
||||
let inputs = match self.explicit_self.node {
|
||||
ast::SelfStatic => &*self.decl.inputs,
|
||||
hir::SelfStatic => &*self.decl.inputs,
|
||||
_ => &self.decl.inputs[1..]
|
||||
};
|
||||
let decl = FnDecl {
|
||||
|
|
@ -1055,15 +1059,15 @@ pub enum SelfTy {
|
|||
SelfExplicit(Type),
|
||||
}
|
||||
|
||||
impl Clean<SelfTy> for ast::ExplicitSelf_ {
|
||||
impl Clean<SelfTy> for hir::ExplicitSelf_ {
|
||||
fn clean(&self, cx: &DocContext) -> SelfTy {
|
||||
match *self {
|
||||
ast::SelfStatic => SelfStatic,
|
||||
ast::SelfValue(_) => SelfValue,
|
||||
ast::SelfRegion(ref lt, ref mt, _) => {
|
||||
hir::SelfStatic => SelfStatic,
|
||||
hir::SelfValue(_) => SelfValue,
|
||||
hir::SelfRegion(ref lt, ref mt, _) => {
|
||||
SelfBorrowed(lt.clean(cx), mt.clean(cx))
|
||||
}
|
||||
ast::SelfExplicit(ref typ, _) => SelfExplicit(typ.clean(cx)),
|
||||
hir::SelfExplicit(ref typ, _) => SelfExplicit(typ.clean(cx)),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -1072,8 +1076,8 @@ impl Clean<SelfTy> for ast::ExplicitSelf_ {
|
|||
pub struct Function {
|
||||
pub decl: FnDecl,
|
||||
pub generics: Generics,
|
||||
pub unsafety: ast::Unsafety,
|
||||
pub constness: ast::Constness,
|
||||
pub unsafety: hir::Unsafety,
|
||||
pub constness: hir::Constness,
|
||||
pub abi: abi::Abi,
|
||||
}
|
||||
|
||||
|
|
@ -1110,7 +1114,7 @@ pub struct Arguments {
|
|||
pub values: Vec<Argument>,
|
||||
}
|
||||
|
||||
impl Clean<FnDecl> for ast::FnDecl {
|
||||
impl Clean<FnDecl> for hir::FnDecl {
|
||||
fn clean(&self, cx: &DocContext) -> FnDecl {
|
||||
FnDecl {
|
||||
inputs: Arguments {
|
||||
|
|
@ -1167,7 +1171,7 @@ pub struct Argument {
|
|||
pub id: ast::NodeId,
|
||||
}
|
||||
|
||||
impl Clean<Argument> for ast::Arg {
|
||||
impl Clean<Argument> for hir::Arg {
|
||||
fn clean(&self, cx: &DocContext) -> Argument {
|
||||
Argument {
|
||||
name: name_from_pat(&*self.pat),
|
||||
|
|
@ -1184,19 +1188,19 @@ pub enum FunctionRetTy {
|
|||
NoReturn
|
||||
}
|
||||
|
||||
impl Clean<FunctionRetTy> for ast::FunctionRetTy {
|
||||
impl Clean<FunctionRetTy> for hir::FunctionRetTy {
|
||||
fn clean(&self, cx: &DocContext) -> FunctionRetTy {
|
||||
match *self {
|
||||
ast::Return(ref typ) => Return(typ.clean(cx)),
|
||||
ast::DefaultReturn(..) => DefaultReturn,
|
||||
ast::NoReturn(..) => NoReturn
|
||||
hir::Return(ref typ) => Return(typ.clean(cx)),
|
||||
hir::DefaultReturn(..) => DefaultReturn,
|
||||
hir::NoReturn(..) => NoReturn
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, RustcEncodable, RustcDecodable, Debug)]
|
||||
pub struct Trait {
|
||||
pub unsafety: ast::Unsafety,
|
||||
pub unsafety: hir::Unsafety,
|
||||
pub items: Vec<Item>,
|
||||
pub generics: Generics,
|
||||
pub bounds: Vec<TyParamBound>,
|
||||
|
|
@ -1221,13 +1225,13 @@ impl Clean<Item> for doctree::Trait {
|
|||
}
|
||||
}
|
||||
|
||||
impl Clean<Type> for ast::TraitRef {
|
||||
impl Clean<Type> for hir::TraitRef {
|
||||
fn clean(&self, cx: &DocContext) -> Type {
|
||||
resolve_type(cx, self.path.clean(cx), self.ref_id)
|
||||
}
|
||||
}
|
||||
|
||||
impl Clean<PolyTrait> for ast::PolyTraitRef {
|
||||
impl Clean<PolyTrait> for hir::PolyTraitRef {
|
||||
fn clean(&self, cx: &DocContext) -> PolyTrait {
|
||||
PolyTrait {
|
||||
trait_: self.trait_ref.clean(cx),
|
||||
|
|
@ -1236,21 +1240,21 @@ impl Clean<PolyTrait> for ast::PolyTraitRef {
|
|||
}
|
||||
}
|
||||
|
||||
impl Clean<Item> for ast::TraitItem {
|
||||
impl Clean<Item> for hir::TraitItem {
|
||||
fn clean(&self, cx: &DocContext) -> Item {
|
||||
let inner = match self.node {
|
||||
ast::ConstTraitItem(ref ty, ref default) => {
|
||||
hir::ConstTraitItem(ref ty, ref default) => {
|
||||
AssociatedConstItem(ty.clean(cx),
|
||||
default.as_ref().map(|expr|
|
||||
expr.span.to_src(cx)))
|
||||
}
|
||||
ast::MethodTraitItem(ref sig, Some(_)) => {
|
||||
hir::MethodTraitItem(ref sig, Some(_)) => {
|
||||
MethodItem(sig.clean(cx))
|
||||
}
|
||||
ast::MethodTraitItem(ref sig, None) => {
|
||||
hir::MethodTraitItem(ref sig, None) => {
|
||||
TyMethodItem(sig.clean(cx))
|
||||
}
|
||||
ast::TypeTraitItem(ref bounds, ref default) => {
|
||||
hir::TypeTraitItem(ref bounds, ref default) => {
|
||||
AssociatedTypeItem(bounds.clean(cx), default.clean(cx))
|
||||
}
|
||||
};
|
||||
|
|
@ -1266,19 +1270,19 @@ impl Clean<Item> for ast::TraitItem {
|
|||
}
|
||||
}
|
||||
|
||||
impl Clean<Item> for ast::ImplItem {
|
||||
impl Clean<Item> for hir::ImplItem {
|
||||
fn clean(&self, cx: &DocContext) -> Item {
|
||||
let inner = match self.node {
|
||||
ast::ConstImplItem(ref ty, ref expr) => {
|
||||
hir::ConstImplItem(ref ty, ref expr) => {
|
||||
ConstantItem(Constant{
|
||||
type_: ty.clean(cx),
|
||||
expr: expr.span.to_src(cx),
|
||||
})
|
||||
}
|
||||
ast::MethodImplItem(ref sig, _) => {
|
||||
hir::MethodImplItem(ref sig, _) => {
|
||||
MethodItem(sig.clean(cx))
|
||||
}
|
||||
ast::TypeImplItem(ref ty) => TypedefItem(Typedef {
|
||||
hir::TypeImplItem(ref ty) => TypedefItem(Typedef {
|
||||
type_: ty.clean(cx),
|
||||
generics: Generics {
|
||||
lifetimes: Vec::new(),
|
||||
|
|
@ -1286,12 +1290,6 @@ impl Clean<Item> for ast::ImplItem {
|
|||
where_predicates: Vec::new()
|
||||
},
|
||||
}, true),
|
||||
ast::MacImplItem(_) => {
|
||||
MacroItem(Macro {
|
||||
source: self.span.to_src(cx),
|
||||
imported_from: None,
|
||||
})
|
||||
}
|
||||
};
|
||||
Item {
|
||||
name: Some(self.ident.clean(cx)),
|
||||
|
|
@ -1308,7 +1306,7 @@ impl Clean<Item> for ast::ImplItem {
|
|||
impl<'tcx> Clean<Item> for ty::Method<'tcx> {
|
||||
fn clean(&self, cx: &DocContext) -> Item {
|
||||
let (self_, sig) = match self.explicit_self {
|
||||
ty::StaticExplicitSelfCategory => (ast::SelfStatic.clean(cx),
|
||||
ty::StaticExplicitSelfCategory => (hir::SelfStatic.clean(cx),
|
||||
self.fty.sig.clone()),
|
||||
s => {
|
||||
let sig = ty::Binder(ty::FnSig {
|
||||
|
|
@ -1354,7 +1352,7 @@ impl<'tcx> Clean<Item> for ty::Method<'tcx> {
|
|||
abi: self.fty.abi,
|
||||
|
||||
// trait methods canot (currently, at least) be const
|
||||
constness: ast::Constness::NotConst,
|
||||
constness: hir::Constness::NotConst,
|
||||
})
|
||||
} else {
|
||||
TyMethodItem(TyMethod {
|
||||
|
|
@ -1368,7 +1366,7 @@ impl<'tcx> Clean<Item> for ty::Method<'tcx> {
|
|||
|
||||
Item {
|
||||
name: Some(self.name.clean(cx)),
|
||||
visibility: Some(ast::Inherited),
|
||||
visibility: Some(hir::Inherited),
|
||||
stability: get_stability(cx, self.def_id),
|
||||
def_id: self.def_id,
|
||||
attrs: inline::load_attrs(cx, cx.tcx(), self.def_id),
|
||||
|
|
@ -1400,7 +1398,7 @@ pub struct PolyTrait {
|
|||
/// it does not preserve mutability or boxes.
|
||||
#[derive(Clone, RustcEncodable, RustcDecodable, PartialEq, Debug)]
|
||||
pub enum Type {
|
||||
/// structs/enums/traits (most that'd be an ast::TyPath)
|
||||
/// structs/enums/traits (most that'd be an hir::TyPath)
|
||||
ResolvedPath {
|
||||
path: Path,
|
||||
typarams: Option<Vec<TyParamBound>>,
|
||||
|
|
@ -1568,9 +1566,9 @@ impl PrimitiveType {
|
|||
}
|
||||
}
|
||||
|
||||
impl Clean<Type> for ast::Ty {
|
||||
impl Clean<Type> for hir::Ty {
|
||||
fn clean(&self, cx: &DocContext) -> Type {
|
||||
use syntax::ast::*;
|
||||
use rustc_front::hir::*;
|
||||
match self.node {
|
||||
TyPtr(ref m) => RawPointer(m.mutbl.clean(cx), box m.ty.clean(cx)),
|
||||
TyRptr(ref l, ref m) =>
|
||||
|
|
@ -1619,9 +1617,6 @@ impl Clean<Type> for ast::Ty {
|
|||
TyTypeof(..) => {
|
||||
panic!("Unimplemented type {:?}", self.node)
|
||||
},
|
||||
TyMac(ref m) => {
|
||||
cx.tcx().sess.span_bug(m.span, "unexpanded type macro found during cleaning")
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -1631,18 +1626,18 @@ impl<'tcx> Clean<Type> for ty::Ty<'tcx> {
|
|||
match self.sty {
|
||||
ty::TyBool => Primitive(Bool),
|
||||
ty::TyChar => Primitive(Char),
|
||||
ty::TyInt(ast::TyIs) => Primitive(Isize),
|
||||
ty::TyInt(ast::TyI8) => Primitive(I8),
|
||||
ty::TyInt(ast::TyI16) => Primitive(I16),
|
||||
ty::TyInt(ast::TyI32) => Primitive(I32),
|
||||
ty::TyInt(ast::TyI64) => Primitive(I64),
|
||||
ty::TyUint(ast::TyUs) => Primitive(Usize),
|
||||
ty::TyUint(ast::TyU8) => Primitive(U8),
|
||||
ty::TyUint(ast::TyU16) => Primitive(U16),
|
||||
ty::TyUint(ast::TyU32) => Primitive(U32),
|
||||
ty::TyUint(ast::TyU64) => Primitive(U64),
|
||||
ty::TyFloat(ast::TyF32) => Primitive(F32),
|
||||
ty::TyFloat(ast::TyF64) => Primitive(F64),
|
||||
ty::TyInt(hir::TyIs) => Primitive(Isize),
|
||||
ty::TyInt(hir::TyI8) => Primitive(I8),
|
||||
ty::TyInt(hir::TyI16) => Primitive(I16),
|
||||
ty::TyInt(hir::TyI32) => Primitive(I32),
|
||||
ty::TyInt(hir::TyI64) => Primitive(I64),
|
||||
ty::TyUint(hir::TyUs) => Primitive(Usize),
|
||||
ty::TyUint(hir::TyU8) => Primitive(U8),
|
||||
ty::TyUint(hir::TyU16) => Primitive(U16),
|
||||
ty::TyUint(hir::TyU32) => Primitive(U32),
|
||||
ty::TyUint(hir::TyU64) => Primitive(U64),
|
||||
ty::TyFloat(hir::TyF32) => Primitive(F32),
|
||||
ty::TyFloat(hir::TyF64) => Primitive(F64),
|
||||
ty::TyStr => Primitive(Str),
|
||||
ty::TyBox(t) => {
|
||||
let box_did = cx.tcx_opt().and_then(|tcx| {
|
||||
|
|
@ -1723,11 +1718,11 @@ pub enum StructField {
|
|||
TypedStructField(Type),
|
||||
}
|
||||
|
||||
impl Clean<Item> for ast::StructField {
|
||||
impl Clean<Item> for hir::StructField {
|
||||
fn clean(&self, cx: &DocContext) -> Item {
|
||||
let (name, vis) = match self.node.kind {
|
||||
ast::NamedField(id, vis) => (Some(id), vis),
|
||||
ast::UnnamedField(vis) => (None, vis)
|
||||
hir::NamedField(id, vis) => (Some(id), vis),
|
||||
hir::UnnamedField(vis) => (None, vis)
|
||||
};
|
||||
Item {
|
||||
name: name.clean(cx),
|
||||
|
|
@ -1766,9 +1761,9 @@ impl<'tcx> Clean<Item> for ty::FieldDefData<'tcx, 'static> {
|
|||
}
|
||||
}
|
||||
|
||||
pub type Visibility = ast::Visibility;
|
||||
pub type Visibility = hir::Visibility;
|
||||
|
||||
impl Clean<Option<Visibility>> for ast::Visibility {
|
||||
impl Clean<Option<Visibility>> for hir::Visibility {
|
||||
fn clean(&self, _: &DocContext) -> Option<Visibility> {
|
||||
Some(*self)
|
||||
}
|
||||
|
|
@ -1811,7 +1806,7 @@ pub struct VariantStruct {
|
|||
pub fields_stripped: bool,
|
||||
}
|
||||
|
||||
impl Clean<VariantStruct> for syntax::ast::StructDef {
|
||||
impl Clean<VariantStruct> for ::rustc_front::hir::StructDef {
|
||||
fn clean(&self, cx: &DocContext) -> VariantStruct {
|
||||
VariantStruct {
|
||||
struct_type: doctree::struct_type_from_def(self),
|
||||
|
|
@ -1886,7 +1881,7 @@ impl<'tcx> Clean<Item> for ty::VariantDefData<'tcx, 'static> {
|
|||
source: Span::empty(),
|
||||
name: Some(field.name.clean(cx)),
|
||||
attrs: Vec::new(),
|
||||
visibility: Some(ast::Public),
|
||||
visibility: Some(hir::Public),
|
||||
// FIXME: this is not accurate, we need an id for
|
||||
// the specific field but we're using the id
|
||||
// for the whole variant. Thus we read the
|
||||
|
|
@ -1908,7 +1903,7 @@ impl<'tcx> Clean<Item> for ty::VariantDefData<'tcx, 'static> {
|
|||
name: Some(self.name.clean(cx)),
|
||||
attrs: inline::load_attrs(cx, cx.tcx(), self.did),
|
||||
source: Span::empty(),
|
||||
visibility: Some(ast::Public),
|
||||
visibility: Some(hir::Public),
|
||||
def_id: self.did,
|
||||
inner: VariantItem(Variant { kind: kind }),
|
||||
stability: get_stability(cx, self.did),
|
||||
|
|
@ -1923,17 +1918,17 @@ pub enum VariantKind {
|
|||
StructVariant(VariantStruct),
|
||||
}
|
||||
|
||||
impl Clean<VariantKind> for ast::VariantKind {
|
||||
impl Clean<VariantKind> for hir::VariantKind {
|
||||
fn clean(&self, cx: &DocContext) -> VariantKind {
|
||||
match self {
|
||||
&ast::TupleVariantKind(ref args) => {
|
||||
&hir::TupleVariantKind(ref args) => {
|
||||
if args.is_empty() {
|
||||
CLikeVariant
|
||||
} else {
|
||||
TupleVariant(args.iter().map(|x| x.ty.clean(cx)).collect())
|
||||
}
|
||||
},
|
||||
&ast::StructVariantKind(ref sd) => StructVariant(sd.clean(cx)),
|
||||
&hir::StructVariantKind(ref sd) => StructVariant(sd.clean(cx)),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -1999,7 +1994,7 @@ impl Path {
|
|||
}
|
||||
}
|
||||
|
||||
impl Clean<Path> for ast::Path {
|
||||
impl Clean<Path> for hir::Path {
|
||||
fn clean(&self, cx: &DocContext) -> Path {
|
||||
Path {
|
||||
global: self.global,
|
||||
|
|
@ -2021,10 +2016,10 @@ pub enum PathParameters {
|
|||
}
|
||||
}
|
||||
|
||||
impl Clean<PathParameters> for ast::PathParameters {
|
||||
impl Clean<PathParameters> for hir::PathParameters {
|
||||
fn clean(&self, cx: &DocContext) -> PathParameters {
|
||||
match *self {
|
||||
ast::AngleBracketedParameters(ref data) => {
|
||||
hir::AngleBracketedParameters(ref data) => {
|
||||
PathParameters::AngleBracketed {
|
||||
lifetimes: data.lifetimes.clean(cx),
|
||||
types: data.types.clean(cx),
|
||||
|
|
@ -2032,7 +2027,7 @@ impl Clean<PathParameters> for ast::PathParameters {
|
|||
}
|
||||
}
|
||||
|
||||
ast::ParenthesizedParameters(ref data) => {
|
||||
hir::ParenthesizedParameters(ref data) => {
|
||||
PathParameters::Parenthesized {
|
||||
inputs: data.inputs.clean(cx),
|
||||
output: data.output.clean(cx)
|
||||
|
|
@ -2048,7 +2043,7 @@ pub struct PathSegment {
|
|||
pub params: PathParameters
|
||||
}
|
||||
|
||||
impl Clean<PathSegment> for ast::PathSegment {
|
||||
impl Clean<PathSegment> for hir::PathSegment {
|
||||
fn clean(&self, cx: &DocContext) -> PathSegment {
|
||||
PathSegment {
|
||||
name: self.identifier.clean(cx),
|
||||
|
|
@ -2057,7 +2052,7 @@ impl Clean<PathSegment> for ast::PathSegment {
|
|||
}
|
||||
}
|
||||
|
||||
fn path_to_string(p: &ast::Path) -> String {
|
||||
fn path_to_string(p: &hir::Path) -> String {
|
||||
let mut s = String::new();
|
||||
let mut first = true;
|
||||
for i in p.segments.iter().map(|x| x.identifier.name.as_str()) {
|
||||
|
|
@ -2108,13 +2103,13 @@ impl Clean<Item> for doctree::Typedef {
|
|||
|
||||
#[derive(Clone, RustcEncodable, RustcDecodable, PartialEq, Debug)]
|
||||
pub struct BareFunctionDecl {
|
||||
pub unsafety: ast::Unsafety,
|
||||
pub unsafety: hir::Unsafety,
|
||||
pub generics: Generics,
|
||||
pub decl: FnDecl,
|
||||
pub abi: String,
|
||||
}
|
||||
|
||||
impl Clean<BareFunctionDecl> for ast::BareFnTy {
|
||||
impl Clean<BareFunctionDecl> for hir::BareFnTy {
|
||||
fn clean(&self, cx: &DocContext) -> BareFunctionDecl {
|
||||
BareFunctionDecl {
|
||||
unsafety: self.unsafety,
|
||||
|
|
@ -2187,11 +2182,11 @@ pub enum Mutability {
|
|||
Immutable,
|
||||
}
|
||||
|
||||
impl Clean<Mutability> for ast::Mutability {
|
||||
impl Clean<Mutability> for hir::Mutability {
|
||||
fn clean(&self, _: &DocContext) -> Mutability {
|
||||
match self {
|
||||
&ast::MutMutable => Mutable,
|
||||
&ast::MutImmutable => Immutable,
|
||||
&hir::MutMutable => Mutable,
|
||||
&hir::MutImmutable => Immutable,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -2202,18 +2197,18 @@ pub enum ImplPolarity {
|
|||
Negative,
|
||||
}
|
||||
|
||||
impl Clean<ImplPolarity> for ast::ImplPolarity {
|
||||
impl Clean<ImplPolarity> for hir::ImplPolarity {
|
||||
fn clean(&self, _: &DocContext) -> ImplPolarity {
|
||||
match self {
|
||||
&ast::ImplPolarity::Positive => ImplPolarity::Positive,
|
||||
&ast::ImplPolarity::Negative => ImplPolarity::Negative,
|
||||
&hir::ImplPolarity::Positive => ImplPolarity::Positive,
|
||||
&hir::ImplPolarity::Negative => ImplPolarity::Negative,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, RustcEncodable, RustcDecodable, Debug)]
|
||||
pub struct Impl {
|
||||
pub unsafety: ast::Unsafety,
|
||||
pub unsafety: hir::Unsafety,
|
||||
pub generics: Generics,
|
||||
pub trait_: Option<Type>,
|
||||
pub for_: Type,
|
||||
|
|
@ -2316,7 +2311,7 @@ fn build_deref_target_impls(cx: &DocContext,
|
|||
|
||||
#[derive(Clone, RustcEncodable, RustcDecodable, Debug)]
|
||||
pub struct DefaultImpl {
|
||||
pub unsafety: ast::Unsafety,
|
||||
pub unsafety: hir::Unsafety,
|
||||
pub trait_: Type,
|
||||
}
|
||||
|
||||
|
|
@ -2327,7 +2322,7 @@ impl Clean<Item> for doctree::DefaultImpl {
|
|||
attrs: self.attrs.clean(cx),
|
||||
source: self.whence.clean(cx),
|
||||
def_id: DefId::local(self.id),
|
||||
visibility: Some(ast::Public),
|
||||
visibility: Some(hir::Public),
|
||||
stability: None,
|
||||
inner: DefaultImplItem(DefaultImpl {
|
||||
unsafety: self.unsafety,
|
||||
|
|
@ -2356,17 +2351,17 @@ impl Clean<Vec<Item>> for doctree::Import {
|
|||
// We consider inlining the documentation of `pub use` statements, but we
|
||||
// forcefully don't inline if this is not public or if the
|
||||
// #[doc(no_inline)] attribute is present.
|
||||
let denied = self.vis != ast::Public || self.attrs.iter().any(|a| {
|
||||
let denied = self.vis != hir::Public || self.attrs.iter().any(|a| {
|
||||
&a.name()[..] == "doc" && match a.meta_item_list() {
|
||||
Some(l) => attr::contains_name(l, "no_inline"),
|
||||
None => false,
|
||||
}
|
||||
});
|
||||
let (mut ret, inner) = match self.node {
|
||||
ast::ViewPathGlob(ref p) => {
|
||||
hir::ViewPathGlob(ref p) => {
|
||||
(vec![], GlobImport(resolve_use_source(cx, p.clean(cx), self.id)))
|
||||
}
|
||||
ast::ViewPathList(ref p, ref list) => {
|
||||
hir::ViewPathList(ref p, ref list) => {
|
||||
// Attempt to inline all reexported items, but be sure
|
||||
// to keep any non-inlineable reexports so they can be
|
||||
// listed in the documentation.
|
||||
|
|
@ -2393,7 +2388,7 @@ impl Clean<Vec<Item>> for doctree::Import {
|
|||
(ret, ImportList(resolve_use_source(cx, p.clean(cx), self.id),
|
||||
remaining))
|
||||
}
|
||||
ast::ViewPathSimple(i, ref p) => {
|
||||
hir::ViewPathSimple(i, ref p) => {
|
||||
if !denied {
|
||||
match inline::try_inline(cx, self.id, Some(i)) {
|
||||
Some(items) => return items,
|
||||
|
|
@ -2440,15 +2435,15 @@ pub struct ViewListIdent {
|
|||
pub source: Option<DefId>,
|
||||
}
|
||||
|
||||
impl Clean<ViewListIdent> for ast::PathListItem {
|
||||
impl Clean<ViewListIdent> for hir::PathListItem {
|
||||
fn clean(&self, cx: &DocContext) -> ViewListIdent {
|
||||
match self.node {
|
||||
ast::PathListIdent { id, name, rename } => ViewListIdent {
|
||||
hir::PathListIdent { id, name, rename } => ViewListIdent {
|
||||
name: name.clean(cx),
|
||||
rename: rename.map(|r| r.clean(cx)),
|
||||
source: resolve_def(cx, id)
|
||||
},
|
||||
ast::PathListMod { id, rename } => ViewListIdent {
|
||||
hir::PathListMod { id, rename } => ViewListIdent {
|
||||
name: "self".to_string(),
|
||||
rename: rename.map(|r| r.clean(cx)),
|
||||
source: resolve_def(cx, id)
|
||||
|
|
@ -2457,7 +2452,7 @@ impl Clean<ViewListIdent> for ast::PathListItem {
|
|||
}
|
||||
}
|
||||
|
||||
impl Clean<Vec<Item>> for ast::ForeignMod {
|
||||
impl Clean<Vec<Item>> for hir::ForeignMod {
|
||||
fn clean(&self, cx: &DocContext) -> Vec<Item> {
|
||||
let mut items = self.items.clean(cx);
|
||||
for item in &mut items {
|
||||
|
|
@ -2470,19 +2465,19 @@ impl Clean<Vec<Item>> for ast::ForeignMod {
|
|||
}
|
||||
}
|
||||
|
||||
impl Clean<Item> for ast::ForeignItem {
|
||||
impl Clean<Item> for hir::ForeignItem {
|
||||
fn clean(&self, cx: &DocContext) -> Item {
|
||||
let inner = match self.node {
|
||||
ast::ForeignItemFn(ref decl, ref generics) => {
|
||||
hir::ForeignItemFn(ref decl, ref generics) => {
|
||||
ForeignFunctionItem(Function {
|
||||
decl: decl.clean(cx),
|
||||
generics: generics.clean(cx),
|
||||
unsafety: ast::Unsafety::Unsafe,
|
||||
unsafety: hir::Unsafety::Unsafe,
|
||||
abi: abi::Rust,
|
||||
constness: ast::Constness::NotConst,
|
||||
constness: hir::Constness::NotConst,
|
||||
})
|
||||
}
|
||||
ast::ForeignItemStatic(ref ty, mutbl) => {
|
||||
hir::ForeignItemStatic(ref ty, mutbl) => {
|
||||
ForeignStaticItem(Static {
|
||||
type_: ty.clean(cx),
|
||||
mutability: if mutbl {Mutable} else {Immutable},
|
||||
|
|
@ -2520,11 +2515,11 @@ impl ToSource for syntax::codemap::Span {
|
|||
}
|
||||
}
|
||||
|
||||
fn lit_to_string(lit: &ast::Lit) -> String {
|
||||
fn lit_to_string(lit: &hir::Lit) -> String {
|
||||
match lit.node {
|
||||
ast::LitStr(ref st, _) => st.to_string(),
|
||||
ast::LitBinary(ref data) => format!("{:?}", data),
|
||||
ast::LitByte(b) => {
|
||||
hir::LitStr(ref st, _) => st.to_string(),
|
||||
hir::LitBinary(ref data) => format!("{:?}", data),
|
||||
hir::LitByte(b) => {
|
||||
let mut res = String::from("b'");
|
||||
for c in (b as char).escape_default() {
|
||||
res.push(c);
|
||||
|
|
@ -2532,16 +2527,16 @@ fn lit_to_string(lit: &ast::Lit) -> String {
|
|||
res.push('\'');
|
||||
res
|
||||
},
|
||||
ast::LitChar(c) => format!("'{}'", c),
|
||||
ast::LitInt(i, _t) => i.to_string(),
|
||||
ast::LitFloat(ref f, _t) => f.to_string(),
|
||||
ast::LitFloatUnsuffixed(ref f) => f.to_string(),
|
||||
ast::LitBool(b) => b.to_string(),
|
||||
hir::LitChar(c) => format!("'{}'", c),
|
||||
hir::LitInt(i, _t) => i.to_string(),
|
||||
hir::LitFloat(ref f, _t) => f.to_string(),
|
||||
hir::LitFloatUnsuffixed(ref f) => f.to_string(),
|
||||
hir::LitBool(b) => b.to_string(),
|
||||
}
|
||||
}
|
||||
|
||||
fn name_from_pat(p: &ast::Pat) -> String {
|
||||
use syntax::ast::*;
|
||||
fn name_from_pat(p: &hir::Pat) -> String {
|
||||
use rustc_front::hir::*;
|
||||
debug!("Trying to get a name from pattern: {:?}", p);
|
||||
|
||||
match p.node {
|
||||
|
|
@ -2576,11 +2571,6 @@ fn name_from_pat(p: &ast::Pat) -> String {
|
|||
let end = end.iter().map(|p| name_from_pat(&**p));
|
||||
format!("[{}]", begin.chain(mid).chain(end).collect::<Vec<_>>().join(", "))
|
||||
},
|
||||
PatMac(..) => {
|
||||
warn!("can't document the name of a function argument \
|
||||
produced by a pattern macro");
|
||||
"(argument produced by macro)".to_string()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -2601,21 +2591,21 @@ fn resolve_type(cx: &DocContext,
|
|||
|
||||
let is_generic = match def {
|
||||
def::DefPrimTy(p) => match p {
|
||||
ast::TyStr => return Primitive(Str),
|
||||
ast::TyBool => return Primitive(Bool),
|
||||
ast::TyChar => return Primitive(Char),
|
||||
ast::TyInt(ast::TyIs) => return Primitive(Isize),
|
||||
ast::TyInt(ast::TyI8) => return Primitive(I8),
|
||||
ast::TyInt(ast::TyI16) => return Primitive(I16),
|
||||
ast::TyInt(ast::TyI32) => return Primitive(I32),
|
||||
ast::TyInt(ast::TyI64) => return Primitive(I64),
|
||||
ast::TyUint(ast::TyUs) => return Primitive(Usize),
|
||||
ast::TyUint(ast::TyU8) => return Primitive(U8),
|
||||
ast::TyUint(ast::TyU16) => return Primitive(U16),
|
||||
ast::TyUint(ast::TyU32) => return Primitive(U32),
|
||||
ast::TyUint(ast::TyU64) => return Primitive(U64),
|
||||
ast::TyFloat(ast::TyF32) => return Primitive(F32),
|
||||
ast::TyFloat(ast::TyF64) => return Primitive(F64),
|
||||
hir::TyStr => return Primitive(Str),
|
||||
hir::TyBool => return Primitive(Bool),
|
||||
hir::TyChar => return Primitive(Char),
|
||||
hir::TyInt(hir::TyIs) => return Primitive(Isize),
|
||||
hir::TyInt(hir::TyI8) => return Primitive(I8),
|
||||
hir::TyInt(hir::TyI16) => return Primitive(I16),
|
||||
hir::TyInt(hir::TyI32) => return Primitive(I32),
|
||||
hir::TyInt(hir::TyI64) => return Primitive(I64),
|
||||
hir::TyUint(hir::TyUs) => return Primitive(Usize),
|
||||
hir::TyUint(hir::TyU8) => return Primitive(U8),
|
||||
hir::TyUint(hir::TyU16) => return Primitive(U16),
|
||||
hir::TyUint(hir::TyU32) => return Primitive(U32),
|
||||
hir::TyUint(hir::TyU64) => return Primitive(U64),
|
||||
hir::TyFloat(hir::TyF32) => return Primitive(F32),
|
||||
hir::TyFloat(hir::TyF64) => return Primitive(F64),
|
||||
},
|
||||
def::DefSelfTy(..) if path.segments.len() == 1 => {
|
||||
return Generic(special_idents::type_self.name.to_string());
|
||||
|
|
@ -2677,7 +2667,7 @@ impl Clean<Item> for doctree::Macro {
|
|||
name: Some(format!("{}!", self.name.clean(cx))),
|
||||
attrs: self.attrs.clean(cx),
|
||||
source: self.whence.clean(cx),
|
||||
visibility: ast::Public.clean(cx),
|
||||
visibility: hir::Public.clean(cx),
|
||||
stability: self.stab.clean(cx),
|
||||
def_id: DefId::local(self.id),
|
||||
inner: MacroItem(Macro {
|
||||
|
|
@ -2849,7 +2839,7 @@ pub struct TypeBinding {
|
|||
pub ty: Type
|
||||
}
|
||||
|
||||
impl Clean<TypeBinding> for ast::TypeBinding {
|
||||
impl Clean<TypeBinding> for hir::TypeBinding {
|
||||
fn clean(&self, cx: &DocContext) -> TypeBinding {
|
||||
TypeBinding {
|
||||
name: self.ident.clean(cx),
|
||||
|
|
|
|||
|
|
@ -14,10 +14,12 @@ use rustc_driver::{driver, target_features};
|
|||
use rustc::session::{self, config};
|
||||
use rustc::middle::def_id::DefId;
|
||||
use rustc::middle::{privacy, ty};
|
||||
use rustc::ast_map;
|
||||
use rustc::front::map as hir_map;
|
||||
use rustc::lint;
|
||||
use rustc_trans::back::link;
|
||||
use rustc_resolve as resolve;
|
||||
use rustc_front::lowering::lower_crate;
|
||||
use rustc_front::hir;
|
||||
|
||||
use syntax::{ast, codemap, diagnostic};
|
||||
use syntax::feature_gate::UnstableFeatures;
|
||||
|
|
@ -42,7 +44,7 @@ pub type ExternalPaths = RefCell<Option<HashMap<DefId,
|
|||
(Vec<String>, clean::TypeKind)>>>;
|
||||
|
||||
pub struct DocContext<'a, 'tcx: 'a> {
|
||||
pub krate: &'tcx ast::Crate,
|
||||
pub krate: &'tcx hir::Crate,
|
||||
pub maybe_typed: MaybeTyped<'a, 'tcx>,
|
||||
pub input: Input,
|
||||
pub external_paths: ExternalPaths,
|
||||
|
|
@ -131,12 +133,15 @@ pub fn run_core(search_paths: SearchPaths, cfgs: Vec<String>, externs: Externs,
|
|||
let krate = driver::phase_2_configure_and_expand(&sess, krate, &name, None)
|
||||
.expect("phase_2_configure_and_expand aborted in rustdoc!");
|
||||
|
||||
let mut forest = ast_map::Forest::new(krate);
|
||||
let krate = driver::assign_node_ids(&sess, krate);
|
||||
// Lower ast -> hir.
|
||||
let mut hir_forest = hir_map::Forest::new(lower_crate(&krate));
|
||||
let arenas = ty::CtxtArenas::new();
|
||||
let ast_map = driver::assign_node_ids_and_map(&sess, &mut forest);
|
||||
let hir_map = driver::make_map(&sess, &mut hir_forest);
|
||||
|
||||
driver::phase_3_run_analysis_passes(sess,
|
||||
ast_map,
|
||||
hir_map,
|
||||
&krate,
|
||||
&arenas,
|
||||
name,
|
||||
resolve::MakeGlobMap::No,
|
||||
|
|
|
|||
|
|
@ -17,13 +17,14 @@ use syntax;
|
|||
use syntax::codemap::Span;
|
||||
use syntax::abi;
|
||||
use syntax::ast;
|
||||
use syntax::attr;
|
||||
use syntax::ast::{Ident, NodeId};
|
||||
use syntax::ptr::P;
|
||||
use rustc_front::hir;
|
||||
use rustc_front::attr;
|
||||
|
||||
pub struct Module {
|
||||
pub name: Option<Ident>,
|
||||
pub attrs: Vec<ast::Attribute>,
|
||||
pub attrs: Vec<hir::Attribute>,
|
||||
pub where_outer: Span,
|
||||
pub where_inner: Span,
|
||||
pub extern_crates: Vec<ExternCrate>,
|
||||
|
|
@ -37,11 +38,11 @@ pub struct Module {
|
|||
pub statics: Vec<Static>,
|
||||
pub constants: Vec<Constant>,
|
||||
pub traits: Vec<Trait>,
|
||||
pub vis: ast::Visibility,
|
||||
pub vis: hir::Visibility,
|
||||
pub stab: Option<attr::Stability>,
|
||||
pub impls: Vec<Impl>,
|
||||
pub def_traits: Vec<DefaultImpl>,
|
||||
pub foreigns: Vec<ast::ForeignMod>,
|
||||
pub foreigns: Vec<hir::ForeignMod>,
|
||||
pub macros: Vec<Macro>,
|
||||
pub is_crate: bool,
|
||||
}
|
||||
|
|
@ -51,7 +52,7 @@ impl Module {
|
|||
Module {
|
||||
name : name,
|
||||
id: 0,
|
||||
vis: ast::Inherited,
|
||||
vis: hir::Inherited,
|
||||
stab: None,
|
||||
where_outer: syntax::codemap::DUMMY_SP,
|
||||
where_inner: syntax::codemap::DUMMY_SP,
|
||||
|
|
@ -89,27 +90,27 @@ pub enum StructType {
|
|||
|
||||
pub enum TypeBound {
|
||||
RegionBound,
|
||||
TraitBound(ast::TraitRef)
|
||||
TraitBound(hir::TraitRef)
|
||||
}
|
||||
|
||||
pub struct Struct {
|
||||
pub vis: ast::Visibility,
|
||||
pub vis: hir::Visibility,
|
||||
pub stab: Option<attr::Stability>,
|
||||
pub id: NodeId,
|
||||
pub struct_type: StructType,
|
||||
pub name: Ident,
|
||||
pub generics: ast::Generics,
|
||||
pub attrs: Vec<ast::Attribute>,
|
||||
pub fields: Vec<ast::StructField>,
|
||||
pub generics: hir::Generics,
|
||||
pub attrs: Vec<hir::Attribute>,
|
||||
pub fields: Vec<hir::StructField>,
|
||||
pub whence: Span,
|
||||
}
|
||||
|
||||
pub struct Enum {
|
||||
pub vis: ast::Visibility,
|
||||
pub vis: hir::Visibility,
|
||||
pub stab: Option<attr::Stability>,
|
||||
pub variants: Vec<Variant>,
|
||||
pub generics: ast::Generics,
|
||||
pub attrs: Vec<ast::Attribute>,
|
||||
pub generics: hir::Generics,
|
||||
pub attrs: Vec<hir::Attribute>,
|
||||
pub id: NodeId,
|
||||
pub whence: Span,
|
||||
pub name: Ident,
|
||||
|
|
@ -117,102 +118,102 @@ pub struct Enum {
|
|||
|
||||
pub struct Variant {
|
||||
pub name: Ident,
|
||||
pub attrs: Vec<ast::Attribute>,
|
||||
pub kind: ast::VariantKind,
|
||||
pub attrs: Vec<hir::Attribute>,
|
||||
pub kind: hir::VariantKind,
|
||||
pub id: ast::NodeId,
|
||||
pub vis: ast::Visibility,
|
||||
pub vis: hir::Visibility,
|
||||
pub stab: Option<attr::Stability>,
|
||||
pub whence: Span,
|
||||
}
|
||||
|
||||
pub struct Function {
|
||||
pub decl: ast::FnDecl,
|
||||
pub attrs: Vec<ast::Attribute>,
|
||||
pub decl: hir::FnDecl,
|
||||
pub attrs: Vec<hir::Attribute>,
|
||||
pub id: NodeId,
|
||||
pub name: Ident,
|
||||
pub vis: ast::Visibility,
|
||||
pub vis: hir::Visibility,
|
||||
pub stab: Option<attr::Stability>,
|
||||
pub unsafety: ast::Unsafety,
|
||||
pub constness: ast::Constness,
|
||||
pub unsafety: hir::Unsafety,
|
||||
pub constness: hir::Constness,
|
||||
pub whence: Span,
|
||||
pub generics: ast::Generics,
|
||||
pub generics: hir::Generics,
|
||||
pub abi: abi::Abi,
|
||||
}
|
||||
|
||||
pub struct Typedef {
|
||||
pub ty: P<ast::Ty>,
|
||||
pub gen: ast::Generics,
|
||||
pub ty: P<hir::Ty>,
|
||||
pub gen: hir::Generics,
|
||||
pub name: Ident,
|
||||
pub id: ast::NodeId,
|
||||
pub attrs: Vec<ast::Attribute>,
|
||||
pub attrs: Vec<hir::Attribute>,
|
||||
pub whence: Span,
|
||||
pub vis: ast::Visibility,
|
||||
pub vis: hir::Visibility,
|
||||
pub stab: Option<attr::Stability>,
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
pub struct Static {
|
||||
pub type_: P<ast::Ty>,
|
||||
pub mutability: ast::Mutability,
|
||||
pub expr: P<ast::Expr>,
|
||||
pub type_: P<hir::Ty>,
|
||||
pub mutability: hir::Mutability,
|
||||
pub expr: P<hir::Expr>,
|
||||
pub name: Ident,
|
||||
pub attrs: Vec<ast::Attribute>,
|
||||
pub vis: ast::Visibility,
|
||||
pub attrs: Vec<hir::Attribute>,
|
||||
pub vis: hir::Visibility,
|
||||
pub stab: Option<attr::Stability>,
|
||||
pub id: ast::NodeId,
|
||||
pub whence: Span,
|
||||
}
|
||||
|
||||
pub struct Constant {
|
||||
pub type_: P<ast::Ty>,
|
||||
pub expr: P<ast::Expr>,
|
||||
pub type_: P<hir::Ty>,
|
||||
pub expr: P<hir::Expr>,
|
||||
pub name: Ident,
|
||||
pub attrs: Vec<ast::Attribute>,
|
||||
pub vis: ast::Visibility,
|
||||
pub attrs: Vec<hir::Attribute>,
|
||||
pub vis: hir::Visibility,
|
||||
pub stab: Option<attr::Stability>,
|
||||
pub id: ast::NodeId,
|
||||
pub whence: Span,
|
||||
}
|
||||
|
||||
pub struct Trait {
|
||||
pub unsafety: ast::Unsafety,
|
||||
pub unsafety: hir::Unsafety,
|
||||
pub name: Ident,
|
||||
pub items: Vec<P<ast::TraitItem>>, //should be TraitItem
|
||||
pub generics: ast::Generics,
|
||||
pub bounds: Vec<ast::TyParamBound>,
|
||||
pub attrs: Vec<ast::Attribute>,
|
||||
pub items: Vec<P<hir::TraitItem>>, //should be TraitItem
|
||||
pub generics: hir::Generics,
|
||||
pub bounds: Vec<hir::TyParamBound>,
|
||||
pub attrs: Vec<hir::Attribute>,
|
||||
pub id: ast::NodeId,
|
||||
pub whence: Span,
|
||||
pub vis: ast::Visibility,
|
||||
pub vis: hir::Visibility,
|
||||
pub stab: Option<attr::Stability>,
|
||||
}
|
||||
|
||||
pub struct Impl {
|
||||
pub unsafety: ast::Unsafety,
|
||||
pub polarity: ast::ImplPolarity,
|
||||
pub generics: ast::Generics,
|
||||
pub trait_: Option<ast::TraitRef>,
|
||||
pub for_: P<ast::Ty>,
|
||||
pub items: Vec<P<ast::ImplItem>>,
|
||||
pub attrs: Vec<ast::Attribute>,
|
||||
pub unsafety: hir::Unsafety,
|
||||
pub polarity: hir::ImplPolarity,
|
||||
pub generics: hir::Generics,
|
||||
pub trait_: Option<hir::TraitRef>,
|
||||
pub for_: P<hir::Ty>,
|
||||
pub items: Vec<P<hir::ImplItem>>,
|
||||
pub attrs: Vec<hir::Attribute>,
|
||||
pub whence: Span,
|
||||
pub vis: ast::Visibility,
|
||||
pub vis: hir::Visibility,
|
||||
pub stab: Option<attr::Stability>,
|
||||
pub id: ast::NodeId,
|
||||
}
|
||||
|
||||
pub struct DefaultImpl {
|
||||
pub unsafety: ast::Unsafety,
|
||||
pub trait_: ast::TraitRef,
|
||||
pub unsafety: hir::Unsafety,
|
||||
pub trait_: hir::TraitRef,
|
||||
pub id: ast::NodeId,
|
||||
pub attrs: Vec<ast::Attribute>,
|
||||
pub attrs: Vec<hir::Attribute>,
|
||||
pub whence: Span,
|
||||
}
|
||||
|
||||
pub struct Macro {
|
||||
pub name: Ident,
|
||||
pub id: ast::NodeId,
|
||||
pub attrs: Vec<ast::Attribute>,
|
||||
pub attrs: Vec<hir::Attribute>,
|
||||
pub whence: Span,
|
||||
pub stab: Option<attr::Stability>,
|
||||
pub imported_from: Option<Ident>,
|
||||
|
|
@ -221,20 +222,20 @@ pub struct Macro {
|
|||
pub struct ExternCrate {
|
||||
pub name: Ident,
|
||||
pub path: Option<String>,
|
||||
pub vis: ast::Visibility,
|
||||
pub attrs: Vec<ast::Attribute>,
|
||||
pub vis: hir::Visibility,
|
||||
pub attrs: Vec<hir::Attribute>,
|
||||
pub whence: Span,
|
||||
}
|
||||
|
||||
pub struct Import {
|
||||
pub id: NodeId,
|
||||
pub vis: ast::Visibility,
|
||||
pub attrs: Vec<ast::Attribute>,
|
||||
pub node: ast::ViewPath_,
|
||||
pub vis: hir::Visibility,
|
||||
pub attrs: Vec<hir::Attribute>,
|
||||
pub node: hir::ViewPath_,
|
||||
pub whence: Span,
|
||||
}
|
||||
|
||||
pub fn struct_type_from_def(sd: &ast::StructDef) -> StructType {
|
||||
pub fn struct_type_from_def(sd: &hir::StructDef) -> StructType {
|
||||
if sd.ctor_id.is_some() {
|
||||
// We are in a tuple-struct
|
||||
match sd.fields.len() {
|
||||
|
|
|
|||
|
|
@ -21,6 +21,7 @@ use std::iter::repeat;
|
|||
use rustc::middle::def_id::{DefId, LOCAL_CRATE};
|
||||
use syntax::abi::Abi;
|
||||
use syntax::ast;
|
||||
use rustc_front::hir;
|
||||
|
||||
use clean;
|
||||
use html::item_type::ItemType;
|
||||
|
|
@ -30,15 +31,15 @@ use html::render::{cache, CURRENT_LOCATION_KEY};
|
|||
/// Helper to render an optional visibility with a space after it (if the
|
||||
/// visibility is preset)
|
||||
#[derive(Copy, Clone)]
|
||||
pub struct VisSpace(pub Option<ast::Visibility>);
|
||||
pub struct VisSpace(pub Option<hir::Visibility>);
|
||||
/// Similarly to VisSpace, this structure is used to render a function style with a
|
||||
/// space after it.
|
||||
#[derive(Copy, Clone)]
|
||||
pub struct UnsafetySpace(pub ast::Unsafety);
|
||||
pub struct UnsafetySpace(pub hir::Unsafety);
|
||||
/// Similarly to VisSpace, this structure is used to render a function constness
|
||||
/// with a space after it.
|
||||
#[derive(Copy, Clone)]
|
||||
pub struct ConstnessSpace(pub ast::Constness);
|
||||
pub struct ConstnessSpace(pub hir::Constness);
|
||||
/// Wrapper struct for properly emitting a method declaration.
|
||||
pub struct Method<'a>(pub &'a clean::SelfTy, pub &'a clean::FnDecl);
|
||||
/// Similar to VisSpace, but used for mutability
|
||||
|
|
@ -56,19 +57,19 @@ pub struct CommaSep<'a, T: 'a>(pub &'a [T]);
|
|||
pub struct AbiSpace(pub Abi);
|
||||
|
||||
impl VisSpace {
|
||||
pub fn get(&self) -> Option<ast::Visibility> {
|
||||
pub fn get(&self) -> Option<hir::Visibility> {
|
||||
let VisSpace(v) = *self; v
|
||||
}
|
||||
}
|
||||
|
||||
impl UnsafetySpace {
|
||||
pub fn get(&self) -> ast::Unsafety {
|
||||
pub fn get(&self) -> hir::Unsafety {
|
||||
let UnsafetySpace(v) = *self; v
|
||||
}
|
||||
}
|
||||
|
||||
impl ConstnessSpace {
|
||||
pub fn get(&self) -> ast::Constness {
|
||||
pub fn get(&self) -> hir::Constness {
|
||||
let ConstnessSpace(v) = *self; v
|
||||
}
|
||||
}
|
||||
|
|
@ -201,8 +202,8 @@ impl fmt::Display for clean::TyParamBound {
|
|||
}
|
||||
clean::TraitBound(ref ty, modifier) => {
|
||||
let modifier_str = match modifier {
|
||||
ast::TraitBoundModifier::None => "",
|
||||
ast::TraitBoundModifier::Maybe => "?",
|
||||
hir::TraitBoundModifier::None => "",
|
||||
hir::TraitBoundModifier::Maybe => "?",
|
||||
};
|
||||
write!(f, "{}{}", modifier_str, *ty)
|
||||
}
|
||||
|
|
@ -618,8 +619,8 @@ impl<'a> fmt::Display for Method<'a> {
|
|||
impl fmt::Display for VisSpace {
|
||||
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
||||
match self.get() {
|
||||
Some(ast::Public) => write!(f, "pub "),
|
||||
Some(ast::Inherited) | None => Ok(())
|
||||
Some(hir::Public) => write!(f, "pub "),
|
||||
Some(hir::Inherited) | None => Ok(())
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -627,8 +628,8 @@ impl fmt::Display for VisSpace {
|
|||
impl fmt::Display for UnsafetySpace {
|
||||
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
||||
match self.get() {
|
||||
ast::Unsafety::Unsafe => write!(f, "unsafe "),
|
||||
ast::Unsafety::Normal => Ok(())
|
||||
hir::Unsafety::Unsafe => write!(f, "unsafe "),
|
||||
hir::Unsafety::Normal => Ok(())
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -636,8 +637,8 @@ impl fmt::Display for UnsafetySpace {
|
|||
impl fmt::Display for ConstnessSpace {
|
||||
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
||||
match self.get() {
|
||||
ast::Constness::Const => write!(f, "const "),
|
||||
ast::Constness::NotConst => Ok(())
|
||||
hir::Constness::Const => write!(f, "const "),
|
||||
hir::Constness::NotConst => Ok(())
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -52,9 +52,10 @@ use std::sync::Arc;
|
|||
use externalfiles::ExternalHtml;
|
||||
|
||||
use serialize::json::{self, ToJson};
|
||||
use syntax::{abi, ast, attr};
|
||||
use syntax::{abi, ast};
|
||||
use rustc::middle::def_id::{DefId, LOCAL_CRATE};
|
||||
use rustc::util::nodemap::NodeSet;
|
||||
use rustc_front::{hir, attr};
|
||||
|
||||
use clean::{self, SelfTy};
|
||||
use doctree;
|
||||
|
|
@ -858,7 +859,7 @@ impl DocFolder for Cache {
|
|||
let orig_privmod = match item.inner {
|
||||
clean::ModuleItem(..) => {
|
||||
let prev = self.privmod;
|
||||
self.privmod = prev || (self.remove_priv && item.visibility != Some(ast::Public));
|
||||
self.privmod = prev || (self.remove_priv && item.visibility != Some(hir::Public));
|
||||
prev
|
||||
}
|
||||
_ => self.privmod,
|
||||
|
|
@ -1327,10 +1328,10 @@ impl Context {
|
|||
clean::ModuleItem(ref m) => {
|
||||
(m.items.is_empty() &&
|
||||
it.doc_value().is_none() &&
|
||||
it.visibility != Some(ast::Public)) ||
|
||||
(self.passes.contains("strip-private") && it.visibility != Some(ast::Public))
|
||||
it.visibility != Some(hir::Public)) ||
|
||||
(self.passes.contains("strip-private") && it.visibility != Some(hir::Public))
|
||||
}
|
||||
clean::PrimitiveItem(..) => it.visibility != Some(ast::Public),
|
||||
clean::PrimitiveItem(..) => it.visibility != Some(hir::Public),
|
||||
_ => false,
|
||||
}
|
||||
}
|
||||
|
|
@ -1975,8 +1976,8 @@ fn render_assoc_item(w: &mut fmt::Formatter, meth: &clean::Item,
|
|||
link: AssocItemLink) -> fmt::Result {
|
||||
fn method(w: &mut fmt::Formatter,
|
||||
it: &clean::Item,
|
||||
unsafety: ast::Unsafety,
|
||||
constness: ast::Constness,
|
||||
unsafety: hir::Unsafety,
|
||||
constness: hir::Constness,
|
||||
abi: abi::Abi,
|
||||
g: &clean::Generics,
|
||||
selfty: &clean::SelfTy,
|
||||
|
|
@ -2009,7 +2010,7 @@ fn render_assoc_item(w: &mut fmt::Formatter, meth: &clean::Item,
|
|||
}
|
||||
match meth.inner {
|
||||
clean::TyMethodItem(ref m) => {
|
||||
method(w, meth, m.unsafety, ast::Constness::NotConst,
|
||||
method(w, meth, m.unsafety, hir::Constness::NotConst,
|
||||
m.abi, &m.generics, &m.self_, &m.decl, link)
|
||||
}
|
||||
clean::MethodItem(ref m) => {
|
||||
|
|
|
|||
|
|
@ -43,6 +43,7 @@ extern crate rustc_driver;
|
|||
extern crate rustc_resolve;
|
||||
extern crate rustc_lint;
|
||||
extern crate rustc_back;
|
||||
extern crate rustc_front;
|
||||
extern crate serialize;
|
||||
extern crate syntax;
|
||||
extern crate test as testing;
|
||||
|
|
|
|||
|
|
@ -14,6 +14,7 @@ use std::cmp;
|
|||
use std::string::String;
|
||||
use std::usize;
|
||||
use syntax::ast;
|
||||
use rustc_front::hir;
|
||||
|
||||
use clean;
|
||||
use clean::Item;
|
||||
|
|
@ -135,7 +136,7 @@ impl<'a> fold::DocFolder for Stripper<'a> {
|
|||
return None;
|
||||
}
|
||||
// Traits are in exported_items even when they're totally private.
|
||||
if i.is_trait() && i.visibility != Some(ast::Public) {
|
||||
if i.is_trait() && i.visibility != Some(hir::Public) {
|
||||
return None;
|
||||
}
|
||||
}
|
||||
|
|
@ -149,13 +150,13 @@ impl<'a> fold::DocFolder for Stripper<'a> {
|
|||
}
|
||||
|
||||
clean::ExternCrateItem(..) | clean::ImportItem(_) => {
|
||||
if i.visibility != Some(ast::Public) {
|
||||
if i.visibility != Some(hir::Public) {
|
||||
return None
|
||||
}
|
||||
}
|
||||
|
||||
clean::StructFieldItem(..) => {
|
||||
if i.visibility != Some(ast::Public) {
|
||||
if i.visibility != Some(hir::Public) {
|
||||
return Some(clean::Item {
|
||||
inner: clean::StructFieldItem(clean::HiddenStructField),
|
||||
..i
|
||||
|
|
|
|||
|
|
@ -25,6 +25,7 @@ use rustc_lint;
|
|||
use rustc::session::{self, config};
|
||||
use rustc::session::config::get_unstable_features_setting;
|
||||
use rustc::session::search_paths::{SearchPaths, PathKind};
|
||||
use rustc_front::lowering::lower_crate;
|
||||
use rustc_back::tempdir::TempDir;
|
||||
use rustc_driver::{driver, Compilation};
|
||||
use syntax::codemap::CodeMap;
|
||||
|
|
@ -80,6 +81,8 @@ pub fn run(input: &str,
|
|||
let krate = driver::phase_2_configure_and_expand(&sess, krate,
|
||||
"rustdoc-test", None)
|
||||
.expect("phase_2_configure_and_expand aborted in rustdoc!");
|
||||
let krate = driver::assign_node_ids(&sess, krate);
|
||||
let krate = lower_crate(&krate);
|
||||
|
||||
let opts = scrape_test_config(&krate);
|
||||
|
||||
|
|
@ -120,9 +123,9 @@ pub fn run(input: &str,
|
|||
}
|
||||
|
||||
// Look for #![doc(test(no_crate_inject))], used by crates in the std facade
|
||||
fn scrape_test_config(krate: &::syntax::ast::Crate) -> TestOptions {
|
||||
use syntax::attr::AttrMetaMethods;
|
||||
use syntax::print::pprust;
|
||||
fn scrape_test_config(krate: &::rustc_front::hir::Crate) -> TestOptions {
|
||||
use rustc_front::attr::AttrMetaMethods;
|
||||
use rustc_front::print::pprust;
|
||||
|
||||
let mut opts = TestOptions {
|
||||
no_crate_inject: false,
|
||||
|
|
|
|||
|
|
@ -16,14 +16,16 @@ use std::mem;
|
|||
|
||||
use syntax::abi;
|
||||
use syntax::ast;
|
||||
use syntax::attr;
|
||||
use syntax::attr::AttrMetaMethods;
|
||||
use syntax::codemap::Span;
|
||||
|
||||
use rustc::ast_map;
|
||||
use rustc::front::map as hir_map;
|
||||
use rustc::middle::def_id::DefId;
|
||||
use rustc::middle::stability;
|
||||
|
||||
use rustc_front::attr;
|
||||
use rustc_front::attr::AttrMetaMethods;
|
||||
use rustc_front::hir;
|
||||
|
||||
use core;
|
||||
use doctree::*;
|
||||
|
||||
|
|
@ -37,7 +39,7 @@ use doctree::*;
|
|||
|
||||
pub struct RustdocVisitor<'a, 'tcx: 'a> {
|
||||
pub module: Module,
|
||||
pub attrs: Vec<ast::Attribute>,
|
||||
pub attrs: Vec<hir::Attribute>,
|
||||
pub cx: &'a core::DocContext<'a, 'tcx>,
|
||||
pub analysis: Option<&'a core::CrateAnalysis>,
|
||||
view_item_stack: HashSet<ast::NodeId>,
|
||||
|
|
@ -65,12 +67,12 @@ impl<'a, 'tcx> RustdocVisitor<'a, 'tcx> {
|
|||
|tcx| stability::lookup(tcx, DefId::local(id)).map(|x| x.clone()))
|
||||
}
|
||||
|
||||
pub fn visit(&mut self, krate: &ast::Crate) {
|
||||
pub fn visit(&mut self, krate: &hir::Crate) {
|
||||
self.attrs = krate.attrs.clone();
|
||||
|
||||
self.module = self.visit_mod_contents(krate.span,
|
||||
krate.attrs.clone(),
|
||||
ast::Public,
|
||||
hir::Public,
|
||||
ast::CRATE_NODE_ID,
|
||||
&krate.module,
|
||||
None);
|
||||
|
|
@ -80,9 +82,9 @@ impl<'a, 'tcx> RustdocVisitor<'a, 'tcx> {
|
|||
self.module.is_crate = true;
|
||||
}
|
||||
|
||||
pub fn visit_struct_def(&mut self, item: &ast::Item,
|
||||
name: ast::Ident, sd: &ast::StructDef,
|
||||
generics: &ast::Generics) -> Struct {
|
||||
pub fn visit_struct_def(&mut self, item: &hir::Item,
|
||||
name: ast::Ident, sd: &hir::StructDef,
|
||||
generics: &hir::Generics) -> Struct {
|
||||
debug!("Visiting struct");
|
||||
let struct_type = struct_type_from_def(&*sd);
|
||||
Struct {
|
||||
|
|
@ -98,9 +100,9 @@ impl<'a, 'tcx> RustdocVisitor<'a, 'tcx> {
|
|||
}
|
||||
}
|
||||
|
||||
pub fn visit_enum_def(&mut self, it: &ast::Item,
|
||||
name: ast::Ident, def: &ast::EnumDef,
|
||||
params: &ast::Generics) -> Enum {
|
||||
pub fn visit_enum_def(&mut self, it: &hir::Item,
|
||||
name: ast::Ident, def: &hir::EnumDef,
|
||||
params: &hir::Generics) -> Enum {
|
||||
debug!("Visiting enum");
|
||||
Enum {
|
||||
name: name,
|
||||
|
|
@ -122,12 +124,12 @@ impl<'a, 'tcx> RustdocVisitor<'a, 'tcx> {
|
|||
}
|
||||
}
|
||||
|
||||
pub fn visit_fn(&mut self, item: &ast::Item,
|
||||
name: ast::Ident, fd: &ast::FnDecl,
|
||||
unsafety: &ast::Unsafety,
|
||||
constness: ast::Constness,
|
||||
pub fn visit_fn(&mut self, item: &hir::Item,
|
||||
name: ast::Ident, fd: &hir::FnDecl,
|
||||
unsafety: &hir::Unsafety,
|
||||
constness: hir::Constness,
|
||||
abi: &abi::Abi,
|
||||
gen: &ast::Generics) -> Function {
|
||||
gen: &hir::Generics) -> Function {
|
||||
debug!("Visiting fn");
|
||||
Function {
|
||||
id: item.id,
|
||||
|
|
@ -144,9 +146,9 @@ impl<'a, 'tcx> RustdocVisitor<'a, 'tcx> {
|
|||
}
|
||||
}
|
||||
|
||||
pub fn visit_mod_contents(&mut self, span: Span, attrs: Vec<ast::Attribute> ,
|
||||
vis: ast::Visibility, id: ast::NodeId,
|
||||
m: &ast::Mod,
|
||||
pub fn visit_mod_contents(&mut self, span: Span, attrs: Vec<hir::Attribute> ,
|
||||
vis: hir::Visibility, id: ast::NodeId,
|
||||
m: &hir::Mod,
|
||||
name: Option<ast::Ident>) -> Module {
|
||||
let mut om = Module::new(name);
|
||||
om.where_outer = span;
|
||||
|
|
@ -161,37 +163,37 @@ impl<'a, 'tcx> RustdocVisitor<'a, 'tcx> {
|
|||
om
|
||||
}
|
||||
|
||||
fn visit_view_path(&mut self, path: ast::ViewPath_,
|
||||
fn visit_view_path(&mut self, path: hir::ViewPath_,
|
||||
om: &mut Module,
|
||||
id: ast::NodeId,
|
||||
please_inline: bool) -> Option<ast::ViewPath_> {
|
||||
please_inline: bool) -> Option<hir::ViewPath_> {
|
||||
match path {
|
||||
ast::ViewPathSimple(dst, base) => {
|
||||
hir::ViewPathSimple(dst, base) => {
|
||||
if self.resolve_id(id, Some(dst), false, om, please_inline) {
|
||||
None
|
||||
} else {
|
||||
Some(ast::ViewPathSimple(dst, base))
|
||||
Some(hir::ViewPathSimple(dst, base))
|
||||
}
|
||||
}
|
||||
ast::ViewPathList(p, paths) => {
|
||||
hir::ViewPathList(p, paths) => {
|
||||
let mine = paths.into_iter().filter(|path| {
|
||||
!self.resolve_id(path.node.id(), None, false, om,
|
||||
please_inline)
|
||||
}).collect::<Vec<ast::PathListItem>>();
|
||||
}).collect::<Vec<hir::PathListItem>>();
|
||||
|
||||
if mine.is_empty() {
|
||||
None
|
||||
} else {
|
||||
Some(ast::ViewPathList(p, mine))
|
||||
Some(hir::ViewPathList(p, mine))
|
||||
}
|
||||
}
|
||||
|
||||
// these are feature gated anyway
|
||||
ast::ViewPathGlob(base) => {
|
||||
hir::ViewPathGlob(base) => {
|
||||
if self.resolve_id(id, None, true, om, please_inline) {
|
||||
None
|
||||
} else {
|
||||
Some(ast::ViewPathGlob(base))
|
||||
Some(hir::ViewPathGlob(base))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -215,16 +217,16 @@ impl<'a, 'tcx> RustdocVisitor<'a, 'tcx> {
|
|||
if !self.view_item_stack.insert(def.node) { return false }
|
||||
|
||||
let ret = match tcx.map.get(def.node) {
|
||||
ast_map::NodeItem(it) => {
|
||||
hir_map::NodeItem(it) => {
|
||||
if glob {
|
||||
let prev = mem::replace(&mut self.inlining_from_glob, true);
|
||||
match it.node {
|
||||
ast::ItemMod(ref m) => {
|
||||
hir::ItemMod(ref m) => {
|
||||
for i in &m.items {
|
||||
self.visit_item(&**i, None, om);
|
||||
}
|
||||
}
|
||||
ast::ItemEnum(..) => {}
|
||||
hir::ItemEnum(..) => {}
|
||||
_ => { panic!("glob not mapped to a module or enum"); }
|
||||
}
|
||||
self.inlining_from_glob = prev;
|
||||
|
|
@ -239,12 +241,12 @@ impl<'a, 'tcx> RustdocVisitor<'a, 'tcx> {
|
|||
return ret;
|
||||
}
|
||||
|
||||
pub fn visit_item(&mut self, item: &ast::Item,
|
||||
pub fn visit_item(&mut self, item: &hir::Item,
|
||||
renamed: Option<ast::Ident>, om: &mut Module) {
|
||||
debug!("Visiting item {:?}", item);
|
||||
let name = renamed.unwrap_or(item.ident);
|
||||
match item.node {
|
||||
ast::ItemExternCrate(ref p) => {
|
||||
hir::ItemExternCrate(ref p) => {
|
||||
let path = match *p {
|
||||
None => None,
|
||||
Some(x) => Some(x.to_string()),
|
||||
|
|
@ -257,9 +259,9 @@ impl<'a, 'tcx> RustdocVisitor<'a, 'tcx> {
|
|||
whence: item.span,
|
||||
})
|
||||
}
|
||||
ast::ItemUse(ref vpath) => {
|
||||
hir::ItemUse(ref vpath) => {
|
||||
let node = vpath.node.clone();
|
||||
let node = if item.vis == ast::Public {
|
||||
let node = if item.vis == hir::Public {
|
||||
let please_inline = item.attrs.iter().any(|item| {
|
||||
match item.meta_item_list() {
|
||||
Some(list) => {
|
||||
|
|
@ -283,7 +285,7 @@ impl<'a, 'tcx> RustdocVisitor<'a, 'tcx> {
|
|||
whence: item.span,
|
||||
});
|
||||
}
|
||||
ast::ItemMod(ref m) => {
|
||||
hir::ItemMod(ref m) => {
|
||||
om.mods.push(self.visit_mod_contents(item.span,
|
||||
item.attrs.clone(),
|
||||
item.vis,
|
||||
|
|
@ -291,14 +293,14 @@ impl<'a, 'tcx> RustdocVisitor<'a, 'tcx> {
|
|||
m,
|
||||
Some(name)));
|
||||
},
|
||||
ast::ItemEnum(ref ed, ref gen) =>
|
||||
hir::ItemEnum(ref ed, ref gen) =>
|
||||
om.enums.push(self.visit_enum_def(item, name, ed, gen)),
|
||||
ast::ItemStruct(ref sd, ref gen) =>
|
||||
hir::ItemStruct(ref sd, ref gen) =>
|
||||
om.structs.push(self.visit_struct_def(item, name, &**sd, gen)),
|
||||
ast::ItemFn(ref fd, ref unsafety, constness, ref abi, ref gen, _) =>
|
||||
hir::ItemFn(ref fd, ref unsafety, constness, ref abi, ref gen, _) =>
|
||||
om.fns.push(self.visit_fn(item, name, &**fd, unsafety,
|
||||
constness, abi, gen)),
|
||||
ast::ItemTy(ref ty, ref gen) => {
|
||||
hir::ItemTy(ref ty, ref gen) => {
|
||||
let t = Typedef {
|
||||
ty: ty.clone(),
|
||||
gen: gen.clone(),
|
||||
|
|
@ -311,7 +313,7 @@ impl<'a, 'tcx> RustdocVisitor<'a, 'tcx> {
|
|||
};
|
||||
om.typedefs.push(t);
|
||||
},
|
||||
ast::ItemStatic(ref ty, ref mut_, ref exp) => {
|
||||
hir::ItemStatic(ref ty, ref mut_, ref exp) => {
|
||||
let s = Static {
|
||||
type_: ty.clone(),
|
||||
mutability: mut_.clone(),
|
||||
|
|
@ -325,7 +327,7 @@ impl<'a, 'tcx> RustdocVisitor<'a, 'tcx> {
|
|||
};
|
||||
om.statics.push(s);
|
||||
},
|
||||
ast::ItemConst(ref ty, ref exp) => {
|
||||
hir::ItemConst(ref ty, ref exp) => {
|
||||
let s = Constant {
|
||||
type_: ty.clone(),
|
||||
expr: exp.clone(),
|
||||
|
|
@ -338,7 +340,7 @@ impl<'a, 'tcx> RustdocVisitor<'a, 'tcx> {
|
|||
};
|
||||
om.constants.push(s);
|
||||
},
|
||||
ast::ItemTrait(unsafety, ref gen, ref b, ref items) => {
|
||||
hir::ItemTrait(unsafety, ref gen, ref b, ref items) => {
|
||||
let t = Trait {
|
||||
unsafety: unsafety,
|
||||
name: name,
|
||||
|
|
@ -353,7 +355,7 @@ impl<'a, 'tcx> RustdocVisitor<'a, 'tcx> {
|
|||
};
|
||||
om.traits.push(t);
|
||||
},
|
||||
ast::ItemImpl(unsafety, polarity, ref gen, ref tr, ref ty, ref items) => {
|
||||
hir::ItemImpl(unsafety, polarity, ref gen, ref tr, ref ty, ref items) => {
|
||||
let i = Impl {
|
||||
unsafety: unsafety,
|
||||
polarity: polarity,
|
||||
|
|
@ -373,7 +375,7 @@ impl<'a, 'tcx> RustdocVisitor<'a, 'tcx> {
|
|||
om.impls.push(i);
|
||||
}
|
||||
},
|
||||
ast::ItemDefaultImpl(unsafety, ref trait_ref) => {
|
||||
hir::ItemDefaultImpl(unsafety, ref trait_ref) => {
|
||||
let i = DefaultImpl {
|
||||
unsafety: unsafety,
|
||||
trait_: trait_ref.clone(),
|
||||
|
|
@ -386,17 +388,14 @@ impl<'a, 'tcx> RustdocVisitor<'a, 'tcx> {
|
|||
om.def_traits.push(i);
|
||||
}
|
||||
}
|
||||
ast::ItemForeignMod(ref fm) => {
|
||||
hir::ItemForeignMod(ref fm) => {
|
||||
om.foreigns.push(fm.clone());
|
||||
}
|
||||
ast::ItemMac(_) => {
|
||||
panic!("rustdoc: macros should be gone, after expansion");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// convert each exported_macro into a doc item
|
||||
fn visit_macro(&self, def: &ast::MacroDef) -> Macro {
|
||||
fn visit_macro(&self, def: &hir::MacroDef) -> Macro {
|
||||
Macro {
|
||||
id: def.id,
|
||||
attrs: def.attrs.clone(),
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue