---

yaml
---
r: 95036
b: refs/heads/dist-snap
c: 6c8e6aa
h: refs/heads/master
v: v3

Author: thestinger

[refs]

@@ -6,7 +6,7 @@ refs/heads/try: c274a6888410ce3e357e014568b43310ed787d36
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c
-refs/heads/dist-snap: 92e7bb67a8038ff73ad9dc88d8be3d3df4777282
+refs/heads/dist-snap: 6c8e6aad7344a62d91d5cf10e0dd1769602a5257
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

branches/dist-snap/Makefile.in

@@ -608,10 +608,6 @@ config.stamp: $(S)configure $(S)Makefile.in $(S)src/snapshots.txt
 # Primary-target makefiles
 ######################################################################
 
-# Issue #9531: If you change the order of any of the following (or add
-# new definitions), make sure definitions always precede their uses,
-# especially for the dependency lists of recipes.
-
 include $(CFG_SRC_DIR)mk/target.mk
 include $(CFG_SRC_DIR)mk/host.mk
 include $(CFG_SRC_DIR)mk/stage0.mk

branches/dist-snap/doc/tutorial.md

@@ -737,7 +737,7 @@ fn area(sh: Shape) -> float {
     match sh {
         Circle { radius: radius, _ } => float::consts::pi * square(radius),
         Rectangle { top_left: top_left, bottom_right: bottom_right } => {
-            (bottom_right.x - top_left.x) * (top_left.y - bottom_right.y) 
+            (bottom_right.x - top_left.x) * (bottom_right.y - top_left.y)
         }
     }
 }
@@ -923,22 +923,60 @@ custom destructors.
 
 # Boxes
 
-Many modern languages represent values as pointers to heap memory by
-default. In contrast, Rust, like C and C++, represents such types directly.
-Another way to say this is that aggregate data in Rust are *unboxed*. This
-means that if you `let x = Point { x: 1f, y: 1f };`, you are creating a struct
-on the stack. If you then copy it into a data structure, you copy the entire
-struct, not just a pointer.
+A value in Rust is stored directly inside the owner. If a `struct` contains
+four `int` fields, it will be four times as large as a single `int`.  The
+following `struct` type is invalid, as it would have an infinite size:
 
-For small structs like `Point`, this is usually more efficient than allocating
-memory and indirecting through a pointer. But for big structs, or mutable
-state, it can be useful to have a single copy on the stack or on the heap, and
-refer to that through a pointer.
+~~~~ {.xfail-test}
+struct List {
+    next: Option<List>,
+    data: int
+}
+~~~~
+
+> ***Note:*** The `Option` type is an enum representing an *optional* value.
+> It's comparable to a nullable pointer in many other languages, but stores the
+> contained value unboxed.
+
+An *owned box* (`~`) uses a heap allocation to provide the invariant of always
+being the size of a pointer, regardless of the contained type. This can be
+leveraged to create a valid recursive `struct` type with a finite size:
+
+~~~~
+struct List {
+    next: Option<~List>,
+    data: int
+}
+~~~~
+
+Since an owned box has a single owner, they are limited to representing
+tree-like data structures.
+
+The most common use case for owned boxes is creating recursive data structures
+like a binary search tree. Rust's trait-based generics system (covered later in
+the tutorial) is usually used for static dispatch, but also provides dynamic
+dispatch via boxing. Values of different types may have different sizes, but a
+box is able to *erase* the difference via the layer of indirection they
+provide.
 
-## Owned boxes
+In uncommon cases, the indirection can provide a performance gain or memory
+reduction by making values smaller. However, unboxed values should almost
+always be preferred.
 
-An owned box (`~`) is a uniquely owned allocation on the heap. It inherits the
-mutability and lifetime of the owner as it would if there was no box:
+Note that returning large unboxed values via boxes is unnecessary. A large
+value is returned via a hidden output parameter, and the decision on where to
+place the return value should be left to the caller:
+
+~~~~
+fn foo() -> (int, int, int, int, int, int) {
+    (5, 5, 5, 5, 5, 5)
+}
+
+let x = ~foo(); // allocates, and writes the integers directly to it
+~~~~
+
+Beyond the properties granted by the size, an owned box behaves as a regular
+value by inheriting the mutability and lifetime of the owner:
 
 ~~~~
 let x = 5; // immutable
@@ -950,35 +988,33 @@ let mut y = ~5; // mutable
 *y += 2; // the * operator is needed to access the contained value
 ~~~~
 
-The purpose of an owned box is to add a layer of indirection in order to create
-recursive data structures or cheaply pass around an object larger than a
-pointer. Since an owned box has a unique owner, it can only be used to
-represent a tree data structure.
+As covered earlier, an owned box has a destructor to clean up the allocated
+memory. This makes it more restricted than an unboxed type with no destructor
+by introducing *move semantics*.
 
-The following struct won't compile, because the lack of indirection would mean
-it has an infinite size:
+# Move semantics
 
-~~~~ {.xfail-test}
-struct Foo {
-    child: Option<Foo>
-}
-~~~~
+Rust uses a shallow copy for parameter passing, assignment and returning from
+functions. This is considered a move of ownership for types with destructors.
+After a value has been moved, it can no longer be used from the source location
+and will not be destroyed when the source goes out of scope.
 
-> ***Note:*** The `Option` type is an enum that represents an *optional* value.
-> It's comparable to a nullable pointer in many other languages, but stores the
-> contained value unboxed.
+~~~~
+let x = ~5;
+let y = x.clone(); // y is a newly allocated box
+let z = x; // no new memory allocated, x can no longer be used
+~~~~
 
-Adding indirection with an owned pointer allocates the child outside of the
-struct on the heap, which makes it a finite size and won't result in a
-compile-time error:
+The mutability of a value may be changed by moving it to a new owner:
 
 ~~~~
-struct Foo {
-    child: Option<~Foo>
-}
+let r = ~13;
+let mut s = r; // box becomes mutable
+*s += 1;
+let t = s; // box becomes immutable
 ~~~~
 
-## Managed boxes
+# Managed boxes
 
 A managed box (`@`) is a heap allocation with the lifetime managed by a
 task-local garbage collector. It will be destroyed at some point after there
@@ -1023,30 +1059,6 @@ d = b;          // box type is the same, okay
 c = b;          // error
 ~~~~
 
-# Move semantics
-
-Rust uses a shallow copy for parameter passing, assignment and returning values
-from functions. A shallow copy is considered a move of ownership if the
-ownership tree of the copied value includes an owned box or a type with a
-custom destructor. After a value has been moved, it can no longer be used from
-the source location and will not be destroyed there.
-
-~~~~
-let x = ~5;
-let y = x.clone(); // y is a newly allocated box
-let z = x; // no new memory allocated, x can no longer be used
-~~~~
-
-Since in owned boxes mutability is a property of the owner, not the
-box, mutable boxes may become immutable when they are moved, and vice-versa.
-
-~~~~
-let r = ~13;
-let mut s = r; // box becomes mutable
-*s += 1;
-let t = s; // box becomes immutable
-~~~~
-
 # Borrowed pointers
 
 Rust's borrowed pointers are a general purpose reference type. In contrast with

branches/dist-snap/mk/docs.mk

@@ -217,6 +217,10 @@ endif
 # Rustdoc (libstd/extra)
 ######################################################################
 
+ifeq ($(CFG_PANDOC),)
+  $(info cfg: no pandoc found, omitting library doc build)
+else
+
 # The rustdoc executable
 RUSTDOC = $(HBIN2_H_$(CFG_BUILD_TRIPLE))/rustdoc$(X_$(CFG_BUILD_TRIPLE))
 
@@ -234,6 +238,7 @@ endef
 
 $(eval $(call libdoc,std,$(STDLIB_CRATE),$(CFG_BUILD_TRIPLE)))
 $(eval $(call libdoc,extra,$(EXTRALIB_CRATE),$(CFG_BUILD_TRIPLE)))
+endif
 
 
 ifdef CFG_DISABLE_DOCS

branches/dist-snap/mk/stage0.mk

@@ -6,6 +6,8 @@ $(HBIN0_H_$(CFG_BUILD_TRIPLE))/:
 $(HLIB0_H_$(CFG_BUILD_TRIPLE))/:
 	mkdir -p $@
 
+SNAPSHOT_RUSTC_POST_CLEANUP=$(HBIN0_H_$(CFG_BUILD_TRIPLE))/rustc$(X_$(CFG_BUILD_TRIPLE))
+
 $(SNAPSHOT_RUSTC_POST_CLEANUP):						\
 		$(S)src/snapshots.txt					\
 		$(S)src/etc/get-snapshot.py $(MKFILE_DEPS)		\

branches/dist-snap/mk/target.mk

@@ -36,8 +36,6 @@ WFLAGS_ST2 = -D warnings
 # had its chance to clean it out; otherwise the other products will be
 # inadvertantly included in the clean out.
 
-SNAPSHOT_RUSTC_POST_CLEANUP=$(HBIN0_H_$(CFG_BUILD_TRIPLE))/rustc$(X_$(CFG_BUILD_TRIPLE))
-
 define TARGET_STAGE_N
 
 $$(TLIB$(1)_T_$(2)_H_$(3))/libmorestack.a: \

branches/dist-snap/src/librustc/middle/check_match.rs

@@ -773,12 +773,12 @@ pub fn specialize(cx: &MatchCheckCtxt,
                         let num_elements = before.len() + after.len();
                         if num_elements < arity && slice.is_some() {
                             Some(vec::append(
-                                [
+                                vec::concat(&[
                                     before,
                                     vec::from_elem(
                                         arity - num_elements, wild()),
                                     after
-                                ].concat_vec(),
+                                ]),
                                 r.tail()
                             ))
                         } else if num_elements == arity {

branches/dist-snap/src/librustdoc/clean.rs

@@ -84,7 +84,7 @@ impl Clean<Crate> for visit_ast::RustdocVisitor {
 #[deriving(Clone, Encodable, Decodable)]
 pub struct Item {
     /// Stringified span
-    source: Span,
+    source: ~str,
     /// Not everything has a name. E.g., impls
     name: Option<~str>,
     attrs: ~[Attribute],
@@ -173,11 +173,12 @@ impl Clean<Item> for doctree::Module {
             visibility: self.vis.clean(),
             id: self.id,
             inner: ModuleItem(Module {
-               items: [self.structs.clean(), self.enums.clean(),
-                       self.fns.clean(), self.foreigns.clean().concat_vec(),
-                       self.mods.clean(), self.typedefs.clean(),
-                       self.statics.clean(), self.traits.clean(),
-                       self.impls.clean(), self.view_items.clean()].concat_vec()
+               items: std::vec::concat(&[self.structs.clean(),
+                              self.enums.clean(), self.fns.clean(),
+                              std::vec::concat(self.foreigns.clean()),
+                              self.mods.clean(), self.typedefs.clean(),
+                              self.statics.clean(), self.traits.clean(),
+                              self.impls.clean(), self.view_items.clean()])
             })
         }
     }
@@ -539,11 +540,9 @@ impl Clean<TraitMethod> for ast::trait_method {
 #[deriving(Clone, Encodable, Decodable)]
 pub enum Type {
     /// structs/enums/traits (anything that'd be an ast::ty_path)
-    ResolvedPath {
-        path: Path,
-        typarams: Option<~[TyParamBound]>,
-        did: ast::DefId
-    },
+    ResolvedPath { path: Path, typarams: Option<~[TyParamBound]>, id: ast::NodeId },
+    /// Reference to an item in an external crate (fully qualified path)
+    External(~str, ~str),
     // I have no idea how to usefully use this.
     TyParamBinder(ast::NodeId),
     /// For parameterized types, so the consumer of the JSON don't go looking
@@ -738,28 +737,10 @@ impl Clean<VariantKind> for ast::variant_kind {
     }
 }
 
-#[deriving(Clone, Encodable, Decodable)]
-pub struct Span {
-    filename: ~str,
-    loline: uint,
-    locol: uint,
-    hiline: uint,
-    hicol: uint,
-}
-
-impl Clean<Span> for syntax::codemap::Span {
-    fn clean(&self) -> Span {
-        let cm = local_data::get(super::ctxtkey, |x| *x.unwrap()).sess.codemap;
-        let filename = cm.span_to_filename(*self);
-        let lo = cm.lookup_char_pos(self.lo);
-        let hi = cm.lookup_char_pos(self.hi);
-        Span {
-            filename: filename.to_owned(),
-            loline: lo.line,
-            locol: *lo.col,
-            hiline: hi.line,
-            hicol: *hi.col,
-        }
+impl Clean<~str> for syntax::codemap::Span {
+    fn clean(&self) -> ~str {
+        let cm = local_data::get(super::ctxtkey, |x| x.unwrap().clone()).sess.codemap;
+        cm.span_to_str(*self)
     }
 }
 
@@ -1053,7 +1034,7 @@ trait ToSource {
 
 impl ToSource for syntax::codemap::Span {
     fn to_src(&self) -> ~str {
-        debug!("converting span %? to snippet", self.clean());
+        debug!("converting span %s to snippet", self.clean());
         let cm = local_data::get(super::ctxtkey, |x| x.unwrap().clone()).sess.codemap.clone();
         let sn = match cm.span_to_snippet(*self) {
             Some(x) => x,
@@ -1149,7 +1130,39 @@ fn resolve_type(path: Path, tpbs: Option<~[TyParamBound]>,
         },
         x => fail!("resolved type maps to a weird def %?", x),
     };
-    ResolvedPath{ path: path, typarams: tpbs, did: def_id }
+
+    if def_id.crate != ast::CRATE_NODE_ID {
+        use rustc::metadata::decoder::*;
+
+        let sess = local_data::get(super::ctxtkey, |x| *x.unwrap()).sess;
+        let cratedata = ::rustc::metadata::cstore::get_crate_data(sess.cstore, def_id.crate);
+        let doc = lookup_item(def_id.node, cratedata.data);
+        let path = syntax::ast_map::path_to_str_with_sep(item_path(doc), "::", sess.intr());
+        let ty = match def_like_to_def(item_to_def_like(doc, def_id, def_id.crate)) {
+            DefFn(*) => ~"fn",
+            DefTy(*) => ~"enum",
+            DefTrait(*) => ~"trait",
+            DefPrimTy(p) => match p {
+                ty_str => ~"str",
+                ty_bool => ~"bool",
+                ty_int(t) => match t.to_str() {
+                    ~"" => ~"i",
+                    s => s
+                },
+                ty_uint(t) => t.to_str(),
+                ty_float(t) => t.to_str(),
+                ty_char => ~"char",
+            },
+            DefTyParam(*) => ~"generic",
+            DefStruct(*) => ~"struct",
+            DefTyParamBinder(*) => ~"typaram_binder",
+            x => fail!("resolved external maps to a weird def %?", x),
+        };
+        let cname = cratedata.name.to_owned();
+        External(cname + "::" + path, ty)
+    } else {
+        ResolvedPath {path: path.clone(), typarams: tpbs, id: def_id.node}
+    }
 }
 
 fn resolve_use_source(path: Path, id: ast::NodeId) -> ImportSource {