mathieu/granite-rust
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

auto merge of #17742 : alexcrichton/rust/rollup, r=alexcrichton

Browse source 
Trying to get a couple of these into the next snapshot.
This commit is contained in:
bors 2014-10-03 18:47:13 +00:00
commit ae81c89f34
61 changed files with 717 additions and 259 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

9
.travis.yml
View file

@ -3,13 +3,6 @@
# downloads a rust/cargo snapshot, which we don't really want for building rust.
language: c
# Make sure we've got an up-to-date g++ compiler to get past the LLVM configure
# script.
install:
- sudo add-apt-repository -y ppa:ubuntu-toolchain-r/test
- sudo apt-get update -qq
- sudo apt-get install g++-4.7
# The test suite is in general way too stressful for travis, especially in
# terms of time limit and reliability. In the past we've tried to scale things
# back to only build the stage1 compiler and run a subset of tests, but this
@ -18,7 +11,7 @@ install:
# As a result, we're just using travis to run `make tidy` now. It'll help
# everyone find out about their trailing spaces early on!
before_script:
- ./configure
- ./configure --llvm-root=path/to/nowhere
script:
- make tidy

2
src/doc/reference.md
View file

@ -1412,7 +1412,7 @@ struct BitsNStrings<'a> {
mystring: &'a str
}
static bits_n_strings: BitsNStrings<'static> = BitsNStrings {
static BITS_N_STRINGS: BitsNStrings<'static> = BitsNStrings {
mybits: BITS,
mystring: STRING
};

63
src/libnum/bigint.rs
View file

@ -86,9 +86,12 @@ pub mod BigDigit {
use super::DoubleBigDigit;
// `DoubleBigDigit` size dependent
#[allow(non_uppercase_statics)]
pub static bits: uint = 32;
#[allow(non_uppercase_statics)]
pub static base: DoubleBigDigit = 1 << bits;
#[allow(non_uppercase_statics)]
static lo_mask: DoubleBigDigit = (-1 as DoubleBigDigit) >> bits;
#[inline]
@ -1841,7 +1844,7 @@ mod biguint_tests {
BigInt::from_biguint(Plus, BigUint::new(vec!(1,2,3))));
}
static sum_triples: &'static [(&'static [BigDigit],
static SUM_TRIPLES: &'static [(&'static [BigDigit],
&'static [BigDigit],
&'static [BigDigit])] = &[
(&[], &[], &[]),
@ -1857,7 +1860,7 @@ mod biguint_tests {
#[test]
fn test_add() {
for elm in sum_triples.iter() {
for elm in SUM_TRIPLES.iter() {
let (a_vec, b_vec, c_vec) = *elm;
let a = BigUint::from_slice(a_vec);
let b = BigUint::from_slice(b_vec);
@ -1870,7 +1873,7 @@ mod biguint_tests {
#[test]
fn test_sub() {
for elm in sum_triples.iter() {
for elm in SUM_TRIPLES.iter() {
let (a_vec, b_vec, c_vec) = *elm;
let a = BigUint::from_slice(a_vec);
let b = BigUint::from_slice(b_vec);
@ -1888,7 +1891,7 @@ mod biguint_tests {
a - b;
}
static mul_triples: &'static [(&'static [BigDigit],
static MUL_TRIPLES: &'static [(&'static [BigDigit],
&'static [BigDigit],
&'static [BigDigit])] = &[
(&[], &[], &[]),
@ -1914,7 +1917,7 @@ mod biguint_tests {
(&[ 0, 0, 1], &[ 0, 0, 0, 1], &[0, 0, 0, 0, 0, 1])
];
static div_rem_quadruples: &'static [(&'static [BigDigit],
static DIV_REM_QUADRUPLES: &'static [(&'static [BigDigit],
&'static [BigDigit],
&'static [BigDigit],
&'static [BigDigit])]
@ -1928,7 +1931,7 @@ mod biguint_tests {
#[test]
fn test_mul() {
for elm in mul_triples.iter() {
for elm in MUL_TRIPLES.iter() {
let (a_vec, b_vec, c_vec) = *elm;
let a = BigUint::from_slice(a_vec);
let b = BigUint::from_slice(b_vec);
@ -1938,7 +1941,7 @@ mod biguint_tests {
assert!(b * a == c);
}
for elm in div_rem_quadruples.iter() {
for elm in DIV_REM_QUADRUPLES.iter() {
let (a_vec, b_vec, c_vec, d_vec) = *elm;
let a = BigUint::from_slice(a_vec);
let b = BigUint::from_slice(b_vec);
@ -1952,7 +1955,7 @@ mod biguint_tests {
#[test]
fn test_div_rem() {
for elm in mul_triples.iter() {
for elm in MUL_TRIPLES.iter() {
let (a_vec, b_vec, c_vec) = *elm;
let a = BigUint::from_slice(a_vec);
let b = BigUint::from_slice(b_vec);
@ -1966,7 +1969,7 @@ mod biguint_tests {
}
}
for elm in div_rem_quadruples.iter() {
for elm in DIV_REM_QUADRUPLES.iter() {
let (a_vec, b_vec, c_vec, d_vec) = *elm;
let a = BigUint::from_slice(a_vec);
let b = BigUint::from_slice(b_vec);
@ -1979,7 +1982,7 @@ mod biguint_tests {
#[test]
fn test_checked_add() {
for elm in sum_triples.iter() {
for elm in SUM_TRIPLES.iter() {
let (a_vec, b_vec, c_vec) = *elm;
let a = BigUint::from_slice(a_vec);
let b = BigUint::from_slice(b_vec);
@ -1992,7 +1995,7 @@ mod biguint_tests {
#[test]
fn test_checked_sub() {
for elm in sum_triples.iter() {
for elm in SUM_TRIPLES.iter() {
let (a_vec, b_vec, c_vec) = *elm;
let a = BigUint::from_slice(a_vec);
let b = BigUint::from_slice(b_vec);
@ -2012,7 +2015,7 @@ mod biguint_tests {
#[test]
fn test_checked_mul() {
for elm in mul_triples.iter() {
for elm in MUL_TRIPLES.iter() {
let (a_vec, b_vec, c_vec) = *elm;
let a = BigUint::from_slice(a_vec);
let b = BigUint::from_slice(b_vec);
@ -2022,7 +2025,7 @@ mod biguint_tests {
assert!(b.checked_mul(&a).unwrap() == c);
}
for elm in div_rem_quadruples.iter() {
for elm in DIV_REM_QUADRUPLES.iter() {
let (a_vec, b_vec, c_vec, d_vec) = *elm;
let a = BigUint::from_slice(a_vec);
let b = BigUint::from_slice(b_vec);
@ -2036,7 +2039,7 @@ mod biguint_tests {
#[test]
fn test_checked_div() {
for elm in mul_triples.iter() {
for elm in MUL_TRIPLES.iter() {
let (a_vec, b_vec, c_vec) = *elm;
let a = BigUint::from_slice(a_vec);
let b = BigUint::from_slice(b_vec);
@ -2440,7 +2443,7 @@ mod bigint_tests {
assert_eq!(negative.to_biguint(), None);
}
static sum_triples: &'static [(&'static [BigDigit],
static SUM_TRIPLES: &'static [(&'static [BigDigit],
&'static [BigDigit],
&'static [BigDigit])] = &[
(&[], &[], &[]),
@ -2456,7 +2459,7 @@ mod bigint_tests {
#[test]
fn test_add() {
for elm in sum_triples.iter() {
for elm in SUM_TRIPLES.iter() {
let (a_vec, b_vec, c_vec) = *elm;
let a = BigInt::from_slice(Plus, a_vec);
let b = BigInt::from_slice(Plus, b_vec);
@ -2475,7 +2478,7 @@ mod bigint_tests {
#[test]
fn test_sub() {
for elm in sum_triples.iter() {
for elm in SUM_TRIPLES.iter() {
let (a_vec, b_vec, c_vec) = *elm;
let a = BigInt::from_slice(Plus, a_vec);
let b = BigInt::from_slice(Plus, b_vec);
@ -2492,7 +2495,7 @@ mod bigint_tests {
}
}
static mul_triples: &'static [(&'static [BigDigit],
static MUL_TRIPLES: &'static [(&'static [BigDigit],
&'static [BigDigit],
&'static [BigDigit])] = &[
(&[], &[], &[]),
@ -2518,7 +2521,7 @@ mod bigint_tests {
(&[ 0, 0, 1], &[ 0, 0, 0, 1], &[0, 0, 0, 0, 0, 1])
];
static div_rem_quadruples: &'static [(&'static [BigDigit],
static DIV_REM_QUADRUPLES: &'static [(&'static [BigDigit],
&'static [BigDigit],
&'static [BigDigit],
&'static [BigDigit])]
@ -2532,7 +2535,7 @@ mod bigint_tests {
#[test]
fn test_mul() {
for elm in mul_triples.iter() {
for elm in MUL_TRIPLES.iter() {
let (a_vec, b_vec, c_vec) = *elm;
let a = BigInt::from_slice(Plus, a_vec);
let b = BigInt::from_slice(Plus, b_vec);
@ -2545,7 +2548,7 @@ mod bigint_tests {
assert!((-b) * a == -c);
}
for elm in div_rem_quadruples.iter() {
for elm in DIV_REM_QUADRUPLES.iter() {
let (a_vec, b_vec, c_vec, d_vec) = *elm;
let a = BigInt::from_slice(Plus, a_vec);
let b = BigInt::from_slice(Plus, b_vec);
@ -2584,7 +2587,7 @@ mod bigint_tests {
}
}
for elm in mul_triples.iter() {
for elm in MUL_TRIPLES.iter() {
let (a_vec, b_vec, c_vec) = *elm;
let a = BigInt::from_slice(Plus, a_vec);
let b = BigInt::from_slice(Plus, b_vec);
@ -2594,7 +2597,7 @@ mod bigint_tests {
if !b.is_zero() { check(&c, &b, &a, &Zero::zero()); }
}
for elm in div_rem_quadruples.iter() {
for elm in DIV_REM_QUADRUPLES.iter() {
let (a_vec, b_vec, c_vec, d_vec) = *elm;
let a = BigInt::from_slice(Plus, a_vec);
let b = BigInt::from_slice(Plus, b_vec);
@ -2627,7 +2630,7 @@ mod bigint_tests {
check_sub(&a.neg(), b, &q.neg(), &r.neg());
check_sub(&a.neg(), &b.neg(), q, &r.neg());
}
for elm in mul_triples.iter() {
for elm in MUL_TRIPLES.iter() {
let (a_vec, b_vec, c_vec) = *elm;
let a = BigInt::from_slice(Plus, a_vec);
let b = BigInt::from_slice(Plus, b_vec);
@ -2637,7 +2640,7 @@ mod bigint_tests {
if !b.is_zero() { check(&c, &b, &a, &Zero::zero()); }
}
for elm in div_rem_quadruples.iter() {
for elm in DIV_REM_QUADRUPLES.iter() {
let (a_vec, b_vec, c_vec, d_vec) = *elm;
let a = BigInt::from_slice(Plus, a_vec);
let b = BigInt::from_slice(Plus, b_vec);
@ -2652,7 +2655,7 @@ mod bigint_tests {
#[test]
fn test_checked_add() {
for elm in sum_triples.iter() {
for elm in SUM_TRIPLES.iter() {
let (a_vec, b_vec, c_vec) = *elm;
let a = BigInt::from_slice(Plus, a_vec);
let b = BigInt::from_slice(Plus, b_vec);
@ -2671,7 +2674,7 @@ mod bigint_tests {
#[test]
fn test_checked_sub() {
for elm in sum_triples.iter() {
for elm in SUM_TRIPLES.iter() {
let (a_vec, b_vec, c_vec) = *elm;
let a = BigInt::from_slice(Plus, a_vec);
let b = BigInt::from_slice(Plus, b_vec);
@ -2690,7 +2693,7 @@ mod bigint_tests {
#[test]
fn test_checked_mul() {
for elm in mul_triples.iter() {
for elm in MUL_TRIPLES.iter() {
let (a_vec, b_vec, c_vec) = *elm;
let a = BigInt::from_slice(Plus, a_vec);
let b = BigInt::from_slice(Plus, b_vec);
@ -2703,7 +2706,7 @@ mod bigint_tests {
assert!((-b).checked_mul(&a).unwrap() == -c);
}
for elm in div_rem_quadruples.iter() {
for elm in DIV_REM_QUADRUPLES.iter() {
let (a_vec, b_vec, c_vec, d_vec) = *elm;
let a = BigInt::from_slice(Plus, a_vec);
let b = BigInt::from_slice(Plus, b_vec);
@ -2716,7 +2719,7 @@ mod bigint_tests {
}
#[test]
fn test_checked_div() {
for elm in mul_triples.iter() {
for elm in MUL_TRIPLES.iter() {
let (a_vec, b_vec, c_vec) = *elm;
let a = BigInt::from_slice(Plus, a_vec);
let b = BigInt::from_slice(Plus, b_vec);

3
src/libnum/rational.rs
View file

@ -406,10 +406,13 @@ mod test {
pub static _2: Rational = Ratio { numer: 2, denom: 1};
pub static _1_2: Rational = Ratio { numer: 1, denom: 2};
pub static _3_2: Rational = Ratio { numer: 3, denom: 2};
#[allow(non_uppercase_statics)]
pub static _neg1_2: Rational = Ratio { numer: -1, denom: 2};
pub static _1_3: Rational = Ratio { numer: 1, denom: 3};
#[allow(non_uppercase_statics)]
pub static _neg1_3: Rational = Ratio { numer: -1, denom: 3};
pub static _2_3: Rational = Ratio { numer: 2, denom: 3};
#[allow(non_uppercase_statics)]
pub static _neg2_3: Rational = Ratio { numer: -2, denom: 3};
pub fn to_big(n: Rational) -> BigRational {

285
src/librand/chacha.rs Normal file
View file

@ -0,0 +1,285 @@
// 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.
//! The ChaCha random number generator.
use core::prelude::*;
use {Rng, SeedableRng, Rand};
static KEY_WORDS : uint = 8; // 8 words for the 256-bit key
static STATE_WORDS : uint = 16;
static CHACHA_ROUNDS: uint = 20; // Cryptographically secure from 8 upwards as of this writing
/// A random number generator that uses the ChaCha20 algorithm [1].
///
/// The ChaCha algorithm is widely accepted as suitable for
/// cryptographic purposes, but this implementation has not been
/// verified as such. Prefer a generator like `OsRng` that defers to
/// the operating system for cases that need high security.
///
/// [1]: D. J. Bernstein, [*ChaCha, a variant of
/// Salsa20*](http://cr.yp.to/chacha.html)
pub struct ChaChaRng {
buffer: [u32, ..STATE_WORDS], // Internal buffer of output
state: [u32, ..STATE_WORDS], // Initial state
index: uint, // Index into state
}
static EMPTY: ChaChaRng = ChaChaRng {
buffer: [0, ..STATE_WORDS],
state: [0, ..STATE_WORDS],
index: STATE_WORDS
};
macro_rules! quarter_round{
($a: expr, $b: expr, $c: expr, $d: expr) => {{
$a += $b; $d ^= $a; $d = $d.rotate_left(16);
$c += $d; $b ^= $c; $b = $b.rotate_left(12);
$a += $b; $d ^= $a; $d = $d.rotate_left( 8);
$c += $d; $b ^= $c; $b = $b.rotate_left( 7);
}}
}
macro_rules! double_round{
($x: expr) => {{
// Column round
quarter_round!($x[ 0], $x[ 4], $x[ 8], $x[12]);
quarter_round!($x[ 1], $x[ 5], $x[ 9], $x[13]);
quarter_round!($x[ 2], $x[ 6], $x[10], $x[14]);
quarter_round!($x[ 3], $x[ 7], $x[11], $x[15]);
// Diagonal round
quarter_round!($x[ 0], $x[ 5], $x[10], $x[15]);
quarter_round!($x[ 1], $x[ 6], $x[11], $x[12]);
quarter_round!($x[ 2], $x[ 7], $x[ 8], $x[13]);
quarter_round!($x[ 3], $x[ 4], $x[ 9], $x[14]);
}}
}
#[inline]
fn core(output: &mut [u32, ..STATE_WORDS], input: &[u32, ..STATE_WORDS]) {
*output = *input;
for _ in range(0, CHACHA_ROUNDS / 2) {
double_round!(output);
}
for i in range(0, STATE_WORDS) {
output[i] += input[i];
}
}
impl ChaChaRng {
/// Create an ChaCha random number generator using the default
/// fixed key of 8 zero words.
pub fn new_unseeded() -> ChaChaRng {
let mut rng = EMPTY;
rng.init(&[0, ..KEY_WORDS]);
rng
}
/// Sets the internal 128-bit ChaCha counter to
/// a user-provided value. This permits jumping
/// arbitrarily ahead (or backwards) in the pseudorandom stream.
///
/// Since the nonce words are used to extend the counter to 128 bits,
/// users wishing to obtain the conventional ChaCha pseudorandom stream
/// associated with a particular nonce can call this function with
/// arguments `0, desired_nonce`.
pub fn set_counter(&mut self, counter_low: u64, counter_high: u64) {
self.state[12] = (counter_low >> 0) as u32;
self.state[13] = (counter_low >> 32) as u32;
self.state[14] = (counter_high >> 0) as u32;
self.state[15] = (counter_high >> 32) as u32;
self.index = STATE_WORDS; // force recomputation
}
/// Initializes `self.state` with the appropriate key and constants
///
/// We deviate slightly from the ChaCha specification regarding
/// the nonce, which is used to extend the counter to 128 bits.
/// This is provably as strong as the original cipher, though,
/// since any distinguishing attack on our variant also works
/// against ChaCha with a chosen-nonce. See the XSalsa20 [1]
/// security proof for a more involved example of this.
///
/// The modified word layout is:
/// ```notrust
/// constant constant constant constant
/// key key key key
/// key key key key
/// counter counter counter counter
/// ```
/// [1]: Daniel J. Bernstein. [*Extending the Salsa20
/// nonce.*](http://cr.yp.to/papers.html#xsalsa)
fn init(&mut self, key: &[u32, ..KEY_WORDS]) {
self.state[0] = 0x61707865;
self.state[1] = 0x3320646E;
self.state[2] = 0x79622D32;
self.state[3] = 0x6B206574;
for i in range(0, KEY_WORDS) {
self.state[4+i] = key[i];
}
self.state[12] = 0;
self.state[13] = 0;
self.state[14] = 0;
self.state[15] = 0;
self.index = STATE_WORDS;
}
/// Refill the internal output buffer (`self.buffer`)
fn update(&mut self) {
core(&mut self.buffer, &self.state);
self.index = 0;
// update 128-bit counter
self.state[12] += 1;
if self.state[12] != 0 { return };
self.state[13] += 1;
if self.state[13] != 0 { return };
self.state[14] += 1;
if self.state[14] != 0 { return };
self.state[15] += 1;
}
}
impl Rng for ChaChaRng {
#[inline]
fn next_u32(&mut self) -> u32 {
if self.index == STATE_WORDS {
self.update();
}
let value = self.buffer[self.index % STATE_WORDS];
self.index += 1;
value
}
}
impl<'a> SeedableRng<&'a [u32]> for ChaChaRng {
fn reseed(&mut self, seed: &'a [u32]) {
// reset state
self.init(&[0u32, ..KEY_WORDS]);
// set key inplace
let key = self.state.slice_mut(4, 4+KEY_WORDS);
for (k, s) in key.iter_mut().zip(seed.iter()) {
*k = *s;
}
}
/// Create a ChaCha generator from a seed,
/// obtained from a variable-length u32 array.
/// Only up to 8 words are used; if less than 8
/// words are used, the remaining are set to zero.
fn from_seed(seed: &'a [u32]) -> ChaChaRng {
let mut rng = EMPTY;
rng.reseed(seed);
rng
}
}
impl Rand for ChaChaRng {
fn rand<R: Rng>(other: &mut R) -> ChaChaRng {
let mut key : [u32, ..KEY_WORDS] = [0, ..KEY_WORDS];
for word in key.iter_mut() {
*word = other.gen();
}
SeedableRng::from_seed(key.as_slice())
}
}
#[cfg(test)]
mod test {
use std::prelude::*;
use core::iter::order;
use {Rng, SeedableRng};
use super::ChaChaRng;
#[test]
fn test_rng_rand_seeded() {
let s = ::test::rng().gen_iter::<u32>().take(8).collect::<Vec<u32>>();
let mut ra: ChaChaRng = SeedableRng::from_seed(s.as_slice());
let mut rb: ChaChaRng = SeedableRng::from_seed(s.as_slice());
assert!(order::equals(ra.gen_ascii_chars().take(100),
rb.gen_ascii_chars().take(100)));
}
#[test]
fn test_rng_seeded() {
let seed : &[_] = &[0,1,2,3,4,5,6,7];
let mut ra: ChaChaRng = SeedableRng::from_seed(seed);
let mut rb: ChaChaRng = SeedableRng::from_seed(seed);
assert!(order::equals(ra.gen_ascii_chars().take(100),
rb.gen_ascii_chars().take(100)));
}
#[test]
fn test_rng_reseed() {
let s = ::test::rng().gen_iter::<u32>().take(8).collect::<Vec<u32>>();
let mut r: ChaChaRng = SeedableRng::from_seed(s.as_slice());
let string1: String = r.gen_ascii_chars().take(100).collect();
r.reseed(s.as_slice());
let string2: String = r.gen_ascii_chars().take(100).collect();
assert_eq!(string1, string2);
}
#[test]
fn test_rng_true_values() {
// Test vectors 1 and 2 from
// http://tools.ietf.org/html/draft-nir-cfrg-chacha20-poly1305-04
let seed : &[_] = &[0u32, ..8];
let mut ra: ChaChaRng = SeedableRng::from_seed(seed);
let v = Vec::from_fn(16, |_| ra.next_u32());
assert_eq!(v,
vec!(0xade0b876, 0x903df1a0, 0xe56a5d40, 0x28bd8653,
0xb819d2bd, 0x1aed8da0, 0xccef36a8, 0xc70d778b,
0x7c5941da, 0x8d485751, 0x3fe02477, 0x374ad8b8,
0xf4b8436a, 0x1ca11815, 0x69b687c3, 0x8665eeb2));
let v = Vec::from_fn(16, |_| ra.next_u32());
assert_eq!(v,
vec!(0xbee7079f, 0x7a385155, 0x7c97ba98, 0x0d082d73,
0xa0290fcb, 0x6965e348, 0x3e53c612, 0xed7aee32,
0x7621b729, 0x434ee69c, 0xb03371d5, 0xd539d874,
0x281fed31, 0x45fb0a51, 0x1f0ae1ac, 0x6f4d794b));
let seed : &[_] = &[0,1,2,3,4,5,6,7];
let mut ra: ChaChaRng = SeedableRng::from_seed(seed);
// Store the 17*i-th 32-bit word,
// i.e., the i-th word of the i-th 16-word block
let mut v : Vec<u32> = Vec::new();
for _ in range(0u, 16) {
v.push(ra.next_u32());
for _ in range(0u, 16) {
ra.next_u32();
}
}
assert_eq!(v,
vec!(0xf225c81a, 0x6ab1be57, 0x04d42951, 0x70858036,
0x49884684, 0x64efec72, 0x4be2d186, 0x3615b384,
0x11cfa18e, 0xd3c50049, 0x75c775f6, 0x434c6530,
0x2c5bad8f, 0x898881dc, 0x5f1c86d9, 0xc1f8e7f4));
}
}

2
src/librand/lib.rs
View file

@ -39,6 +39,7 @@ extern crate core;
use core::prelude::*;
pub use isaac::{IsaacRng, Isaac64Rng};
pub use chacha::ChaChaRng;
use distributions::{Range, IndependentSample};
use distributions::range::SampleRange;
@ -48,6 +49,7 @@ static RAND_BENCH_N: u64 = 100;
pub mod distributions;
pub mod isaac;
pub mod chacha;
pub mod reseeding;
mod rand_impls;

6
src/librand/reseeding.rs
View file

@ -209,15 +209,15 @@ mod test {
assert_eq!(string1, string2);
}
static fill_bytes_v_len: uint = 13579;
static FILL_BYTES_V_LEN: uint = 13579;
#[test]
fn test_rng_fill_bytes() {
let mut v = Vec::from_elem(fill_bytes_v_len, 0u8);
let mut v = Vec::from_elem(FILL_BYTES_V_LEN, 0u8);
::test::rng().fill_bytes(v.as_mut_slice());
// Sanity test: if we've gotten here, `fill_bytes` has not infinitely
// recursed.
assert_eq!(v.len(), fill_bytes_v_len);
assert_eq!(v.len(), FILL_BYTES_V_LEN);
// To test that `fill_bytes` actually did something, check that the
// average of `v` is not 0.

2
src/librustc/driver/config.rs
View file

@ -494,6 +494,7 @@ pub fn get_os(triple: &str) -> Option<abi::Os> {
}
None
}
#[allow(non_uppercase_statics)]
static os_names : &'static [(&'static str, abi::Os)] = &[
("mingw32", abi::OsWindows),
("win32", abi::OsWindows),
@ -511,6 +512,7 @@ pub fn get_arch(triple: &str) -> Option<abi::Architecture> {
}
None
}
#[allow(non_uppercase_statics)]
static architecture_abis : &'static [(&'static str, abi::Architecture)] = &[
("i386", abi::X86),
("i486", abi::X86),

23
src/librustc/lint/builtin.rs
View file

@ -631,7 +631,7 @@ impl LintPass for UnusedAttribute {
}
}
declare_lint!(PATH_STATEMENT, Warn,
declare_lint!(pub PATH_STATEMENT, Warn,
"path statements with no effect")
pub struct PathStatement;
@ -655,10 +655,10 @@ impl LintPass for PathStatement {
}
}
declare_lint!(UNUSED_MUST_USE, Warn,
declare_lint!(pub UNUSED_MUST_USE, Warn,
"unused result of a type flagged as #[must_use]")
declare_lint!(UNUSED_RESULT, Allow,
declare_lint!(pub UNUSED_RESULT, Allow,
"unused result of an expression in a statement")
pub struct UnusedResult;
@ -871,13 +871,17 @@ impl NonSnakeCase {
fn to_snake_case(str: &str) -> String {
let mut words = vec![];
for s in str.split('_') {
let mut last_upper = false;
let mut buf = String::new();
if s.is_empty() { continue; }
for ch in s.chars() {
if !buf.is_empty() && buf.as_slice() != "'" && ch.is_uppercase() {
if !buf.is_empty() && buf.as_slice() != "'"
&& ch.is_uppercase()
&& !last_upper {
words.push(buf);
buf = String::new();
}
last_upper = ch.is_uppercase();
buf.push_char(ch.to_lowercase());
}
words.push(buf);
@ -961,7 +965,7 @@ impl LintPass for NonSnakeCase {
}
}
declare_lint!(pub NON_UPPERCASE_STATICS, Allow,
declare_lint!(pub NON_UPPERCASE_STATICS, Warn,
"static constants should have uppercase identifiers")
pub struct NonUppercaseStatics;
@ -1136,7 +1140,7 @@ impl LintPass for UnnecessaryImportBraces {
}
}
declare_lint!(UNUSED_UNSAFE, Warn,
declare_lint!(pub UNUSED_UNSAFE, Warn,
"unnecessary use of an `unsafe` block")
pub struct UnusedUnsafe;
@ -1488,6 +1492,8 @@ impl LintPass for Stability {
});
if skip { return; }
let mut span = e.span;
let id = match e.node {
ast::ExprPath(..) | ast::ExprStruct(..) => {
match cx.tcx.def_map.borrow().find(&e.id) {
@ -1495,7 +1501,8 @@ impl LintPass for Stability {
None => return
}
}
ast::ExprMethodCall(..) => {
ast::ExprMethodCall(i, _, _) => {
span = i.span;
let method_call = typeck::MethodCall::expr(e.id);
match cx.tcx.method_map.borrow().find(&method_call) {
Some(method) => {
@ -1552,7 +1559,7 @@ impl LintPass for Stability {
_ => format!("use of {} item", label)
};
cx.span_lint(lint, e.span, msg.as_slice());
cx.span_lint(lint, span, msg.as_slice());
}
}

3
src/librustc/lint/context.rs
View file

@ -203,7 +203,8 @@ impl LintStore {
add_lint_group!(sess, "unused",
UNUSED_IMPORTS, UNUSED_VARIABLE, DEAD_ASSIGNMENT, DEAD_CODE,
UNUSED_MUT, UNREACHABLE_CODE, UNUSED_EXTERN_CRATE)
UNUSED_MUT, UNREACHABLE_CODE, UNUSED_EXTERN_CRATE, UNUSED_MUST_USE,
UNUSED_UNSAFE, UNUSED_RESULT, PATH_STATEMENT)
// We have one lint pass defined in this module.
self.register_pass(sess, false, box GatherNodeLevels as LintPassObject);

1
src/librustc/lint/mod.rs
View file

@ -98,6 +98,7 @@ macro_rules! declare_lint (
#[macro_export]
macro_rules! lint_array ( ($( $lint:expr ),*) => (
{
#[allow(non_uppercase_statics)]
static array: LintArray = &[ $( $lint ),* ];
array
}

2
src/librustc/metadata/common.rs
View file

@ -8,7 +8,7 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
#![allow(non_camel_case_types)]
#![allow(non_camel_case_types, non_uppercase_statics)]
use std::mem;
use back::svh::Svh;

1
src/librustc/metadata/encoder.rs
View file

@ -2028,6 +2028,7 @@ fn encode_dylib_dependency_formats(rbml_w: &mut Encoder, ecx: &EncodeContext) {
}
// NB: Increment this as you change the metadata encoding version.
#[allow(non_uppercase_statics)]
pub static metadata_encoding_version : &'static [u8] = &[b'r', b'u', b's', b't', 0, 0, 0, 1 ];
pub fn encode_metadata(parms: EncodeParams, krate: &Crate) -> Vec<u8> {

2
src/librustc/middle/borrowck/move_data.rs
View file

@ -83,6 +83,7 @@ impl Clone for MovePathIndex {
}
}
#[allow(non_uppercase_statics)]
static InvalidMovePathIndex: MovePathIndex =
MovePathIndex(uint::MAX);
@ -96,6 +97,7 @@ impl MoveIndex {
}
}
#[allow(non_uppercase_statics)]
static InvalidMoveIndex: MoveIndex =
MoveIndex(uint::MAX);

4
src/librustc/middle/graph.rs
View file

@ -57,16 +57,20 @@ pub struct Edge<E> {
#[deriving(Clone, PartialEq, Show)]
pub struct NodeIndex(pub uint);
#[allow(non_uppercase_statics)]
pub static InvalidNodeIndex: NodeIndex = NodeIndex(uint::MAX);
#[deriving(PartialEq)]
pub struct EdgeIndex(pub uint);
#[allow(non_uppercase_statics)]
pub static InvalidEdgeIndex: EdgeIndex = EdgeIndex(uint::MAX);
// Use a private field here to guarantee no more instances are created:
#[deriving(Show)]
pub struct Direction { repr: uint }
#[allow(non_uppercase_statics)]
pub static Outgoing: Direction = Direction { repr: 0 };
#[allow(non_uppercase_statics)]
pub static Incoming: Direction = Direction { repr: 1 };
impl NodeIndex {

2
src/librustc/middle/trans/adt.rs
View file

@ -389,10 +389,12 @@ fn mk_cenum(cx: &CrateContext, hint: Hint, bounds: &IntBounds) -> Repr {
fn range_to_inttype(cx: &CrateContext, hint: Hint, bounds: &IntBounds) -> IntType {
debug!("range_to_inttype: {:?} {:?}", hint, bounds);
// Lists of sizes to try. u64 is always allowed as a fallback.
#[allow(non_uppercase_statics)]
static choose_shortest: &'static[IntType] = &[
attr::UnsignedInt(ast::TyU8), attr::SignedInt(ast::TyI8),
attr::UnsignedInt(ast::TyU16), attr::SignedInt(ast::TyI16),
attr::UnsignedInt(ast::TyU32), attr::SignedInt(ast::TyI32)];
#[allow(non_uppercase_statics)]
static at_least_32: &'static[IntType] = &[
attr::UnsignedInt(ast::TyU32), attr::SignedInt(ast::TyI32)];

4
src/librustc/middle/trans/builder.rs
View file

@ -31,8 +31,8 @@ pub struct Builder<'a, 'tcx: 'a> {
// This is a really awful way to get a zero-length c-string, but better (and a
// lot more efficient) than doing str::as_c_str("", ...) every time.
pub fn noname() -> *const c_char {
static cnull: c_char = 0;
&cnull as *const c_char
static CNULL: c_char = 0;
&CNULL as *const c_char
}
impl<'a, 'tcx> Builder<'a, 'tcx> {

7
src/librustc/middle/trans/debuginfo.rs
View file

@ -218,13 +218,20 @@ use syntax::parse::token::special_idents;
static DW_LANG_RUST: c_uint = 0x9000;
#[allow(non_uppercase_statics)]
static DW_TAG_auto_variable: c_uint = 0x100;
#[allow(non_uppercase_statics)]
static DW_TAG_arg_variable: c_uint = 0x101;
#[allow(non_uppercase_statics)]
static DW_ATE_boolean: c_uint = 0x02;
#[allow(non_uppercase_statics)]
static DW_ATE_float: c_uint = 0x04;
#[allow(non_uppercase_statics)]
static DW_ATE_signed: c_uint = 0x05;
#[allow(non_uppercase_statics)]
static DW_ATE_unsigned: c_uint = 0x07;
#[allow(non_uppercase_statics)]
static DW_ATE_unsigned_char: c_uint = 0x08;
static UNKNOWN_LINE_NUMBER: c_uint = 0;

6
src/librustc/middle/ty.rs
View file

@ -2197,7 +2197,10 @@ macro_rules! def_type_content_sets(
#[allow(non_snake_case)]
mod $mname {
use middle::ty::TypeContents;
$(pub static $name: TypeContents = TypeContents { bits: $bits };)+
$(
#[allow(non_uppercase_statics)]
pub static $name: TypeContents = TypeContents { bits: $bits };
)+
}
}
)
@ -4650,6 +4653,7 @@ pub fn unboxed_closure_upvars(tcx: &ctxt, closure_id: ast::DefId)
}
pub fn is_binopable(cx: &ctxt, ty: t, op: ast::BinOp) -> bool {
#![allow(non_uppercase_statics)]
static tycat_other: int = 0;
static tycat_bool: int = 1;
static tycat_char: int = 2;

21
src/librustc/middle/typeck/check/mod.rs
View file

@ -693,16 +693,6 @@ pub fn check_item(ccx: &CrateCtxt, it: &ast::Item) {
debug!("ItemImpl {} with id {}", token::get_ident(it.ident), it.id);
let impl_pty = ty::lookup_item_type(ccx.tcx, ast_util::local_def(it.id));
for impl_item in impl_items.iter() {
match *impl_item {
ast::MethodImplItem(ref m) => {
check_method_body(ccx, &impl_pty.generics, &**m);
}
ast::TypeImplItem(_) => {
// Nothing to do here.
}
}
}
match *opt_trait_ref {
Some(ref ast_trait_ref) => {
@ -717,6 +707,17 @@ pub fn check_item(ccx: &CrateCtxt, it: &ast::Item) {
None => { }
}
for impl_item in impl_items.iter() {
match *impl_item {
ast::MethodImplItem(ref m) => {
check_method_body(ccx, &impl_pty.generics, &**m);
}
ast::TypeImplItem(_) => {
// Nothing to do here.
}
}
}
}
ast::ItemTrait(_, _, _, ref trait_methods) => {
let trait_def = ty::lookup_trait_def(ccx.tcx, local_def(it.id));

2
src/librustc/middle/typeck/infer/resolve.rs
View file

@ -46,6 +46,8 @@
// future). If you want to resolve everything but one type, you are
// probably better off writing `resolve_all - resolve_ivar`.
#![allow(non_uppercase_statics)]
use middle::ty::{FloatVar, FloatVid, IntVar, IntVid, RegionVid, TyVar, TyVid};
use middle::ty::{IntType, UintType};
use middle::ty;

2
src/librustc/util/ppaux.rs
View file

@ -427,7 +427,7 @@ pub fn ty_to_string(cx: &ctxt, typ: t) -> String {
ty_vec(t, sz) => {
match sz {
Some(n) => {
format!("[{}, .. {}]", ty_to_string(cx, t), n)
format!("[{}, ..{}]", ty_to_string(cx, t), n)
}
None => format!("[{}]", ty_to_string(cx, t)),
}

2
src/librustc_back/abi.rs
View file

@ -8,6 +8,8 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
#![allow(non_uppercase_statics)]
pub static box_field_refcnt: uint = 0u;
pub static box_field_drop_glue: uint = 1u;
pub static box_field_body: uint = 4u;

30
src/librustrt/c_str.rs
View file

@ -733,9 +733,9 @@ mod bench {
}
}
static s_short: &'static str = "Mary";
static s_medium: &'static str = "Mary had a little lamb";
static s_long: &'static str = "\
static S_SHORT: &'static str = "Mary";
static S_MEDIUM: &'static str = "Mary had a little lamb";
static S_LONG: &'static str = "\
Mary had a little lamb, Little lamb
Mary had a little lamb, Little lamb
Mary had a little lamb, Little lamb
@ -752,17 +752,17 @@ mod bench {
#[bench]
fn bench_to_c_str_short(b: &mut Bencher) {
bench_to_string(b, s_short)
bench_to_string(b, S_SHORT)
}
#[bench]
fn bench_to_c_str_medium(b: &mut Bencher) {
bench_to_string(b, s_medium)
bench_to_string(b, S_MEDIUM)
}
#[bench]
fn bench_to_c_str_long(b: &mut Bencher) {
bench_to_string(b, s_long)
bench_to_string(b, S_LONG)
}
fn bench_to_c_str_unchecked(b: &mut Bencher, s: &str) {
@ -774,17 +774,17 @@ mod bench {
#[bench]
fn bench_to_c_str_unchecked_short(b: &mut Bencher) {
bench_to_c_str_unchecked(b, s_short)
bench_to_c_str_unchecked(b, S_SHORT)
}
#[bench]
fn bench_to_c_str_unchecked_medium(b: &mut Bencher) {
bench_to_c_str_unchecked(b, s_medium)
bench_to_c_str_unchecked(b, S_MEDIUM)
}
#[bench]
fn bench_to_c_str_unchecked_long(b: &mut Bencher) {
bench_to_c_str_unchecked(b, s_long)
bench_to_c_str_unchecked(b, S_LONG)
}
fn bench_with_c_str(b: &mut Bencher, s: &str) {
@ -795,17 +795,17 @@ mod bench {
#[bench]
fn bench_with_c_str_short(b: &mut Bencher) {
bench_with_c_str(b, s_short)
bench_with_c_str(b, S_SHORT)
}
#[bench]
fn bench_with_c_str_medium(b: &mut Bencher) {
bench_with_c_str(b, s_medium)
bench_with_c_str(b, S_MEDIUM)
}
#[bench]
fn bench_with_c_str_long(b: &mut Bencher) {
bench_with_c_str(b, s_long)
bench_with_c_str(b, S_LONG)
}
fn bench_with_c_str_unchecked(b: &mut Bencher, s: &str) {
@ -818,16 +818,16 @@ mod bench {
#[bench]
fn bench_with_c_str_unchecked_short(b: &mut Bencher) {
bench_with_c_str_unchecked(b, s_short)
bench_with_c_str_unchecked(b, S_SHORT)
}
#[bench]
fn bench_with_c_str_unchecked_medium(b: &mut Bencher) {
bench_with_c_str_unchecked(b, s_medium)
bench_with_c_str_unchecked(b, S_MEDIUM)
}
#[bench]
fn bench_with_c_str_unchecked_long(b: &mut Bencher) {
bench_with_c_str_unchecked(b, s_long)
bench_with_c_str_unchecked(b, S_LONG)
}
}

1
src/librustrt/libunwind.rs
View file

@ -10,6 +10,7 @@
//! Unwind library interface
#![allow(non_uppercase_statics)]
#![allow(non_camel_case_types)]
#![allow(non_snake_case)]
#![allow(dead_code)] // these are just bindings

212
src/librustrt/local_data.rs
View file

@ -416,37 +416,37 @@ mod tests {
#[test]
fn test_tls_multitask() {
static my_key: Key<String> = &KeyValueKey;
my_key.replace(Some("parent data".to_string()));
static MY_KEY: Key<String> = &KeyValueKey;
MY_KEY.replace(Some("parent data".to_string()));
task::spawn(proc() {
// TLD shouldn't carry over.
assert!(my_key.get().is_none());
my_key.replace(Some("child data".to_string()));
assert!(my_key.get().as_ref().unwrap().as_slice() == "child data");
assert!(MY_KEY.get().is_none());
MY_KEY.replace(Some("child data".to_string()));
assert!(MY_KEY.get().as_ref().unwrap().as_slice() == "child data");
// should be cleaned up for us
});
// Must work multiple times
assert!(my_key.get().unwrap().as_slice() == "parent data");
assert!(my_key.get().unwrap().as_slice() == "parent data");
assert!(my_key.get().unwrap().as_slice() == "parent data");
assert!(MY_KEY.get().unwrap().as_slice() == "parent data");
assert!(MY_KEY.get().unwrap().as_slice() == "parent data");
assert!(MY_KEY.get().unwrap().as_slice() == "parent data");
}
#[test]
fn test_tls_overwrite() {
static my_key: Key<String> = &KeyValueKey;
my_key.replace(Some("first data".to_string()));
my_key.replace(Some("next data".to_string())); // Shouldn't leak.
assert!(my_key.get().unwrap().as_slice() == "next data");
static MY_KEY: Key<String> = &KeyValueKey;
MY_KEY.replace(Some("first data".to_string()));
MY_KEY.replace(Some("next data".to_string())); // Shouldn't leak.
assert!(MY_KEY.get().unwrap().as_slice() == "next data");
}
#[test]
fn test_tls_pop() {
static my_key: Key<String> = &KeyValueKey;
my_key.replace(Some("weasel".to_string()));
assert!(my_key.replace(None).unwrap() == "weasel".to_string());
static MY_KEY: Key<String> = &KeyValueKey;
MY_KEY.replace(Some("weasel".to_string()));
assert!(MY_KEY.replace(None).unwrap() == "weasel".to_string());
// Pop must remove the data from the map.
assert!(my_key.replace(None).is_none());
assert!(MY_KEY.replace(None).is_none());
}
#[test]
@ -457,58 +457,58 @@ mod tests {
// to get recorded as something within a rust stack segment. Then a
// subsequent upcall (esp. for logging, think vsnprintf) would run on
// a stack smaller than 1 MB.
static my_key: Key<String> = &KeyValueKey;
static MY_KEY: Key<String> = &KeyValueKey;
task::spawn(proc() {
my_key.replace(Some("hax".to_string()));
MY_KEY.replace(Some("hax".to_string()));
});
}
#[test]
fn test_tls_multiple_types() {
static str_key: Key<String> = &KeyValueKey;
static box_key: Key<Box<int>> = &KeyValueKey;
static int_key: Key<int> = &KeyValueKey;
static STR_KEY: Key<String> = &KeyValueKey;
static BOX_KEY: Key<Box<int>> = &KeyValueKey;
static INT_KEY: Key<int> = &KeyValueKey;
task::spawn(proc() {
str_key.replace(Some("string data".to_string()));
box_key.replace(Some(box 0));
int_key.replace(Some(42));
STR_KEY.replace(Some("string data".to_string()));
BOX_KEY.replace(Some(box 0));
INT_KEY.replace(Some(42));
});
}
#[test]
fn test_tls_overwrite_multiple_types() {
static str_key: Key<String> = &KeyValueKey;
static box_key: Key<Box<int>> = &KeyValueKey;
static int_key: Key<int> = &KeyValueKey;
static STR_KEY: Key<String> = &KeyValueKey;
static BOX_KEY: Key<Box<int>> = &KeyValueKey;
static INT_KEY: Key<int> = &KeyValueKey;
task::spawn(proc() {
str_key.replace(Some("string data".to_string()));
str_key.replace(Some("string data 2".to_string()));
box_key.replace(Some(box 0));
box_key.replace(Some(box 1));
int_key.replace(Some(42));
STR_KEY.replace(Some("string data".to_string()));
STR_KEY.replace(Some("string data 2".to_string()));
BOX_KEY.replace(Some(box 0));
BOX_KEY.replace(Some(box 1));
INT_KEY.replace(Some(42));
// This could cause a segfault if overwriting-destruction is done
// with the crazy polymorphic transmute rather than the provided
// finaliser.
int_key.replace(Some(31337));
INT_KEY.replace(Some(31337));
});
}
#[test]
#[should_fail]
fn test_tls_cleanup_on_failure() {
static str_key: Key<String> = &KeyValueKey;
static box_key: Key<Box<int>> = &KeyValueKey;
static int_key: Key<int> = &KeyValueKey;
str_key.replace(Some("parent data".to_string()));
box_key.replace(Some(box 0));
static STR_KEY: Key<String> = &KeyValueKey;
static BOX_KEY: Key<Box<int>> = &KeyValueKey;
static INT_KEY: Key<int> = &KeyValueKey;
STR_KEY.replace(Some("parent data".to_string()));
BOX_KEY.replace(Some(box 0));
task::spawn(proc() {
str_key.replace(Some("string data".to_string()));
box_key.replace(Some(box 2));
int_key.replace(Some(42));
STR_KEY.replace(Some("string data".to_string()));
BOX_KEY.replace(Some(box 2));
INT_KEY.replace(Some(42));
fail!();
});
// Not quite nondeterministic.
int_key.replace(Some(31337));
INT_KEY.replace(Some(31337));
fail!();
}
@ -523,9 +523,9 @@ mod tests {
self.tx.send(());
}
}
static key: Key<Dropper> = &KeyValueKey;
static KEY: Key<Dropper> = &KeyValueKey;
let _ = task::try(proc() {
key.replace(Some(Dropper{ tx: tx }));
KEY.replace(Some(Dropper{ tx: tx }));
});
// At this point the task has been cleaned up and the TLD dropped.
// If the channel doesn't have a value now, then the Sender was leaked.
@ -534,56 +534,56 @@ mod tests {
#[test]
fn test_static_pointer() {
static key: Key<&'static int> = &KeyValueKey;
static KEY: Key<&'static int> = &KeyValueKey;
static VALUE: int = 0;
key.replace(Some(&VALUE));
KEY.replace(Some(&VALUE));
}
#[test]
fn test_owned() {
static key: Key<Box<int>> = &KeyValueKey;
key.replace(Some(box 1));
static KEY: Key<Box<int>> = &KeyValueKey;
KEY.replace(Some(box 1));
{
let k1 = key.get().unwrap();
let k2 = key.get().unwrap();
let k3 = key.get().unwrap();
let k1 = KEY.get().unwrap();
let k2 = KEY.get().unwrap();
let k3 = KEY.get().unwrap();
assert_eq!(**k1, 1);
assert_eq!(**k2, 1);
assert_eq!(**k3, 1);
}
key.replace(Some(box 2));
assert_eq!(**key.get().unwrap(), 2);
KEY.replace(Some(box 2));
assert_eq!(**KEY.get().unwrap(), 2);
}
#[test]
fn test_same_key_type() {
static key1: Key<int> = &KeyValueKey;
static key2: Key<int> = &KeyValueKey;
static key3: Key<int> = &KeyValueKey;
static key4: Key<int> = &KeyValueKey;
static key5: Key<int> = &KeyValueKey;
key1.replace(Some(1));
key2.replace(Some(2));
key3.replace(Some(3));
key4.replace(Some(4));
key5.replace(Some(5));
static KEY1: Key<int> = &KeyValueKey;
static KEY2: Key<int> = &KeyValueKey;
static KEY3: Key<int> = &KeyValueKey;
static KEY4: Key<int> = &KeyValueKey;
static KEY5: Key<int> = &KeyValueKey;
KEY1.replace(Some(1));
KEY2.replace(Some(2));
KEY3.replace(Some(3));
KEY4.replace(Some(4));
KEY5.replace(Some(5));
assert_eq!(*key1.get().unwrap(), 1);
assert_eq!(*key2.get().unwrap(), 2);
assert_eq!(*key3.get().unwrap(), 3);
assert_eq!(*key4.get().unwrap(), 4);
assert_eq!(*key5.get().unwrap(), 5);
assert_eq!(*KEY1.get().unwrap(), 1);
assert_eq!(*KEY2.get().unwrap(), 2);
assert_eq!(*KEY3.get().unwrap(), 3);
assert_eq!(*KEY4.get().unwrap(), 4);
assert_eq!(*KEY5.get().unwrap(), 5);
}
#[test]
#[should_fail]
fn test_nested_get_set1() {
static key: Key<int> = &KeyValueKey;
assert_eq!(key.replace(Some(4)), None);
static KEY: Key<int> = &KeyValueKey;
assert_eq!(KEY.replace(Some(4)), None);
let _k = key.get();
key.replace(Some(4));
let _k = KEY.get();
KEY.replace(Some(4));
}
// ClearKey is a RAII class that ensures the keys are cleared from the map.
@ -601,95 +601,95 @@ mod tests {
#[bench]
fn bench_replace_none(b: &mut test::Bencher) {
static key: Key<uint> = &KeyValueKey;
let _clear = ClearKey(key);
key.replace(None);
static KEY: Key<uint> = &KeyValueKey;
let _clear = ClearKey(KEY);
KEY.replace(None);
b.iter(|| {
key.replace(None)
KEY.replace(None)
});
}
#[bench]
fn bench_replace_some(b: &mut test::Bencher) {
static key: Key<uint> = &KeyValueKey;
let _clear = ClearKey(key);
key.replace(Some(1u));
static KEY: Key<uint> = &KeyValueKey;
let _clear = ClearKey(KEY);
KEY.replace(Some(1u));
b.iter(|| {
key.replace(Some(2))
KEY.replace(Some(2))
});
}
#[bench]
fn bench_replace_none_some(b: &mut test::Bencher) {
static key: Key<uint> = &KeyValueKey;
let _clear = ClearKey(key);
key.replace(Some(0u));
static KEY: Key<uint> = &KeyValueKey;
let _clear = ClearKey(KEY);
KEY.replace(Some(0u));
b.iter(|| {
let old = key.replace(None).unwrap();
let old = KEY.replace(None).unwrap();
let new = old + 1;
key.replace(Some(new))
KEY.replace(Some(new))
});
}
#[bench]
fn bench_100_keys_replace_last(b: &mut test::Bencher) {
static keys: [KeyValue<uint>, ..100] = [KeyValueKey, ..100];
let _clear = keys.iter().map(ClearKey).collect::<Vec<ClearKey<uint>>>();
for (i, key) in keys.iter().enumerate() {
static KEYS: [KeyValue<uint>, ..100] = [KeyValueKey, ..100];
let _clear = KEYS.iter().map(ClearKey).collect::<Vec<ClearKey<uint>>>();
for (i, key) in KEYS.iter().enumerate() {
key.replace(Some(i));
}
b.iter(|| {
let key: Key<uint> = &keys[99];
let key: Key<uint> = &KEYS[99];
key.replace(Some(42))
});
}
#[bench]
fn bench_1000_keys_replace_last(b: &mut test::Bencher) {
static keys: [KeyValue<uint>, ..1000] = [KeyValueKey, ..1000];
let _clear = keys.iter().map(ClearKey).collect::<Vec<ClearKey<uint>>>();
for (i, key) in keys.iter().enumerate() {
static KEYS: [KeyValue<uint>, ..1000] = [KeyValueKey, ..1000];
let _clear = KEYS.iter().map(ClearKey).collect::<Vec<ClearKey<uint>>>();
for (i, key) in KEYS.iter().enumerate() {
key.replace(Some(i));
}
b.iter(|| {
let key: Key<uint> = &keys[999];
let key: Key<uint> = &KEYS[999];
key.replace(Some(42))
});
for key in keys.iter() { key.clear(); }
for key in KEYS.iter() { key.clear(); }
}
#[bench]
fn bench_get(b: &mut test::Bencher) {
static key: Key<uint> = &KeyValueKey;
let _clear = ClearKey(key);
key.replace(Some(42));
static KEY: Key<uint> = &KeyValueKey;
let _clear = ClearKey(KEY);
KEY.replace(Some(42));
b.iter(|| {
key.get()
KEY.get()
});
}
#[bench]
fn bench_100_keys_get_last(b: &mut test::Bencher) {
static keys: [KeyValue<uint>, ..100] = [KeyValueKey, ..100];
let _clear = keys.iter().map(ClearKey).collect::<Vec<ClearKey<uint>>>();
for (i, key) in keys.iter().enumerate() {
static KEYS: [KeyValue<uint>, ..100] = [KeyValueKey, ..100];
let _clear = KEYS.iter().map(ClearKey).collect::<Vec<ClearKey<uint>>>();
for (i, key) in KEYS.iter().enumerate() {
key.replace(Some(i));
}
b.iter(|| {
let key: Key<uint> = &keys[99];
let key: Key<uint> = &KEYS[99];
key.get()
});
}
#[bench]
fn bench_1000_keys_get_last(b: &mut test::Bencher) {
static keys: [KeyValue<uint>, ..1000] = [KeyValueKey, ..1000];
let _clear = keys.iter().map(ClearKey).collect::<Vec<ClearKey<uint>>>();
for (i, key) in keys.iter().enumerate() {
static KEYS: [KeyValue<uint>, ..1000] = [KeyValueKey, ..1000];
let _clear = KEYS.iter().map(ClearKey).collect::<Vec<ClearKey<uint>>>();
for (i, key) in KEYS.iter().enumerate() {
key.replace(Some(i));
}
b.iter(|| {
let key: Key<uint> = &keys[999];
let key: Key<uint> = &KEYS[999];
key.get()
});
}

8
src/librustrt/mutex.rs
View file

@ -376,8 +376,8 @@ mod imp {
#[cfg(target_arch = "arm")]
static __PTHREAD_COND_SIZE__: uint = 24;
static _PTHREAD_MUTEX_SIG_init: libc::c_long = 0x32AAABA7;
static _PTHREAD_COND_SIG_init: libc::c_long = 0x3CB0B1BB;
static _PTHREAD_MUTEX_SIG_INIT: libc::c_long = 0x32AAABA7;
static _PTHREAD_COND_SIG_INIT: libc::c_long = 0x3CB0B1BB;
#[repr(C)]
pub struct pthread_mutex_t {
@ -391,11 +391,11 @@ mod imp {
}
pub static PTHREAD_MUTEX_INITIALIZER: pthread_mutex_t = pthread_mutex_t {
__sig: _PTHREAD_MUTEX_SIG_init,
__sig: _PTHREAD_MUTEX_SIG_INIT,
__opaque: [0, ..__PTHREAD_MUTEX_SIZE__],
};
pub static PTHREAD_COND_INITIALIZER: pthread_cond_t = pthread_cond_t {
__sig: _PTHREAD_COND_SIG_init,
__sig: _PTHREAD_COND_SIG_INIT,
__opaque: [0, ..__PTHREAD_COND_SIZE__],
};
}

2
src/librustrt/util.rs
View file

@ -28,7 +28,9 @@ pub static ENFORCE_SANITY: bool = true || !cfg!(rtopt) || cfg!(rtdebug) ||
pub struct Stdio(libc::c_int);
#[allow(non_uppercase_statics)]
pub static Stdout: Stdio = Stdio(libc::STDOUT_FILENO);
#[allow(non_uppercase_statics)]
pub static Stderr: Stdio = Stdio(libc::STDERR_FILENO);
impl fmt::FormatWriter for Stdio {

2
src/libserialize/json.rs
View file

@ -360,7 +360,9 @@ fn escape_char(writer: &mut io::Writer, v: char) -> Result<(), io::IoError> {
}
fn spaces(wr: &mut io::Writer, mut n: uint) -> Result<(), io::IoError> {
#[allow(non_uppercase_statics)]
static len: uint = 16;
#[allow(non_uppercase_statics)]
static buf: [u8, ..len] = [b' ', ..len];
while n >= len {

10
src/libstd/bitflags.rs
View file

@ -123,7 +123,10 @@ macro_rules! bitflags {
bits: $T,
}
$($(#[$Flag_attr])* pub static $Flag: $BitFlags = $BitFlags { bits: $value };)+
$(
#[allow(non_uppercase_statics)]
$(#[$Flag_attr])* pub static $Flag: $BitFlags = $BitFlags { bits: $value };
)+
impl $BitFlags {
/// Returns an empty set of flags.
@ -240,7 +243,10 @@ macro_rules! bitflags {
bitflags! {
$(#[$attr])*
flags $BitFlags: $T {
$($(#[$Flag_attr])* static $Flag = $value),+
$(
#[allow(non_uppercase_statics)]
$(#[$Flag_attr])* static $Flag = $value
),+
}
}
};

27
src/libstd/io/process.rs
View file

@ -11,6 +11,7 @@
//! Bindings for executing child processes
#![allow(experimental)]
#![allow(non_uppercase_statics)]
use prelude::*;
@ -1024,32 +1025,6 @@ mod tests {
"didn't find RUN_TEST_NEW_ENV inside of:\n\n{}", output);
}
#[test]
fn test_remove_from_env() {
use os;
// save original environment
let old_env = os::getenv("RUN_TEST_NEW_ENV");
os::setenv("RUN_TEST_NEW_ENV", "123");
let prog = env_cmd().env_remove("RUN_TEST_NEW_ENV").spawn().unwrap();
let result = prog.wait_with_output().unwrap();
let output = str::from_utf8_lossy(result.output.as_slice()).into_string();
// restore original environment
match old_env {
None => {
os::unsetenv("RUN_TEST_NEW_ENV");
}
Some(val) => {
os::setenv("RUN_TEST_NEW_ENV", val.as_slice());
}
}
assert!(!output.as_slice().contains("RUN_TEST_NEW_ENV"),
"found RUN_TEST_NEW_ENV inside of:\n\n{}", output);
}
#[cfg(unix)]
pub fn sleeper() -> Process {
Command::new("sleep").arg("1000").spawn().unwrap()

2
src/libstd/macros.rs
View file

@ -304,9 +304,11 @@ macro_rules! println(
#[macro_export]
macro_rules! local_data_key(
($name:ident: $ty:ty) => (
#[allow(non_uppercase_statics)]
static $name: ::std::local_data::Key<$ty> = &::std::local_data::KeyValueKey;
);
(pub $name:ident: $ty:ty) => (
#[allow(non_uppercase_statics)]
pub static $name: ::std::local_data::Key<$ty> = &::std::local_data::KeyValueKey;
);
)

2
src/libstd/path/posix.rs
View file

@ -457,7 +457,9 @@ fn normalize_helper<'a>(v: &'a [u8], is_abs: bool) -> Option<Vec<&'a [u8]>> {
}
}
#[allow(non_uppercase_statics)]
static dot_static: &'static [u8] = b".";
#[allow(non_uppercase_statics)]
static dot_dot_static: &'static [u8] = b"..";
#[cfg(test)]

2
src/libstd/rand/mod.rs
View file

@ -233,7 +233,7 @@ use core_rand::IsaacRng as IsaacWordRng;
use core_rand::Isaac64Rng as IsaacWordRng;
pub use core_rand::{Rand, Rng, SeedableRng, Open01, Closed01};
pub use core_rand::{XorShiftRng, IsaacRng, Isaac64Rng};
pub use core_rand::{XorShiftRng, IsaacRng, Isaac64Rng, ChaChaRng};
pub use core_rand::{distributions, reseeding};
pub use rand::os::OsRng;

4
src/libstd/task.rs
View file

@ -569,10 +569,10 @@ mod test {
// climbing the task tree to dereference each ancestor. (See #1789)
// (well, it would if the constant were 8000+ - I lowered it to be more
// valgrind-friendly. try this at home, instead..!)
static generations: uint = 16;
static GENERATIONS: uint = 16;
fn child_no(x: uint) -> proc(): Send {
return proc() {
if x < generations {
if x < GENERATIONS {
TaskBuilder::new().spawn(child_no(x+1));
}
}

3
src/libsyntax/abi.rs
View file

@ -47,7 +47,9 @@ pub enum Architecture {
Mipsel
}
#[allow(non_uppercase_statics)]
static IntelBits: u32 = (1 << (X86 as uint)) | (1 << (X86_64 as uint));
#[allow(non_uppercase_statics)]
static ArmBits: u32 = (1 << (Arm as uint));
pub struct AbiData {
@ -70,6 +72,7 @@ pub enum AbiArchitecture {
Archs(u32)
}
#[allow(non_uppercase_statics)]
static AbiDatas: &'static [AbiData] = &[
// Platform-specific ABIs
AbiData {abi: Cdecl, name: "cdecl", abi_arch: Archs(IntelBits)},

1
src/libsyntax/ast_util.rs
View file

@ -293,6 +293,7 @@ pub fn operator_prec(op: ast::BinOp) -> uint {
/// Precedence of the `as` operator, which is a binary operator
/// not appearing in the prior table.
#[allow(non_uppercase_statics)]
pub static as_prec: uint = 12u;
pub fn empty_generics() -> Generics {

31
src/libsyntax/parse/parser.rs
View file

@ -3402,9 +3402,10 @@ impl<'a> Parser<'a> {
binding_mode: ast::BindingMode)
-> ast::Pat_ {
if !is_plain_ident(&self.token) {
let last_span = self.last_span;
self.span_fatal(last_span,
"expected identifier, found path");
let span = self.span;
let tok_str = self.this_token_to_string();
self.span_fatal(span,
format!("expected identifier, found `{}`", tok_str).as_slice());
}
let ident = self.parse_ident();
let last_span = self.last_span;
@ -4731,8 +4732,7 @@ impl<'a> Parser<'a> {
}
}
fn parse_item_const(&mut self) -> ItemInfo {
let m = if self.eat_keyword(keywords::Mut) {MutMutable} else {MutImmutable};
fn parse_item_const(&mut self, m: Mutability) -> ItemInfo {
let id = self.parse_ident();
self.expect(&token::COLON);
let ty = self.parse_ty(true);
@ -5288,7 +5288,26 @@ impl<'a> Parser<'a> {
if self.is_keyword(keywords::Static) {
// STATIC ITEM
self.bump();
let (ident, item_, extra_attrs) = self.parse_item_const();
let m = if self.eat_keyword(keywords::Mut) {MutMutable} else {MutImmutable};
let (ident, item_, extra_attrs) = self.parse_item_const(m);
let last_span = self.last_span;
let item = self.mk_item(lo,
last_span.hi,
ident,
item_,
visibility,
maybe_append(attrs, extra_attrs));
return IoviItem(item);
}
if self.is_keyword(keywords::Const) {
// CONST ITEM
self.bump();
if self.eat_keyword(keywords::Mut) {
let last_span = self.last_span;
self.span_err(last_span, "const globals cannot be mutable, \
did you mean to declare a static?");
}
let (ident, item_, extra_attrs) = self.parse_item_const(MutImmutable);
let last_span = self.last_span;
let item = self.mk_item(lo,
last_span.hi,

7
src/libsyntax/parse/token.rs
View file

@ -383,12 +383,15 @@ macro_rules! declare_special_idents_and_keywords {(
pub mod special_idents {
use ast::{Ident, Name};
$( pub static $si_static: Ident = Ident { name: Name($si_name), ctxt: 0 }; )*
$(
#[allow(non_uppercase_statics)]
pub static $si_static: Ident = Ident { name: Name($si_name), ctxt: 0 };
)*
}
pub mod special_names {
use ast::Name;
$( pub static $si_static: Name = Name($si_name); )*
$( #[allow(non_uppercase_statics)] pub static $si_static: Name = Name($si_name); )*
}
/**

2
src/libsyntax/print/pprust.rs
View file

@ -89,8 +89,10 @@ pub fn rust_printer_annotated<'a>(writer: Box<io::Writer+'static>,
}
}
#[allow(non_uppercase_statics)]
pub static indent_unit: uint = 4u;
#[allow(non_uppercase_statics)]
pub static default_columns: uint = 78u;
/// Requires you to pass an input filename and reader so that

1
src/libuuid/lib.rs
View file

@ -173,6 +173,7 @@ impl fmt::Show for ParseError {
}
// Length of each hyphenated group in hex digits
#[allow(non_uppercase_statics)]
static UuidGroupLens: [uint, ..5] = [8u, 4u, 4u, 4u, 12u];
/// UUID support

1
src/test/compile-fail-fulldeps/syntax-extension-regex-unused-static.rs
View file

@ -17,6 +17,7 @@ extern crate regex;
#[deny(unused_variable)]
#[deny(dead_code)]
#[allow(non_uppercase_statics)]
// Tests to make sure that extraneous dead code warnings aren't emitted from
// the code generated by regex!.

2
src/test/compile-fail/asm-misplaced-option.rs
View file

@ -12,7 +12,7 @@
#![feature(asm)]
#![allow(dead_code)]
#![allow(dead_code, non_uppercase_statics)]
#[cfg(any(target_arch = "x86",
target_arch = "x86_64"))]

2
src/test/compile-fail/dst-bad-coerce1.rs
View file

@ -22,7 +22,7 @@ pub fn main() {
let f1 = Fat { ptr: [1, 2, 3] };
let f2: &Fat<[int, ..3]> = &f1;
let f3: &Fat<[uint]> = f2;
//~^ ERROR mismatched types: expected `&Fat<[uint]>`, found `&Fat<[int, .. 3]>`
//~^ ERROR mismatched types: expected `&Fat<[uint]>`, found `&Fat<[int, ..3]>`
// With a trait.
let f1 = Fat { ptr: Foo };

2
src/test/compile-fail/dst-bad-coerce4.rs
View file

@ -18,5 +18,5 @@ pub fn main() {
// With a vec of ints.
let f1: &Fat<[int]> = &Fat { ptr: [1, 2, 3] };
let f2: &Fat<[int, ..3]> = f1;
//~^ ERROR mismatched types: expected `&Fat<[int, .. 3]>`, found `&Fat<[int]>`
//~^ ERROR mismatched types: expected `&Fat<[int, ..3]>`, found `&Fat<[int]>`
}

2
src/test/compile-fail/issue-13482.rs
View file

@ -12,7 +12,7 @@ fn main() {
let x = [1,2];
let y = match x {
[] => None,
//~^ ERROR expected `[<generic integer #0>, .. 2]`, found a fixed vector pattern of size 0
//~^ ERROR expected `[<generic integer #0>, ..2]`, found a fixed vector pattern of size 0
[a,_] => Some(a)
};
}

4
src/test/compile-fail/issue-14845.rs
View file

@ -16,9 +16,9 @@ struct X {
fn main() {
let x = X { a: [0] };
let _f = &x.a as *mut u8;
//~^ ERROR mismatched types: expected `*mut u8`, found `&[u8, .. 1]`
//~^ ERROR mismatched types: expected `*mut u8`, found `&[u8, ..1]`
let local = [0u8];
let _v = &local as *mut u8;
//~^ ERROR mismatched types: expected `*mut u8`, found `&[u8, .. 1]`
//~^ ERROR mismatched types: expected `*mut u8`, found `&[u8, ..1]`
}

14
src/test/compile-fail/issue-15914.rs Normal file
View file

@ -0,0 +1,14 @@
// 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.
fn main() {
let ref
(); //~ ERROR expected identifier, found `(`
}

23
src/test/compile-fail/issue-17337.rs Normal file
View file

@ -0,0 +1,23 @@
// 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.
#![deny(deprecated)]
struct Foo;
impl Foo {
#[deprecated]
fn foo(self) {}
}
fn main() {
Foo
.foo(); //~ ERROR use of deprecated item
}

4
src/test/compile-fail/issue-17441.rs
View file

@ -10,7 +10,7 @@
fn main() {
let _foo = &[1u, 2] as [uint];
//~^ ERROR cast to unsized type: `&[uint, .. 2]` as `[uint]`
//~^ ERROR cast to unsized type: `&[uint, ..2]` as `[uint]`
//~^^ NOTE consider using an implicit coercion to `&[uint]` instead
let _bar = box 1u as std::fmt::Show;
//~^ ERROR cast to unsized type: `Box<uint>` as `core::fmt::Show`
@ -19,6 +19,6 @@ fn main() {
//~^ ERROR cast to unsized type: `uint` as `core::fmt::Show`
//~^^ NOTE consider using a box or reference as appropriate
let _quux = [1u, 2] as [uint];
//~^ ERROR cast to unsized type: `[uint, .. 2]` as `[uint]`
//~^ ERROR cast to unsized type: `[uint, ..2]` as `[uint]`
//~^^ NOTE consider using a box or reference as appropriate
}

17
src/test/compile-fail/issue-17718-const-mut.rs Normal file
View file

@ -0,0 +1,17 @@
// 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
mut //~ ERROR: const globals cannot be mutable, did you mean to declare a static?
FOO: uint = 3;
fn main() {
}

2
src/test/compile-fail/issue-2149.rs
View file

@ -22,5 +22,5 @@ impl<A> vec_monad<A> for Vec<A> {
}
fn main() {
["hi"].bind(|x| [x] );
//~^ ERROR type `[&str, .. 1]` does not implement any method in scope named `bind`
//~^ ERROR type `[&str, ..1]` does not implement any method in scope named `bind`
}

2
src/test/compile-fail/issue-4517.rs
View file

@ -13,6 +13,6 @@ fn bar(int_param: int) {}
fn main() {
let foo: [u8, ..4] = [1u8, ..4u];
bar(foo);
//~^ ERROR mismatched types: expected `int`, found `[u8, .. 4]`
//~^ ERROR mismatched types: expected `int`, found `[u8, ..4]`
// (expected int, found vector)
}

2
src/test/compile-fail/issue-6804.rs
View file

@ -30,4 +30,4 @@ fn main() {
// At least one error is needed so that compilation fails
#[static_assert]
static b: bool = false; //~ ERROR static assertion failed
static B: bool = false; //~ ERROR static assertion failed

1
src/test/compile-fail/lint-dead-code-1.rs
View file

@ -11,6 +11,7 @@
#![no_std]
#![allow(unused_variable)]
#![allow(non_camel_case_types)]
#![allow(non_uppercase_statics)]
#![deny(dead_code)]
#![feature(lang_items)]

1
src/test/compile-fail/lint-directives-on-use-items-issue-10534.rs
View file

@ -9,6 +9,7 @@
// except according to those terms.
#![deny(unused_imports)]
#![allow(non_uppercase_statics)]
// The aim of this test is to ensure that deny/allow/warn directives
// are applied to individual "use" statements instead of silently

5
src/test/compile-fail/lint-non-snake-case-functions.rs
View file

@ -23,11 +23,14 @@ impl Foo {
pub fn xyZ(&mut self) {}
//~^ ERROR method `xyZ` should have a snake case name such as `xy_z`
fn render_HTML() {}
//~^ ERROR method `render_HTML` should have a snake case name such as `render_html`
}
trait X {
fn ABC();
//~^ ERROR trait method `ABC` should have a snake case name such as `a_b_c`
//~^ ERROR trait method `ABC` should have a snake case name such as `abc`
fn a_b_C(&self) {}
//~^ ERROR trait method `a_b_C` should have a snake case name such as `a_b_c`

28
src/test/pretty/issue-4264.pp
View file

@ -26,33 +26,33 @@ pub fn foo(_: [int, ..(3 as uint)]) { }
pub fn bar() {
static FOO: uint = ((5u as uint) - (4u as uint) as uint);
let _: [(), ..(FOO as uint)] = ([(() as ())] as [(), .. 1]);
let _: [(), ..(FOO as uint)] = ([(() as ())] as [(), ..1]);
let _: [(), ..(1u as uint)] = ([(() as ())] as [(), .. 1]);
let _: [(), ..(1u as uint)] = ([(() as ())] as [(), ..1]);
let _ =
(((&((([(1i as int), (2 as int), (3 as int)] as [int, .. 3])) as
[int, .. 3]) as &[int, .. 3]) as *const _ as
*const [int, .. 3]) as *const [int, ..(3u as uint)] as
*const [int, .. 3]);
(((&((([(1i as int), (2 as int), (3 as int)] as [int, ..3])) as
[int, ..3]) as &[int, ..3]) as *const _ as *const [int, ..3])
as *const [int, ..(3u as uint)] as *const [int, ..3]);
(match (() as ()) {
() => {
#[inline]
#[allow(dead_code)]
static __STATIC_FMTSTR: [&'static str, ..(1u as uint)] =
([("test" as &'static str)] as [&'static str, .. 1]);
([("test" as &'static str)] as [&'static str, ..1]);
let __args_vec =
(&([] as [core::fmt::Argument<'_>, .. 0]) as
&[core::fmt::Argument<'_>, .. 0]);
(&([] as [core::fmt::Argument<'_>, ..0]) as
&[core::fmt::Argument<'_>, ..0]);
let __args =
(unsafe {
((::std::fmt::Arguments::new as
unsafe fn(&'static [&'static str], &'a [core::fmt::Argument<'a>]) -> core::fmt::Arguments<'a>)((__STATIC_FMTSTR
as
[&'static str, .. 1]),
[&'static str, ..1]),
(__args_vec
as
&[core::fmt::Argument<'_>, .. 0]))
&[core::fmt::Argument<'_>, ..0]))
as core::fmt::Arguments<'_>)
} as core::fmt::Arguments<'_>);
@ -83,8 +83,8 @@ pub fn id<T>(x: T) -> T { (x as T) }
pub fn use_id() {
let _ =
((id::<[int, ..(3u as uint)]> as
fn([int, .. 3]) -> [int, .. 3])(([(1 as int), (2 as int),
(3 as int)] as [int, .. 3])) as
[int, .. 3]);
fn([int, ..3]) -> [int, ..3])(([(1 as int), (2 as int),
(3 as int)] as [int, ..3])) as
[int, ..3]);
}
fn main() { }

2
src/test/run-make/rustdoc-where/verify.sh
View file

@ -1,4 +1,4 @@
#!/bin/bash
#!/bin/sh
set -e
# $1 is the TMPDIR

8
src/test/compile-fail/removed-syntax-const-item.rs → src/test/run-pass/issue-17718-parse-const.rs
View file

@ -1,4 +1,4 @@
// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
// 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.
//
@ -8,4 +8,8 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
const i: int = 42; //~ ERROR expected item, found `const`
const FOO: uint = 3;
fn main() {
assert_eq!(FOO, 3);
}

53
src/test/run-pass/process-remove-from-env.rs Normal file
View file

@ -0,0 +1,53 @@
// 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::io::Command;
use std::os;
#[cfg(all(unix, not(target_os="android")))]
pub fn env_cmd() -> Command {
Command::new("env")
}
#[cfg(target_os="android")]
pub fn env_cmd() -> Command {
let mut cmd = Command::new("/system/bin/sh");
cmd.arg("-c").arg("set");
cmd
}
#[cfg(windows)]
pub fn env_cmd() -> Command {
let mut cmd = Command::new("cmd");
cmd.arg("/c").arg("set");
cmd
}
fn main() {
// save original environment
let old_env = os::getenv("RUN_TEST_NEW_ENV");
os::setenv("RUN_TEST_NEW_ENV", "123");
let mut cmd = env_cmd();
cmd.env_remove("RUN_TEST_NEW_ENV");
// restore original environment
match old_env {
None => os::unsetenv("RUN_TEST_NEW_ENV"),
Some(val) => os::setenv("RUN_TEST_NEW_ENV", val.as_slice())
}
let prog = cmd.spawn().unwrap();
let result = prog.wait_with_output().unwrap();
let output = String::from_utf8_lossy(result.output.as_slice());
assert!(!output.as_slice().contains("RUN_TEST_NEW_ENV"),
"found RUN_TEST_NEW_ENV inside of:\n\n{}", output);
}