---

yaml
---
r: 71991
b: refs/heads/dist-snap
c: 79d4f14
h: refs/heads/master
i:
  71989: 41a017a
  71987: 6db50b0
  71983: 344f68f
v: v3

Author: bors

[refs]

@@ -7,7 +7,7 @@ refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c
 refs/heads/incoming: b50030718cf28f2a5a81857a26b57442734fe854
-refs/heads/dist-snap: 59e69aa0e79302887abcb4b6bf3613c84b48e5d7
+refs/heads/dist-snap: 79d4f1402e9abc7a8910a5d81dbb4d19c8c1b2b6
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

branches/dist-snap/src/compiletest/errors.rs

@@ -30,34 +30,36 @@ pub fn load_errors(testfile: &Path) -> ~[ExpectedError] {
 }
 
 fn parse_expected(line_num: uint, line: ~str) -> ~[ExpectedError] {
-    let error_tag = ~"//~";
-    let mut idx;
-    match str::find_str(line, error_tag) {
-      None => return ~[],
-      Some(nn) => { idx = (nn as uint) + str::len(error_tag); }
-    }
+    unsafe {
+        let error_tag = ~"//~";
+        let mut idx;
+        match str::find_str(line, error_tag) {
+          None => return ~[],
+          Some(nn) => { idx = (nn as uint) + str::len(error_tag); }
+        }
 
-    // "//~^^^ kind msg" denotes a message expected
-    // three lines above current line:
-    let mut adjust_line = 0u;
-    let len = str::len(line);
-    while idx < len && line[idx] == ('^' as u8) {
-        adjust_line += 1u;
-        idx += 1u;
-    }
+        // "//~^^^ kind msg" denotes a message expected
+        // three lines above current line:
+        let mut adjust_line = 0u;
+        let len = str::len(line);
+        while idx < len && line[idx] == ('^' as u8) {
+            adjust_line += 1u;
+            idx += 1u;
+        }
 
-    // Extract kind:
-    while idx < len && line[idx] == (' ' as u8) { idx += 1u; }
-    let start_kind = idx;
-    while idx < len && line[idx] != (' ' as u8) { idx += 1u; }
-    let kind = str::to_lower(str::slice(line, start_kind, idx).to_owned());
+        // Extract kind:
+        while idx < len && line[idx] == (' ' as u8) { idx += 1u; }
+        let start_kind = idx;
+        while idx < len && line[idx] != (' ' as u8) { idx += 1u; }
+        let kind = str::to_lower(str::slice(line, start_kind, idx).to_owned());
 
-    // Extract msg:
-    while idx < len && line[idx] == (' ' as u8) { idx += 1u; }
-    let msg = str::slice(line, idx, len).to_owned();
+        // Extract msg:
+        while idx < len && line[idx] == (' ' as u8) { idx += 1u; }
+        let msg = str::slice(line, idx, len).to_owned();
 
-    debug!("line=%u kind=%s msg=%s", line_num - adjust_line, kind, msg);
+        debug!("line=%u kind=%s msg=%s", line_num - adjust_line, kind, msg);
 
-    return ~[ExpectedError{line: line_num - adjust_line, kind: kind,
-                           msg: msg}];
+        return ~[ExpectedError{line: line_num - adjust_line, kind: kind,
+                               msg: msg}];
+    }
 }

branches/dist-snap/src/compiletest/header.rs

@@ -171,14 +171,16 @@ fn parse_name_directive(line: ~str, directive: ~str) -> bool {
 
 fn parse_name_value_directive(line: ~str,
                               directive: ~str) -> Option<~str> {
-    let keycolon = directive + ~":";
-    match str::find_str(line, keycolon) {
-        Some(colon) => {
-            let value = str::slice(line, colon + str::len(keycolon),
-                                   str::len(line)).to_owned();
-            debug!("%s: %s", directive,  value);
-            Some(value)
+    unsafe {
+        let keycolon = directive + ~":";
+        match str::find_str(line, keycolon) {
+            Some(colon) => {
+                let value = str::slice(line, colon + str::len(keycolon),
+                                       str::len(line)).to_owned();
+                debug!("%s: %s", directive,  value);
+                Some(value)
+            }
+            None => None
         }
-        None => None
     }
 }

branches/dist-snap/src/libcore/comm.rs

@@ -188,14 +188,16 @@ impl<T: Owned> Peekable<T> for Port<T> {
 
 #[inline(always)]
 fn port_peek<T:Owned>(self: &Port<T>) -> bool {
-    let mut endp = None;
-    endp <-> self.endp;
-    let peek = match &endp {
-        &Some(ref endp) => peek(endp),
-        &None => fail!(~"peeking empty stream")
-    };
-    self.endp <-> endp;
-    peek
+    unsafe {
+        let mut endp = None;
+        endp <-> self.endp;
+        let peek = match &endp {
+            &Some(ref endp) => peek(endp),
+            &None => fail!(~"peeking empty stream")
+        };
+        self.endp <-> endp;
+        peek
+    }
 }
 
 impl<T: Owned> Selectable for Port<T> {

branches/dist-snap/src/libcore/io.rs

@@ -1536,8 +1536,11 @@ pub fn with_bytes_writer(f: &fn(@Writer)) -> ~[u8] {
 pub fn with_str_writer(f: &fn(@Writer)) -> ~str {
     let mut v = with_bytes_writer(f);
 
-    // Make sure the vector has a trailing null and is proper utf8.
-    v.push(0);
+    // FIXME (#3758): This should not be needed.
+    unsafe {
+        // Make sure the vector has a trailing null and is proper utf8.
+        v.push(0);
+    }
     assert!(str::is_utf8(v));
 
     unsafe { ::cast::transmute(v) }
@@ -1637,14 +1640,16 @@ pub mod fsync {
     // outer res
     pub fn FILE_res_sync(file: &FILERes, opt_level: Option<Level>,
                          blk: &fn(v: Res<*libc::FILE>)) {
-        blk(Res(Arg {
-            val: file.f, opt_level: opt_level,
-            fsync_fn: |file, l| {
-                unsafe {
-                    os::fsync_fd(libc::fileno(file), l) as int
+        unsafe {
+            blk(Res(Arg {
+                val: file.f, opt_level: opt_level,
+                fsync_fn: |file, l| {
+                    unsafe {
+                        os::fsync_fd(libc::fileno(file), l) as int
+                    }
                 }
-            }
-        }));
+            }));
+        }
     }
 
     // fsync fd after executing blk

branches/dist-snap/src/libcore/managed.rs

@@ -38,13 +38,13 @@ pub mod raw {
 #[inline(always)]
 pub fn ptr_eq<T>(a: @T, b: @T) -> bool {
     //! Determine if two shared boxes point to the same object
-    ptr::addr_of(&(*a)) == ptr::addr_of(&(*b))
+    unsafe { ptr::addr_of(&(*a)) == ptr::addr_of(&(*b)) }
 }
 
 #[inline(always)]
 pub fn mut_ptr_eq<T>(a: @mut T, b: @mut T) -> bool {
     //! Determine if two mutable shared boxes point to the same object
-    ptr::addr_of(&(*a)) == ptr::addr_of(&(*b))
+    unsafe { ptr::addr_of(&(*a)) == ptr::addr_of(&(*b)) }
 }
 
 #[cfg(notest)]

branches/dist-snap/src/libcore/num/float.rs

@@ -369,27 +369,27 @@ pub fn is_NaN(x: float) -> bool { f64::is_NaN(x as f64) }
 
 #[inline(always)]
 pub fn abs(x: float) -> float {
-    f64::abs(x as f64) as float
+    unsafe { f64::abs(x as f64) as float }
 }
 #[inline(always)]
 pub fn sqrt(x: float) -> float {
-    f64::sqrt(x as f64) as float
+    unsafe { f64::sqrt(x as f64) as float }
 }
 #[inline(always)]
 pub fn atan(x: float) -> float {
-    f64::atan(x as f64) as float
+    unsafe { f64::atan(x as f64) as float }
 }
 #[inline(always)]
 pub fn sin(x: float) -> float {
-    f64::sin(x as f64) as float
+    unsafe { f64::sin(x as f64) as float }
 }
 #[inline(always)]
 pub fn cos(x: float) -> float {
-    f64::cos(x as f64) as float
+    unsafe { f64::cos(x as f64) as float }
 }
 #[inline(always)]
 pub fn tan(x: float) -> float {
-    f64::tan(x as f64) as float
+    unsafe { f64::tan(x as f64) as float }
 }
 
 #[cfg(notest)]

branches/dist-snap/src/libcore/path.rs

@@ -389,11 +389,13 @@ impl GenericPath for PosixPath {
     }
 
     fn dirname(&self) -> ~str {
-        let s = self.dir_path().to_str();
-        if s.len() == 0 {
-            ~"."
-        } else {
-            s
+        unsafe {
+            let s = self.dir_path().to_str();
+            if s.len() == 0 {
+                ~"."
+            } else {
+                s
+            }
         }
     }
 
@@ -437,8 +439,10 @@ impl GenericPath for PosixPath {
     }
 
     fn with_filename(&self, f: &str) -> PosixPath {
-        assert!(! str::any(f, |c| windows::is_sep(c as u8)));
-        self.dir_path().push(f)
+        unsafe {
+            assert!(! str::any(f, |c| windows::is_sep(c as u8)));
+            self.dir_path().push(f)
+        }
     }
 
     fn with_filestem(&self, s: &str) -> PosixPath {
@@ -505,7 +509,7 @@ impl GenericPath for PosixPath {
             for str::each_split_nonempty(*e, |c| windows::is_sep(c as u8)) |s| {
                 ss.push(s.to_owned())
             }
-            v.push_all_move(ss);
+            unsafe { v.push_all_move(ss); }
         }
         PosixPath { is_absolute: self.is_absolute,
                     components: v }
@@ -517,14 +521,14 @@ impl GenericPath for PosixPath {
         for str::each_split_nonempty(s, |c| windows::is_sep(c as u8)) |s| {
             ss.push(s.to_owned())
         }
-        v.push_all_move(ss);
+        unsafe { v.push_all_move(ss); }
         PosixPath { components: v, ..copy *self }
     }
 
     fn pop(&self) -> PosixPath {
         let mut cs = copy self.components;
         if cs.len() != 0 {
-            cs.pop();
+            unsafe { cs.pop(); }
         }
         return PosixPath {
             is_absolute: self.is_absolute,
@@ -603,11 +607,13 @@ impl GenericPath for WindowsPath {
     }
 
     fn dirname(&self) -> ~str {
-        let s = self.dir_path().to_str();
-        if s.len() == 0 {
-            ~"."
-        } else {
-            s
+        unsafe {
+            let s = self.dir_path().to_str();
+            if s.len() == 0 {
+                ~"."
+            } else {
+                s
+            }
         }
     }
 
@@ -764,7 +770,7 @@ impl GenericPath for WindowsPath {
             for str::each_split_nonempty(*e, |c| windows::is_sep(c as u8)) |s| {
                 ss.push(s.to_owned())
             }
-            v.push_all_move(ss);
+            unsafe { v.push_all_move(ss); }
         }
         // tedious, but as-is, we can't use ..self
         return WindowsPath {
@@ -781,14 +787,14 @@ impl GenericPath for WindowsPath {
         for str::each_split_nonempty(s, |c| windows::is_sep(c as u8)) |s| {
             ss.push(s.to_owned())
         }
-        v.push_all_move(ss);
+        unsafe { v.push_all_move(ss); }
         return WindowsPath { components: v, ..copy *self }
     }
 
     fn pop(&self) -> WindowsPath {
         let mut cs = copy self.components;
         if cs.len() != 0 {
-            cs.pop();
+            unsafe { cs.pop(); }
         }
         return WindowsPath {
             host: copy self.host,
@@ -814,14 +820,18 @@ impl GenericPath for WindowsPath {
 
 pub fn normalize(components: &[~str]) -> ~[~str] {
     let mut cs = ~[];
-    for components.each |c| {
-        if *c == ~"." && components.len() > 1 { loop; }
-        if *c == ~"" { loop; }
-        if *c == ~".." && cs.len() != 0 {
-            cs.pop();
-            loop;
+    unsafe {
+        for components.each |c| {
+            unsafe {
+                if *c == ~"." && components.len() > 1 { loop; }
+                if *c == ~"" { loop; }
+                if *c == ~".." && cs.len() != 0 {
+                    cs.pop();
+                    loop;
+                }
+                cs.push(copy *c);
+            }
         }
-        cs.push(copy *c);
     }
     cs
 }

branches/dist-snap/src/libcore/ptr.rs

@@ -55,13 +55,17 @@ pub fn addr_of<T>(val: &T) -> *T { unsafe { rusti::addr_of(*val) } }
 /// Calculate the offset from a pointer
 #[inline(always)]
 pub fn offset<T>(ptr: *T, count: uint) -> *T {
-    (ptr as uint + count * sys::size_of::<T>()) as *T
+    unsafe {
+        (ptr as uint + count * sys::size_of::<T>()) as *T
+    }
 }
 
 /// Calculate the offset from a const pointer
 #[inline(always)]
 pub fn const_offset<T>(ptr: *const T, count: uint) -> *const T {
-    (ptr as uint + count * sys::size_of::<T>()) as *T
+    unsafe {
+        (ptr as uint + count * sys::size_of::<T>()) as *T
+    }
 }
 
 /// Calculate the offset from a mut pointer

branches/dist-snap/src/libcore/rt/context.rs

@@ -205,6 +205,8 @@ fn align_down(sp: *mut uint) -> *mut uint {
 #[inline(always)]
 pub fn mut_offset<T>(ptr: *mut T, count: int) -> *mut T {
     use core::sys::size_of;
-    (ptr as int + count * (size_of::<T>() as int)) as *mut T
+    unsafe {
+        (ptr as int + count * (size_of::<T>() as int)) as *mut T
+    }
 }
 

branches/dist-snap/src/libcore/rt/thread_local_storage.rs

@@ -21,17 +21,17 @@ pub type Key = pthread_key_t;
 
 #[cfg(unix)]
 pub unsafe fn create(key: &mut Key) {
-    assert!(0 == pthread_key_create(key, null()));
+    unsafe { assert!(0 == pthread_key_create(key, null())); }
 }
 
 #[cfg(unix)]
 pub unsafe fn set(key: Key, value: *mut c_void) {
-    assert!(0 == pthread_setspecific(key, value));
+    unsafe { assert!(0 == pthread_setspecific(key, value)); }
 }
 
 #[cfg(unix)]
 pub unsafe fn get(key: Key) -> *mut c_void {
-    pthread_getspecific(key)
+    unsafe { pthread_getspecific(key) }
 }
 
 #[cfg(target_os="macos")]