---

yaml
---
r: 151518
b: refs/heads/try2
c: 11571cd
h: refs/heads/master
v: v3

Author: bors

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: 4cbd7754ea7277aa3e4ae20492e2bfca81e4cd11
+refs/heads/try2: 11571cd9c1cde63c3b46ca65e608b84647785ac8
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/src/doc/rust.md

@@ -17,14 +17,13 @@ This document does not serve as a tutorial introduction to the
 language. Background familiarity with the language is assumed. A separate
 [tutorial] document is available to help acquire such background familiarity.
 
-This document also does not serve as a reference to the [standard] or [extra]
-libraries included in the language distribution. Those libraries are
+This document also does not serve as a reference to the [standard]
+library included in the language distribution. Those libraries are
 documented separately by extracting documentation attributes from their
 source code.
 
 [tutorial]: tutorial.html
 [standard]: std/index.html
-[extra]: extra/index.html
 
 ## Disclaimer
 

branches/try2/src/etc/vim/indent/rust.vim

@@ -13,7 +13,7 @@ setlocal cindent
 setlocal cinoptions=L0,(0,Ws,JN,j1
 setlocal cinkeys=0{,0},!^F,o,O,0[,0]
 " Don't think cinwords will actually do anything at all... never mind
-setlocal cinwords=do,for,if,else,while,loop,impl,mod,unsafe,trait,struct,enum,fn,extern
+setlocal cinwords=for,if,else,while,loop,impl,mod,unsafe,trait,struct,enum,fn,extern
 
 " Some preliminary settings
 setlocal nolisp		" Make sure lisp indenting doesn't supersede us
@@ -40,12 +40,12 @@ function! s:get_line_trimmed(lnum)
 		" If the last character in the line is a comment, do a binary search for
 		" the start of the comment.  synID() is slow, a linear search would take
 		" too long on a long line.
-		if synIDattr(synID(a:lnum, line_len, 1), "name") =~ "Comment\|Todo"
+		if synIDattr(synID(a:lnum, line_len, 1), "name") =~ 'Comment\|Todo'
 			let min = 1
 			let max = line_len
 			while min < max
 				let col = (min + max) / 2
-				if synIDattr(synID(a:lnum, col, 1), "name") =~ "Comment\|Todo"
+				if synIDattr(synID(a:lnum, col, 1), "name") =~ 'Comment\|Todo'
 					let max = col
 				else
 					let min = col + 1
@@ -87,10 +87,10 @@ function GetRustIndent(lnum)
 		if synname == "rustString"
 			" If the start of the line is in a string, don't change the indent
 			return -1
-		elseif synname =~ "\\(Comment\\|Todo\\)"
-					\ && line !~ "^\\s*/\\*"  " not /* opening line
+		elseif synname =~ '\(Comment\|Todo\)'
+					\ && line !~ '^\s*/\*'  " not /* opening line
 			if synname =~ "CommentML" " multi-line
-				if line !~ "^\\s*\\*" && getline(a:lnum - 1) =~ "^\\s*/\\*"
+				if line !~ '^\s*\*' && getline(a:lnum - 1) =~ '^\s*/\*'
 					" This is (hopefully) the line after a /*, and it has no
 					" leader, so the correct indentation is that of the
 					" previous line.
@@ -115,11 +115,16 @@ function GetRustIndent(lnum)
 	" };
 
 	" Search backwards for the previous non-empty line.
-	let prevline = s:get_line_trimmed(prevnonblank(a:lnum - 1))
+	let prevlinenum = prevnonblank(a:lnum - 1)
+	let prevline = s:get_line_trimmed(prevlinenum)
+	while prevlinenum > 1 && prevline !~ '[^[:blank:]]'
+		let prevlinenum = prevnonblank(prevlinenum - 1)
+		let prevline = s:get_line_trimmed(prevlinenum)
+	endwhile
 	if prevline[len(prevline) - 1] == ","
-				\ && s:get_line_trimmed(a:lnum) !~ "^\\s*[\\[\\]{}]"
-				\ && prevline !~ "^\\s*fn\\s"
-				\ && prevline !~ "([^()]\\+,$"
+				\ && s:get_line_trimmed(a:lnum) !~ '^\s*[\[\]{}]'
+				\ && prevline !~ '^\s*fn\s'
+				\ && prevline !~ '([^()]\+,$'
 		" Oh ho! The previous line ended in a comma! I bet cindent will try to
 		" take this too far... For now, let's normally use the previous line's
 		" indent.
@@ -166,7 +171,7 @@ function GetRustIndent(lnum)
 	" column zero)
 
 	call cursor(a:lnum, 1)
-	if searchpair('{\|(', '', '}\|)', 'nbW'
+	if searchpair('{\|(', '', '}\|)', 'nbW',
 				\ 's:is_string_comment(line("."), col("."))') == 0
 		if searchpair('\[', '', '\]', 'nbW',
 					\ 's:is_string_comment(line("."), col("."))') == 0

branches/try2/src/libcore/intrinsics.rs

@@ -137,7 +137,7 @@ pub trait TyVisitor {
                        sz: uint, align: uint) -> bool;
 
     fn visit_enter_enum(&mut self, n_variants: uint,
-                        get_disr: extern unsafe fn(ptr: *Opaque) -> Disr,
+                        get_disr: unsafe extern fn(ptr: *Opaque) -> Disr,
                         sz: uint, align: uint) -> bool;
     fn visit_enter_enum_variant(&mut self, variant: uint,
                                 disr_val: Disr,
@@ -149,7 +149,7 @@ pub trait TyVisitor {
                                 n_fields: uint,
                                 name: &str) -> bool;
     fn visit_leave_enum(&mut self, n_variants: uint,
-                        get_disr: extern unsafe fn(ptr: *Opaque) -> Disr,
+                        get_disr: unsafe extern fn(ptr: *Opaque) -> Disr,
                         sz: uint, align: uint) -> bool;
 
     fn visit_enter_fn(&mut self, purity: uint, proto: uint,

branches/try2/src/libcore/result.rs

@@ -24,7 +24,7 @@
 //!
 //! Functions return `Result` whenever errors are expected and
 //! recoverable. In the `std` crate `Result` is most prominently used
-//! for [I/O](../io/index.html).
+//! for [I/O](../../std/io/index.html).
 //!
 //! A simple function returning `Result` might be
 //! defined and used like so:

branches/try2/src/libnative/io/net.rs

@@ -149,7 +149,7 @@ fn last_error() -> io::IoError {
 #[cfg(unix)]    unsafe fn close(sock: sock_t) { let _ = libc::close(sock); }
 
 fn sockname(fd: sock_t,
-            f: extern "system" unsafe fn(sock_t, *mut libc::sockaddr,
+            f: unsafe extern "system" fn(sock_t, *mut libc::sockaddr,
                                          *mut libc::socklen_t) -> libc::c_int)
     -> IoResult<ip::SocketAddr>
 {

branches/try2/src/librustc/util/ppaux.rs

@@ -236,12 +236,7 @@ pub fn ty_to_str(cx: &ctxt, typ: t) -> ~str {
                       ident: Option<ast::Ident>,
                       sig: &ty::FnSig)
                       -> ~str {
-        let mut s = if abi == abi::Rust {
-            StrBuf::new()
-        } else {
-            StrBuf::from_owned_str(format!("extern {} ", abi.to_str()))
-        };
-
+        let mut s = StrBuf::new();
         match fn_style {
             ast::NormalFn => {}
             _ => {
@@ -250,6 +245,10 @@ pub fn ty_to_str(cx: &ctxt, typ: t) -> ~str {
             }
         };
 
+        if abi != abi::Rust {
+            s.push_str(format!("extern {} ", abi.to_str()));
+        };
+
         s.push_str("fn");
 
         match ident {
@@ -584,7 +583,7 @@ impl Repr for ty::ParamBounds {
                 ty::BoundStatic => "'static".to_owned(),
                 ty::BoundSend => "Send".to_owned(),
                 ty::BoundSized => "Sized".to_owned(),
-                ty::BoundCopy => "Pod".to_owned(),
+                ty::BoundCopy => "Copy".to_owned(),
                 ty::BoundShare => "Share".to_owned(),
             });
         }
@@ -862,7 +861,7 @@ impl UserString for ty::BuiltinBound {
             ty::BoundStatic => "'static".to_owned(),
             ty::BoundSend => "Send".to_owned(),
             ty::BoundSized => "Sized".to_owned(),
-            ty::BoundCopy => "Pod".to_owned(),
+            ty::BoundCopy => "Copy".to_owned(),
             ty::BoundShare => "Share".to_owned(),
         }
     }

branches/try2/src/librustdoc/clean.rs

@@ -670,15 +670,7 @@ pub enum Type {
     ResolvedPath {
         pub path: Path,
         pub typarams: Option<Vec<TyParamBound>>,
-        pub id: ast::NodeId,
-    },
-    /// Same as above, but only external variants
-    ExternalPath {
-        pub path: Path,
-        pub typarams: Option<Vec<TyParamBound>>,
-        pub fqn: Vec<~str>,
-        pub kind: TypeKind,
-        pub krate: ast::CrateNum,
+        pub did: ast::DefId,
     },
     // I have no idea how to usefully use this.
     TyParamBinder(ast::NodeId),
@@ -715,19 +707,18 @@ pub enum Type {
 
 #[deriving(Clone, Encodable, Decodable)]
 pub enum TypeKind {
-    TypeStruct,
     TypeEnum,
-    TypeTrait,
     TypeFunction,
+    TypeModule,
+    TypeStatic,
+    TypeStruct,
+    TypeTrait,
+    TypeVariant,
 }
 
 impl Clean<Type> for ast::Ty {
     fn clean(&self) -> Type {
         use syntax::ast::*;
-        debug!("cleaning type `{:?}`", self);
-        let ctxt = super::ctxtkey.get().unwrap();
-        let codemap = ctxt.sess().codemap();
-        debug!("span corresponds to `{}`", codemap.span_to_str(self.span));
         match self.node {
             TyNil => Unit,
             TyPtr(ref m) => RawPointer(m.mutbl.clean(), box m.ty.clean()),
@@ -1153,7 +1144,7 @@ pub enum ViewPath {
     // use source::*;
     GlobImport(ImportSource),
     // use source::{a, b, c};
-    ImportList(ImportSource, Vec<ViewListIdent> ),
+    ImportList(ImportSource, Vec<ViewListIdent>),
 }
 
 #[deriving(Clone, Encodable, Decodable)]
@@ -1298,48 +1289,47 @@ fn resolve_type(path: Path, tpbs: Option<Vec<TyParamBound> >,
         core::NotTyped(_) => return Bool
     };
     debug!("searching for {:?} in defmap", id);
-    let d = match tycx.def_map.borrow().find(&id) {
+    let def = match tycx.def_map.borrow().find(&id) {
         Some(&k) => k,
-        None => {
-            debug!("could not find {:?} in defmap (`{}`)", id, tycx.map.node_to_str(id));
-            fail!("Unexpected failure: unresolved id not in defmap (this is a bug!)")
-        }
+        None => fail!("unresolved id not in defmap")
     };
 
-    let (def_id, kind) = match d {
-        ast::DefFn(i, _) => (i, TypeFunction),
+    match def {
         ast::DefSelfTy(i) => return Self(i),
-        ast::DefTy(i) => (i, TypeEnum),
-        ast::DefTrait(i) => {
-            debug!("saw DefTrait in def_to_id");
-            (i, TypeTrait)
-        },
         ast::DefPrimTy(p) => match p {
             ast::TyStr => return String,
             ast::TyBool => return Bool,
             _ => return Primitive(p)
         },
         ast::DefTyParam(i, _) => return Generic(i.node),
+        ast::DefTyParamBinder(i) => return TyParamBinder(i),
+        _ => {}
+    };
+    let did = register_def(&**cx, def);
+    ResolvedPath { path: path, typarams: tpbs, did: did }
+}
+
+fn register_def(cx: &core::DocContext, def: ast::Def) -> ast::DefId {
+    let (did, kind) = match def {
+        ast::DefFn(i, _) => (i, TypeFunction),
+        ast::DefTy(i) => (i, TypeEnum),
+        ast::DefTrait(i) => (i, TypeTrait),
         ast::DefStruct(i) => (i, TypeStruct),
-        ast::DefTyParamBinder(i) => {
-            debug!("found a typaram_binder, what is it? {}", i);
-            return TyParamBinder(i);
-        },
-        x => fail!("resolved type maps to a weird def {:?}", x),
+        ast::DefMod(i) => (i, TypeModule),
+        ast::DefStatic(i, _) => (i, TypeStatic),
+        ast::DefVariant(i, _, _) => (i, TypeEnum),
+        _ => return ast_util::def_id_of_def(def),
     };
-    if ast_util::is_local(def_id) {
-        ResolvedPath{ path: path, typarams: tpbs, id: def_id.node }
-    } else {
-        let fqn = csearch::get_item_path(tycx, def_id);
-        let fqn = fqn.move_iter().map(|i| i.to_str()).collect();
-        ExternalPath {
-            path: path,
-            typarams: tpbs,
-            fqn: fqn,
-            kind: kind,
-            krate: def_id.krate,
-        }
-    }
+    if ast_util::is_local(did) { return did }
+    let tcx = match cx.maybe_typed {
+        core::Typed(ref t) => t,
+        core::NotTyped(_) => return did
+    };
+    let fqn = csearch::get_item_path(tcx, did);
+    let fqn = fqn.move_iter().map(|i| i.to_str()).collect();
+    debug!("recording {} => {}", did, fqn);
+    cx.external_paths.borrow_mut().get_mut_ref().insert(did, (fqn, kind));
+    return did;
 }
 
 fn resolve_use_source(path: Path, id: ast::NodeId) -> ImportSource {
@@ -1353,7 +1343,7 @@ fn resolve_def(id: ast::NodeId) -> Option<ast::DefId> {
     let cx = super::ctxtkey.get().unwrap();
     match cx.maybe_typed {
         core::Typed(ref tcx) => {
-            tcx.def_map.borrow().find(&id).map(|&d| ast_util::def_id_of_def(d))
+            tcx.def_map.borrow().find(&id).map(|&def| register_def(&**cx, def))
         }
         core::NotTyped(_) => None
     }

branches/try2/src/librustdoc/core.rs

@@ -20,7 +20,7 @@ use syntax;
 
 use std::cell::RefCell;
 use std::os;
-use collections::HashSet;
+use collections::{HashSet, HashMap};
 
 use visit_ast::RustdocVisitor;
 use clean;
@@ -31,10 +31,14 @@ pub enum MaybeTyped {
     NotTyped(driver::session::Session)
 }
 
+pub type ExternalPaths = RefCell<Option<HashMap<ast::DefId,
+                                                (Vec<~str>, clean::TypeKind)>>>;
+
 pub struct DocContext {
     pub krate: ast::Crate,
     pub maybe_typed: MaybeTyped,
     pub src: Path,
+    pub external_paths: ExternalPaths,
 }
 
 impl DocContext {
@@ -49,6 +53,7 @@ impl DocContext {
 pub struct CrateAnalysis {
     pub exported_items: privacy::ExportedItems,
     pub public_items: privacy::PublicItems,
+    pub external_paths: ExternalPaths,
 }
 
 /// Parses, resolves, and typechecks the given crate
@@ -98,9 +103,11 @@ fn get_ast_and_resolve(cpath: &Path, libs: HashSet<Path>, cfgs: Vec<~str>)
         krate: krate,
         maybe_typed: Typed(ty_cx),
         src: cpath.clone(),
+        external_paths: RefCell::new(Some(HashMap::new())),
     }, CrateAnalysis {
         exported_items: exported_items,
         public_items: public_items,
+        external_paths: RefCell::new(None),
     })
 }
 
@@ -116,5 +123,7 @@ pub fn run_core(libs: HashSet<Path>, cfgs: Vec<~str>, path: &Path)
         v.clean()
     };
 
+    let external_paths = ctxt.external_paths.borrow_mut().take();
+    *analysis.external_paths.borrow_mut() = external_paths;
     (krate, analysis)
 }