---

yaml
---
r: 118055
b: refs/heads/try
c: 1380893
h: refs/heads/master
i:
  118053: 218f164
  118051: 147bf80
  118047: bf67346
v: v3

Author: michaelwoerister

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 3770c42a4959cbabc73da52abc7e3db96657974e
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: d6736a1440d42f6af967a8a20ab8d73522112b72
-refs/heads/try: 729ee203387cc3a3f7387cffd018aba93b0110e6
+refs/heads/try: 138089355d7a1bc28fa58f2bea7680af96bd5b92
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c

branches/try/src/doc/rust.md

@@ -1036,7 +1036,6 @@ Unsafe operations are those that potentially violate the memory-safety guarantee
 The following language level features cannot be used in the safe subset of Rust:
 
   - Dereferencing a [raw pointer](#pointer-types).
-  - Reading or writing a [mutable static variable](#mutable-statics).
   - Calling an unsafe function (including an intrinsic or foreign function).
 
 ##### Unsafe functions

branches/try/src/liballoc/arc.rs

@@ -160,8 +160,7 @@ impl<T: Send + Share + Clone> Arc<T> {
         // reference count is guaranteed to be 1 at this point, and we required
         // the Arc itself to be `mut`, so we're returning the only possible
         // reference to the inner data.
-        let inner = unsafe { &mut *self._ptr };
-        &mut inner.data
+        unsafe { mem::transmute::<&_, &mut _>(self.deref()) }
     }
 }
 

branches/try/src/libcore/cmp.rs

@@ -37,9 +37,6 @@
 //! assert!(SketchyNum {num: 25} != SketchyNum {num: 57});
 //! ```
 
-pub use PartialEq = cmp::Eq;
-pub use PartialOrd = cmp::Ord;
-
 /// Trait for values that can be compared for equality and inequality.
 ///
 /// This trait allows partial equality, where types can be unordered instead of

branches/try/src/libnative/io/file_win32.rs

@@ -90,25 +90,6 @@ impl FileDesc {
     pub fn handle(&self) -> libc::HANDLE {
         unsafe { libc::get_osfhandle(self.fd()) as libc::HANDLE }
     }
-
-    // A version of seek that takes &self so that tell can call it
-    //   - the private seek should of course take &mut self.
-    fn seek_common(&self, pos: i64, style: io::SeekStyle) -> Result<u64, IoError> {
-        let whence = match style {
-            io::SeekSet => libc::FILE_BEGIN,
-            io::SeekEnd => libc::FILE_END,
-            io::SeekCur => libc::FILE_CURRENT,
-        };
-        unsafe {
-            let mut newpos = 0;
-            match libc::SetFilePointerEx(self.handle(), pos, &mut newpos,
-                                         whence) {
-                0 => Err(super::last_error()),
-                _ => Ok(newpos as u64),
-            }
-        }
-    }
-
 }
 
 impl io::Reader for FileDesc {
@@ -170,13 +151,26 @@ impl rtio::RtioFileStream for FileDesc {
         }
         Ok(())
     }
-
     fn seek(&mut self, pos: i64, style: io::SeekStyle) -> Result<u64, IoError> {
-        self.seek_common(pos, style)
+        let whence = match style {
+            io::SeekSet => libc::FILE_BEGIN,
+            io::SeekEnd => libc::FILE_END,
+            io::SeekCur => libc::FILE_CURRENT,
+        };
+        unsafe {
+            let mut newpos = 0;
+            match libc::SetFilePointerEx(self.handle(), pos, &mut newpos,
+                                         whence) {
+                0 => Err(super::last_error()),
+                _ => Ok(newpos as u64),
+            }
+        }
     }
-
     fn tell(&self) -> Result<u64, IoError> {
-        self.seek_common(0, io::SeekCur)
+        // This transmute is fine because our seek implementation doesn't
+        // actually use the mutable self at all.
+        // FIXME #13933: Remove/justify all `&T` to `&mut T` transmutes
+        unsafe { mem::transmute::<&_, &mut FileDesc>(self).seek(0, io::SeekCur) }
     }
 
     fn fsync(&mut self) -> Result<(), IoError> {

branches/try/src/librustc/middle/cfg/construct.rs

@@ -113,7 +113,7 @@ impl<'a> CFGBuilder<'a> {
                 self.add_node(pat.id, [pred])
             }
 
-            ast::PatBox(subpat) |
+            ast::PatUniq(subpat) |
             ast::PatRegion(subpat) |
             ast::PatIdent(_, _, Some(subpat)) => {
                 let subpat_exit = self.pat(subpat, pred);

branches/try/src/librustc/middle/check_match.rs

@@ -383,7 +383,7 @@ fn pat_ctor_id(cx: &MatchCheckCtxt, p: @Pat) -> Option<ctor> {
           _ => Some(single)
         }
       }
-      PatBox(_) | PatTup(_) | PatRegion(..) => {
+      PatUniq(_) | PatTup(_) | PatRegion(..) => {
         Some(single)
       }
       PatVec(ref before, slice, ref after) => {
@@ -764,7 +764,7 @@ fn specialize(cx: &MatchCheckCtxt,
             PatTup(args) => {
                 Some(args.iter().map(|x| *x).collect::<Vec<_>>().append(r.tail()))
             }
-            PatBox(a) | PatRegion(a) => {
+            PatUniq(a) | PatRegion(a) => {
                 Some((vec!(a)).append(r.tail()))
             }
             PatLit(expr) => {
@@ -924,7 +924,7 @@ fn find_refutable(cx: &MatchCheckCtxt, pat: &Pat, spans: &mut Vec<Span>) {
     }
 
     match pat.node {
-      PatBox(sub) | PatRegion(sub) | PatIdent(_, _, Some(sub)) => {
+      PatUniq(sub) | PatRegion(sub) | PatIdent(_, _, Some(sub)) => {
         find_refutable(cx, sub, spans)
       }
       PatWild | PatWildMulti | PatIdent(_, _, None) => {}

branches/try/src/librustc/middle/mem_categorization.rs

@@ -1064,7 +1064,7 @@ impl<'t,TYPER:Typer> MemCategorizationContext<'t,TYPER> {
             }
           }
 
-          ast::PatBox(subpat) | ast::PatRegion(subpat) => {
+          ast::PatUniq(subpat) | ast::PatRegion(subpat) => {
             // @p1, ~p1
             let subcmt = self.cat_deref(pat, cmt, 0);
             if_ok!(self.cat_pattern(subcmt, subpat, op));

branches/try/src/librustc/middle/region.rs

@@ -671,7 +671,7 @@ fn resolve_local(visitor: &mut RegionResolutionVisitor,
                 subpats.iter().any(|&p| is_binding_pat(p))
             }
 
-            ast::PatBox(subpat) => {
+            ast::PatUniq(subpat) => {
                 is_binding_pat(subpat)
             }
 

branches/try/src/librustc/middle/trans/_match.rs

@@ -838,7 +838,7 @@ fn enter_uniq<'a, 'b>(
     let dummy = @ast::Pat {id: 0, node: ast::PatWild, span: DUMMY_SP};
     enter_match(bcx, dm, m, col, val, |p| {
         match p.node {
-            ast::PatBox(sub) => {
+            ast::PatUniq(sub) => {
                 Some(vec!(sub))
             }
             _ => {
@@ -1105,7 +1105,7 @@ macro_rules! any_pat (
 )
 
 fn any_uniq_pat(m: &[Match], col: uint) -> bool {
-    any_pat!(m, ast::PatBox(_))
+    any_pat!(m, ast::PatUniq(_))
 }
 
 fn any_region_pat(m: &[Match], col: uint) -> bool {
@@ -2270,7 +2270,7 @@ fn bind_irrefutable_pat<'a>(
                                            binding_mode, cleanup_scope);
             }
         }
-        ast::PatBox(inner) => {
+        ast::PatUniq(inner) => {
             let llbox = Load(bcx, val);
             bcx = bind_irrefutable_pat(bcx, inner, llbox, binding_mode, cleanup_scope);
         }