---

yaml
---
r: 275995
b: refs/heads/master
c: c31e2e7
h: refs/heads/master
i:
  275993: 6f3f61d
  275991: 884c337

Author: alexcrichton

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: ea6b3ddee9663e27221f366671261b21618394a0
+refs/heads/master: c31e2e77ed955faafffe7b22859f045cc1e5deec
 refs/heads/snap-stage3: 235d77457d80b549dad3ac36d94f235208a1eafb
 refs/heads/try: 49312a405e14a449b98fe0056b12a40ac128be4a
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105

trunk/mk/crates.mk

@@ -120,7 +120,7 @@ DEPS_rustc_trans := arena flate getopts graphviz libc rustc rustc_back rustc_mir
                     log syntax serialize rustc_llvm rustc_platform_intrinsics \
                     rustc_const_math rustc_const_eval rustc_incremental
 DEPS_rustc_incremental := rbml rustc serialize rustc_data_structures
-DEPS_rustc_save_analysis := rustc log syntax serialize
+DEPS_rustc_save_analysis := rustc log syntax
 DEPS_rustc_typeck := rustc syntax rustc_platform_intrinsics rustc_const_math \
                      rustc_const_eval
 

trunk/mk/tests.mk

@@ -623,7 +623,7 @@ CTEST_COMMON_ARGS$(1)-T-$(2)-H-$(3) := \
 	--lldb-python $$(CFG_LLDB_PYTHON) \
         --gdb-version="$(CFG_GDB_VERSION)" \
         --lldb-version="$(CFG_LLDB_VERSION)" \
-        --android-cross-path=$(CFG_ARM_LINUX_ANDROIDEABI_NDK) \
+        --android-cross-path=$(CFG_ANDROID_CROSS_PATH) \
         --adb-path=$(CFG_ADB) \
         --adb-test-dir=$(CFG_ADB_TEST_DIR) \
         --host-rustcflags "$(RUSTC_FLAGS_$(3)) $$(CTEST_RUSTC_FLAGS) -L $$(RT_OUTPUT_DIR_$(3))" \

trunk/src/doc/book/getting-started.md

@@ -412,7 +412,7 @@ enter the following commands:
 
 ```bash
 $ mkdir src
-$ mv main.rs src/main.rs # or 'move main.rs src/main.rs' on Windows
+$ mv main.rs src/main.rs
 $ rm main  # or 'del main.exe' on Windows
 ```
 

trunk/src/doc/book/lifetimes.md

@@ -1,7 +1,7 @@
 % Lifetimes
 
-This is the last of three sections presenting Rust’s ownership system. This is one of
-Rust’s most distinct and compelling features, with which Rust developers should
+This guide is three of three presenting Rust’s ownership system. This is one of
+Rust’s most unique and compelling features, with which Rust developers should
 become quite acquainted. Ownership is how Rust achieves its largest goal,
 memory safety. There are a few distinct concepts, each with its own chapter:
 

trunk/src/doc/book/ownership.md

@@ -1,7 +1,7 @@
 % Ownership
 
-This is the first of three sections presenting Rust’s ownership system. This is one of
-Rust’s most distinct and compelling features, with which Rust developers should
+This guide is one of three presenting Rust’s ownership system. This is one of
+Rust’s most unique and compelling features, with which Rust developers should
 become quite acquainted. Ownership is how Rust achieves its largest goal,
 memory safety. There are a few distinct concepts, each with its own
 chapter:

trunk/src/doc/book/references-and-borrowing.md

@@ -1,7 +1,7 @@
 % References and Borrowing
 
-This is the second of three sections presenting Rust’s ownership system. This is one of
-Rust’s most distinct and compelling features, with which Rust developers should
+This guide is two of three presenting Rust’s ownership system. This is one of
+Rust’s most unique and compelling features, with which Rust developers should
 become quite acquainted. Ownership is how Rust achieves its largest goal,
 memory safety. There are a few distinct concepts, each with its own
 chapter:
@@ -77,32 +77,6 @@ let answer = foo(&v1, &v2);
 // we can use v1 and v2 here!
 ```
 
-A more concrete example:
-
-```rust
-fn main() {
-    // Don't worry if you don't understand how `fold` works, the point here is that an immutable reference is borrowed.
-    fn sum_vec(v: &Vec<i32>) -> i32 {
-        return v.iter().fold(0, |a, &b| a + b);
-    }
-    // Borrow two vectors and and sum them.
-    // This kind of borrowing does not allow mutation to the borrowed.
-    fn foo(v1: &Vec<i32>, v2: &Vec<i32>) -> i32 {
-        // do stuff with v1 and v2
-        let s1 = sum_vec(v1);
-        let s2 = sum_vec(v2);
-        // return the answer
-        s1 + s2
-    }
-
-    let v1 = vec![1, 2, 3];
-    let v2 = vec![4, 5, 6];
-
-    let answer = foo(&v1, &v2);
-    println!("{}", answer);
-}
-```
-
 Instead of taking `Vec<i32>`s as our arguments, we take a reference:
 `&Vec<i32>`. And instead of passing `v1` and `v2` directly, we pass `&v1` and
 `&v2`. We call the `&T` type a ‘reference’, and rather than owning the resource,

trunk/src/libcore/clone.rs

@@ -75,17 +75,6 @@ pub trait Clone : Sized {
     }
 }
 
-// FIXME(aburka): this method is used solely by #[derive] to
-// assert that every component of a type implements Clone.
-//
-// This should never be called by user code.
-#[doc(hidden)]
-#[inline(always)]
-#[unstable(feature = "derive_clone_copy",
-           reason = "deriving hack, should not be public",
-           issue = "0")]
-pub fn assert_receiver_is_clone<T: Clone + ?Sized>(_: &T) {}
-
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<'a, T: ?Sized> Clone for &'a T {
     /// Returns a shallow copy of the reference.

trunk/src/libcore/ptr.rs

@@ -459,9 +459,6 @@ impl<T: ?Sized> *mut T {
     /// ```
     /// let mut s = [1, 2, 3];
     /// let ptr: *mut u32 = s.as_mut_ptr();
-    /// let first_value = unsafe { ptr.as_mut().unwrap() };
-    /// *first_value = 4;
-    /// println!("{:?}", s); // It'll print: "[4, 2, 3]".
     /// ```
     #[stable(feature = "ptr_as_ref", since = "1.9.0")]
     #[inline]

trunk/src/librustc/infer/error_reporting.rs

@@ -157,7 +157,7 @@ impl<'tcx> TyCtxt<'tcx> {
                         "scope of call-site for function"
                     }
                     region::CodeExtentData::ParameterScope { .. } => {
-                        "scope of function body"
+                        "scope of parameters for function"
                     }
                     region::CodeExtentData::DestructionScope(_) => {
                         new_string = format!("destruction scope surrounding {}", tag);

trunk/src/librustc/infer/mod.rs

@@ -35,7 +35,7 @@ use ty::fold::TypeFoldable;
 use ty::relate::{Relate, RelateResult, TypeRelation};
 use traits::{self, PredicateObligations, ProjectionMode};
 use rustc_data_structures::unify::{self, UnificationTable};
-use std::cell::{Cell, RefCell, Ref};
+use std::cell::{RefCell, Ref};
 use std::fmt;
 use syntax::ast;
 use syntax::codemap;
@@ -110,25 +110,6 @@ pub struct InferCtxt<'a, 'tcx: 'a> {
     // documentation for `ProjectionMode`.
     projection_mode: ProjectionMode,
 
-    // When an error occurs, we want to avoid reporting "derived"
-    // errors that are due to this original failure. Normally, we
-    // handle this with the `err_count_on_creation` count, which
-    // basically just tracks how many errors were reported when we
-    // started type-checking a fn and checks to see if any new errors
-    // have been reported since then. Not great, but it works.
-    //
-    // However, when errors originated in other passes -- notably
-    // resolve -- this heuristic breaks down. Therefore, we have this
-    // auxiliary flag that one can set whenever one creates a
-    // type-error that is due to an error in a prior pass.
-    //
-    // Don't read this flag directly, call `is_tainted_by_errors()`
-    // and `set_tainted_by_errors()`.
-    tainted_by_errors_flag: Cell<bool>,
-
-    // Track how many errors were reported when this infcx is created.
-    // If the number of errors increases, that's also a sign (line
-    // `tained_by_errors`) to avoid reporting certain kinds of errors.
     err_count_on_creation: usize,
 }
 
@@ -398,7 +379,6 @@ pub fn new_infer_ctxt<'a, 'tcx>(tcx: &'a TyCtxt<'tcx>,
         reported_trait_errors: RefCell::new(FnvHashSet()),
         normalize: false,
         projection_mode: projection_mode,
-        tainted_by_errors_flag: Cell::new(false),
         err_count_on_creation: tcx.sess.err_count()
     }
 }
@@ -1148,36 +1128,15 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
                                         .map(|method| resolve_ty(method.ty)))
     }
 
-    /// True if errors have been reported since this infcx was
-    /// created.  This is sometimes used as a heuristic to skip
-    /// reporting errors that often occur as a result of earlier
-    /// errors, but where it's hard to be 100% sure (e.g., unresolved
-    /// inference variables, regionck errors).
-    pub fn is_tainted_by_errors(&self) -> bool {
-        debug!("is_tainted_by_errors(err_count={}, err_count_on_creation={}, \
-                tainted_by_errors_flag={})",
-               self.tcx.sess.err_count(),
-               self.err_count_on_creation,
-               self.tainted_by_errors_flag.get());
-
-        if self.tcx.sess.err_count() > self.err_count_on_creation {
-            return true; // errors reported since this infcx was made
-        }
-        self.tainted_by_errors_flag.get()
-    }
-
-    /// Set the "tainted by errors" flag to true. We call this when we
-    /// observe an error from a prior pass.
-    pub fn set_tainted_by_errors(&self) {
-        debug!("set_tainted_by_errors()");
-        self.tainted_by_errors_flag.set(true)
+    pub fn errors_since_creation(&self) -> bool {
+        self.tcx.sess.err_count() - self.err_count_on_creation != 0
     }
 
     pub fn node_type(&self, id: ast::NodeId) -> Ty<'tcx> {
         match self.tables.borrow().node_types.get(&id) {
             Some(&t) => t,
             // FIXME
-            None if self.is_tainted_by_errors() =>
+            None if self.errors_since_creation() =>
                 self.tcx.types.err,
             None => {
                 bug!("no type for node {}: {} in fcx",
@@ -1199,7 +1158,7 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
                                              free_regions: &FreeRegionMap,
                                              subject_node_id: ast::NodeId) {
         let errors = self.region_vars.resolve_regions(free_regions, subject_node_id);
-        if !self.is_tainted_by_errors() {
+        if !self.errors_since_creation() {
             // As a heuristic, just skip reporting region errors
             // altogether if other errors have been reported while
             // this infcx was in use.  This is totally hokey but

trunk/src/librustc/infer/sub.rs

@@ -91,7 +91,6 @@ impl<'a, 'tcx> TypeRelation<'a, 'tcx> for Sub<'a, 'tcx> {
             }
 
             (&ty::TyError, _) | (_, &ty::TyError) => {
-                infcx.set_tainted_by_errors();
                 Ok(self.tcx().types.err)
             }
 

trunk/src/librustc/middle/region.rs

@@ -389,7 +389,7 @@ impl RegionMaps {
                            // but this isn't the only place
                 }
                 let idx = CodeExtent(self.code_extents.borrow().len() as u32);
-                debug!("CodeExtent({}) = {:?} [parent={}]", idx.0, e, parent.0);
+                info!("CodeExtent({}) = {:?} [parent={}]", idx.0, e, parent.0);
                 self.code_extents.borrow_mut().push(e);
                 self.scope_map.borrow_mut().push(parent);
                 *v.insert(idx)

trunk/src/librustc/session/config.rs

@@ -618,9 +618,7 @@ options! {DebuggingOptions, DebuggingSetter, basic_debugging_options,
     ls: bool = (false, parse_bool,
         "list the symbols defined by a library crate"),
     save_analysis: bool = (false, parse_bool,
-        "write syntax and type analysis (in JSON format) information in addition to normal output"),
-    save_analysis_csv: bool = (false, parse_bool,
-        "write syntax and type analysis (in CSV format) information in addition to normal output"),
+        "write syntax and type analysis information in addition to normal output"),
     print_move_fragments: bool = (false, parse_bool,
         "print out move-fragment data for every fn"),
     flowgraph_print_loans: bool = (false, parse_bool,

trunk/src/librustc/traits/error_reporting.rs

@@ -624,12 +624,6 @@ pub fn maybe_report_ambiguity<'a, 'tcx>(infcx: &InferCtxt<'a, 'tcx>,
            predicate,
            obligation);
 
-    // Ambiguity errors are often caused as fallout from earlier
-    // errors. So just ignore them if this infcx is tainted.
-    if infcx.is_tainted_by_errors() {
-        return;
-    }
-
     match predicate {
         ty::Predicate::Trait(ref data) => {
             let trait_ref = data.to_poly_trait_ref();

trunk/src/librustc/traits/fulfill.rs

@@ -542,12 +542,12 @@ fn process_predicate1<'a,'tcx>(selcx: &mut SelectionContext<'a,'tcx>,
             let trait_obligation = obligation.with(data.clone());
             match selcx.select(&trait_obligation) {
                 Ok(Some(vtable)) => {
-                    debug!("selecting trait `{:?}` at depth {} yielded Ok(Some)",
+                    info!("selecting trait `{:?}` at depth {} yielded Ok(Some)",
                           data, obligation.recursion_depth);
                     Ok(Some(vtable.nested_obligations()))
                 }
                 Ok(None) => {
-                    debug!("selecting trait `{:?}` at depth {} yielded Ok(None)",
+                    info!("selecting trait `{:?}` at depth {} yielded Ok(None)",
                           data, obligation.recursion_depth);
 
                     // This is a bit subtle: for the most part, the
@@ -781,6 +781,8 @@ impl<'tcx> GlobalFulfilledPredicates<'tcx> {
             self.dep_graph.read(data.dep_node());
             debug!("check_duplicate: global predicate `{:?}` already proved elsewhere", data);
 
+            info!("check_duplicate_trait hit: `{:?}`", data);
+
             true
         } else {
             false
@@ -796,6 +798,7 @@ impl<'tcx> GlobalFulfilledPredicates<'tcx> {
             if data.is_global() {
                 if self.set.insert(data.clone()) {
                     debug!("add_if_global: global predicate `{:?}` added", data);
+                    info!("check_duplicate_trait entry: `{:?}`", data);
                 }
             }
         }

trunk/src/librustc_back/target/arm_linux_androideabi.rs

@@ -12,7 +12,7 @@ use target::Target;
 
 pub fn target() -> Target {
     let mut base = super::android_base::opts();
-    base.features = "+v7,+vfp3,+d16".to_string();
+    base.features = "+v7".to_string();
 
     Target {
         llvm_target: "arm-linux-androideabi".to_string(),

trunk/src/librustc_const_eval/eval.rs

@@ -562,51 +562,44 @@ pub fn eval_const_expr_partial<'tcx>(tcx: &TyCtxt<'tcx>,
     let result = match e.node {
       hir::ExprUnary(hir::UnNeg, ref inner) => {
         // unary neg literals already got their sign during creation
-        match inner.node {
-            hir::ExprLit(ref lit) => {
-                use syntax::ast::*;
-                use syntax::ast::LitIntType::*;
-                const I8_OVERFLOW: u64 = ::std::i8::MAX as u64 + 1;
-                const I16_OVERFLOW: u64 = ::std::i16::MAX as u64 + 1;
-                const I32_OVERFLOW: u64 = ::std::i32::MAX as u64 + 1;
-                const I64_OVERFLOW: u64 = ::std::i64::MAX as u64 + 1;
-                match (&lit.node, ety.map(|t| &t.sty)) {
-                    (&LitKind::Int(I8_OVERFLOW, Unsuffixed), Some(&ty::TyInt(IntTy::I8))) |
-                    (&LitKind::Int(I8_OVERFLOW, Signed(IntTy::I8)), _) => {
-                        return Ok(Integral(I8(::std::i8::MIN)))
-                    },
-                    (&LitKind::Int(I16_OVERFLOW, Unsuffixed), Some(&ty::TyInt(IntTy::I16))) |
-                    (&LitKind::Int(I16_OVERFLOW, Signed(IntTy::I16)), _) => {
-                        return Ok(Integral(I16(::std::i16::MIN)))
-                    },
-                    (&LitKind::Int(I32_OVERFLOW, Unsuffixed), Some(&ty::TyInt(IntTy::I32))) |
-                    (&LitKind::Int(I32_OVERFLOW, Signed(IntTy::I32)), _) => {
-                        return Ok(Integral(I32(::std::i32::MIN)))
-                    },
-                    (&LitKind::Int(I64_OVERFLOW, Unsuffixed), Some(&ty::TyInt(IntTy::I64))) |
-                    (&LitKind::Int(I64_OVERFLOW, Signed(IntTy::I64)), _) => {
-                        return Ok(Integral(I64(::std::i64::MIN)))
-                    },
-                    (&LitKind::Int(n, Unsuffixed), Some(&ty::TyInt(IntTy::Is))) |
-                    (&LitKind::Int(n, Signed(IntTy::Is)), _) => {
-                        match tcx.sess.target.int_type {
-                            IntTy::I32 => if n == I32_OVERFLOW {
-                                return Ok(Integral(Isize(Is32(::std::i32::MIN))));
-                            },
-                            IntTy::I64 => if n == I64_OVERFLOW {
-                                return Ok(Integral(Isize(Is64(::std::i64::MIN))));
-                            },
-                            _ => bug!(),
-                        }
-                    },
-                    _ => {},
-                }
-            },
-            hir::ExprUnary(hir::UnNeg, ref inner) => {
-                // skip `--$expr`
-                return eval_const_expr_partial(tcx, inner, ty_hint, fn_args);
-            },
-            _ => {},
+        if let hir::ExprLit(ref lit) = inner.node {
+            use syntax::ast::*;
+            use syntax::ast::LitIntType::*;
+            const I8_OVERFLOW: u64 = ::std::i8::MAX as u64 + 1;
+            const I16_OVERFLOW: u64 = ::std::i16::MAX as u64 + 1;
+            const I32_OVERFLOW: u64 = ::std::i32::MAX as u64 + 1;
+            const I64_OVERFLOW: u64 = ::std::i64::MAX as u64 + 1;
+            match (&lit.node, ety.map(|t| &t.sty)) {
+                (&LitKind::Int(I8_OVERFLOW, Unsuffixed), Some(&ty::TyInt(IntTy::I8))) |
+                (&LitKind::Int(I8_OVERFLOW, Signed(IntTy::I8)), _) => {
+                    return Ok(Integral(I8(::std::i8::MIN)))
+                },
+                (&LitKind::Int(I16_OVERFLOW, Unsuffixed), Some(&ty::TyInt(IntTy::I16))) |
+                (&LitKind::Int(I16_OVERFLOW, Signed(IntTy::I16)), _) => {
+                    return Ok(Integral(I16(::std::i16::MIN)))
+                },
+                (&LitKind::Int(I32_OVERFLOW, Unsuffixed), Some(&ty::TyInt(IntTy::I32))) |
+                (&LitKind::Int(I32_OVERFLOW, Signed(IntTy::I32)), _) => {
+                    return Ok(Integral(I32(::std::i32::MIN)))
+                },
+                (&LitKind::Int(I64_OVERFLOW, Unsuffixed), Some(&ty::TyInt(IntTy::I64))) |
+                (&LitKind::Int(I64_OVERFLOW, Signed(IntTy::I64)), _) => {
+                    return Ok(Integral(I64(::std::i64::MIN)))
+                },
+                (&LitKind::Int(n, Unsuffixed), Some(&ty::TyInt(IntTy::Is))) |
+                (&LitKind::Int(n, Signed(IntTy::Is)), _) => {
+                    match tcx.sess.target.int_type {
+                        IntTy::I32 => if n == I32_OVERFLOW {
+                            return Ok(Integral(Isize(Is32(::std::i32::MIN))));
+                        },
+                        IntTy::I64 => if n == I64_OVERFLOW {
+                            return Ok(Integral(Isize(Is64(::std::i64::MIN))));
+                        },
+                        _ => bug!(),
+                    }
+                },
+                _ => {},
+            }
         }
         match eval_const_expr_partial(tcx, &inner, ty_hint, fn_args)? {
           Float(f) => Float(-f),