---

yaml
---
r: 151517
b: refs/heads/try2
c: 4cbd775
h: refs/heads/master
i:
  151515: 947d5a8
v: v3

Author: Manishearth

[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: 1001635dc1be7ee7c42800e7e2e537a811280c8a
+refs/heads/try2: 4cbd7754ea7277aa3e4ae20492e2bfca81e4cd11
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/src/doc/rust.md

@@ -17,13 +17,14 @@ 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]
-library included in the language distribution. Those libraries are
+This document also does not serve as a reference to the [standard] or [extra]
+libraries 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=for,if,else,while,loop,impl,mod,unsafe,trait,struct,enum,fn,extern
+setlocal cinwords=do,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,16 +115,11 @@ function GetRustIndent(lnum)
 	" };
 
 	" Search backwards for the previous non-empty line.
-	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
+	let prevline = s:get_line_trimmed(prevnonblank(a:lnum - 1))
 	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.
@@ -171,7 +166,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: unsafe extern fn(ptr: *Opaque) -> Disr,
+                        get_disr: extern unsafe 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: unsafe extern fn(ptr: *Opaque) -> Disr,
+                        get_disr: extern unsafe 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](../../std/io/index.html).
+//! for [I/O](../io/index.html).
 //!
 //! A simple function returning `Result` might be
 //! defined and used like so:

branches/try2/src/liblibc/lib.rs

@@ -92,8 +92,8 @@ pub use types::os::common::bsd44::{addrinfo, in_addr, in6_addr, sockaddr_storage
 pub use types::os::common::bsd44::{ip_mreq, ip6_mreq, sockaddr, sockaddr_un};
 pub use types::os::common::bsd44::{sa_family_t, sockaddr_in, sockaddr_in6, socklen_t};
 pub use types::os::arch::c95::{c_char, c_double, c_float, c_int, c_uint};
-pub use types::os::arch::c95::{c_long, c_short, c_uchar, c_ulong};
-pub use types::os::arch::c95::{c_ushort, clock_t, ptrdiff_t};
+pub use types::os::arch::c95::{c_long, c_short, c_uchar, c_ulong, wchar_t};
+pub use types::os::arch::c95::{c_ushort, clock_t, ptrdiff_t, c_schar};
 pub use types::os::arch::c95::{size_t, time_t, suseconds_t};
 pub use types::os::arch::c99::{c_longlong, c_ulonglong};
 pub use types::os::arch::c99::{intptr_t, uintptr_t};

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: unsafe extern "system" fn(sock_t, *mut libc::sockaddr,
+            f: extern "system" unsafe fn(sock_t, *mut libc::sockaddr,
                                          *mut libc::socklen_t) -> libc::c_int)
     -> IoResult<ip::SocketAddr>
 {

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

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

branches/try2/src/librustdoc/clean.rs

@@ -670,7 +670,15 @@ pub enum Type {
     ResolvedPath {
         pub path: Path,
         pub typarams: Option<Vec<TyParamBound>>,
-        pub did: ast::DefId,
+        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,
     },
     // I have no idea how to usefully use this.
     TyParamBinder(ast::NodeId),
@@ -707,18 +715,19 @@ pub enum Type {
 
 #[deriving(Clone, Encodable, Decodable)]
 pub enum TypeKind {
-    TypeEnum,
-    TypeFunction,
-    TypeModule,
-    TypeStatic,
     TypeStruct,
+    TypeEnum,
     TypeTrait,
-    TypeVariant,
+    TypeFunction,
 }
 
 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()),
@@ -1144,7 +1153,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)]
@@ -1289,47 +1298,48 @@ fn resolve_type(path: Path, tpbs: Option<Vec<TyParamBound> >,
         core::NotTyped(_) => return Bool
     };
     debug!("searching for {:?} in defmap", id);
-    let def = match tycx.def_map.borrow().find(&id) {
+    let d = match tycx.def_map.borrow().find(&id) {
         Some(&k) => k,
-        None => fail!("unresolved id not in defmap")
+        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!)")
+        }
     };
 
-    match def {
+    let (def_id, kind) = match d {
+        ast::DefFn(i, _) => (i, TypeFunction),
         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::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(did) { return did }
-    let tcx = match cx.maybe_typed {
-        core::Typed(ref t) => t,
-        core::NotTyped(_) => return did
+        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),
     };
-    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;
+    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,
+        }
+    }
 }
 
 fn resolve_use_source(path: Path, id: ast::NodeId) -> ImportSource {
@@ -1343,7 +1353,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(|&def| register_def(&**cx, def))
+            tcx.def_map.borrow().find(&id).map(|&d| ast_util::def_id_of_def(d))
         }
         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, HashMap};
+use collections::HashSet;
 
 use visit_ast::RustdocVisitor;
 use clean;
@@ -31,14 +31,10 @@ 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 {
@@ -53,7 +49,6 @@ 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
@@ -103,11 +98,9 @@ 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),
     })
 }
 
@@ -123,7 +116,5 @@ 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)
 }