---

yaml
---
r: 139314
b: refs/heads/try2
c: 3d588c5
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: de468c8cd2f55124f98ae67941bc4c11dee92c14
+refs/heads/try2: 3d588c528685fa0590ff91f189f0ef44a3815ec2
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/doc/rust.css

@@ -101,4 +101,9 @@ td {
 #TOC ul {
     list-style: none;
     padding-left: 0px;
+}
+
+/* Adjust list alignment so rustdoc indexes don't align with blockquotes */
+div.index ul {
+    padding-left: 1em;
 }

branches/try2/doc/rust.md

@@ -1671,6 +1671,10 @@ vec_elems : [expr [',' expr]*] | [expr ',' ".." expr]
 A [_vector_](#vector-types) _expression_ is written by enclosing zero or
 more comma-separated expressions of uniform type in square brackets.
 
+In the `[expr ',' ".." expr]` form, the expression after the `".."`
+must be a constant expression that can be evaluated at compile time, such
+as a [literal](#literals) or a [static item](#static-items).
+
 ~~~~
 [1, 2, 3, 4];
 ["a", "b", "c", "d"];
@@ -2156,6 +2160,19 @@ do f |j| {
 }
 ~~~~
 
+In this example, both calls to the (binary) function `k` are equivalent:
+
+~~~~
+# fn k(x:int, f: &fn(int)) { }
+# fn l(i: int) { }
+
+k(3, |j| l(j));
+
+do k(3) |j| {
+   l(j);
+}
+~~~~
+
 
 ### For expressions
 
@@ -2184,7 +2201,7 @@ and early boolean-valued returns from the `block` function,
 such that the meaning of `break` and `loop` is preserved in a primitive loop
 when rewritten as a `for` loop controlled by a higher order function.
 
-An example a for loop:
+An example of a for loop over the contents of a vector:
 
 ~~~~
 # type foo = int;
@@ -2198,6 +2215,14 @@ for v.each |e| {
 }
 ~~~~
 
+An example of a for loop over a series of integers:
+
+~~~~
+# fn bar(b:uint) { }
+for uint::range(0, 256) |i| {
+    bar(i);
+}
+~~~~
 
 ### If expressions
 
@@ -2474,6 +2499,7 @@ fail_unless!(b != "world");
 
 The vector type constructor represents a homogeneous array of values of a given type.
 A vector has a fixed size.
+(Operations like `vec::push` operate solely on owned vectors.)
 A vector type can be annotated with a _definite_ size,
 written with a trailing asterisk and integer literal, such as `[int * 10]`.
 Such a definite-sized vector type is a first-class type, since its size is known statically.
@@ -2484,6 +2510,10 @@ such as `&[T]`, `@[T]` or `~[T]`.
 The kind of a vector type depends on the kind of its element type,
 as with other simple structural types.
 
+Expressions producing vectors of definite size cannot be evaluated in a
+context expecting a vector of indefinite size; one must copy the
+definite-sized vector contents into a distinct vector of indefinite size.
+
 An example of a vector type and its use:
 
 ~~~~

branches/try2/src/libcore/cast.rs

@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+//! Unsafe casting functions
+
 pub mod rusti {
     #[abi = "rust-intrinsic"]
     #[link_name = "rusti"]

branches/try2/src/libcore/cell.rs

@@ -8,13 +8,17 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+//! A mutable, nullable memory location
+
 use cast::transmute;
 use option;
 use prelude::*;
 
-/// A dynamic, mutable location.
-///
-/// Similar to a mutable option type, but friendlier.
+/*
+A dynamic, mutable location.
+
+Similar to a mutable option type, but friendlier.
+*/
 
 pub struct Cell<T> {
     mut value: Option<T>

branches/try2/src/libcore/clone.rs

@@ -8,9 +8,20 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-/**
-Clonable types are copied with the clone method
+/*! The Clone trait for types that cannot be "implicitly copied"
+
+In Rust, some simple types are "implicitly copyable" and when you
+assign them or pass them as arguments, the receiver will get a copy,
+leaving the original value in place. These types do not require
+allocation to copy and do not have finalizers (i.e. they do not
+contain owned pointers or implement `Drop`), so the compiler considers
+them cheap and safe to copy and automatically implements the `Copy`
+trait for them. For other types copies must be made explicitly,
+by convention implementing the `Clone` trait and calling the
+`clone` method.
+
 */
+
 pub trait Clone {
     fn clone(&self) -> Self;
 }

branches/try2/src/libcore/comm.rs

@@ -8,6 +8,10 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+/*!
+Message passing
+*/
+
 use cast;
 use either::{Either, Left, Right};
 use kinds::Owned;

branches/try2/src/libcore/condition.rs

@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+/*! Condition handling */
+
 use prelude::*;
 use task;
 use task::local_data::{local_data_pop, local_data_set};

branches/try2/src/libcore/core.rc

@@ -10,27 +10,39 @@
 
 /*!
 
-The Rust core library
+# The Rust core library
 
 The Rust core library provides runtime features required by the language,
 including the task scheduler and memory allocators, as well as library
 support for Rust built-in types, platform abstractions, and other commonly
 used features.
 
 `core` includes modules corresponding to each of the integer types, each of
-the floating point types, the `bool` type, tuples, characters, strings,
-vectors (`vec`), managed boxes (`managed`), owned boxes (`owned`), and unsafe
-and borrowed pointers (`ptr`).  Additionally, `core` provides task management
-and creation (`task`), communication primitives (`comm` and `pipes`), platform
-abstractions (`os` and `path`), basic I/O abstractions (`io`), common traits
-(`cmp`, `num`, `to_str`), and complete bindings to the C standard library
-(`libc`).
+the floating point types, the `bool` type, tuples, characters, strings
+(`str`), vectors (`vec`), managed boxes (`managed`), owned boxes (`owned`),
+and unsafe and borrowed pointers (`ptr`).  Additionally, `core` provides
+pervasive types (`option` and `result`), task creation and communication
+primitives (`task`, `comm`), platform abstractions (`os` and `path`), basic
+I/O abstractions (`io`), common traits (`kinds`, `ops`, `cmp`, `num`,
+`to_str`), and complete bindings to the C standard library (`libc`).
 
-`core` is linked to all crates by default and its contents imported.
-Implicitly, all crates behave as if they included the following prologue:
+# Core injection and the Rust prelude
+
+`core` is imported at the topmost level of every crate by default, as
+if the first line of each crate was
 
     extern mod core;
-    use core::*;
+
+This means that the contents of core can be accessed from from any context
+with the `core::` path prefix, as in `use core::vec`, `use core::task::spawn`,
+etc.
+
+Additionally, `core` contains a `prelude` module that reexports many of the
+most common core modules, types and traits. The contents of the prelude are
+imported inte every *module* by default.  Implicitly, all modules behave as if
+they contained the following prologue:
+
+    use core::prelude::*;
 
 */
 

branches/try2/src/libcore/iter.rs

@@ -284,7 +284,8 @@ pub fn build_sized_opt<A,B: Buildable<A>>(size: Option<uint>,
 
 // Functions that combine iteration and building
 
-/// Applies a function to each element of an iterable and returns the results.
+/// Applies a function to each element of an iterable and returns the results
+/// in a sequence built via `BU`.  See also `map_to_vec`.
 #[inline(always)]
 pub fn map<T,IT: BaseIter<T>,U,BU: Buildable<U>>(v: &IT, f: &fn(&T) -> U)
     -> BU {

branches/try2/src/libcore/prelude.rs

@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// This file is imported into every module by default.
+//! The Rust prelude. Imported into every module by default.
 
 /* Reexported core operators */
 

branches/try2/src/libcore/rt/mod.rs

@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#[doc(hidden)];
+
 use libc::c_char;
 
 // Some basic logging

branches/try2/src/libcore/unstable/lang.rs

@@ -99,8 +99,12 @@ pub unsafe fn borrow_as_imm(a: *u8) {
 #[lang="return_to_mut"]
 #[inline(always)]
 pub unsafe fn return_to_mut(a: *u8) {
-    let a: *mut BoxRepr = transmute(a);
-    (*a).header.ref_count &= !FROZEN_BIT;
+    // Sometimes the box is null, if it is conditionally frozen.
+    // See e.g. #4904.
+    if !a.is_null() {
+        let a: *mut BoxRepr = transmute(a);
+        (*a).header.ref_count &= !FROZEN_BIT;
+    }
 }
 
 #[lang="check_not_borrowed"]

branches/try2/src/libcore/vec.rs

@@ -172,12 +172,12 @@ pub fn with_capacity<T>(capacity: uint) -> ~[T] {
 /**
  * Builds a vector by calling a provided function with an argument
  * function that pushes an element to the back of a vector.
- * This version takes an initial size for the vector.
+ * This version takes an initial capacity for the vector.
  *
  * # Arguments
  *
  * * size - An initial size of the vector to reserve
- * * builder - A function that will construct the vector. It recieves
+ * * builder - A function that will construct the vector. It receives
  *             as an argument a function that will push an element
  *             onto the vector being constructed.
  */
@@ -194,7 +194,7 @@ pub fn build_sized<A>(size: uint, builder: &fn(push: &fn(v: A))) -> ~[A] {
  *
  * # Arguments
  *
- * * builder - A function that will construct the vector. It recieves
+ * * builder - A function that will construct the vector. It receives
  *             as an argument a function that will push an element
  *             onto the vector being constructed.
  */

branches/try2/src/librustc/README.txt

@@ -32,8 +32,8 @@ lib/      - bindings to LLVM
 The files concerned purely with syntax -- that is, the AST, parser,
 pretty-printer, lexer, macro expander, and utilities for traversing
 ASTs -- are in a separate crate called "syntax", whose files are in
-./../libsyntax if the parent directory of front/, middle/, back/, and
-so on is . .
+./../libsyntax, where . is the current directory (that is, the parent
+directory of front/, middle/, back/, and so on).
 
 The entry-point for the compiler is main() in driver/rustc.rs, and
 this file sequences the various parts together.

branches/try2/src/librustc/middle/borrowck/gather_loans.rs

@@ -145,7 +145,7 @@ fn req_loans_in_expr(ex: @ast::expr,
 
         // make sure that the thing we are pointing out stays valid
         // for the lifetime `scope_r` of the resulting ptr:
-        let scope_r = ty_region(tcx.ty(ex));
+        let scope_r = ty_region(tcx, ex.span, tcx.ty(ex));
         self.guarantee_valid(base_cmt, mutbl, scope_r);
         visit::visit_expr(ex, self, vt);
       }
@@ -599,7 +599,8 @@ pub impl GatherLoanCtxt {
                     // find the region of the resulting pointer (note that
                     // the type of such a pattern will *always* be a
                     // region pointer)
-                    let scope_r = ty_region(self.tcx().ty(pat));
+                    let scope_r = ty_region(self.tcx(), pat.span,
+                                            self.tcx().ty(pat));
 
                     // if the scope of the region ptr turns out to be
                     // specific to this arm, wrap the categorization with

branches/try2/src/librustc/middle/trans/base.rs

@@ -1579,7 +1579,17 @@ pub fn new_fn_ctxt_w_id(ccx: @CrateContext,
                         id: ast::node_id,
                         impl_id: Option<ast::def_id>,
                         param_substs: Option<@param_substs>,
-                        sp: Option<span>) -> fn_ctxt {
+                        sp: Option<span>) -> fn_ctxt
+{
+    for param_substs.each |p| { p.validate(); }
+
+    debug!("new_fn_ctxt_w_id(path=%s, id=%?, impl_id=%?, \
+            param_substs=%s",
+           path_str(ccx.sess, path),
+           id,
+           impl_id,
+           opt_param_substs_to_str(ccx.tcx, &param_substs));
+
     let llbbs = mk_standard_basic_blocks(llfndecl);
     return @mut fn_ctxt_ {
           llfn: llfndecl,

branches/try2/src/librustc/middle/trans/callee.rs

@@ -217,7 +217,7 @@ pub fn trans_fn_ref_with_vtables(
     // - `type_params`: values for each of the fn/method's type parameters
     // - `vtables`: values for each bound on each of the type parameters
 
-    let _icx = bcx.insn_ctxt("trans_fn_with_vtables");
+    let _icx = bcx.insn_ctxt("trans_fn_ref_with_vtables");
     let ccx = bcx.ccx();
     let tcx = ccx.tcx;
 
@@ -228,6 +228,8 @@ pub fn trans_fn_ref_with_vtables(
            vtables);
     let _indenter = indenter();
 
+    fail_unless!(type_params.all(|t| !ty::type_needs_infer(*t)));
+
     // Polytype of the function item (may have type params)
     let fn_tpt = ty::lookup_item_type(tcx, def_id);