---

yaml
---
r: 105435
b: refs/heads/master
c: af93684
h: refs/heads/master
i:
  105433: f01e82b
  105431: d328d3f
v: v3

Author: bors

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 695114ea2c1ae147dcf1c3ac690a75ecf928b8b2
+refs/heads/master: af9368452d8578af219713b34f7e3be4bd085186
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: b8601a3d8b91ad3b653d143307611f2f5c75617e
 refs/heads/try: db814977d07bd798feb24f6b74c00800ef458a13

trunk/src/librustc/middle/borrowck/check_loans.rs

@@ -522,6 +522,9 @@ impl<'a> CheckLoanCtxt<'a> {
                 None => {
                     return true;
                 }
+                Some(mc::AliasableStaticMut) => {
+                    return true;
+                }
                 Some(cause) => {
                     this.bccx.report_aliasability_violation(
                         expr.span,

trunk/src/librustc/middle/check_const.rs

@@ -156,6 +156,7 @@ fn check_expr(v: &mut CheckCrateVisitor, e: &Expr, is_const: bool) {
                 }
             }
           }
+          ExprVstore(_, ExprVstoreMutSlice) |
           ExprVstore(_, ExprVstoreSlice) |
           ExprVec(_, MutImmutable) |
           ExprAddrOf(MutImmutable, _) |

trunk/src/librustc/middle/check_static.rs

@@ -107,6 +107,10 @@ impl<'a> Visitor<bool> for CheckStaticVisitor<'a> {
             ast::ExprVstore(_, ast::ExprVstoreSlice) => {
                 visit::walk_expr(self, e, is_const);
             }
+            ast::ExprVstore(_, ast::ExprVstoreMutSlice) => {
+                self.tcx.sess.span_err(e.span,
+                                       "static items are not allowed to have mutable slices");
+           },
             ast::ExprUnary(ast::UnBox, _) => {
                 self.tcx.sess.span_err(e.span,
                                    "static items are not allowed to have managed pointers");

trunk/src/librustc/middle/trans/consts.rs

@@ -10,7 +10,8 @@
 
 
 use back::abi;
-use lib::llvm::{llvm, ConstFCmp, ConstICmp, SetLinkage, PrivateLinkage, ValueRef, Bool, True};
+use lib::llvm::{llvm, ConstFCmp, ConstICmp, SetLinkage, PrivateLinkage, ValueRef, Bool, True,
+    False};
 use lib::llvm::{IntEQ, IntNE, IntUGT, IntUGE, IntULT, IntULE, IntSGT, IntSGE, IntSLT, IntSLE,
     RealOEQ, RealOGT, RealOGE, RealOLT, RealOLE, RealONE};
 
@@ -574,7 +575,8 @@ fn const_expr_unadjusted(cx: &CrateContext, e: &ast::Expr,
                                                is_local);
             (v, inlineable)
           }
-          ast::ExprVstore(sub, ast::ExprVstoreSlice) => {
+          ast::ExprVstore(sub, store @ ast::ExprVstoreSlice) |
+          ast::ExprVstore(sub, store @ ast::ExprVstoreMutSlice) => {
             match sub.node {
               ast::ExprLit(ref lit) => {
                 match lit.node {
@@ -592,7 +594,8 @@ fn const_expr_unadjusted(cx: &CrateContext, e: &ast::Expr,
                     llvm::LLVMAddGlobal(cx.llmod, llty.to_ref(), name)
                 });
                 llvm::LLVMSetInitializer(gv, cv);
-                llvm::LLVMSetGlobalConstant(gv, True);
+                llvm::LLVMSetGlobalConstant(gv,
+                      if store == ast::ExprVstoreMutSlice { False } else { True });
                 SetLinkage(gv, PrivateLinkage);
                 let p = const_ptrcast(cx, gv, llunitty);
                 (C_struct(cx, [p, C_uint(cx, es.len())], false), false)

trunk/src/libstd/str.rs

@@ -1376,9 +1376,8 @@ pub mod raw {
 
     #[lang="strdup_uniq"]
     #[cfg(not(test))]
-    #[allow(missing_doc)]
     #[inline]
-    pub unsafe fn strdup_uniq(ptr: *u8, len: uint) -> ~str {
+    unsafe fn strdup_uniq(ptr: *u8, len: uint) -> ~str {
         from_buf_len(ptr, len)
     }
 

trunk/src/libstd/sync/atomics.rs

@@ -27,14 +27,6 @@ use std::kinds::marker;
 use option::{Option,Some,None};
 use ops::Drop;
 
-/**
- * A simple atomic flag, that can be set and cleared. The most basic atomic type.
- */
-pub struct AtomicFlag {
-    priv v: int,
-    priv nopod: marker::NoPod
-}
-
 /**
  * An atomic boolean type.
  */
@@ -92,36 +84,11 @@ pub enum Ordering {
     SeqCst
 }
 
-pub static INIT_ATOMIC_FLAG : AtomicFlag = AtomicFlag { v: 0, nopod: marker::NoPod };
 pub static INIT_ATOMIC_BOOL : AtomicBool = AtomicBool { v: 0, nopod: marker::NoPod };
 pub static INIT_ATOMIC_INT  : AtomicInt  = AtomicInt  { v: 0, nopod: marker::NoPod };
 pub static INIT_ATOMIC_UINT : AtomicUint = AtomicUint { v: 0, nopod: marker::NoPod };
 pub static INIT_ATOMIC_U64 : AtomicU64 = AtomicU64 { v: 0, nopod: marker::NoPod };
 
-impl AtomicFlag {
-
-    pub fn new() -> AtomicFlag {
-        AtomicFlag { v: 0, nopod: marker::NoPod}
-    }
-
-    /**
-     * Clears the atomic flag
-     */
-    #[inline]
-    pub fn clear(&mut self, order: Ordering) {
-        unsafe {atomic_store(&mut self.v, 0, order)}
-    }
-
-    /**
-     * Sets the flag if it was previously unset, returns the previous value of the
-     * flag.
-     */
-    #[inline]
-    pub fn test_and_set(&mut self, order: Ordering) -> bool {
-        unsafe { atomic_compare_and_swap(&mut self.v, 0, 1, order) > 0 }
-    }
-}
-
 impl AtomicBool {
     pub fn new(v: bool) -> AtomicBool {
         AtomicBool { v: if v { 1 } else { 0 }, nopod: marker::NoPod }
@@ -539,13 +506,13 @@ mod test {
     use super::*;
 
     #[test]
-    fn flag() {
-        let mut flg = AtomicFlag::new();
-        assert!(!flg.test_and_set(SeqCst));
-        assert!(flg.test_and_set(SeqCst));
+    fn bool_() {
+        let mut a = AtomicBool::new(false);
+        assert_eq!(a.compare_and_swap(false, true, SeqCst), false);
+        assert_eq!(a.compare_and_swap(false, true, SeqCst), true);
 
-        flg.clear(SeqCst);
-        assert!(!flg.test_and_set(SeqCst));
+        a.store(false, SeqCst);
+        assert_eq!(a.compare_and_swap(false, true, SeqCst), false);
     }
 
     #[test]
@@ -595,15 +562,13 @@ mod test {
         assert_eq!(a.load(SeqCst),false);
     }
 
-    static mut S_FLAG : AtomicFlag = INIT_ATOMIC_FLAG;
     static mut S_BOOL : AtomicBool = INIT_ATOMIC_BOOL;
     static mut S_INT  : AtomicInt  = INIT_ATOMIC_INT;
     static mut S_UINT : AtomicUint = INIT_ATOMIC_UINT;
 
     #[test]
     fn static_init() {
         unsafe {
-            assert!(!S_FLAG.test_and_set(SeqCst));
             assert!(!S_BOOL.load(SeqCst));
             assert!(S_INT.load(SeqCst) == 0);
             assert!(S_UINT.load(SeqCst) == 0);

trunk/src/test/compile-fail/check-static-immutable-mut-slices.rs

@@ -0,0 +1,16 @@
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// Checks that immutable static items can't have mutable slices
+
+static TEST: &'static mut [int] = &mut [];
+//~^ ERROR static items are not allowed to have mutable slices
+
+pub fn main() { }

trunk/src/test/compile-fail/std-uncopyable-atomics.rs

@@ -16,8 +16,6 @@ use std::sync::atomics::*;
 use std::ptr;
 
 fn main() {
-    let x = INIT_ATOMIC_FLAG; //~ ERROR cannot move out of static item
-    let x = *&x; //~ ERROR: cannot move out of dereference
     let x = INIT_ATOMIC_BOOL; //~ ERROR cannot move out of static item
     let x = *&x; //~ ERROR: cannot move out of dereference
     let x = INIT_ATOMIC_INT; //~ ERROR cannot move out of static item

trunk/src/test/run-pass/check-static-mut-slices.rs

@@ -0,0 +1,20 @@
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// Checks that mutable static items can have mutable slices
+
+static mut TEST: &'static mut [int] = &mut [1];
+
+pub fn main() {
+    unsafe {
+        TEST[0] += 1;
+        assert_eq!(TEST[0], 2);
+    }
+}