---

yaml
---
r: 50994
b: refs/heads/try
c: 969e8b7
h: refs/heads/master
v: v3

Author: jbclements

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 5f13e9ccc2e3328d4cd8ca49f84e6840dd998346
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: f7a2371c176663d59062ec5158f39faecba45768
-refs/heads/try: 3f7c74d0225354b93bf7649fed8cdd2774480106
+refs/heads/try: 969e8b76a184ce3083c7854a986baf3f279b5c81
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c

branches/try/RELEASES.txt

@@ -62,6 +62,8 @@ Version 0.6 (March 2013)
       * Pattern matching over vectors improved and expanded
       * Typechecking of closure types has been overhauled to
         improve inference and eliminate unsoundness
+      * Macros leave scope at the end of modules, unless that module is
+        tagged with #[macro_escape]
 
    * Libraries
       * Added big integers to `std::bigint`

branches/try/doc/rust.css

@@ -101,9 +101,4 @@ 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/try/doc/rust.md

@@ -1671,10 +1671,6 @@ 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"];
@@ -2160,19 +2156,6 @@ 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
 
@@ -2201,7 +2184,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 of a for loop over the contents of a vector:
+An example a for loop:
 
 ~~~~
 # type foo = int;
@@ -2215,14 +2198,6 @@ 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
 
@@ -2499,7 +2474,6 @@ 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.
@@ -2510,10 +2484,6 @@ 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/try/src/libcore/cast.rs

@@ -8,8 +8,6 @@
 // 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/try/src/libcore/cell.rs

@@ -8,17 +8,13 @@
 // 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/try/src/libcore/clone.rs

@@ -8,20 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-/*! 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.
-
+/**
+Clonable types are copied with the clone method
 */
-
 pub trait Clone {
     fn clone(&self) -> Self;
 }

branches/try/src/libcore/comm.rs

@@ -8,10 +8,6 @@
 // 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/try/src/libcore/condition.rs

@@ -8,8 +8,6 @@
 // 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/try/src/libcore/core.rc

@@ -10,39 +10,27 @@
 
 /*!
 
-# 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
-(`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`).
+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`).
 
-# 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
+`core` is linked to all crates by default and its contents imported.
+Implicitly, all crates behave as if they included the following prologue:
 
     extern mod 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::*;
+    use core::*;
 
 */
 

branches/try/src/libcore/iter.rs

@@ -284,8 +284,7 @@ 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
-/// in a sequence built via `BU`.  See also `map_to_vec`.
+/// Applies a function to each element of an iterable and returns the results.
 #[inline(always)]
 pub fn map<T,IT: BaseIter<T>,U,BU: Buildable<U>>(v: &IT, f: &fn(&T) -> U)
     -> BU {

branches/try/src/libcore/prelude.rs

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

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

@@ -8,8 +8,6 @@
 // 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/try/src/libcore/unstable/lang.rs

@@ -99,12 +99,8 @@ pub unsafe fn borrow_as_imm(a: *u8) {
 #[lang="return_to_mut"]
 #[inline(always)]
 pub unsafe fn return_to_mut(a: *u8) {
-    // 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;
-    }
+    let a: *mut BoxRepr = transmute(a);
+    (*a).header.ref_count &= !FROZEN_BIT;
 }
 
 #[lang="check_not_borrowed"]

branches/try/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 capacity for the vector.
+ * This version takes an initial size for the vector.
  *
  * # Arguments
  *
  * * size - An initial size of the vector to reserve
- * * builder - A function that will construct the vector. It receives
+ * * builder - A function that will construct the vector. It recieves
  *             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 receives
+ * * builder - A function that will construct the vector. It recieves
  *             as an argument a function that will push an element
  *             onto the vector being constructed.
  */

branches/try/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, where . is the current directory (that is, the parent
-directory of front/, middle/, back/, and so on).
+./../libsyntax if the parent directory of front/, middle/, back/, and
+so on is . .
 
 The entry-point for the compiler is main() in driver/rustc.rs, and
 this file sequences the various parts together.

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

@@ -1579,17 +1579,7 @@ 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
-{
-    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));
-
+                        sp: Option<span>) -> fn_ctxt {
     let llbbs = mk_standard_basic_blocks(llfndecl);
     return @mut fn_ctxt_ {
           llfn: llfndecl,

branches/try/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_ref_with_vtables");
+    let _icx = bcx.insn_ctxt("trans_fn_with_vtables");
     let ccx = bcx.ccx();
     let tcx = ccx.tcx;
 
@@ -228,8 +228,6 @@ 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);
 

branches/try/src/librustc/middle/trans/common.rs

@@ -250,25 +250,13 @@ pub struct param_substs {
     self_ty: Option<ty::t>
 }
 
-pub impl param_substs {
-    fn validate(&self) {
-        for self.tys.each |t| { fail_unless!(!ty::type_needs_infer(*t)); }
-        for self.self_ty.each |t| { fail_unless!(!ty::type_needs_infer(*t)); }
-    }
-}
-
 pub fn param_substs_to_str(tcx: ty::ctxt, substs: &param_substs) -> ~str {
     fmt!("param_substs {tys:%?, vtables:%?, bounds:%?}",
          substs.tys.map(|t| ty_to_str(tcx, *t)),
          substs.vtables.map(|vs| vs.map(|v| v.to_str(tcx))),
          substs.bounds.map(|b| ty::param_bounds_to_str(tcx, *b)))
 }
 
-pub fn opt_param_substs_to_str(tcx: ty::ctxt,
-                               substs: &Option<@param_substs>) -> ~str {
-    substs.map_default(~"None", |&ps| param_substs_to_str(tcx, ps))
-}
-
 // Function context.  Every LLVM function we create will have one of
 // these.
 pub struct fn_ctxt_ {
@@ -1379,13 +1367,6 @@ pub fn expr_ty_adjusted(bcx: block, ex: @ast::expr) -> ty::t {
 pub fn node_id_type_params(bcx: block, id: ast::node_id) -> ~[ty::t] {
     let tcx = bcx.tcx();
     let params = ty::node_id_to_type_params(tcx, id);
-
-    if !params.all(|t| !ty::type_needs_infer(*t)) {
-        bcx.sess().bug(
-            fmt!("Type parameters for node %d include inference types: %s",
-                 id, str::connect(params.map(|t| bcx.ty_to_str(*t)), ",")));
-    }
-
     match bcx.fcx.param_substs {
       Some(substs) => {
         do vec::map(params) |t| {
@@ -1442,7 +1423,7 @@ pub fn resolve_vtable_in_fn_ctxt(fcx: fn_ctxt, +vt: typeck::vtable_origin)
 }
 
 pub fn find_vtable(tcx: ty::ctxt, ps: &param_substs,
-                   n_param: uint, n_bound: uint)
+               n_param: uint, n_bound: uint)
     -> typeck::vtable_origin {
     debug!("find_vtable_in_fn_ctxt(n_param=%u, n_bound=%u, ps=%?)",
            n_param, n_bound, param_substs_to_str(tcx, ps));