use syntax::ast_util::PostExpansionMethod;
use syntax::attr;
use syntax::attr::{AttributeMethods, AttrMetaMethods};
-use syntax::codemap::Pos;
+use syntax::codemap::{DUMMY_SP, Pos};
use syntax::parse::token::InternedString;
use syntax::parse::token;
+use syntax::ptr::P;
use rustc::back::link;
use rustc::driver::driver;
use std::rc::Rc;
use std::u32;
-use std::gc::{Gc, GC};
use core::DocContext;
use doctree;
}
}
-impl<T: 'static + Clean<U>, U> Clean<U> for Gc<T> {
+impl<T: Clean<U>, U> Clean<U> for P<T> {
fn clean(&self, cx: &DocContext) -> U {
(**self).clean(cx)
}
pub name: String,
pub module: Option<Item>,
pub externs: Vec<(ast::CrateNum, ExternalCrate)>,
- pub primitives: Vec<Primitive>,
+ pub primitives: Vec<PrimitiveType>,
}
impl<'a, 'tcx> Clean<Crate> for visit_ast::RustdocVisitor<'a, 'tcx> {
_ => unreachable!(),
};
let mut tmp = Vec::new();
- for child in m.items.mut_iter() {
+ for child in m.items.iter_mut() {
let inner = match child.inner {
ModuleItem(ref mut m) => m,
_ => continue,
};
- let prim = match Primitive::find(child.attrs.as_slice()) {
+ let prim = match PrimitiveType::find(child.attrs.as_slice()) {
Some(prim) => prim,
None => continue,
};
inner.items.push(i);
}
- m.items.extend(tmp.move_iter());
+ m.items.extend(tmp.into_iter());
}
Crate {
pub struct ExternalCrate {
pub name: String,
pub attrs: Vec<Attribute>,
- pub primitives: Vec<Primitive>,
+ pub primitives: Vec<PrimitiveType>,
}
impl Clean<ExternalCrate> for cstore::crate_metadata {
_ => return
};
let attrs = inline::load_attrs(cx, tcx, did);
- Primitive::find(attrs.as_slice()).map(|prim| primitives.push(prim));
+ PrimitiveType::find(attrs.as_slice()).map(|prim| primitives.push(prim));
})
});
ExternalCrate {
/// `static`s from an extern block
ForeignStaticItem(Static),
MacroItem(Macro),
- PrimitiveItem(Primitive),
+ PrimitiveItem(PrimitiveType),
+ AssociatedTypeItem,
}
#[deriving(Clone, Encodable, Decodable)]
"".to_string()
};
let mut foreigns = Vec::new();
- for subforeigns in self.foreigns.clean(cx).move_iter() {
- for foreign in subforeigns.move_iter() {
+ for subforeigns in self.foreigns.clean(cx).into_iter() {
+ for foreign in subforeigns.into_iter() {
foreigns.push(foreign)
}
}
self.statics.clean(cx),
self.traits.clean(cx),
self.impls.clean(cx),
- self.view_items.clean(cx).move_iter()
- .flat_map(|s| s.move_iter()).collect(),
+ self.view_items.clean(cx).into_iter()
+ .flat_map(|s| s.into_iter()).collect(),
self.macros.clean(cx),
);
impl Clean<Attribute> for ast::Attribute {
fn clean(&self, cx: &DocContext) -> Attribute {
- self.desugar_doc().node.value.clean(cx)
+ self.with_desugared_doc(|a| a.node.value.clean(cx))
}
}
_ => None,
}
}
- fn meta_item_list<'a>(&'a self) -> Option<&'a [
Gc<ast::MetaItem>]> { None }
+ fn meta_item_list<'a>(&'a self) -> Option<&'a [
P<ast::MetaItem>]> { None }
}
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<'a>(&'a self) -> Option<&'a [
Gc<ast::MetaItem>]> { None }
+ fn meta_item_list<'a>(&'a self) -> Option<&'a [
P<ast::MetaItem>]> { None }
}
#[deriving(Clone, Encodable, Decodable, PartialEq)]
external_path(cx, "Sync", &empty)),
};
let fqn = csearch::get_item_path(tcx, did);
- let fqn = fqn.move_iter().map(|i| i.to_string()).collect();
+ let fqn = fqn.into_iter().map(|i| i.to_string()).collect();
cx.external_paths.borrow_mut().as_mut().unwrap().insert(did,
(fqn, TypeTrait));
TraitBound(ResolvedPath {
None => return RegionBound,
};
let fqn = csearch::get_item_path(tcx, self.def_id);
- let fqn = fqn.move_iter().map(|i| i.to_string())
+ let fqn = fqn.into_iter().map(|i| i.to_string())
.collect::<Vec<String>>();
let path = external_path(cx, fqn.last().unwrap().as_slice(),
&self.substs);
match *self {
ast::SelfStatic => SelfStatic,
ast::SelfValue(_) => SelfValue,
- ast::SelfRegion(lt, mt, _) => {
+ ast::SelfRegion(ref lt, ref mt, _) => {
SelfBorrowed(lt.clean(cx), mt.clean(cx))
}
- ast::SelfExplicit(typ, _) => SelfExplicit(typ.clean(cx)),
+ ast::SelfExplicit(ref typ, _) => SelfExplicit(typ.clean(cx)),
}
}
}
fn clean(&self, cx: &DocContext) -> FnDecl {
let (did, sig) = *self;
let mut names = if did.node != 0 {
- csearch::get_method_arg_names(&cx.tcx().sess.cstore, did).move_iter()
+ csearch::get_method_arg_names(&cx.tcx().sess.cstore, did).into_iter()
} else {
- Vec::new().move_iter()
+ Vec::new().into_iter()
}.peekable();
if names.peek().map(|s| s.as_slice()) == Some("self") {
let _ = names.next();
#[deriving(Clone, Encodable, Decodable)]
pub struct Trait {
- pub items: Vec<TraitItem>,
+ pub items: Vec<TraitMethod>,
pub generics: Generics,
pub bounds: Vec<TyParamBound>,
}
}
#[deriving(Clone, Encodable, Decodable)]
-pub enum TraitItem {
+pub enum TraitMethod {
RequiredMethod(Item),
ProvidedMethod(Item),
+ TypeTraitItem(Item),
}
-impl TraitItem {
+impl TraitMethod {
pub fn is_req(&self) -> bool {
match self {
&RequiredMethod(..) => true,
match *self {
RequiredMethod(ref item) => item,
ProvidedMethod(ref item) => item,
+ TypeTraitItem(ref item) => item,
}
}
}
-impl Clean<TraitItem> for ast::TraitItem {
- fn clean(&self, cx: &DocContext) -> TraitItem {
+impl Clean<TraitMethod> for ast::TraitItem {
+ fn clean(&self, cx: &DocContext) -> TraitMethod {
match self {
&ast::RequiredMethod(ref t) => RequiredMethod(t.clean(cx)),
&ast::ProvidedMethod(ref t) => ProvidedMethod(t.clean(cx)),
+ &ast::TypeTraitItem(ref t) => TypeTraitItem(t.clean(cx)),
}
}
}
#[deriving(Clone, Encodable, Decodable)]
-pub enum ImplItem {
+pub enum ImplMethod {
MethodImplItem(Item),
+ TypeImplItem(Item),
}
-impl Clean<ImplItem> for ast::ImplItem {
- fn clean(&self, cx: &DocContext) -> ImplItem {
+impl Clean<ImplMethod> for ast::ImplItem {
+ fn clean(&self, cx: &DocContext) -> ImplMethod {
match self {
&ast::MethodImplItem(ref t) => MethodImplItem(t.clean(cx)),
+ &ast::TypeImplItem(ref t) => TypeImplItem(t.clean(cx)),
}
}
}
fn clean(&self, cx: &DocContext) -> Item {
match *self {
ty::MethodTraitItem(ref mti) => mti.clean(cx),
+ ty::TypeTraitItem(ref tti) => tti.clean(cx),
}
}
}
/// For references to self
Self(ast::DefId),
/// Primitives are just the fixed-size numeric types (plus int/uint/float), and char.
- Primitive(Primitive),
+ Primitive(PrimitiveType),
Closure(Box<ClosureDecl>),
Proc(Box<ClosureDecl>),
/// extern "ABI" fn
}
#[deriving(Clone, Encodable, Decodable, PartialEq, Eq, Hash)]
-pub enum Primitive {
+pub enum PrimitiveType {
Int, I8, I16, I32, I64,
Uint, U8, U16, U32, U64,
F32, F64,
TypeStruct,
TypeTrait,
TypeVariant,
+ TypeTypedef,
}
-impl Primitive {
- fn from_str(s: &str) -> Option<Primitive> {
+impl PrimitiveType {
+ fn from_str(s: &str) -> Option<PrimitiveType> {
match s.as_slice() {
"int" => Some(Int),
"i8" => Some(I8),
}
}
- fn find(attrs: &[Attribute]) -> Option<Primitive> {
+ fn find(attrs: &[Attribute]) -> Option<PrimitiveType> {
for attr in attrs.iter() {
let list = match *attr {
List(ref k, ref l) if k.as_slice() == "doc" => l,
if k.as_slice() == "primitive" => v.as_slice(),
_ => continue,
};
- match Primitive::from_str(value) {
+ match PrimitiveType::from_str(value) {
Some(p) => return Some(p),
None => {}
}
TyRptr(ref l, ref m) =>
BorrowedRef {lifetime: l.clean(cx), mutability: m.mutbl.clean(cx),
type_: box m.ty.clean(cx)},
- TyBox(ty) => Managed(box ty.clean(cx)),
- TyUniq(ty) => Unique(box ty.clean(cx)),
- TyVec(ty) => Vector(box ty.clean(cx)),
- TyFixedLengthVec(ty, ref e) => FixedVector(box ty.clean(cx),
- e.span.to_src(cx)),
+ TyBox(ref ty) => Managed(box ty.clean(cx)),
+ TyUniq(ref ty) => Unique(box ty.clean(cx)),
+ TyVec(ref ty) => Vector(box ty.clean(cx)),
+ TyFixedLengthVec(ref ty, ref e) => FixedVector(box ty.clean(cx),
+ e.span.to_src(cx)),
TyTup(ref tys) => Tuple(tys.clean(cx)),
TyPath(ref p, ref tpbs, id) => {
resolve_type(cx, p.clean(cx), tpbs.clean(cx), id)
ty::ty_enum(did, ref substs) |
ty::ty_trait(box ty::TyTrait { def_id: did, ref substs, .. }) => {
let fqn = csearch::get_item_path(cx.tcx(), did);
- let fqn: Vec<String> = fqn.move_iter().map(|i| {
+ let fqn: Vec<String> = fqn.into_iter().map(|i| {
i.to_string()
}).collect();
let kind = match ty::get(*self).sty {
generics: self.generics.clean(cx),
trait_: self.trait_.clean(cx),
for_: self.for_.clean(cx),
- items: self.items.clean(cx).move_iter().map(|ti| {
+ items: self.items.clean(cx).into_iter().map(|ti| {
match ti {
MethodImplItem(i) => i,
+ TypeImplItem(i) => i,
}
}).collect(),
derived: detect_derived(self.attrs.as_slice()),
let remaining = list.iter().filter(|path| {
match inline::try_inline(cx, path.node.id(), None) {
Some(items) => {
- ret.extend(items.move_iter()); false
+ ret.extend(items.into_iter()); false
}
None => true,
}
remaining,
b.clone());
let path = syntax::codemap::dummy_spanned(path);
- ret.push(convert(&ast::ViewItemUse(box(GC) path)));
+ ret.push(convert(&ast::ViewItemUse(P(path))));
}
}
ast::ViewPathSimple(ident, _, id) => {
match inline::try_inline(cx, id, Some(ident)) {
- Some(items) => ret.extend(items.move_iter()),
+ Some(items) => ret.extend(items.into_iter()),
None => ret.push(convert(&self.node)),
}
}
},
PatTup(ref elts) => format!("({})", elts.iter().map(|p| name_from_pat(&**p))
.collect::<Vec<String>>().connect(", ")),
- PatBox(p) => name_from_pat(&*p),
- PatRegion(p) => name_from_pat(&*p),
+ PatBox(ref p) => name_from_pat(&**p),
+ PatRegion(ref p) => name_from_pat(&**p),
PatLit(..) => {
warn!("tried to get argument name from PatLit, \
which is silly in function arguments");
fn register_def(cx: &DocContext, def: def::Def) -> ast::DefId {
let (did, kind) = match def {
def::DefFn(i, _) => (i, TypeFunction),
- def::DefTy(i) => (i, TypeEnum),
+ def::DefTy(i, false) => (i, TypeTypedef),
+ def::DefTy(i, true) => (i, TypeEnum),
def::DefTrait(i) => (i, TypeTrait),
def::DefStruct(i) => (i, TypeStruct),
def::DefMod(i) => (i, TypeModule),
}
}
+impl Clean<Item> for ast::AssociatedType {
+ fn clean(&self, cx: &DocContext) -> Item {
+ Item {
+ source: self.span.clean(cx),
+ name: Some(self.ident.clean(cx)),
+ attrs: self.attrs.clean(cx),
+ inner: AssociatedTypeItem,
+ visibility: None,
+ def_id: ast_util::local_def(self.id),
+ stability: None,
+ }
+ }
+}
+
+impl Clean<Item> for ty::AssociatedType {
+ fn clean(&self, cx: &DocContext) -> Item {
+ Item {
+ source: DUMMY_SP.clean(cx),
+ name: Some(self.ident.clean(cx)),
+ attrs: Vec::new(),
+ inner: AssociatedTypeItem,
+ visibility: None,
+ def_id: self.def_id,
+ stability: None,
+ }
+ }
+}
+
+impl Clean<Item> for ast::Typedef {
+ fn clean(&self, cx: &DocContext) -> Item {
+ Item {
+ source: self.span.clean(cx),
+ name: Some(self.ident.clean(cx)),
+ attrs: self.attrs.clean(cx),
+ inner: TypedefItem(Typedef {
+ type_: self.typ.clean(cx),
+ generics: Generics {
+ lifetimes: Vec::new(),
+ type_params: Vec::new(),
+ },
+ }),
+ visibility: None,
+ def_id: ast_util::local_def(self.id),
+ stability: None,
+ }
+ }
+}
+
fn lang_struct(cx: &DocContext, did: Option<ast::DefId>,
t: ty::t, name: &str,
fallback: fn(Box<Type>) -> Type) -> Type {
None => return fallback(box t.clean(cx)),
};
let fqn = csearch::get_item_path(cx.tcx(), did);
- let fqn: Vec<String> = fqn.move_iter().map(|i| {
+ let fqn: Vec<String> = fqn.into_iter().map(|i| {
i.to_string()
}).collect();
cx.external_paths.borrow_mut().as_mut().unwrap().insert(did, (fqn, TypeStruct));
projects / rust.git / blobdiff