---

yaml
---
r: 177843
b: refs/heads/snap-stage3
c: f9f3ba5
h: refs/heads/master
i:
  177841: 3fd9a43
  177839: 6b1c4e9
v: v3

Author: eddyb

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 474b324eda10440d6568ef872a7307d38e7de95b
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 52c74e63dacd49017b19330e0cbecbac0a3fe62e
+refs/heads/snap-stage3: f9f3ba5920ddb2b8bae5047eea556081e0da159d
 refs/heads/try: fde4472848b662a4d1236388c4cf15e2450237e6
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d

branches/snap-stage3/src/librustc/middle/infer/mod.rs

@@ -33,12 +33,10 @@ use std::rc::Rc;
 use syntax::ast;
 use syntax::codemap;
 use syntax::codemap::Span;
-use util::common::indent;
 use util::nodemap::FnvHashMap;
 use util::ppaux::{ty_to_string};
 use util::ppaux::{Repr, UserString};
 
-use self::coercion::Coerce;
 use self::combine::{Combine, Combineable, CombineFields};
 use self::region_inference::{RegionVarBindings, RegionSnapshot};
 use self::equate::Equate;
@@ -47,7 +45,6 @@ use self::lub::Lub;
 use self::unify::{UnificationTable, InferCtxtMethodsForSimplyUnifiableTypes};
 use self::error_reporting::ErrorReporting;
 
-pub mod coercion;
 pub mod combine;
 pub mod doc;
 pub mod equate;
@@ -68,7 +65,6 @@ pub type Bound<T> = Option<T>;
 pub type cres<'tcx, T> = Result<T,ty::type_err<'tcx>>; // "combine result"
 pub type ures<'tcx> = cres<'tcx, ()>; // "unify result"
 pub type fres<T> = Result<T, fixup_err>; // "fixup result"
-pub type CoerceResult<'tcx> = cres<'tcx, Option<ty::AutoAdjustment<'tcx>>>;
 
 pub struct InferCtxt<'a, 'tcx: 'a> {
     pub tcx: &'a ty::ctxt<'tcx>,
@@ -409,24 +405,6 @@ fn expected_found<T>(a_is_expected: bool,
     }
 }
 
-pub fn mk_coercety<'a, 'tcx>(cx: &InferCtxt<'a, 'tcx>,
-                             a_is_expected: bool,
-                             origin: TypeOrigin,
-                             a: Ty<'tcx>,
-                             b: Ty<'tcx>)
-                             -> CoerceResult<'tcx> {
-    debug!("mk_coercety({} -> {})", a.repr(cx.tcx), b.repr(cx.tcx));
-    indent(|| {
-        cx.commit_if_ok(|| {
-            let trace = TypeTrace {
-                origin: origin,
-                values: Types(expected_found(a_is_expected, a, b))
-            };
-            Coerce(cx.combine_fields(a_is_expected, trace)).tys(a, b)
-        })
-    })
-}
-
 trait then<'tcx> {
     fn then<T, F>(&self, f: F) -> Result<T, ty::type_err<'tcx>> where
         T: Clone,
@@ -689,10 +667,7 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
     {
         debug!("sub_types({} <: {})", a.repr(self.tcx), b.repr(self.tcx));
         self.commit_if_ok(|| {
-            let trace = TypeTrace {
-                origin: origin,
-                values: Types(expected_found(a_is_expected, a, b))
-            };
+            let trace = TypeTrace::types(origin, a_is_expected, a, b);
             self.sub(a_is_expected, trace).tys(a, b).to_ures()
         })
     }
@@ -705,10 +680,7 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
                     -> ures<'tcx>
     {
         self.commit_if_ok(|| {
-            let trace = TypeTrace {
-                origin: origin,
-                values: Types(expected_found(a_is_expected, a, b))
-            };
+            let trace = TypeTrace::types(origin, a_is_expected, a, b);
             self.equate(a_is_expected, trace).tys(a, b).to_ures()
         })
     }
@@ -1118,6 +1090,17 @@ impl<'tcx> TypeTrace<'tcx> {
         self.origin.span()
     }
 
+    pub fn types(origin: TypeOrigin,
+                 a_is_expected: bool,
+                 a: Ty<'tcx>,
+                 b: Ty<'tcx>)
+                 -> TypeTrace<'tcx> {
+        TypeTrace {
+            origin: origin,
+            values: Types(expected_found(a_is_expected, a, b))
+        }
+    }
+
     pub fn dummy(tcx: &ty::ctxt<'tcx>) -> TypeTrace<'tcx> {
         TypeTrace {
             origin: Misc(codemap::DUMMY_SP),

branches/snap-stage3/src/librustc_borrowck/borrowck/mod.rs

@@ -770,7 +770,16 @@ impl<'a, 'tcx> BorrowckCtxt<'a, 'tcx> {
             MutabilityViolation => {
                 "cannot assign to data"
             }
-            BorrowViolation(euv::ClosureCapture(_)) |
+            BorrowViolation(euv::ClosureCapture(_)) => {
+                // I don't think we can get aliasability violations
+                // with closure captures, so no need to come up with a
+                // good error message. The reason this cannot happen
+                // is because we only capture local variables in
+                // closures, and those are never aliasable.
+                self.tcx.sess.span_bug(
+                    span,
+                    "aliasability violation with closure");
+            }
             BorrowViolation(euv::OverloadedOperator) |
             BorrowViolation(euv::AddrOf) |
             BorrowViolation(euv::AutoRef) |
@@ -800,17 +809,8 @@ impl<'a, 'tcx> BorrowckCtxt<'a, 'tcx> {
                 self.tcx.sess.span_err(span,
                                        format!("{} in a captured outer \
                                                variable in an `Fn` closure", prefix).as_slice());
-                if let BorrowViolation(euv::ClosureCapture(_)) = kind {
-                    // The aliasability violation with closure captures can
-                    // happen for nested closures, so we know the enclosing
-                    // closure incorrectly accepts an `Fn` while it needs to
-                    // be `FnMut`.
-                    span_help!(self.tcx.sess, self.tcx.map.span(id),
-                           "consider changing this to accept closures that implement `FnMut`");
-                } else {
-                    span_help!(self.tcx.sess, self.tcx.map.span(id),
+                span_help!(self.tcx.sess, self.tcx.map.span(id),
                            "consider changing this closure to take self by mutable reference");
-                }
             }
             mc::AliasableStatic(..) |
             mc::AliasableStaticMut(..) => {

branches/snap-stage3/src/librustc_trans/trans/expr.rs

@@ -420,15 +420,9 @@ fn apply_adjustments<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
         let tcx = bcx.tcx();
 
         let datum_ty = datum.ty;
-
-        debug!("unsize_unique_vec expr.id={} datum_ty={} len={}",
-               expr.id, datum_ty.repr(tcx), len);
-
-        // We do not arrange cleanup ourselves; if we already are an
-        // L-value, then cleanup will have already been scheduled (and
-        // the `datum.store_to` call below will emit code to zero the
-        // drop flag when moving out of the L-value). If we are an R-value,
-        // then we do not need to schedule cleanup.
+        // Arrange cleanup
+        let lval = unpack_datum!(bcx,
+                                 datum.to_lvalue_datum(bcx, "unsize_unique_vec", expr.id));
 
         let ll_len = C_uint(bcx.ccx(), len);
         let unit_ty = ty::sequence_element_type(tcx, ty::type_content(datum_ty));
@@ -439,7 +433,7 @@ fn apply_adjustments<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
         let base = PointerCast(bcx,
                                base,
                                type_of::type_of(bcx.ccx(), datum_ty).ptr_to());
-        bcx = datum.store_to(bcx, base);
+        bcx = lval.store_to(bcx, base);
 
         Store(bcx, ll_len, get_len(bcx, scratch.val));
         DatumBlock::new(bcx, scratch.to_expr_datum())
@@ -461,20 +455,22 @@ fn apply_adjustments<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
         };
         let result_ty = ty::mk_uniq(tcx, ty::unsize_ty(tcx, unboxed_ty, k, expr.span));
 
-        // We do not arrange cleanup ourselves; if we already are an
-        // L-value, then cleanup will have already been scheduled (and
-        // the `datum.store_to` call below will emit code to zero the
-        // drop flag when moving out of the L-value). If we are an R-value,
-        // then we do not need to schedule cleanup.
+        let lval = unpack_datum!(bcx,
+                                 datum.to_lvalue_datum(bcx, "unsize_unique_expr", expr.id));
 
         let scratch = rvalue_scratch_datum(bcx, result_ty, "__uniq_fat_ptr");
         let llbox_ty = type_of::type_of(bcx.ccx(), datum_ty);
         let base = PointerCast(bcx, get_dataptr(bcx, scratch.val), llbox_ty.ptr_to());
-        bcx = datum.store_to(bcx, base);
+        bcx = lval.store_to(bcx, base);
 
         let info = unsized_info(bcx, k, expr.id, unboxed_ty, |t| ty::mk_uniq(tcx, t));
         Store(bcx, info, get_len(bcx, scratch.val));
 
+        let scratch = unpack_datum!(bcx,
+                                    scratch.to_expr_datum().to_lvalue_datum(bcx,
+                                                                            "fresh_uniq_fat_ptr",
+                                                                            expr.id));
+
         DatumBlock::new(bcx, scratch.to_expr_datum())
     }
 }

branches/snap-stage3/src/librustc/middle/infer/coercion.rs renamed to branches/snap-stage3/src/librustc_typeck/check/coercion.rs

@@ -60,14 +60,15 @@
 //! sort of a minor point so I've opted to leave it for later---after all
 //! we may want to adjust precisely when coercions occur.
 
-use super::{CoerceResult, Coercion};
-use super::combine::{CombineFields, Combine};
-use super::sub::Sub;
+use middle::infer::{cres, Coercion, InferCtxt, TypeOrigin, TypeTrace};
+use middle::infer::combine::{CombineFields, Combine};
+use middle::infer::sub::Sub;
 
 use middle::subst;
 use middle::ty::{AutoPtr, AutoDerefRef, AdjustDerefRef, AutoUnsize, AutoUnsafe};
 use middle::ty::{mt};
 use middle::ty::{self, Ty};
+use util::common::indent;
 use util::ppaux;
 use util::ppaux::Repr;
 
@@ -472,24 +473,6 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
         }
     }
 
-    pub fn coerce_borrowed_fn(&self,
-                              a: Ty<'tcx>,
-                              b: Ty<'tcx>)
-                              -> CoerceResult<'tcx> {
-        debug!("coerce_borrowed_fn(a={}, b={})",
-               a.repr(self.tcx()),
-               b.repr(self.tcx()));
-
-        match a.sty {
-            ty::ty_bare_fn(Some(a_def_id), f) => {
-                self.coerce_from_fn_item(a, a_def_id, f, b)
-            }
-            _ => {
-                self.subtype(a, b)
-            }
-        }
-    }
-
     fn coerce_from_fn_item(&self,
                            a: Ty<'tcx>,
                            fn_def_id_a: ast::DefId,
@@ -551,6 +534,23 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
     }
 }
 
+pub type CoerceResult<'tcx> = cres<'tcx, Option<ty::AutoAdjustment<'tcx>>>;
+
+pub fn mk_coercety<'a, 'tcx>(cx: &InferCtxt<'a, 'tcx>,
+                             a_is_expected: bool,
+                             origin: TypeOrigin,
+                             a: Ty<'tcx>,
+                             b: Ty<'tcx>)
+                             -> CoerceResult<'tcx> {
+    debug!("mk_coercety({} -> {})", a.repr(cx.tcx), b.repr(cx.tcx));
+    indent(|| {
+        cx.commit_if_ok(|| {
+            let trace = TypeTrace::types(origin, a_is_expected, a, b);
+            Coerce(cx.combine_fields(a_is_expected, trace)).tys(a, b)
+        })
+    })
+}
+
 fn can_coerce_mutbls(from_mutbl: ast::Mutability,
                      to_mutbl: ast::Mutability)
                      -> bool {

branches/snap-stage3/src/librustc_typeck/check/mod.rs

@@ -132,6 +132,7 @@ pub mod vtable;
 pub mod writeback;
 pub mod regionmanip;
 pub mod regionck;
+pub mod coercion;
 pub mod demand;
 pub mod method;
 mod upvar;
@@ -1730,18 +1731,17 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                        sub: Ty<'tcx>,
                        sup: Ty<'tcx>)
                        -> Result<(), ty::type_err<'tcx>> {
-        match infer::mk_coercety(self.infcx(),
-                                 false,
-                                 infer::ExprAssignable(expr.span),
-                                 sub,
-                                 sup) {
-            Ok(None) => Ok(()),
-            Err(ref e) => Err((*e)),
-            Ok(Some(adjustment)) => {
+        match try!(coercion::mk_coercety(self.infcx(),
+                                         false,
+                                         infer::ExprAssignable(expr.span),
+                                         sub,
+                                         sup)) {
+            None => {}
+            Some(adjustment) => {
                 self.write_adjustment(expr.id, expr.span, adjustment);
-                Ok(())
             }
         }
+        Ok(())
     }
 
     pub fn mk_eqty(&self,