---

yaml
---
r: 273365
b: refs/heads/beta
c: 2dd5776
h: refs/heads/master
i:
  273363: 4dbbaea

Author: Daniel J Rollins

[refs]

@@ -23,7 +23,7 @@ refs/tags/0.9: 36870b185fc5f5486636d4515f0e22677493f225
 refs/tags/0.10: ac33f2b15782272ae348dbd7b14b8257b2148b5a
 refs/tags/0.11.0: e1247cb1d0d681be034adb4b558b5a0c0d5720f9
 refs/tags/0.12.0: f0c419429ef30723ceaf6b42f9b5a2aeb5d2e2d1
-refs/heads/beta: 78e8a00514052bf812af0677dde8710336d77cbb
+refs/heads/beta: 2dd5776b1110a24d9ceb1d1f89dd684d0e63fbf7
 refs/tags/1.0.0-alpha: e42bd6d93a1d3433c486200587f8f9e12590a4d7
 refs/heads/tmp: e06d2ad9fcd5027bcaac5b08fc9aa39a49d0ecd3
 refs/tags/1.0.0-alpha.2: 4c705f6bc559886632d3871b04f58aab093bfa2f

branches/beta/src/libcore/intrinsics.rs

@@ -53,35 +53,19 @@ extern "rust-intrinsic" {
     // NB: These intrinsics take raw pointers because they mutate aliased
     // memory, which is not valid for either `&` or `&mut`.
 
-    #[cfg(stage0)]
     pub fn atomic_cxchg<T>(dst: *mut T, old: T, src: T) -> T;
-    #[cfg(stage0)]
     pub fn atomic_cxchg_acq<T>(dst: *mut T, old: T, src: T) -> T;
-    #[cfg(stage0)]
     pub fn atomic_cxchg_rel<T>(dst: *mut T, old: T, src: T) -> T;
-    #[cfg(stage0)]
     pub fn atomic_cxchg_acqrel<T>(dst: *mut T, old: T, src: T) -> T;
-    #[cfg(stage0)]
     pub fn atomic_cxchg_relaxed<T>(dst: *mut T, old: T, src: T) -> T;
-
-    #[cfg(not(stage0))]
-    pub fn atomic_cxchg<T>(dst: *mut T, old: T, src: T) -> (T, bool);
-    #[cfg(not(stage0))]
-    pub fn atomic_cxchg_acq<T>(dst: *mut T, old: T, src: T) -> (T, bool);
-    #[cfg(not(stage0))]
-    pub fn atomic_cxchg_rel<T>(dst: *mut T, old: T, src: T) -> (T, bool);
-    #[cfg(not(stage0))]
-    pub fn atomic_cxchg_acqrel<T>(dst: *mut T, old: T, src: T) -> (T, bool);
-    #[cfg(not(stage0))]
-    pub fn atomic_cxchg_relaxed<T>(dst: *mut T, old: T, src: T) -> (T, bool);
     #[cfg(not(stage0))]
-    pub fn atomic_cxchg_failrelaxed<T>(dst: *mut T, old: T, src: T) -> (T, bool);
+    pub fn atomic_cxchg_failrelaxed<T>(dst: *mut T, old: T, src: T) -> T;
     #[cfg(not(stage0))]
-    pub fn atomic_cxchg_failacq<T>(dst: *mut T, old: T, src: T) -> (T, bool);
+    pub fn atomic_cxchg_failacq<T>(dst: *mut T, old: T, src: T) -> T;
     #[cfg(not(stage0))]
-    pub fn atomic_cxchg_acq_failrelaxed<T>(dst: *mut T, old: T, src: T) -> (T, bool);
+    pub fn atomic_cxchg_acq_failrelaxed<T>(dst: *mut T, old: T, src: T) -> T;
     #[cfg(not(stage0))]
-    pub fn atomic_cxchg_acqrel_failrelaxed<T>(dst: *mut T, old: T, src: T) -> (T, bool);
+    pub fn atomic_cxchg_acqrel_failrelaxed<T>(dst: *mut T, old: T, src: T) -> T;
 
     #[cfg(not(stage0))]
     pub fn atomic_cxchgweak<T>(dst: *mut T, old: T, src: T) -> (T, bool);

branches/beta/src/libcore/sync/atomic.rs

@@ -407,7 +407,7 @@ pub fn common_supertype<'a, 'tcx>(cx: &InferCtxt<'a, 'tcx>,
     match result {
         Ok(t) => t,
         Err(ref err) => {
-            cx.report_and_explain_type_error(trace, err).emit();
+            cx.report_and_explain_type_error(trace, err);
             cx.tcx.types.err
         }
     }
@@ -1396,7 +1396,7 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
                 found: actual
             })
         };
-        self.report_and_explain_type_error(trace, &err).emit();
+        self.report_and_explain_type_error(trace, &err);
     }
 
     pub fn report_conflicting_default_types(&self,
@@ -1411,13 +1411,11 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
             })
         };
 
-        self.report_and_explain_type_error(
-            trace,
+        self.report_and_explain_type_error(trace,
             &TypeError::TyParamDefaultMismatch(ExpectedFound {
                 expected: expected,
                 found: actual
-            }))
-            .emit();
+        }));
     }
 
     pub fn replace_late_bound_regions_with_fresh_var<T>(

branches/beta/src/librustc/middle/infer/error_reporting.rs

@@ -17,7 +17,7 @@ pub use self::CombineMapType::*;
 pub use self::RegionResolutionError::*;
 pub use self::VarValue::*;
 
-use super::{RegionVariableOrigin, SubregionOrigin, MiscVariable};
+use super::{RegionVariableOrigin, SubregionOrigin, TypeTrace, MiscVariable};
 use super::unify_key;
 
 use rustc_data_structures::graph::{self, Direction, NodeIndex};
@@ -27,6 +27,7 @@ use middle::ty::{self, Ty, TyCtxt};
 use middle::ty::{BoundRegion, Region, RegionVid};
 use middle::ty::{ReEmpty, ReStatic, ReFree, ReEarlyBound};
 use middle::ty::{ReLateBound, ReScope, ReVar, ReSkolemized, BrFresh};
+use middle::ty::error::TypeError;
 use util::common::indenter;
 use util::nodemap::{FnvHashMap, FnvHashSet};
 
@@ -151,16 +152,11 @@ pub enum RegionResolutionError<'tcx> {
     /// more specific errors message by suggesting to the user where they
     /// should put a lifetime. In those cases we process and put those errors
     /// into `ProcessedErrors` before we do any reporting.
-    ProcessedErrors(Vec<ProcessedErrorOrigin<'tcx>>,
+    ProcessedErrors(Vec<RegionVariableOrigin>,
+                    Vec<(TypeTrace<'tcx>, TypeError<'tcx>)>,
                     Vec<SameRegions>),
 }
 
-#[derive(Clone, Debug)]
-pub enum ProcessedErrorOrigin<'tcx> {
-    ConcreteFailure(SubregionOrigin<'tcx>, Region, Region),
-    VariableFailure(RegionVariableOrigin),
-}
-
 /// SameRegions is used to group regions that we think are the same and would
 /// like to indicate so to the user.
 /// For example, the following function
@@ -534,14 +530,16 @@ impl<'a, 'tcx> RegionVarBindings<'a, 'tcx> {
         assert!(self.values_are_none());
 
         debug!("RegionVarBindings: lub_regions({:?}, {:?})", a, b);
-        if a == ty::ReStatic || b == ty::ReStatic {
-            ReStatic // nothing lives longer than static
-        } else if a == b {
-            a // LUB(a,a) = a
-        } else {
-            self.combine_vars(Lub, a, b, origin.clone(), |this, old_r, new_r| {
-                this.make_subregion(origin.clone(), old_r, new_r)
-            })
+        match (a, b) {
+            (ReStatic, _) | (_, ReStatic) => {
+                ReStatic // nothing lives longer than static
+            }
+
+            _ => {
+                self.combine_vars(Lub, a, b, origin.clone(), |this, old_r, new_r| {
+                    this.make_subregion(origin.clone(), old_r, new_r)
+                })
+            }
         }
     }
 
@@ -552,11 +550,8 @@ impl<'a, 'tcx> RegionVarBindings<'a, 'tcx> {
         debug!("RegionVarBindings: glb_regions({:?}, {:?})", a, b);
         match (a, b) {
             (ReStatic, r) | (r, ReStatic) => {
-                r // static lives longer than everything else
-            }
-
-            _ if a == b => {
-                a // GLB(a,a) = a
+                // static lives longer than everything else
+                r
             }
 
             _ => {

branches/beta/src/librustc/middle/infer/mod.rs

@@ -725,7 +725,6 @@ pub fn trans_intrinsic_call<'a, 'blk, 'tcx>(mut bcx: Block<'blk, 'tcx>,
         (_, name) if name.starts_with("atomic_") => {
             let split: Vec<&str> = name.split('_').collect();
 
-            let is_cxchg = split[1] == "cxchg" || split[1] == "cxchgweak";
             let (order, failorder) = match split.len() {
                 2 => (llvm::SequentiallyConsistent, llvm::SequentiallyConsistent),
                 3 => match split[2] {
@@ -734,34 +733,39 @@ pub fn trans_intrinsic_call<'a, 'blk, 'tcx>(mut bcx: Block<'blk, 'tcx>,
                     "acq"     => (llvm::Acquire, llvm::Acquire),
                     "rel"     => (llvm::Release, llvm::Monotonic),
                     "acqrel"  => (llvm::AcquireRelease, llvm::Acquire),
-                    "failrelaxed" if is_cxchg =>
+                    "failrelaxed" if split[1] == "cxchg" || split[1] == "cxchgweak" =>
                         (llvm::SequentiallyConsistent, llvm::Monotonic),
-                    "failacq" if is_cxchg =>
+                    "failacq" if split[1] == "cxchg" || split[1] == "cxchgweak" =>
                         (llvm::SequentiallyConsistent, llvm::Acquire),
                     _ => ccx.sess().fatal("unknown ordering in atomic intrinsic")
                 },
                 4 => match (split[2], split[3]) {
-                    ("acq", "failrelaxed") if is_cxchg =>
+                    ("acq", "failrelaxed") if split[1] == "cxchg" || split[1] == "cxchgweak" =>
                         (llvm::Acquire, llvm::Monotonic),
-                    ("acqrel", "failrelaxed") if is_cxchg =>
+                    ("acqrel", "failrelaxed") if split[1] == "cxchg" || split[1] == "cxchgweak" =>
                         (llvm::AcquireRelease, llvm::Monotonic),
                     _ => ccx.sess().fatal("unknown ordering in atomic intrinsic")
                 },
                 _ => ccx.sess().fatal("Atomic intrinsic not in correct format"),
             };
 
             match split[1] {
-                "cxchg" | "cxchgweak" => {
+                "cxchg" => {
                     let cmp = from_immediate(bcx, llargs[1]);
                     let src = from_immediate(bcx, llargs[2]);
                     let ptr = PointerCast(bcx, llargs[0], val_ty(src).ptr_to());
-                    let weak = if split[1] == "cxchgweak" { llvm::True } else { llvm::False };
-                    let val = AtomicCmpXchg(bcx, ptr, cmp, src, order, failorder, weak);
+                    let res = AtomicCmpXchg(bcx, ptr, cmp, src, order, failorder, llvm::False);
+                    ExtractValue(bcx, res, 0)
+                }
+
+                "cxchgweak" => {
+                    let cmp = from_immediate(bcx, llargs[1]);
+                    let src = from_immediate(bcx, llargs[2]);
+                    let ptr = PointerCast(bcx, llargs[0], val_ty(src).ptr_to());
+                    let val = AtomicCmpXchg(bcx, ptr, cmp, src, order, failorder, llvm::True);
                     let result = ExtractValue(bcx, val, 0);
                     let success = ZExt(bcx, ExtractValue(bcx, val, 1), Type::bool(bcx.ccx()));
-                    Store(bcx,
-                          result,
-                          PointerCast(bcx, StructGEP(bcx, llresult, 0), val_ty(src).ptr_to()));
+                    Store(bcx, result, StructGEP(bcx, llresult, 0));
                     Store(bcx, success, StructGEP(bcx, llresult, 1));
                     C_nil(ccx)
                 }
@@ -774,7 +778,6 @@ pub fn trans_intrinsic_call<'a, 'blk, 'tcx>(mut bcx: Block<'blk, 'tcx>,
                     }
                     to_immediate(bcx, AtomicLoad(bcx, ptr, order), tp_ty)
                 }
-
                 "store" => {
                     let val = from_immediate(bcx, llargs[1]);
                     let ptr = PointerCast(bcx, llargs[0], val_ty(val).ptr_to());