---

yaml
---
r: 274268
b: refs/heads/stable
c: 082c03b
h: refs/heads/master

Author: dsprenkels

[refs]

@@ -29,7 +29,7 @@ refs/heads/tmp: e06d2ad9fcd5027bcaac5b08fc9aa39a49d0ecd3
 refs/tags/1.0.0-alpha.2: 4c705f6bc559886632d3871b04f58aab093bfa2f
 refs/tags/homu-tmp: c0221c8897db309a79990367476177b1230bb264
 refs/tags/1.0.0-beta: 8cbb92b53468ee2b0c2d3eeb8567005953d40828
-refs/heads/stable: ef96037f7e95f344d34252fa70bb10109ad5b285
+refs/heads/stable: 082c03b0780b2de24b68be04e96d1596a7c5b3cf
 refs/tags/1.0.0: 55bd4f8ff2b323f317ae89e254ce87162d52a375
 refs/tags/1.1.0: bc3c16f09287e5545c1d3f76b7abd54f2eca868b
 refs/tags/1.2.0: f557861f822c34f07270347b94b5280de20a597e

branches/stable/src/doc/book/error-handling.md

@@ -1512,7 +1512,7 @@ and [`rustc-serialize`](https://crates.io/crates/rustc-serialize) crates.
 
 We're not going to spend a lot of time on setting up a project with
 Cargo because it is already covered well in [the Cargo
-section](getting-started.html#hello-cargo) and [Cargo's documentation][14].
+section](../book/hello-cargo.html) and [Cargo's documentation][14].
 
 To get started from scratch, run `cargo new --bin city-pop` and make sure your
 `Cargo.toml` looks something like this:

branches/stable/src/doc/book/getting-started.md

@@ -167,10 +167,6 @@ variable. If it isn't, run the installer again, select "Change" on the "Change,
 repair, or remove installation" page and ensure "Add to PATH" is installed on
 the local hard drive.
 
-Rust does not do its own linking, and so you’ll need to have a linker
-installed. Doing so will depend on your specific system, consult its
-documentation for more details.
-
 If not, there are a number of places where we can get help. The easiest is
 [the #rust IRC channel on irc.mozilla.org][irc], which we can access through
 [Mibbit][mibbit]. Click that link, and we'll be chatting with other Rustaceans
@@ -608,11 +604,11 @@ This chapter covered the basics that will serve you well through the rest of
 this book, and the rest of your time with Rust. Now that you’ve got the tools
 down, we'll cover more about the Rust language itself.
 
-You have two options: Dive into a project with ‘[Tutorial: Guessing Game][guessinggame]’, or
+You have two options: Dive into a project with ‘[Learn Rust][learnrust]’, or
 start from the bottom and work your way up with ‘[Syntax and
 Semantics][syntax]’. More experienced systems programmers will probably prefer
-‘Tutorial: Guessing Game’, while those from dynamic backgrounds may enjoy either. Different
+‘Learn Rust’, while those from dynamic backgrounds may enjoy either. Different
 people learn differently! Choose whatever’s right for you.
 
-[guessinggame]: guessing-game.html
+[learnrust]: learn-rust.html
 [syntax]: syntax-and-semantics.html

branches/stable/src/doc/book/learn-rust.md

@@ -0,0 +1,9 @@
+% Learn Rust
+
+Welcome! This chapter has a few tutorials that teach you Rust through building
+projects. You’ll get a high-level overview, but we’ll skim over the details.
+
+If you’d prefer a more ‘from the ground up’-style experience, check
+out [Syntax and Semantics][ss].
+
+[ss]: syntax-and-semantics.html

branches/stable/src/doc/book/loops.md

@@ -195,7 +195,7 @@ for x in 0..10 {
 You may also encounter situations where you have nested loops and need to
 specify which one your `break` or `continue` statement is for. Like most
 other languages, by default a `break` or `continue` will apply to innermost
-loop. In a situation where you would like to `break` or `continue` for one
+loop. In a situation where you would like to a `break` or `continue` for one
 of the outer loops, you can use labels to specify which loop the `break` or
  `continue` statement applies to. This will only print when both `x` and `y` are
  odd:

branches/stable/src/libcore/cell.rs

@@ -414,9 +414,7 @@ impl<T: ?Sized> RefCell<T> {
     ///
     /// let c = RefCell::new(5);
     ///
-    /// *c.borrow_mut() = 7;
-    ///
-    /// assert_eq!(*c.borrow(), 7);
+    /// let borrowed_five = c.borrow_mut();
     /// ```
     ///
     /// An example of panic:

branches/stable/src/libcore/iter.rs

@@ -2740,13 +2740,7 @@ pub trait Extend<A> {
 /// It is important to note that both back and forth work on the same range,
 /// and do not cross: iteration is over when they meet in the middle.
 ///
-/// In a similar fashion to the [`Iterator`] protocol, once a
-/// `DoubleEndedIterator` returns `None` from a `next_back()`, calling it again
-/// may or may not ever return `Some` again. `next()` and `next_back()` are
-/// interchangable for this purpose.
-///
 /// [`Iterator`]: trait.Iterator.html
-///
 /// # Examples
 ///
 /// Basic usage:
@@ -4252,15 +4246,13 @@ impl<A: Step> RangeFrom<A> {
     ///
     /// # Examples
     ///
-    /// ```
-    /// # #![feature(step_by)]
-    ///
-    /// for i in (0u8..).step_by(2).take(10) {
+    /// ```ignore
+    /// for i in (0u8..).step_by(2) {
     ///     println!("{}", i);
     /// }
     /// ```
     ///
-    /// This prints the first ten even natural integers (0 to 18).
+    /// This prints all even `u8` values.
     #[unstable(feature = "step_by", reason = "recent addition",
                issue = "27741")]
     pub fn step_by(self, by: A) -> StepBy<A, Self> {

branches/stable/src/librustc/lib.rs

@@ -108,6 +108,7 @@ pub mod middle {
     pub mod free_region;
     pub mod intrinsicck;
     pub mod infer;
+    pub mod implicator;
     pub mod lang_items;
     pub mod liveness;
     pub mod mem_categorization;

branches/stable/src/librustc/middle/const_eval.rs

@@ -28,7 +28,7 @@ use util::num::ToPrimitive;
 use util::nodemap::NodeMap;
 
 use graphviz::IntoCow;
-use syntax::ast;
+use syntax::{ast, abi};
 use rustc_front::hir::Expr;
 use rustc_front::hir;
 use rustc_front::intravisit::FnKind;
@@ -1090,16 +1090,19 @@ pub fn eval_const_expr_partial<'tcx>(tcx: &ty::ctxt<'tcx>,
       hir::ExprCall(ref callee, ref args) => {
           let sub_ty_hint = ty_hint.erase_hint();
           let callee_val = try!(eval_const_expr_partial(tcx, callee, sub_ty_hint, fn_args));
-          let did = match callee_val {
-              Function(did) => did,
-              callee => signal!(e, CallOn(callee)),
-          };
-          let (decl, result) = if let Some(fn_like) = lookup_const_fn_by_id(tcx, did) {
-              (fn_like.decl(), &fn_like.body().expr)
-          } else {
-              signal!(e, NonConstPath)
-          };
-          let result = result.as_ref().expect("const fn has no result expression");
+          let (decl, block, constness) = try!(get_fn_def(tcx, e, callee_val));
+          match (ty_hint, constness) {
+              (ExprTypeChecked, _) => {
+                  // no need to check for constness... either check_const
+                  // already forbids this or we const eval over whatever
+                  // we want
+              },
+              (_, hir::Constness::Const) => {
+                  // we don't know much about the function, so we force it to be a const fn
+                  // so compilation will fail later in case the const fn's body is not const
+              },
+              _ => signal!(e, NonConstPath),
+          }
           assert_eq!(decl.inputs.len(), args.len());
 
           let mut call_args = NodeMap();
@@ -1114,6 +1117,7 @@ pub fn eval_const_expr_partial<'tcx>(tcx: &ty::ctxt<'tcx>,
               let old = call_args.insert(arg.pat.id, arg_val);
               assert!(old.is_none());
           }
+          let result = block.expr.as_ref().unwrap();
           debug!("const call({:?})", call_args);
           try!(eval_const_expr_partial(tcx, &**result, ty_hint, Some(&call_args)))
       },
@@ -1385,3 +1389,46 @@ pub fn compare_lit_exprs<'tcx>(tcx: &ty::ctxt<'tcx>,
     };
     compare_const_vals(&a, &b)
 }
+
+
+// returns Err if callee is not `Function`
+// `e` is only used for error reporting/spans
+fn get_fn_def<'a>(tcx: &'a ty::ctxt,
+                  e: &hir::Expr,
+                  callee: ConstVal)
+                  -> Result<(&'a hir::FnDecl, &'a hir::Block, hir::Constness), ConstEvalErr> {
+    let did = match callee {
+        Function(did) => did,
+        callee => signal!(e, CallOn(callee)),
+    };
+    debug!("fn call: {:?}", tcx.map.get_if_local(did));
+    match tcx.map.get_if_local(did) {
+        None => signal!(e, UnimplementedConstVal("calling non-local const fn")), // non-local
+        Some(ast_map::NodeItem(it)) => match it.node {
+            hir::ItemFn(
+                ref decl,
+                hir::Unsafety::Normal,
+                constness,
+                abi::Abi::Rust,
+                _, // ducktype generics? types are funky in const_eval
+                ref block,
+            ) => Ok((&**decl, &**block, constness)),
+            _ => signal!(e, NonConstPath),
+        },
+        Some(ast_map::NodeImplItem(it)) => match it.node {
+            hir::ImplItemKind::Method(
+                hir::MethodSig {
+                    ref decl,
+                    unsafety: hir::Unsafety::Normal,
+                    constness,
+                    abi: abi::Abi::Rust,
+                    .. // ducktype generics? types are funky in const_eval
+                },
+                ref block,
+            ) => Ok((decl, block, constness)),
+            _ => signal!(e, NonConstPath),
+        },
+        Some(ast_map::NodeTraitItem(..)) => signal!(e, NonConstPath),
+        Some(_) => signal!(e, UnimplementedConstVal("calling struct, tuple or variant")),
+    }
+}

branches/stable/src/librustc/middle/cstore.rs

@@ -267,28 +267,24 @@ impl InlinedItem {
 
 // FIXME: find a better place for this?
 pub fn validate_crate_name(sess: Option<&Session>, s: &str, sp: Option<Span>) {
-    let mut err_count = 0;
-    {
-        let mut say = |s: &str| {
-            match (sp, sess) {
-                (_, None) => panic!("{}", s),
-                (Some(sp), Some(sess)) => sess.span_err(sp, s),
-                (None, Some(sess)) => sess.err(s),
-            }
-            err_count += 1;
-        };
-        if s.is_empty() {
-            say("crate name must not be empty");
-        }
-        for c in s.chars() {
-            if c.is_alphanumeric() { continue }
-            if c == '_'  { continue }
-            say(&format!("invalid character `{}` in crate name: `{}`", c, s));
+    let say = |s: &str| {
+        match (sp, sess) {
+            (_, None) => panic!("{}", s),
+            (Some(sp), Some(sess)) => sess.span_err(sp, s),
+            (None, Some(sess)) => sess.err(s),
         }
+    };
+    if s.is_empty() {
+        say("crate name must not be empty");
     }
-
-    if err_count > 0 {
-        sess.unwrap().abort_if_errors();
+    for c in s.chars() {
+        if c.is_alphanumeric() { continue }
+        if c == '_'  { continue }
+        say(&format!("invalid character `{}` in crate name: `{}`", c, s));
+    }
+    match sess {
+        Some(sess) => sess.abort_if_errors(),
+        None => {}
     }
 }
 

branches/stable/src/librustc/middle/dataflow.rs

@@ -527,7 +527,8 @@ impl<'a, 'tcx, O:DataFlowOperator+Clone+'static> DataFlowContext<'a, 'tcx, O> {
         debug!("{}", {
             let mut v = Vec::new();
             self.pretty_print_to(box &mut v, blk).unwrap();
-            String::from_utf8(v).unwrap()
+            println!("{}", String::from_utf8(v).unwrap());
+            ""
         });
     }