user0/rust
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Add an intital HIR and lowering step

Browse source
This commit is contained in:
Nick Cameron 2015-07-31 00:04:06 -07:00
parent cfd76b364c
commit facdf2ebb1
160 changed files with 13917 additions and 4451 deletions
Download patch file Download diff file Expand all files Collapse all files

23
src/librustdoc/clean/inline.rs
View file

@ -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);

312
src/librustdoc/clean/mod.rs
View file

@ -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),