test: Convert statics to constants

Additionally, add lots of tests for new functionality around statics and
`static mut`.

Author: alexcrichton

src/test/auxiliary/cci_const.rs

@@ -11,6 +11,6 @@
 pub extern fn bar() {
 }
 
-pub static foopy: &'static str = "hi there";
-pub static uint_val: uint = 12;
-pub static uint_expr: uint = (1 << uint_val) - 1;
+pub const foopy: &'static str = "hi there";
+pub const uint_val: uint = 12;
+pub const uint_expr: uint = (1 << uint_val) - 1;

src/test/auxiliary/iss.rs

@@ -17,7 +17,7 @@ pub struct C<'a> {
 }
 
 fn no_op() { }
-pub static D : C<'static> = C {
+pub const D : C<'static> = C {
     k: no_op
 };
 

src/test/auxiliary/issue-13620-1.rs

@@ -14,6 +14,6 @@ pub struct Foo {
 
 extern fn the_foo() {}
 
-pub static FOO: Foo = Foo {
+pub const FOO: Foo = Foo {
     foo: the_foo
 };

src/test/auxiliary/issue-17718-const-privacy.rs

@@ -0,0 +1,18 @@
+// 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.
+
+pub use foo::FOO2;
+
+pub const FOO: uint = 3;
+const BAR: uint = 3;
+
+mod foo {
+    pub const FOO2: uint = 3;
+}

src/test/auxiliary/issue-17718.rs

@@ -0,0 +1,22 @@
+// 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.
+
+use std::sync::atomic;
+
+pub const C1: uint = 1;
+pub const C2: atomic::AtomicUint = atomic::INIT_ATOMIC_UINT;
+pub const C3: fn() = foo;
+pub const C4: uint = C1 * C1 + C1 / C1;
+pub const C5: &'static uint = &C4;
+
+pub static S1: uint = 3;
+pub static S2: atomic::AtomicUint = atomic::INIT_ATOMIC_UINT;
+
+fn foo() {}

src/test/auxiliary/issue13213aux.rs

@@ -21,7 +21,7 @@ mod private {
     pub struct P {
         p: i32,
     }
-    pub static THREE: P = P { p: 3 };
+    pub const THREE: P = P { p: 3 };
 }
 
 pub static A: S = S { p: private::THREE };

src/test/bench/shootout-fasta-redux.rs

@@ -45,24 +45,24 @@ use std::io::{stdout, IoResult};
 use std::os;
 use std::slice::bytes::copy_memory;
 
-static LINE_LEN: uint = 60;
-static LOOKUP_SIZE: uint = 4 * 1024;
-static LOOKUP_SCALE: f32 = (LOOKUP_SIZE - 1) as f32;
+const LINE_LEN: uint = 60;
+const LOOKUP_SIZE: uint = 4 * 1024;
+const LOOKUP_SCALE: f32 = (LOOKUP_SIZE - 1) as f32;
 
 // Random number generator constants
-static IM: u32 = 139968;
-static IA: u32 = 3877;
-static IC: u32 = 29573;
+const IM: u32 = 139968;
+const IA: u32 = 3877;
+const IC: u32 = 29573;
 
-static ALU: &'static str = "GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTG\
+const ALU: &'static str = "GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTG\
                             GGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGA\
                             GACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAA\
                             AATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAAT\
                             CCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAAC\
                             CCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTG\
                             CACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA";
 
-static NULL_AMINO_ACID: AminoAcid = AminoAcid { c: ' ' as u8, p: 0.0 };
+const NULL_AMINO_ACID: AminoAcid = AminoAcid { c: ' ' as u8, p: 0.0 };
 
 static IUB: [AminoAcid, ..15] = [
     AminoAcid { c: 'a' as u8, p: 0.27 },

src/test/bench/shootout-fasta.rs

@@ -45,8 +45,8 @@ use std::io::{BufferedWriter, File};
 use std::cmp::min;
 use std::os;
 
-static LINE_LENGTH: uint = 60;
-static IM: u32 = 139968;
+const LINE_LENGTH: uint = 60;
+const IM: u32 = 139968;
 
 struct MyRandom {
     last: u32

src/test/bench/shootout-mandelbrot.rs

@@ -49,9 +49,9 @@ use std::os;
 use std::simd::f64x2;
 use std::sync::{Arc, Future};
 
-static ITER: int = 50;
-static LIMIT: f64 = 2.0;
-static WORKERS: uint = 16;
+const ITER: int = 50;
+const LIMIT: f64 = 2.0;
+const WORKERS: uint = 16;
 
 #[inline(always)]
 fn mandelbrot<W: io::Writer>(w: uint, mut out: W) -> io::IoResult<()> {
@@ -144,7 +144,7 @@ fn mandelbrot<W: io::Writer>(w: uint, mut out: W) -> io::IoResult<()> {
 fn write_line(init_i: f64, vec_init_r: &[f64], res: &mut Vec<u8>) {
     let v_init_i : f64x2 = f64x2(init_i, init_i);
     let v_2 : f64x2 = f64x2(2.0, 2.0);
-    static LIMIT_SQUARED: f64 = LIMIT * LIMIT;
+    const LIMIT_SQUARED: f64 = LIMIT * LIMIT;
 
     for chunk_init_r in vec_init_r.chunks(8) {
         let mut cur_byte = 0xff;

src/test/bench/shootout-nbody.rs

@@ -38,10 +38,10 @@
 // ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
 // OF THE POSSIBILITY OF SUCH DAMAGE.
 
-static PI: f64 = 3.141592653589793;
-static SOLAR_MASS: f64 = 4.0 * PI * PI;
-static YEAR: f64 = 365.24;
-static N_BODIES: uint = 5;
+const PI: f64 = 3.141592653589793;
+const SOLAR_MASS: f64 = 4.0 * PI * PI;
+const YEAR: f64 = 365.24;
+const N_BODIES: uint = 5;
 
 static BODIES: [Planet, ..N_BODIES] = [
     // Sun

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

@@ -11,6 +11,6 @@
 // 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
+//~^ ERROR statics are not allowed to have mutable references
 
 pub fn main() { }

src/test/compile-fail/check-static-values-constraints.rs

@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// Verifies all possible restrictions for static items values.
+// Verifies all possible restrictions for statics values.
 
 use std::kinds::marker;
 
@@ -21,7 +21,7 @@ impl Drop for WithDtor {
 // This enum will be used to test the following rules:
 // 1. Variants are safe for static
 // 2. Expr calls are allowed as long as they arguments are safe
-// 3. Expr calls with unsafe arguments for static items are rejected
+// 3. Expr calls with unsafe arguments for statics are rejected
 enum SafeEnum {
     Variant1,
     Variant2(int),
@@ -35,7 +35,7 @@ static STATIC2: SafeEnum = Variant2(0);
 
 // This one should fail
 static STATIC3: SafeEnum = Variant3(WithDtor);
-//~^ ERROR static items are not allowed to have destructors
+//~^ ERROR statics are not allowed to have destructors
 
 
 // This enum will be used to test that variants
@@ -52,9 +52,9 @@ impl Drop for UnsafeEnum {
 
 
 static STATIC4: UnsafeEnum = Variant5;
-//~^ ERROR static items are not allowed to have destructors
+//~^ ERROR statics are not allowed to have destructors
 static STATIC5: UnsafeEnum = Variant6(0);
-//~^ ERROR static items are not allowed to have destructors
+//~^ ERROR statics are not allowed to have destructors
 
 
 struct SafeStruct {
@@ -68,7 +68,7 @@ static STATIC6: SafeStruct = SafeStruct{field1: Variant1, field2: Variant2(0)};
 
 // field2 has an unsafe value, hence this should fail
 static STATIC7: SafeStruct = SafeStruct{field1: Variant1, field2: Variant3(WithDtor)};
-//~^ ERROR static items are not allowed to have destructors
+//~^ ERROR statics are not allowed to have destructors
 
 // Test variadic constructor for structs. The base struct should be examined
 // as well as every field present in the constructor.
@@ -79,7 +79,7 @@ static STATIC8: SafeStruct = SafeStruct{field1: Variant1,
 // This example should fail because field1 in the base struct is not safe
 static STATIC9: SafeStruct = SafeStruct{field1: Variant1,
                                         ..SafeStruct{field1: Variant3(WithDtor), field2: Variant1}};
-//~^ ERROR static items are not allowed to have destructors
+//~^ ERROR statics are not allowed to have destructors
 
 struct UnsafeStruct;
 
@@ -89,44 +89,48 @@ impl Drop for UnsafeStruct {
 
 // Types with destructors are not allowed for statics
 static STATIC10: UnsafeStruct = UnsafeStruct;
-//~^ ERROR static items are not allowed to have destructor
+//~^ ERROR statics are not allowed to have destructor
 
 struct MyOwned;
 
 static STATIC11: Box<MyOwned> = box MyOwned;
-//~^ ERROR static items are not allowed to have custom pointers
+//~^ ERROR statics are not allowed to have custom pointers
 
 // The following examples test that mutable structs are just forbidden
 // to have types with destructors
 // These should fail
 static mut STATIC12: UnsafeStruct = UnsafeStruct;
-//~^ ERROR mutable static items are not allowed to have destructors
+//~^ ERROR mutable statics are not allowed to have destructors
+//~^^ ERROR statics are not allowed to have destructors
 
 static mut STATIC13: SafeStruct = SafeStruct{field1: Variant1, field2: Variant3(WithDtor)};
-//~^ ERROR mutable static items are not allowed to have destructors
+//~^ ERROR mutable statics are not allowed to have destructors
+//~^^ ERROR: statics are not allowed to have destructors
 
 static mut STATIC14: SafeStruct = SafeStruct {
-//~^ ERROR mutable static items are not allowed to have destructors
+//~^ ERROR mutable statics are not allowed to have destructors
     field1: Variant1,
     field2: Variant4("str".to_string())
 };
 
-static STATIC15: &'static [Box<MyOwned>] = &[box MyOwned, box MyOwned];
-//~^ ERROR static items are not allowed to have custom pointers
-//~^^ ERROR static items are not allowed to have custom pointers
+static STATIC15: &'static [Box<MyOwned>] = &[
+    box MyOwned, //~ ERROR statics are not allowed to have custom pointers
+    box MyOwned, //~ ERROR statics are not allowed to have custom pointers
+];
 
-static STATIC16: (&'static Box<MyOwned>, &'static Box<MyOwned>) =
-    (&box MyOwned, &box MyOwned);
-//~^ ERROR static items are not allowed to have custom pointers
-//~^^ ERROR static items are not allowed to have custom pointers
+static STATIC16: (&'static Box<MyOwned>, &'static Box<MyOwned>) = (
+    &box MyOwned, //~ ERROR statics are not allowed to have custom pointers
+    &box MyOwned, //~ ERROR statics are not allowed to have custom pointers
+);
 
 static mut STATIC17: SafeEnum = Variant1;
-//~^ ERROR mutable static items are not allowed to have destructors
+//~^ ERROR mutable statics are not allowed to have destructors
 
-static STATIC19: Box<int> = box 3;
-//~^ ERROR static items are not allowed to have custom pointers
+static STATIC19: Box<int> =
+    box 3;
+//~^ ERROR statics are not allowed to have custom pointers
 
 pub fn main() {
     let y = { static x: Box<int> = box 3; x };
-    //~^ ERROR static items are not allowed to have custom pointers
+    //~^ ERROR statics are not allowed to have custom pointers
 }

src/test/compile-fail/issue-15524.rs

@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-static N: int = 1;
+const N: int = 1;
 
 enum Foo {
     A = 1,

src/test/compile-fail/issue-16149.rs

@@ -15,7 +15,7 @@ extern {
 fn main() {
     let boolValue = match 42 {
         externalValue => true,
-        //~^ ERROR extern statics cannot be referenced in patterns
+        //~^ ERROR static variables cannot be referenced in a pattern
         _ => false
     };
 }

src/test/compile-fail/issue-17718-borrow-interior.rs

@@ -0,0 +1,24 @@
+// 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.
+
+struct S { a: uint }
+static A: S  = S { a: 3 };
+static B: &'static uint = &A.a;
+//~^ ERROR: cannot refer to the interior of another static
+static C: &'static uint = &(A.a);
+//~^ ERROR: cannot refer to the interior of another static
+
+static D: [uint, ..1] = [1];
+static E: uint = D[0];
+//~^ ERROR: cannot refer to other statics by value
+static F: &'static uint = &D[0];
+//~^ ERROR: cannot refer to the interior of another static
+
+fn main() {}

src/test/compile-fail/issue-17718-const-bad-values.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.
+
+const C1: &'static mut [uint] = &mut [];
+//~^ ERROR: constants are not allowed to have mutable references
+
+static mut S: uint = 3;
+const C2: &'static mut uint = &mut S;
+//~^ ERROR: constants cannot refer to other statics
+//~^^ ERROR: are not allowed to have mutable references
+
+fn main() {}
+

src/test/compile-fail/issue-17718-const-borrow.rs

@@ -0,0 +1,24 @@
+// 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.
+
+use std::cell::UnsafeCell;
+
+const A: UnsafeCell<uint> = UnsafeCell { value: 1 };
+const B: &'static UnsafeCell<uint> = &A;
+//~^ ERROR: cannot borrow a constant which contains interior mutability
+
+struct C { a: UnsafeCell<uint> }
+const D: C = C { a: UnsafeCell { value: 1 } };
+const E: &'static UnsafeCell<uint> = &D.a;
+//~^ ERROR: cannot borrow a constant which contains interior mutability
+const F: &'static C = &D;
+//~^ ERROR: cannot borrow a constant which contains interior mutability
+
+fn main() {}

src/test/compile-fail/issue-17718-const-destructors.rs

@@ -14,6 +14,6 @@ impl Drop for A {
 }
 
 const FOO: A = A;
-//~ ERROR: constants are not allowed to have destructors
+//~^ ERROR: constants are not allowed to have destructors
 
 fn main() {}