---

yaml
---
r: 277375
b: refs/heads/try
c: 0b5b782
h: refs/heads/master
i:
  277373: 9ae6a39
  277371: b65ef92
  277367: ee58f53
  277359: c9a6a03
  277343: b6cdbdc
  277311: 080e83c
  277247: f6e1c7d

Author: mitaa

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 6dbb0e86aec11050480beb76eade6fb805010ba7
 refs/heads/snap-stage3: 235d77457d80b549dad3ac36d94f235208a1eafb
-refs/heads/try: b50a2ff4d15324bebf6ce8a1661448195c213f5d
+refs/heads/try: 0b5b782e392f0e1d000a7e9fefaad9cbebc0e586
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try/src/doc/book/const-and-static.md

@@ -79,5 +79,5 @@ the result of a function call or anything similarly complex or at runtime.
 
 Almost always, if you can choose between the two, choose `const`. It’s pretty
 rare that you actually want a memory location associated with your constant,
-and using a `const` allows for optimizations like constant propagation not only
+and using a const allows for optimizations like constant propagation not only
 in your crate but downstream crates.

branches/try/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

branches/try/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)
             }
 

branches/try/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();

branches/try/src/librustc_back/target/apple_base.rs

@@ -33,8 +33,9 @@ pub fn opts() -> TargetOptions {
     }).unwrap_or((10, 7));
 
     TargetOptions {
-        // OSX has -dead_strip, which doesn't rely on function_sections
+        // OSX has -dead_strip, which doesn't rely on ffunction_sections
         function_sections: false,
+        linker: "cc".to_string(),
         dynamic_linking: true,
         executables: true,
         is_like_osx: true,

branches/try/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(),

branches/try/src/librustc_back/target/bitrig_base.rs

@@ -13,6 +13,7 @@ use std::default::Default;
 
 pub fn opts() -> TargetOptions {
     TargetOptions {
+        linker: "cc".to_string(),
         dynamic_linking: true,
         executables: true,
         linker_is_gnu: true,

branches/try/src/librustc_back/target/dragonfly_base.rs

@@ -13,6 +13,7 @@ use std::default::Default;
 
 pub fn opts() -> TargetOptions {
     TargetOptions {
+        linker: "cc".to_string(),
         dynamic_linking: true,
         executables: true,
         linker_is_gnu: true,

branches/try/src/librustc_back/target/freebsd_base.rs

@@ -13,6 +13,7 @@ use std::default::Default;
 
 pub fn opts() -> TargetOptions {
     TargetOptions {
+        linker: "cc".to_string(),
         dynamic_linking: true,
         executables: true,
         linker_is_gnu: true,

branches/try/src/librustc_back/target/netbsd_base.rs

@@ -13,6 +13,7 @@ use std::default::Default;
 
 pub fn opts() -> TargetOptions {
     TargetOptions {
+        linker: "cc".to_string(),
         dynamic_linking: true,
         executables: true,
         linker_is_gnu: true,

branches/try/src/librustc_back/target/openbsd_base.rs

@@ -13,6 +13,7 @@ use std::default::Default;
 
 pub fn opts() -> TargetOptions {
     TargetOptions {
+        linker: "cc".to_string(),
         dynamic_linking: true,
         executables: true,
         linker_is_gnu: true,

branches/try/src/librustc_back/target/solaris_base.rs

@@ -13,6 +13,7 @@ use std::default::Default;
 
 pub fn opts() -> TargetOptions {
     TargetOptions {
+        linker: "cc".to_string(),
         dynamic_linking: true,
         executables: true,
         has_rpath: true,

branches/try/src/librustc_typeck/astconv.rs

@@ -155,12 +155,6 @@ pub trait AstConv<'tcx> {
                     _trait_ref: ty::TraitRef<'tcx>,
                     _item_name: ast::Name)
                     -> Ty<'tcx>;
-
-    /// Invoked when we encounter an error from some prior pass
-    /// (e.g. resolve) that is translated into a ty-error. This is
-    /// used to help suppress derived errors typeck might otherwise
-    /// report.
-    fn set_tainted_by_errors(&self);
 }
 
 pub fn ast_region_to_region(tcx: &TyCtxt, lifetime: &hir::Lifetime)
@@ -1539,7 +1533,6 @@ fn base_def_to_ty<'tcx>(this: &AstConv<'tcx>,
             prim_ty_to_ty(tcx, base_segments, prim_ty)
         }
         Def::Err => {
-            this.set_tainted_by_errors();
             return this.tcx().types.err;
         }
         _ => {

branches/try/src/librustc_typeck/check/_match.rs

@@ -209,7 +209,6 @@ pub fn check_pat<'a, 'tcx>(pcx: &pat_ctxt<'a, 'tcx>,
             let self_ty = fcx.to_ty(&qself.ty);
             let path_res = if let Some(&d) = tcx.def_map.borrow().get(&pat.id) {
                 if d.base_def == Def::Err {
-                    fcx.infcx().set_tainted_by_errors();
                     fcx.write_error(pat.id);
                     return;
                 }
@@ -629,7 +628,6 @@ fn check_pat_enum<'a, 'tcx>(pcx: &pat_ctxt<'a, 'tcx>,
     let path_res = match tcx.def_map.borrow().get(&pat.id) {
         Some(&path_res) if path_res.base_def != Def::Err => path_res,
         _ => {
-            fcx.infcx().set_tainted_by_errors();
             fcx.write_error(pat.id);
 
             if let Some(subpats) = subpats {

branches/try/src/librustc_typeck/check/cast.rs

@@ -45,21 +45,19 @@ use super::structurally_resolved_type;
 
 use lint;
 use hir::def_id::DefId;
-use rustc::hir;
-use rustc::traits;
 use rustc::ty::{self, Ty, TypeFoldable};
 use rustc::ty::cast::{CastKind, CastTy};
-use syntax::ast;
 use syntax::codemap::Span;
-use util::common::ErrorReported;
+use rustc::hir;
+use syntax::ast;
+
 
 /// Reifies a cast check to be checked once we have full type information for
 /// a function context.
 pub struct CastCheck<'tcx> {
     expr: &'tcx hir::Expr,
     expr_ty: Ty<'tcx>,
     cast_ty: Ty<'tcx>,
-    cast_span: Span,
     span: Span,
 }
 
@@ -113,37 +111,17 @@ enum CastError {
 }
 
 impl<'tcx> CastCheck<'tcx> {
-    pub fn new<'a>(fcx: &FnCtxt<'a, 'tcx>,
-                   expr: &'tcx hir::Expr,
-                   expr_ty: Ty<'tcx>,
-                   cast_ty: Ty<'tcx>,
-                   cast_span: Span,
-                   span: Span)
-                   -> Result<CastCheck<'tcx>, ErrorReported> {
-        let check = CastCheck {
+    pub fn new(expr: &'tcx hir::Expr, expr_ty: Ty<'tcx>, cast_ty: Ty<'tcx>, span: Span)
+               -> CastCheck<'tcx> {
+        CastCheck {
             expr: expr,
             expr_ty: expr_ty,
             cast_ty: cast_ty,
-            cast_span: cast_span,
             span: span,
-        };
-
-        // For better error messages, check for some obviously unsized
-        // cases now. We do a more thorough check at the end, once
-        // inference is more completely known.
-        match cast_ty.sty {
-            ty::TyTrait(..) | ty::TySlice(..) => {
-                check.report_cast_to_unsized_type(fcx);
-                Err(ErrorReported)
-            }
-            _ => {
-                Ok(check)
-            }
         }
     }
 
-    fn report_cast_error<'a>(&self,
-                             fcx: &FnCtxt<'a, 'tcx>,
+    fn report_cast_error<'a>(&self, fcx: &FnCtxt<'a, 'tcx>,
                              e: CastError) {
         match e {
             CastError::NeedViaPtr |
@@ -208,61 +186,6 @@ impl<'tcx> CastCheck<'tcx> {
         }
     }
 
-    fn report_cast_to_unsized_type<'a>(&self,
-                                       fcx: &FnCtxt<'a, 'tcx>) {
-        if
-            self.cast_ty.references_error() ||
-            self.expr_ty.references_error()
-        {
-            return;
-        }
-
-        let tstr = fcx.infcx().ty_to_string(self.cast_ty);
-        let mut err = fcx.type_error_struct(self.span, |actual| {
-            format!("cast to unsized type: `{}` as `{}`", actual, tstr)
-        }, self.expr_ty, None);
-        match self.expr_ty.sty {
-            ty::TyRef(_, ty::TypeAndMut { mutbl: mt, .. }) => {
-                let mtstr = match mt {
-                    hir::MutMutable => "mut ",
-                    hir::MutImmutable => ""
-                };
-                if self.cast_ty.is_trait() {
-                    match fcx.tcx().sess.codemap().span_to_snippet(self.cast_span) {
-                        Ok(s) => {
-                            err.span_suggestion(self.cast_span,
-                                                "try casting to a reference instead:",
-                                                format!("&{}{}", mtstr, s));
-                        },
-                        Err(_) =>
-                            span_help!(err, self.cast_span,
-                                       "did you mean `&{}{}`?", mtstr, tstr),
-                    }
-                } else {
-                    span_help!(err, self.span,
-                               "consider using an implicit coercion to `&{}{}` instead",
-                               mtstr, tstr);
-                }
-            }
-            ty::TyBox(..) => {
-                match fcx.tcx().sess.codemap().span_to_snippet(self.cast_span) {
-                    Ok(s) => {
-                        err.span_suggestion(self.cast_span,
-                                            "try casting to a `Box` instead:",
-                                            format!("Box<{}>", s));
-                    },
-                    Err(_) =>
-                        span_help!(err, self.cast_span, "did you mean `Box<{}>`?", tstr),
-                }
-            }
-            _ => {
-                span_help!(err, self.expr.span,
-                           "consider using a box or reference as appropriate");
-            }
-        }
-        err.emit();
-    }
-
     fn trivial_cast_lint<'a>(&self, fcx: &FnCtxt<'a, 'tcx>) {
         let t_cast = self.cast_ty;
         let t_expr = self.expr_ty;
@@ -295,9 +218,7 @@ impl<'tcx> CastCheck<'tcx> {
         debug!("check_cast({}, {:?} as {:?})", self.expr.id, self.expr_ty,
                self.cast_ty);
 
-        if !fcx.type_is_known_to_be_sized(self.cast_ty, self.span) {
-            self.report_cast_to_unsized_type(fcx);
-        } else if self.expr_ty.references_error() || self.cast_ty.references_error() {
+        if self.expr_ty.references_error() || self.cast_ty.references_error() {
             // No sense in giving duplicate error messages
         } else if self.try_coercion_cast(fcx) {
             self.trivial_cast_lint(fcx);
@@ -482,17 +403,3 @@ impl<'tcx> CastCheck<'tcx> {
     }
 
 }
-
-impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
-    fn type_is_known_to_be_sized(&self,
-                                 ty: Ty<'tcx>,
-                                 span: Span)
-                                 -> bool
-    {
-        traits::type_known_to_meet_builtin_bound(self.infcx(),
-                                                 ty,
-                                                 ty::BoundSized,
-                                                 span)
-    }
-}
-