diff options
Diffstat (limited to 'src')
133 files changed, 1874 insertions, 889 deletions
diff --git a/src/compiletest/runtest.rs b/src/compiletest/runtest.rs index 85bbd2cb42e..7ac8a9b041c 100644 --- a/src/compiletest/runtest.rs +++ b/src/compiletest/runtest.rs @@ -127,7 +127,7 @@ fn run_rfail_test(config: &Config, props: &TestProps, testfile: &Path) { }; // The value our Makefile configures valgrind to return on failure - static VALGRIND_ERR: int = 100; + const VALGRIND_ERR: int = 100; if proc_res.status.matches_exit_status(VALGRIND_ERR) { fatal_proc_rec("run-fail test isn't valgrind-clean!", &proc_res); } @@ -139,7 +139,7 @@ fn run_rfail_test(config: &Config, props: &TestProps, testfile: &Path) { fn check_correct_failure_status(proc_res: &ProcRes) { // The value the rust runtime returns on failure - static RUST_ERR: int = 101; + const RUST_ERR: int = 101; if !proc_res.status.matches_exit_status(RUST_ERR) { fatal_proc_rec( &format!("failure produced the wrong error: {:?}", diff --git a/src/compiletest/util.rs b/src/compiletest/util.rs index 778629dd202..c0d7c59ef6a 100644 --- a/src/compiletest/util.rs +++ b/src/compiletest/util.rs @@ -14,7 +14,7 @@ use common::Config; use std::env; /// Conversion table from triple OS name to Rust SYSNAME -static OS_TABLE: &'static [(&'static str, &'static str)] = &[ +const OS_TABLE: &'static [(&'static str, &'static str)] = &[ ("mingw32", "windows"), ("win32", "windows"), ("windows", "windows"), diff --git a/src/doc/reference.md b/src/doc/reference.md index 2f047d2c173..333d6fddbbd 100644 --- a/src/doc/reference.md +++ b/src/doc/reference.md @@ -2495,6 +2495,12 @@ The currently implemented features of the reference compiler are: * `staged_api` - Allows usage of stability markers and `#![staged_api]` in a crate +* `static_assert` - The `#[static_assert]` functionality is experimental and + unstable. The attribute can be attached to a `static` of + type `bool` and the compiler will error if the `bool` is + `false` at compile time. This version of this functionality + is unintuitive and suboptimal. + * `start` - Allows use of the `#[start]` attribute, which changes the entry point into a Rust program. This capabiilty, especially the signature for the annotated function, is subject to change. diff --git a/src/etc/unicode.py b/src/etc/unicode.py index dc8716d1378..5472ba3c7ed 100755 --- a/src/etc/unicode.py +++ b/src/etc/unicode.py @@ -290,11 +290,11 @@ def emit_bsearch_range_table(f): fn bsearch_range_table(c: char, r: &'static [(char,char)]) -> bool { use core::cmp::Ordering::{Equal, Less, Greater}; use core::slice::SliceExt; - r.binary_search(|&(lo,hi)| { + r.binary_search_by(|&(lo,hi)| { if lo <= c && c <= hi { Equal } else if hi < c { Less } else { Greater } - }).found().is_some() + }).is_ok() }\n """) @@ -303,7 +303,7 @@ def emit_table(f, name, t_data, t_type = "&'static [(char, char)]", is_pub=True, pub_string = "" if is_pub: pub_string = "pub " - f.write(" %sstatic %s: %s = &[\n" % (pub_string, name, t_type)) + f.write(" %sconst %s: %s = &[\n" % (pub_string, name, t_type)) data = "" first = True for dat in t_data: @@ -329,14 +329,14 @@ def emit_property_module(f, mod, tbl, emit_fn): def emit_regex_module(f, cats, w_data): f.write("pub mod regex {\n") regex_class = "&'static [(char, char)]" - class_table = "&'static [(&'static str, &'static %s)]" % regex_class + class_table = "&'static [(&'static str, %s)]" % regex_class emit_table(f, "UNICODE_CLASSES", cats, class_table, - pfun=lambda x: "(\"%s\",&super::%s::%s_table)" % (x[0], x[1], x[0])) + pfun=lambda x: "(\"%s\",super::%s::%s_table)" % (x[0], x[1], x[0])) - f.write(" pub static PERLD: &'static %s = &super::general_category::Nd_table;\n\n" + f.write(" pub const PERLD: %s = super::general_category::Nd_table;\n\n" % regex_class) - f.write(" pub static PERLS: &'static %s = &super::property::White_Space_table;\n\n" + f.write(" pub const PERLS: %s = super::property::White_Space_table;\n\n" % regex_class) emit_table(f, "PERLW", w_data, regex_class) @@ -350,7 +350,7 @@ def emit_conversions_module(f, lowerupper, upperlower): use core::slice::SliceExt; use core::option::Option; use core::option::Option::{Some, None}; - use core::slice; + use core::result::Result::{Ok, Err}; pub fn to_lower(c: char) -> char { match bsearch_case_table(c, LuLl_table) { @@ -367,13 +367,13 @@ def emit_conversions_module(f, lowerupper, upperlower): } fn bsearch_case_table(c: char, table: &'static [(char, char)]) -> Option<usize> { - match table.binary_search(|&(key, _)| { + match table.binary_search_by(|&(key, _)| { if c == key { Equal } else if key < c { Less } else { Greater } }) { - slice::BinarySearchResult::Found(i) => Some(i), - slice::BinarySearchResult::NotFound(_) => None, + Ok(i) => Some(i), + Err(_) => None, } } @@ -386,10 +386,9 @@ def emit_conversions_module(f, lowerupper, upperlower): def emit_grapheme_module(f, grapheme_table, grapheme_cats): f.write("""pub mod grapheme { - use core::kinds::Copy; use core::slice::SliceExt; pub use self::GraphemeCat::*; - use core::slice; + use core::result::Result::{Ok, Err}; #[allow(non_camel_case_types)] #[derive(Clone, Copy)] @@ -401,16 +400,16 @@ def emit_grapheme_module(f, grapheme_table, grapheme_cats): fn bsearch_range_value_table(c: char, r: &'static [(char, char, GraphemeCat)]) -> GraphemeCat { use core::cmp::Ordering::{Equal, Less, Greater}; - match r.binary_search(|&(lo, hi, _)| { + match r.binary_search_by(|&(lo, hi, _)| { if lo <= c && c <= hi { Equal } else if hi < c { Less } else { Greater } }) { - slice::BinarySearchResult::Found(idx) => { + Ok(idx) => { let (_, _, cat) = r[idx]; cat } - slice::BinarySearchResult::NotFound(_) => GC_Any + Err(_) => GC_Any } } @@ -430,20 +429,20 @@ def emit_charwidth_module(f, width_table): f.write(" use core::option::Option;\n") f.write(" use core::option::Option::{Some, None};\n") f.write(" use core::slice::SliceExt;\n") - f.write(" use core::slice;\n") + f.write(" use core::result::Result::{Ok, Err};\n") f.write(""" fn bsearch_range_value_table(c: char, is_cjk: bool, r: &'static [(char, char, u8, u8)]) -> u8 { use core::cmp::Ordering::{Equal, Less, Greater}; - match r.binary_search(|&(lo, hi, _, _)| { + match r.binary_search_by(|&(lo, hi, _, _)| { if lo <= c && c <= hi { Equal } else if hi < c { Less } else { Greater } }) { - slice::BinarySearchResult::Found(idx) => { + Ok(idx) => { let (_, _, r_ncjk, r_cjk) = r[idx]; if is_cjk { r_cjk } else { r_ncjk } } - slice::BinarySearchResult::NotFound(_) => 1 + Err(_) => 1 } } """) @@ -530,17 +529,17 @@ def emit_norm_module(f, canon, compat, combine, norm_props): fn bsearch_range_value_table(c: char, r: &'static [(char, char, u8)]) -> u8 { use core::cmp::Ordering::{Equal, Less, Greater}; use core::slice::SliceExt; - use core::slice; - match r.binary_search(|&(lo, hi, _)| { + use core::result::Result::{Ok, Err}; + match r.binary_search_by(|&(lo, hi, _)| { if lo <= c && c <= hi { Equal } else if hi < c { Less } else { Greater } }) { - slice::BinarySearchResult::Found(idx) => { + Ok(idx) => { let (_, _, result) = r[idx]; result } - slice::BinarySearchResult::NotFound(_) => 0 + Err(_) => 0 } }\n """) @@ -609,7 +608,7 @@ if __name__ == "__main__": unicode_version = re.search(pattern, readme.read()).groups() rf.write(""" /// The version of [Unicode](http://www.unicode.org/) -/// that the `UnicodeChar` and `UnicodeStrPrelude` traits are based on. +/// that the unicode parts of `CharExt` and `UnicodeStrPrelude` traits are based on. pub const UNICODE_VERSION: (u64, u64, u64) = (%s, %s, %s); """ % unicode_version) (canon_decomp, compat_decomp, gencats, combines, diff --git a/src/libcollections/bit.rs b/src/libcollections/bit.rs index a92eccce142..b0490b287ad 100644 --- a/src/libcollections/bit.rs +++ b/src/libcollections/bit.rs @@ -818,11 +818,11 @@ impl BitVec { let full_value = if value { !0 } else { 0 }; // Correct the old tail word, setting or clearing formerly unused bits - let old_last_word = blocks_for_bits(self.nbits) - 1; + let num_cur_blocks = blocks_for_bits(self.nbits); if self.nbits % u32::BITS as usize > 0 { let mask = mask_for_bits(self.nbits); if value { - self.storage[old_last_word] |= !mask; + self.storage[num_cur_blocks - 1] |= !mask; } else { // Extra bits are already zero by invariant. } @@ -830,7 +830,7 @@ impl BitVec { // Fill in words after the old tail word let stop_idx = cmp::min(self.storage.len(), new_nblocks); - for idx in old_last_word + 1..stop_idx { + for idx in num_cur_blocks..stop_idx { self.storage[idx] = full_value; } @@ -2544,7 +2544,7 @@ mod bit_vec_bench { use super::BitVec; - static BENCH_BITS : usize = 1 << 14; + const BENCH_BITS : usize = 1 << 14; fn rng() -> rand::IsaacRng { let seed: &[_] = &[1, 2, 3, 4, 5, 6, 7, 8, 9, 0]; @@ -3039,7 +3039,7 @@ mod bit_set_bench { use super::{BitVec, BitSet}; - static BENCH_BITS : usize = 1 << 14; + const BENCH_BITS : usize = 1 << 14; fn rng() -> rand::IsaacRng { let seed: &[_] = &[1, 2, 3, 4, 5, 6, 7, 8, 9, 0]; diff --git a/src/libcollections/btree/map.rs b/src/libcollections/btree/map.rs index 8a3a1fcb9f3..1fa592ac477 100644 --- a/src/libcollections/btree/map.rs +++ b/src/libcollections/btree/map.rs @@ -25,7 +25,7 @@ use core::fmt::Debug; use core::hash::{Hash, Hasher}; use core::iter::{Map, FromIterator, IntoIterator}; use core::ops::{Index, IndexMut}; -use core::{iter, fmt, mem}; +use core::{iter, fmt, mem, usize}; use Bound::{self, Included, Excluded, Unbounded}; use borrow::Borrow; @@ -1467,7 +1467,7 @@ macro_rules! range_impl { $Range { inner: AbsIter { traversals: traversals, - size: 0, // unused + size: usize::MAX, // unused } } } diff --git a/src/libcollections/btree/node.rs b/src/libcollections/btree/node.rs index 4a80d75575e..f2a6910a302 100644 --- a/src/libcollections/btree/node.rs +++ b/src/libcollections/btree/node.rs @@ -1215,7 +1215,8 @@ impl<K, V> Node<K, V> { ptr::copy( self.edges_mut().as_mut_ptr().offset(index as isize), self.edges().as_ptr().offset(index as isize + 1), - self.len() - index + 1 + // index can be == len+1, so do the +1 first to avoid underflow. + (self.len() + 1) - index ); edge diff --git a/src/libcollections/slice.rs b/src/libcollections/slice.rs index a2924f8fe53..b3706e20352 100644 --- a/src/libcollections/slice.rs +++ b/src/libcollections/slice.rs @@ -96,6 +96,7 @@ use core::iter::{range_step, MultiplicativeIterator}; use core::marker::Sized; use core::mem::size_of; use core::mem; +use core::num::wrapping::WrappingOps; use core::ops::FnMut; use core::option::Option::{self, Some, None}; use core::ptr::PtrExt; @@ -1209,10 +1210,14 @@ struct SizeDirection { impl Iterator for ElementSwaps { type Item = (usize, usize); - #[inline] + // #[inline] fn next(&mut self) -> Option<(usize, usize)> { + fn new_pos_wrapping(i: usize, s: Direction) -> usize { + i.wrapping_add(match s { Pos => 1, Neg => -1 }) + } + fn new_pos(i: usize, s: Direction) -> usize { - i + match s { Pos => 1, Neg => -1 } + match s { Pos => i + 1, Neg => i - 1 } } // Find the index of the largest mobile element: @@ -1220,7 +1225,7 @@ impl Iterator for ElementSwaps { // swap should be with a smaller `size` element. let max = self.sdir.iter().cloned().enumerate() .filter(|&(i, sd)| - new_pos(i, sd.dir) < self.sdir.len() && + new_pos_wrapping(i, sd.dir) < self.sdir.len() && self.sdir[new_pos(i, sd.dir)].size < sd.size) .max_by(|&(_, sd)| sd.size); match max { @@ -1343,8 +1348,8 @@ fn insertion_sort<T, F>(v: &mut [T], mut compare: F) where F: FnMut(&T, &T) -> O fn merge_sort<T, F>(v: &mut [T], mut compare: F) where F: FnMut(&T, &T) -> Ordering { // warning: this wildly uses unsafe. - static BASE_INSERTION: usize = 32; - static LARGE_INSERTION: usize = 16; + const BASE_INSERTION: usize = 32; + const LARGE_INSERTION: usize = 16; // FIXME #12092: smaller insertion runs seems to make sorting // vectors of large elements a little faster on some platforms, diff --git a/src/libcollections/str.rs b/src/libcollections/str.rs index 86fcac3e4b8..599b92d05dd 100644 --- a/src/libcollections/str.rs +++ b/src/libcollections/str.rs @@ -756,6 +756,7 @@ pub trait StrExt: Index<RangeFull, Output = str> { /// ``` #[unstable(feature = "collections")] #[deprecated(since = "1.0.0", reason = "use `split()` with a `&str`")] + #[allow(deprecated) /* for SplitStr */] fn split_str<'a, P: Pattern<'a>>(&'a self, pat: P) -> SplitStr<'a, P> { core_str::StrExt::split_str(&self[..], pat) } diff --git a/src/libcollections/string.rs b/src/libcollections/string.rs index 94abffa3db6..33189bd68bd 100644 --- a/src/libcollections/string.rs +++ b/src/libcollections/string.rs @@ -153,8 +153,8 @@ impl String { } } - static TAG_CONT_U8: u8 = 128u8; - static REPLACEMENT: &'static [u8] = b"\xEF\xBF\xBD"; // U+FFFD in UTF-8 + const TAG_CONT_U8: u8 = 128u8; + const REPLACEMENT: &'static [u8] = b"\xEF\xBF\xBD"; // U+FFFD in UTF-8 let total = v.len(); fn unsafe_get(xs: &[u8], i: usize) -> u8 { unsafe { *xs.get_unchecked(i) } diff --git a/src/libcollections/vec.rs b/src/libcollections/vec.rs index 805e4623396..a4d39974c70 100644 --- a/src/libcollections/vec.rs +++ b/src/libcollections/vec.rs @@ -1499,9 +1499,9 @@ impl<T> Extend<T> for Vec<T> { __impl_slice_eq1! { Vec<A>, Vec<B> } __impl_slice_eq2! { Vec<A>, &'b [B] } __impl_slice_eq2! { Vec<A>, &'b mut [B] } -__impl_slice_eq2! { CowVec<'a, A>, &'b [B], Clone } -__impl_slice_eq2! { CowVec<'a, A>, &'b mut [B], Clone } -__impl_slice_eq2! { CowVec<'a, A>, Vec<B>, Clone } +__impl_slice_eq2! { Cow<'a, [A]>, &'b [B], Clone } +__impl_slice_eq2! { Cow<'a, [A]>, &'b mut [B], Clone } +__impl_slice_eq2! { Cow<'a, [A]>, Vec<B>, Clone } macro_rules! array_impls { ($($N: expr)+) => { @@ -1510,9 +1510,9 @@ macro_rules! array_impls { __impl_slice_eq2! { Vec<A>, [B; $N] } __impl_slice_eq2! { Vec<A>, &'b [B; $N] } // __impl_slice_eq2! { Vec<A>, &'b mut [B; $N] } - // __impl_slice_eq2! { CowVec<'a, A>, [B; $N], Clone } - // __impl_slice_eq2! { CowVec<'a, A>, &'b [B; $N], Clone } - // __impl_slice_eq2! { CowVec<'a, A>, &'b mut [B; $N], Clone } + // __impl_slice_eq2! { Cow<'a, [A]>, [B; $N], Clone } + // __impl_slice_eq2! { Cow<'a, [A]>, &'b [B; $N], Clone } + // __impl_slice_eq2! { Cow<'a, [A]>, &'b mut [B; $N], Clone } )+ } } diff --git a/src/libcollections/vec_deque.rs b/src/libcollections/vec_deque.rs index abcc0cef9f1..551d28b91b4 100644 --- a/src/libcollections/vec_deque.rs +++ b/src/libcollections/vec_deque.rs @@ -26,6 +26,7 @@ use core::fmt; use core::iter::{self, repeat, FromIterator, IntoIterator, RandomAccessIterator}; use core::mem; use core::num::{Int, UnsignedInt}; +use core::num::wrapping::WrappingOps; use core::ops::{Index, IndexMut}; use core::ptr::{self, Unique}; use core::raw::Slice as RawSlice; @@ -39,8 +40,8 @@ use alloc::heap; #[unstable(feature = "collections")] pub use VecDeque as RingBuf; -static INITIAL_CAPACITY: usize = 7; // 2^3 - 1 -static MINIMUM_CAPACITY: usize = 1; // 2 - 1 +const INITIAL_CAPACITY: usize = 7; // 2^3 - 1 +const MINIMUM_CAPACITY: usize = 1; // 2 - 1 /// `VecDeque` is a growable ring buffer, which can be used as a /// double-ended queue efficiently. @@ -120,6 +121,20 @@ impl<T> VecDeque<T> { #[inline] fn wrap_index(&self, idx: usize) -> usize { wrap_index(idx, self.cap) } + /// Returns the index in the underlying buffer for a given logical element + /// index + addend. + #[inline] + fn wrap_add(&self, idx: usize, addend: usize) -> usize { + wrap_index(idx.wrapping_add(addend), self.cap) + } + + /// Returns the index in the underlying buffer for a given logical element + /// index - subtrahend. + #[inline] + fn wrap_sub(&self, idx: usize, subtrahend: usize) -> usize { + wrap_index(idx.wrapping_sub(subtrahend), self.cap) + } + /// Copies a contiguous block of memory len long from src to dst #[inline] unsafe fn copy(&self, dst: usize, src: usize, len: usize) { @@ -197,7 +212,7 @@ impl<T> VecDeque<T> { #[stable(feature = "rust1", since = "1.0.0")] pub fn get(&self, i: usize) -> Option<&T> { if i < self.len() { - let idx = self.wrap_index(self.tail + i); + let idx = self.wrap_add(self.tail, i); unsafe { Some(&*self.ptr.offset(idx as isize)) } } else { None @@ -227,7 +242,7 @@ impl<T> VecDeque<T> { #[stable(feature = "rust1", since = "1.0.0")] pub fn get_mut(&mut self, i: usize) -> Option<&mut T> { if i < self.len() { - let idx = self.wrap_index(self.tail + i); + let idx = self.wrap_add(self.tail, i); unsafe { Some(&mut *self.ptr.offset(idx as isize)) } } else { None @@ -257,8 +272,8 @@ impl<T> VecDeque<T> { pub fn swap(&mut self, i: usize, j: usize) { assert!(i < self.len()); assert!(j < self.len()); - let ri = self.wrap_index(self.tail + i); - let rj = self.wrap_index(self.tail + j); + let ri = self.wrap_add(self.tail, i); + let rj = self.wrap_add(self.tail, j); unsafe { ptr::swap(self.ptr.offset(ri as isize), self.ptr.offset(rj as isize)) } @@ -427,7 +442,7 @@ impl<T> VecDeque<T> { // [. . . o o o o o o o . . . . . . ] // H T // [o o . o o o o o ] - let len = self.wrap_index(self.head - target_cap); + let len = self.wrap_sub(self.head, target_cap); unsafe { self.copy_nonoverlapping(0, target_cap, len); } @@ -438,7 +453,7 @@ impl<T> VecDeque<T> { // [o o o o o . . . . . . . . . o o ] // H T // [o o o o o . o o ] - debug_assert!(self.wrap_index(self.head - 1) < target_cap); + debug_assert!(self.wrap_sub(self.head, 1) < target_cap); let len = self.cap - self.tail; let new_tail = target_cap - len; unsafe { @@ -775,7 +790,7 @@ impl<T> VecDeque<T> { None } else { let tail = self.tail; - self.tail = self.wrap_index(self.tail + 1); + self.tail = self.wrap_add(self.tail, 1); unsafe { Some(self.buffer_read(tail)) } } } @@ -799,7 +814,7 @@ impl<T> VecDeque<T> { debug_assert!(!self.is_full()); } - self.tail = self.wrap_index(self.tail - 1); + self.tail = self.wrap_sub(self.tail, 1); let tail = self.tail; unsafe { self.buffer_write(tail, t); } } @@ -824,7 +839,7 @@ impl<T> VecDeque<T> { } let head = self.head; - self.head = self.wrap_index(self.head + 1); + self.head = self.wrap_add(self.head, 1); unsafe { self.buffer_write(head, t) } } @@ -847,7 +862,7 @@ impl<T> VecDeque<T> { if self.is_empty() { None } else { - self.head = self.wrap_index(self.head - 1); + self.head = self.wrap_sub(self.head, 1); let head = self.head; unsafe { Some(self.buffer_read(head)) } } @@ -971,7 +986,7 @@ impl<T> VecDeque<T> { // A - The element that should be after the insertion point // M - Indicates element was moved - let idx = self.wrap_index(self.tail + i); + let idx = self.wrap_add(self.tail, i); let distance_to_tail = i; let distance_to_head = self.len() - i; @@ -990,7 +1005,7 @@ impl<T> VecDeque<T> { // [A o o o o o o o . . . . . I] // - self.tail = self.wrap_index(self.tail - 1); + self.tail = self.wrap_sub(self.tail, 1); }, (true, true, _) => unsafe { // contiguous, insert closer to tail: @@ -1012,7 +1027,7 @@ impl<T> VecDeque<T> { // [o I A o o o o o . . . . . . . o] // M M - let new_tail = self.wrap_index(self.tail - 1); + let new_tail = self.wrap_sub(self.tail, 1); self.copy(new_tail, self.tail, 1); // Already moved the tail, so we only copy `i - 1` elements. @@ -1031,7 +1046,7 @@ impl<T> VecDeque<T> { // M M M self.copy(idx + 1, idx, self.head - idx); - self.head = self.wrap_index(self.head + 1); + self.head = self.wrap_add(self.head, 1); }, (false, true, true) => unsafe { // discontiguous, insert closer to tail, tail section: @@ -1123,7 +1138,7 @@ impl<T> VecDeque<T> { } // tail might've been changed so we need to recalculate - let new_idx = self.wrap_index(self.tail + i); + let new_idx = self.wrap_add(self.tail, i); unsafe { self.buffer_write(new_idx, t); } @@ -1170,7 +1185,7 @@ impl<T> VecDeque<T> { // R - Indicates element that is being removed // M - Indicates element was moved - let idx = self.wrap_index(self.tail + i); + let idx = self.wrap_add(self.tail, i); let elem = unsafe { Some(self.buffer_read(idx)) @@ -1219,7 +1234,7 @@ impl<T> VecDeque<T> { // M M self.copy(self.tail + 1, self.tail, i); - self.tail = self.wrap_index(self.tail + 1); + self.tail = self.wrap_add(self.tail, 1); }, (false, false, false) => unsafe { // discontiguous, remove closer to head, head section: @@ -1265,7 +1280,7 @@ impl<T> VecDeque<T> { self.copy(0, 1, self.head - 1); } - self.head = self.wrap_index(self.head - 1); + self.head = self.wrap_sub(self.head, 1); }, (false, true, false) => unsafe { // discontiguous, remove closer to tail, head section: @@ -1286,7 +1301,7 @@ impl<T> VecDeque<T> { // move elements from tail to end forward, excluding the last one self.copy(self.tail + 1, self.tail, self.cap - self.tail - 1); - self.tail = self.wrap_index(self.tail + 1); + self.tail = self.wrap_add(self.tail, 1); } } @@ -1354,7 +1369,7 @@ impl<T> VecDeque<T> { } // Cleanup where the ends of the buffers are - self.head = self.wrap_index(self.head - other_len); + self.head = self.wrap_sub(self.head, other_len); other.head = other.wrap_index(other_len); other @@ -1429,7 +1444,7 @@ fn wrap_index(index: usize, size: usize) -> usize { #[inline] fn count(tail: usize, head: usize, size: usize) -> usize { // size is always a power of 2 - (head - tail) & (size - 1) + (head.wrapping_sub(tail)) & (size - 1) } /// `VecDeque` iterator. @@ -1461,7 +1476,7 @@ impl<'a, T> Iterator for Iter<'a, T> { return None; } let tail = self.tail; - self.tail = wrap_index(self.tail + 1, self.ring.len()); + self.tail = wrap_index(self.tail.wrapping_add(1), self.ring.len()); unsafe { Some(self.ring.get_unchecked(tail)) } } @@ -1479,7 +1494,7 @@ impl<'a, T> DoubleEndedIterator for Iter<'a, T> { if self.tail == self.head { return None; } - self.head = wrap_index(self.head - 1, self.ring.len()); + self.head = wrap_index(self.head.wrapping_sub(1), self.ring.len()); unsafe { Some(self.ring.get_unchecked(self.head)) } } } @@ -1500,7 +1515,7 @@ impl<'a, T> RandomAccessIterator for Iter<'a, T> { if j >= self.indexable() { None } else { - let idx = wrap_index(self.tail + j, self.ring.len()); + let idx = wrap_index(self.tail.wrapping_add(j), self.ring.len()); unsafe { Some(self.ring.get_unchecked(idx)) } } } @@ -1524,7 +1539,7 @@ impl<'a, T> Iterator for IterMut<'a, T> { return None; } let tail = self.tail; - self.tail = wrap_index(self.tail + 1, self.ring.len()); + self.tail = wrap_index(self.tail.wrapping_add(1), self.ring.len()); unsafe { let elem = self.ring.get_unchecked_mut(tail); @@ -1546,7 +1561,7 @@ impl<'a, T> DoubleEndedIterator for IterMut<'a, T> { if self.tail == self.head { return None; } - self.head = wrap_index(self.head - 1, self.ring.len()); + self.head = wrap_index(self.head.wrapping_sub(1), self.ring.len()); unsafe { let elem = self.ring.get_unchecked_mut(self.head); diff --git a/src/libcore/atomic.rs b/src/libcore/atomic.rs index 38e2bd98ef9..c316236a804 100644 --- a/src/libcore/atomic.rs +++ b/src/libcore/atomic.rs @@ -1067,6 +1067,7 @@ pub struct AtomicInt { v: UnsafeCell<int>, } +#[allow(deprecated)] unsafe impl Sync for AtomicInt {} #[unstable(feature = "core")] @@ -1077,6 +1078,7 @@ pub struct AtomicUint { v: UnsafeCell<uint>, } +#[allow(deprecated)] unsafe impl Sync for AtomicUint {} #[unstable(feature = "core")] diff --git a/src/libcore/fmt/float.rs b/src/libcore/fmt/float.rs index 81eef132b9c..2eeb564859c 100644 --- a/src/libcore/fmt/float.rs +++ b/src/libcore/fmt/float.rs @@ -53,7 +53,7 @@ pub enum SignFormat { SignNeg } -static DIGIT_E_RADIX: u32 = ('e' as u32) - ('a' as u32) + 11; +const DIGIT_E_RADIX: u32 = ('e' as u32) - ('a' as u32) + 11; /// Converts a number to its string representation as a byte vector. /// This is meant to be a common base implementation for all numeric string diff --git a/src/libcore/fmt/num.rs b/src/libcore/fmt/num.rs index 0175e21c8da..045442e28ac 100644 --- a/src/libcore/fmt/num.rs +++ b/src/libcore/fmt/num.rs @@ -84,7 +84,7 @@ struct LowerHex; /// A hexadecimal (base 16) radix, formatted with upper-case characters #[derive(Clone, PartialEq)] -pub struct UpperHex; +struct UpperHex; macro_rules! radix { ($T:ident, $base:expr, $prefix:expr, $($x:pat => $conv:expr),+) => { @@ -156,7 +156,7 @@ pub fn radix<T>(x: T, base: u8) -> RadixFmt<T, Radix> { } macro_rules! radix_fmt { - ($T:ty as $U:ty, $fmt:ident, $S:expr) => { + ($T:ty as $U:ty, $fmt:ident) => { #[stable(feature = "rust1", since = "1.0.0")] impl fmt::Debug for RadixFmt<$T, Radix> { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { @@ -182,8 +182,8 @@ macro_rules! int_base { } } -macro_rules! show { - ($T:ident with $S:expr) => { +macro_rules! debug { + ($T:ident) => { #[stable(feature = "rust1", since = "1.0.0")] impl fmt::Debug for $T { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { @@ -194,27 +194,24 @@ macro_rules! show { } macro_rules! integer { ($Int:ident, $Uint:ident) => { - integer! { $Int, $Uint, stringify!($Int), stringify!($Uint) } - }; - ($Int:ident, $Uint:ident, $SI:expr, $SU:expr) => { int_base! { Display for $Int as $Int -> Decimal } int_base! { Binary for $Int as $Uint -> Binary } int_base! { Octal for $Int as $Uint -> Octal } int_base! { LowerHex for $Int as $Uint -> LowerHex } int_base! { UpperHex for $Int as $Uint -> UpperHex } - radix_fmt! { $Int as $Int, fmt_int, $SI } - show! { $Int with $SI } + radix_fmt! { $Int as $Int, fmt_int } + debug! { $Int } int_base! { Display for $Uint as $Uint -> Decimal } int_base! { Binary for $Uint as $Uint -> Binary } int_base! { Octal for $Uint as $Uint -> Octal } int_base! { LowerHex for $Uint as $Uint -> LowerHex } int_base! { UpperHex for $Uint as $Uint -> UpperHex } - radix_fmt! { $Uint as $Uint, fmt_int, $SU } - show! { $Uint with $SU } + radix_fmt! { $Uint as $Uint, fmt_int } + debug! { $Uint } } } -integer! { isize, usize, "i", "u" } +integer! { isize, usize } integer! { i8, u8 } integer! { i16, u16 } integer! { i32, u32 } diff --git a/src/libcore/hash/sip.rs b/src/libcore/hash/sip.rs index 39bcbacdff1..df0008c500b 100644 --- a/src/libcore/hash/sip.rs +++ b/src/libcore/hash/sip.rs @@ -14,7 +14,7 @@ use prelude::*; use default::Default; - +use num::wrapping::WrappingOps; use super::Hasher; /// An implementation of SipHash 2-4. @@ -71,17 +71,17 @@ macro_rules! u8to64_le { macro_rules! rotl { ($x:expr, $b:expr) => - (($x << $b) | ($x >> (64 - $b))) + (($x << $b) | ($x >> (64.wrapping_sub($b)))) } macro_rules! compress { ($v0:expr, $v1:expr, $v2:expr, $v3:expr) => ({ - $v0 += $v1; $v1 = rotl!($v1, 13); $v1 ^= $v0; + $v0 = $v0.wrapping_add($v1); $v1 = rotl!($v1, 13); $v1 ^= $v0; $v0 = rotl!($v0, 32); - $v2 += $v3; $v3 = rotl!($v3, 16); $v3 ^= $v2; - $v0 += $v3; $v3 = rotl!($v3, 21); $v3 ^= $v0; - $v2 += $v1; $v1 = rotl!($v1, 17); $v1 ^= $v2; + $v2 = $v2.wrapping_add($v3); $v3 = rotl!($v3, 16); $v3 ^= $v2; + $v0 = $v0.wrapping_add($v3); $v3 = rotl!($v3, 21); $v3 ^= $v0; + $v2 = $v2.wrapping_add($v1); $v1 = rotl!($v1, 17); $v1 ^= $v2; $v2 = rotl!($v2, 32); }) } diff --git a/src/libcore/intrinsics.rs b/src/libcore/intrinsics.rs index 1ca243134cc..ed129136091 100644 --- a/src/libcore/intrinsics.rs +++ b/src/libcore/intrinsics.rs @@ -546,3 +546,14 @@ extern "rust-intrinsic" { /// Performs checked `u64` multiplication. pub fn u64_mul_with_overflow(x: u64, y: u64) -> (u64, bool); } + +// SNAP 880fb89 +#[cfg(not(stage0))] +extern "rust-intrinsic" { + /// Returns (a + b) mod 2^N, where N is the width of N in bits. + pub fn overflowing_add<T>(a: T, b: T) -> T; + /// Returns (a - b) mod 2^N, where N is the width of N in bits. + pub fn overflowing_sub<T>(a: T, b: T) -> T; + /// Returns (a * b) mod 2^N, where N is the width of N in bits. + pub fn overflowing_mul<T>(a: T, b: T) -> T; +} diff --git a/src/libcore/iter.rs b/src/libcore/iter.rs index 518ec05f5b9..9495bc2e19d 100644 --- a/src/libcore/iter.rs +++ b/src/libcore/iter.rs @@ -728,10 +728,11 @@ pub trait IteratorExt: Iterator + Sized { P: FnMut(Self::Item) -> bool, Self: ExactSizeIterator + DoubleEndedIterator { - let mut i = self.len() - 1; + let mut i = self.len(); + while let Some(v) = self.next_back() { if predicate(v) { - return Some(i); + return Some(i - 1); } i -= 1; } @@ -1129,7 +1130,11 @@ impl<I> RandomAccessIterator for Rev<I> where I: DoubleEndedIterator + RandomAcc #[inline] fn idx(&mut self, index: usize) -> Option<<I as Iterator>::Item> { let amt = self.indexable(); - self.iter.idx(amt - index - 1) + if amt > index { + self.iter.idx(amt - index - 1) + } else { + None + } } } @@ -2061,6 +2066,7 @@ pub struct Scan<I, St, F> { f: F, /// The current internal state to be passed to the closure next. + #[unstable(feature = "core")] pub state: St, } @@ -2338,6 +2344,7 @@ impl<I: RandomAccessIterator, F> RandomAccessIterator for Inspect<I, F> pub struct Unfold<St, F> { f: F, /// Internal state that will be passed to the closure on the next iteration + #[unstable(feature = "core")] pub state: St, } diff --git a/src/libcore/lib.rs b/src/libcore/lib.rs index 7cc963bed35..94d37cee5b3 100644 --- a/src/libcore/lib.rs +++ b/src/libcore/lib.rs @@ -69,6 +69,7 @@ #![feature(unboxed_closures)] #![feature(rustc_attrs)] #![feature(optin_builtin_traits)] +#![feature(concat_idents)] #[macro_use] mod macros; diff --git a/src/libcore/num/mod.rs b/src/libcore/num/mod.rs index d77a1eb4203..92cdd84160b 100644 --- a/src/libcore/num/mod.rs +++ b/src/libcore/num/mod.rs @@ -15,6 +15,8 @@ #![stable(feature = "rust1", since = "1.0.0")] #![allow(missing_docs)] +use self::wrapping::{OverflowingOps, WrappingOps}; + use char::CharExt; use clone::Clone; use cmp::{PartialEq, Eq, PartialOrd, Ord}; @@ -30,6 +32,9 @@ use option::Option::{self, Some, None}; use result::Result::{self, Ok, Err}; use str::{FromStr, StrExt}; +#[unstable(feature = "core", reason = "may be removed or relocated")] +pub mod wrapping; + /// A built-in signed or unsigned integer. #[stable(feature = "rust1", since = "1.0.0")] pub trait Int @@ -48,6 +53,8 @@ pub trait Int + BitXor<Output=Self> + Shl<uint, Output=Self> + Shr<uint, Output=Self> + + WrappingOps + + OverflowingOps { /// Returns the `0` value of this integer type. // FIXME (#5527): Should be an associated constant @@ -376,11 +383,23 @@ pub trait Int let mut base = self; let mut acc: Self = Int::one(); + let mut prev_base = self; + let mut base_oflo = false; while exp > 0 { if (exp & 1) == 1 { - acc = acc * base; + if base_oflo { + // ensure overflow occurs in the same manner it + // would have otherwise (i.e. signal any exception + // it would have otherwise). + acc = acc * (prev_base * prev_base); + } else { + acc = acc * base; + } } - base = base * base; + prev_base = base; + let (new_base, new_base_oflo) = base.overflowing_mul(base); + base = new_base; + base_oflo = new_base_oflo; exp /= 2; } acc @@ -691,12 +710,12 @@ signed_int_impl! { int } /// A built-in unsigned integer. #[stable(feature = "rust1", since = "1.0.0")] -pub trait UnsignedInt: Int { +pub trait UnsignedInt: Int + WrappingOps { /// Returns `true` iff `self == 2^k` for some `k`. #[stable(feature = "rust1", since = "1.0.0")] #[inline] fn is_power_of_two(self) -> bool { - (self - Int::one()) & self == Int::zero() && !(self == Int::zero()) + (self.wrapping_sub(Int::one())) & self == Int::zero() && !(self == Int::zero()) } /// Returns the smallest power of two greater than or equal to `self`. @@ -706,7 +725,7 @@ pub trait UnsignedInt: Int { fn next_power_of_two(self) -> Self { let bits = size_of::<Self>() * 8; let one: Self = Int::one(); - one << ((bits - (self - one).leading_zeros() as usize) % bits) + one << ((bits - self.wrapping_sub(one).leading_zeros() as usize) % bits) } /// Returns the smallest power of two greater than or equal to `n`. If the diff --git a/src/libcore/num/uint_macros.rs b/src/libcore/num/uint_macros.rs index 330f0b91bf1..d0c4885ad00 100644 --- a/src/libcore/num/uint_macros.rs +++ b/src/libcore/num/uint_macros.rs @@ -20,6 +20,6 @@ pub const BYTES : u32 = ($bits / 8); #[stable(feature = "rust1", since = "1.0.0")] pub const MIN: $T = 0 as $T; #[stable(feature = "rust1", since = "1.0.0")] -pub const MAX: $T = 0 as $T - 1 as $T; +pub const MAX: $T = !0 as $T; ) } diff --git a/src/libcore/num/wrapping.rs b/src/libcore/num/wrapping.rs new file mode 100644 index 00000000000..707e41a948b --- /dev/null +++ b/src/libcore/num/wrapping.rs @@ -0,0 +1,300 @@ +// 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. +#![allow(missing_docs)] + +use ops::*; + +#[cfg(not(stage0))] +use intrinsics::{overflowing_add, overflowing_sub, overflowing_mul}; + +use intrinsics::{i8_add_with_overflow, u8_add_with_overflow}; +use intrinsics::{i16_add_with_overflow, u16_add_with_overflow}; +use intrinsics::{i32_add_with_overflow, u32_add_with_overflow}; +use intrinsics::{i64_add_with_overflow, u64_add_with_overflow}; +use intrinsics::{i8_sub_with_overflow, u8_sub_with_overflow}; +use intrinsics::{i16_sub_with_overflow, u16_sub_with_overflow}; +use intrinsics::{i32_sub_with_overflow, u32_sub_with_overflow}; +use intrinsics::{i64_sub_with_overflow, u64_sub_with_overflow}; +use intrinsics::{i8_mul_with_overflow, u8_mul_with_overflow}; +use intrinsics::{i16_mul_with_overflow, u16_mul_with_overflow}; +use intrinsics::{i32_mul_with_overflow, u32_mul_with_overflow}; +use intrinsics::{i64_mul_with_overflow, u64_mul_with_overflow}; + +pub trait WrappingOps { + fn wrapping_add(self, rhs: Self) -> Self; + fn wrapping_sub(self, rhs: Self) -> Self; + fn wrapping_mul(self, rhs: Self) -> Self; +} + +#[unstable(feature = "core", reason = "may be removed, renamed, or relocated")] +pub trait OverflowingOps { + fn overflowing_add(self, rhs: Self) -> (Self, bool); + fn overflowing_sub(self, rhs: Self) -> (Self, bool); + fn overflowing_mul(self, rhs: Self) -> (Self, bool); +} + +#[cfg(not(stage0))] +macro_rules! wrapping_impl { + ($($t:ty)*) => ($( + impl WrappingOps for $t { + #[inline(always)] + fn wrapping_add(self, rhs: $t) -> $t { + unsafe { + overflowing_add(self, rhs) + } + } + #[inline(always)] + fn wrapping_sub(self, rhs: $t) -> $t { + unsafe { + overflowing_sub(self, rhs) + } + } + #[inline(always)] + fn wrapping_mul(self, rhs: $t) -> $t { + unsafe { + overflowing_mul(self, rhs) + } + } + } + )*) +} + +#[cfg(stage0)] +macro_rules! wrapping_impl { + ($($t:ty)*) => ($( + impl WrappingOps for $t { + #[inline(always)] + fn wrapping_add(self, rhs: $t) -> $t { + self + rhs + } + #[inline(always)] + fn wrapping_sub(self, rhs: $t) -> $t { + self - rhs + } + #[inline(always)] + fn wrapping_mul(self, rhs: $t) -> $t { + self * rhs + } + } + )*) +} + +wrapping_impl! { uint u8 u16 u32 u64 int i8 i16 i32 i64 } + +#[unstable(feature = "core", reason = "may be removed, renamed, or relocated")] +#[derive(PartialEq,Eq,PartialOrd,Ord,Clone,Copy)] +pub struct Wrapping<T>(pub T); + +impl<T:WrappingOps> Add for Wrapping<T> { + type Output = Wrapping<T>; + + #[inline(always)] + fn add(self, other: Wrapping<T>) -> Wrapping<T> { + Wrapping(self.0.wrapping_add(other.0)) + } +} + +impl<T:WrappingOps> Sub for Wrapping<T> { + type Output = Wrapping<T>; + + #[inline(always)] + fn sub(self, other: Wrapping<T>) -> Wrapping<T> { + Wrapping(self.0.wrapping_sub(other.0)) + } +} + +impl<T:WrappingOps> Mul for Wrapping<T> { + type Output = Wrapping<T>; + + #[inline(always)] + fn mul(self, other: Wrapping<T>) -> Wrapping<T> { + Wrapping(self.0.wrapping_mul(other.0)) + } +} + +impl<T:WrappingOps+Not<Output=T>> Not for Wrapping<T> { + type Output = Wrapping<T>; + + fn not(self) -> Wrapping<T> { + Wrapping(!self.0) + } +} + +impl<T:WrappingOps+BitXor<Output=T>> BitXor for Wrapping<T> { + type Output = Wrapping<T>; + + #[inline(always)] + fn bitxor(self, other: Wrapping<T>) -> Wrapping<T> { + Wrapping(self.0 ^ other.0) + } +} + +impl<T:WrappingOps+BitOr<Output=T>> BitOr for Wrapping<T> { + type Output = Wrapping<T>; + + #[inline(always)] + fn bitor(self, other: Wrapping<T>) -> Wrapping<T> { + Wrapping(self.0 | other.0) + } +} + +impl<T:WrappingOps+BitAnd<Output=T>> BitAnd for Wrapping<T> { + type Output = Wrapping<T>; + + #[inline(always)] + fn bitand(self, other: Wrapping<T>) -> Wrapping<T> { + Wrapping(self.0 & other.0) + } +} + +impl<T:WrappingOps+Shl<uint,Output=T>> Shl<uint> for Wrapping<T> { + type Output = Wrapping<T>; + + #[inline(always)] + fn shl(self, other: uint) -> Wrapping<T> { + Wrapping(self.0 << other) + } +} + +impl<T:WrappingOps+Shr<uint,Output=T>> Shr<uint> for Wrapping<T> { + type Output = Wrapping<T>; + + #[inline(always)] + fn shr(self, other: uint) -> Wrapping<T> { + Wrapping(self.0 >> other) + } +} + +macro_rules! overflowing_impl { + ($($t:ident)*) => ($( + impl OverflowingOps for $t { + #[inline(always)] + fn overflowing_add(self, rhs: $t) -> ($t, bool) { + unsafe { + concat_idents!($t, _add_with_overflow)(self, rhs) + } + } + #[inline(always)] + fn overflowing_sub(self, rhs: $t) -> ($t, bool) { + unsafe { + concat_idents!($t, _sub_with_overflow)(self, rhs) + } + } + #[inline(always)] + fn overflowing_mul(self, rhs: $t) -> ($t, bool) { + unsafe { + concat_idents!($t, _mul_with_overflow)(self, rhs) + } + } + } + )*) +} + +overflowing_impl! { u8 u16 u32 u64 i8 i16 i32 i64 } + +#[cfg(target_pointer_width = "64")] +impl OverflowingOps for usize { + #[inline(always)] + fn overflowing_add(self, rhs: usize) -> (usize, bool) { + unsafe { + let res = u64_add_with_overflow(self as u64, rhs as u64); + (res.0 as usize, res.1) + } + } + #[inline(always)] + fn overflowing_sub(self, rhs: usize) -> (usize, bool) { + unsafe { + let res = u64_sub_with_overflow(self as u64, rhs as u64); + (res.0 as usize, res.1) + } + } + #[inline(always)] + fn overflowing_mul(self, rhs: usize) -> (usize, bool) { + unsafe { + let res = u64_mul_with_overflow(self as u64, rhs as u64); + (res.0 as usize, res.1) + } + } +} + +#[cfg(target_pointer_width = "32")] +impl OverflowingOps for usize { + #[inline(always)] + fn overflowing_add(self, rhs: usize) -> (usize, bool) { + unsafe { + let res = u32_add_with_overflow(self as u32, rhs as u32); + (res.0 as usize, res.1) + } + } + #[inline(always)] + fn overflowing_sub(self, rhs: usize) -> (usize, bool) { + unsafe { + let res = u32_sub_with_overflow(self as u32, rhs as u32); + (res.0 as usize, res.1) + } + } + #[inline(always)] + fn overflowing_mul(self, rhs: usize) -> (usize, bool) { + unsafe { + let res = u32_mul_with_overflow(self as u32, rhs as u32); + (res.0 as usize, res.1) + } + } +} + +#[cfg(target_pointer_width = "64")] +impl OverflowingOps for isize { + #[inline(always)] + fn overflowing_add(self, rhs: isize) -> (isize, bool) { + unsafe { + let res = i64_add_with_overflow(self as i64, rhs as i64); + (res.0 as isize, res.1) + } + } + #[inline(always)] + fn overflowing_sub(self, rhs: isize) -> (isize, bool) { + unsafe { + let res = i64_sub_with_overflow(self as i64, rhs as i64); + (res.0 as isize, res.1) + } + } + #[inline(always)] + fn overflowing_mul(self, rhs: isize) -> (isize, bool) { + unsafe { + let res = i64_mul_with_overflow(self as i64, rhs as i64); + (res.0 as isize, res.1) + } + } +} + +#[cfg(target_pointer_width = "32")] +impl OverflowingOps for isize { + #[inline(always)] + fn overflowing_add(self, rhs: isize) -> (isize, bool) { + unsafe { + let res = i32_add_with_overflow(self as i32, rhs as i32); + (res.0 as isize, res.1) + } + } + #[inline(always)] + fn overflowing_sub(self, rhs: isize) -> (isize, bool) { + unsafe { + let res = i32_sub_with_overflow(self as i32, rhs as i32); + (res.0 as isize, res.1) + } + } + #[inline(always)] + fn overflowing_mul(self, rhs: isize) -> (isize, bool) { + unsafe { + let res = i32_mul_with_overflow(self as i32, rhs as i32); + (res.0 as isize, res.1) + } + } +} diff --git a/src/libcore/raw.rs b/src/libcore/raw.rs index 5cc210df5b4..35dfc762687 100644 --- a/src/libcore/raw.rs +++ b/src/libcore/raw.rs @@ -70,6 +70,7 @@ impl<T> Copy for Slice<T> {} #[deprecated(reason = "unboxed new closures do not have a universal representation; \ `&Fn` (etc) trait objects should use `TraitObject` instead", since= "1.0.0")] +#[allow(deprecated) /* for deriving Copy impl */] pub struct Closure { pub code: *mut (), pub env: *mut (), diff --git a/src/libcore/slice.rs b/src/libcore/slice.rs index 5b78da34edd..1f58d775354 100644 --- a/src/libcore/slice.rs +++ b/src/libcore/slice.rs @@ -351,6 +351,7 @@ impl<T> SliceExt for [T] { ChunksMut { v: self, chunk_size: chunk_size } } + #[inline] fn swap(&mut self, a: usize, b: usize) { unsafe { // Can't take two mutable loans from one vector, so instead just cast @@ -1167,13 +1168,23 @@ forward_iterator! { SplitNMut: T, &'a mut [T] } forward_iterator! { RSplitNMut: T, &'a mut [T] } /// An iterator over overlapping subslices of length `size`. -#[derive(Clone)] #[stable(feature = "rust1", since = "1.0.0")] pub struct Windows<'a, T:'a> { v: &'a [T], size: usize } +// FIXME(#19839) Remove in favor of `#[derive(Clone)]` +#[stable(feature = "rust1", since = "1.0.0")] +impl<'a, T> Clone for Windows<'a, T> { + fn clone(&self) -> Windows<'a, T> { + Windows { + v: self.v, + size: self.size, + } + } +} + #[stable(feature = "rust1", since = "1.0.0")] impl<'a, T> Iterator for Windows<'a, T> { type Item = &'a [T]; @@ -1239,13 +1250,23 @@ impl<'a, T> RandomAccessIterator for Windows<'a, T> { /// /// When the slice len is not evenly divided by the chunk size, the last slice /// of the iteration will be the remainder. -#[derive(Clone)] #[stable(feature = "rust1", since = "1.0.0")] pub struct Chunks<'a, T:'a> { v: &'a [T], size: usize } +// FIXME(#19839) Remove in favor of `#[derive(Clone)]` +#[stable(feature = "rust1", since = "1.0.0")] +impl<'a, T> Clone for Chunks<'a, T> { + fn clone(&self) -> Chunks<'a, T> { + Chunks { + v: self.v, + size: self.size, + } + } +} + #[stable(feature = "rust1", since = "1.0.0")] impl<'a, T> Iterator for Chunks<'a, T> { type Item = &'a [T]; diff --git a/src/libcore/str/mod.rs b/src/libcore/str/mod.rs index b354116993c..4f4164f673b 100644 --- a/src/libcore/str/mod.rs +++ b/src/libcore/str/mod.rs @@ -134,12 +134,23 @@ impl FromStr for bool { /// Parse a `bool` from a string. /// - /// Yields an `Option<bool>`, because `s` may or may not actually be - /// parseable. + /// Yields a `Result<bool, ParseBoolError>`, because `s` may or may not + /// actually be parseable. /// /// # Examples /// /// ```rust + /// use std::str::FromStr; + /// + /// assert_eq!(FromStr::from_str("true"), Ok(true)); + /// assert_eq!(FromStr::from_str("false"), Ok(false)); + /// assert!(<bool as FromStr>::from_str("not even a boolean").is_err()); + /// ``` + /// + /// Note, in many cases, the StrExt::parse() which is based on + /// this FromStr::from_str() is more proper. + /// + /// ```rust /// assert_eq!("true".parse(), Ok(true)); /// assert_eq!("false".parse(), Ok(false)); /// assert!("not even a boolean".parse::<bool>().is_err()); @@ -830,6 +841,7 @@ impl TwoWaySearcher { #[inline] #[allow(dead_code)] fn maximal_suffix(arr: &[u8], reversed: bool) -> (usize, usize) { + use num::wrapping::WrappingOps; let mut left = -1; // Corresponds to i in the paper let mut right = 0; // Corresponds to j in the paper let mut offset = 1; // Corresponds to k in the paper @@ -839,17 +851,17 @@ impl TwoWaySearcher { let a; let b; if reversed { - a = arr[left + offset]; + a = arr[left.wrapping_add(offset)]; b = arr[right + offset]; } else { a = arr[right + offset]; - b = arr[left + offset]; + b = arr[left.wrapping_add(offset)]; } if a < b { // Suffix is smaller, period is entire prefix so far. right += offset; offset = 1; - period = right - left; + period = right.wrapping_sub(left); } else if a == b { // Advance through repetition of the current period. if offset == period { @@ -866,7 +878,7 @@ impl TwoWaySearcher { period = 1; } } - (left + 1, period) + (left.wrapping_add(1), period) } } @@ -935,6 +947,7 @@ impl<'a, P: Pattern<'a>> Iterator for MatchIndices<'a, P> { #[unstable(feature = "core")] #[deprecated(since = "1.0.0", reason = "use `Split` with a `&str`")] pub struct SplitStr<'a, P: Pattern<'a>>(Split<'a, P>); +#[allow(deprecated)] impl<'a, P: Pattern<'a>> Iterator for SplitStr<'a, P> { type Item = &'a str; @@ -1325,6 +1338,7 @@ pub trait StrExt { fn split_terminator<'a, P: Pattern<'a>>(&'a self, pat: P) -> SplitTerminator<'a, P>; fn rsplitn<'a, P: Pattern<'a>>(&'a self, count: usize, pat: P) -> RSplitN<'a, P>; fn match_indices<'a, P: Pattern<'a>>(&'a self, pat: P) -> MatchIndices<'a, P>; + #[allow(deprecated) /* for SplitStr */] fn split_str<'a, P: Pattern<'a>>(&'a self, pat: P) -> SplitStr<'a, P>; fn lines<'a>(&'a self) -> Lines<'a>; fn lines_any<'a>(&'a self) -> LinesAny<'a>; diff --git a/src/libcoretest/num/int_macros.rs b/src/libcoretest/num/int_macros.rs index d1bfb475b07..fa41167cae8 100644 --- a/src/libcoretest/num/int_macros.rs +++ b/src/libcoretest/num/int_macros.rs @@ -70,12 +70,12 @@ mod tests { assert!(-(0b11 as $T) - (1 as $T) == (0b11 as $T).not()); } - static A: $T = 0b0101100; - static B: $T = 0b0100001; - static C: $T = 0b1111001; + const A: $T = 0b0101100; + const B: $T = 0b0100001; + const C: $T = 0b1111001; - static _0: $T = 0; - static _1: $T = !0; + const _0: $T = 0; + const _1: $T = !0; #[test] fn test_count_ones() { diff --git a/src/libcoretest/num/mod.rs b/src/libcoretest/num/mod.rs index 1cd1989c11d..721354b6a44 100644 --- a/src/libcoretest/num/mod.rs +++ b/src/libcoretest/num/mod.rs @@ -92,7 +92,7 @@ mod test { assert_eq!("127".parse::<i8>().ok(), Some(i8_val)); assert_eq!("128".parse::<i8>().ok(), None); - i8_val += 1 as i8; + i8_val = i8_val.wrapping_add(1); assert_eq!("-128".parse::<i8>().ok(), Some(i8_val)); assert_eq!("-129".parse::<i8>().ok(), None); @@ -100,7 +100,7 @@ mod test { assert_eq!("32767".parse::<i16>().ok(), Some(i16_val)); assert_eq!("32768".parse::<i16>().ok(), None); - i16_val += 1 as i16; + i16_val = i16_val.wrapping_add(1); assert_eq!("-32768".parse::<i16>().ok(), Some(i16_val)); assert_eq!("-32769".parse::<i16>().ok(), None); @@ -108,7 +108,7 @@ mod test { assert_eq!("2147483647".parse::<i32>().ok(), Some(i32_val)); assert_eq!("2147483648".parse::<i32>().ok(), None); - i32_val += 1 as i32; + i32_val = i32_val.wrapping_add(1); assert_eq!("-2147483648".parse::<i32>().ok(), Some(i32_val)); assert_eq!("-2147483649".parse::<i32>().ok(), None); @@ -116,7 +116,7 @@ mod test { assert_eq!("9223372036854775807".parse::<i64>().ok(), Some(i64_val)); assert_eq!("9223372036854775808".parse::<i64>().ok(), None); - i64_val += 1 as i64; + i64_val = i64_val.wrapping_add(1); assert_eq!("-9223372036854775808".parse::<i64>().ok(), Some(i64_val)); assert_eq!("-9223372036854775809".parse::<i64>().ok(), None); } diff --git a/src/libcoretest/num/uint_macros.rs b/src/libcoretest/num/uint_macros.rs index 5c6efc857f1..39e41a4fad3 100644 --- a/src/libcoretest/num/uint_macros.rs +++ b/src/libcoretest/num/uint_macros.rs @@ -38,12 +38,12 @@ mod tests { assert!(MAX - (0b1011 as $T) == (0b1011 as $T).not()); } - static A: $T = 0b0101100; - static B: $T = 0b0100001; - static C: $T = 0b1111001; + const A: $T = 0b0101100; + const B: $T = 0b0100001; + const C: $T = 0b1111001; - static _0: $T = 0; - static _1: $T = !0; + const _0: $T = 0; + const _1: $T = !0; #[test] fn test_count_ones() { diff --git a/src/libflate/lib.rs b/src/libflate/lib.rs index 2ce52cdec25..58531830043 100644 --- a/src/libflate/lib.rs +++ b/src/libflate/lib.rs @@ -73,9 +73,9 @@ extern { -> *mut c_void; } -static LZ_NORM : c_int = 0x80; // LZ with 128 probes, "normal" -static TINFL_FLAG_PARSE_ZLIB_HEADER : c_int = 0x1; // parse zlib header and adler32 checksum -static TDEFL_WRITE_ZLIB_HEADER : c_int = 0x01000; // write zlib header and adler32 checksum +const LZ_NORM: c_int = 0x80; // LZ with 128 probes, "normal" +const TINFL_FLAG_PARSE_ZLIB_HEADER: c_int = 0x1; // parse zlib header and adler32 checksum +const TDEFL_WRITE_ZLIB_HEADER: c_int = 0x01000; // write zlib header and adler32 checksum fn deflate_bytes_internal(bytes: &[u8], flags: c_int) -> Option<Bytes> { unsafe { diff --git a/src/libgraphviz/lib.rs b/src/libgraphviz/lib.rs index 09fbf4935e4..2f60a9e2cca 100644 --- a/src/libgraphviz/lib.rs +++ b/src/libgraphviz/lib.rs @@ -37,7 +37,7 @@ //! Each node label is derived directly from the int representing the node, //! while the edge labels are all empty strings. //! -//! This example also illustrates how to use `CowVec` to return +//! This example also illustrates how to use `Cow<[T]>` to return //! an owned vector or a borrowed slice as appropriate: we construct the //! node vector from scratch, but borrow the edge list (rather than //! constructing a copy of all the edges from scratch). @@ -502,7 +502,7 @@ pub type Edges<'a,E> = Cow<'a,[E]>; /// that is bound by the self lifetime `'a`. /// /// The `nodes` and `edges` method each return instantiations of -/// `CowVec` to leave implementers the freedom to create +/// `Cow<[T]>` to leave implementers the freedom to create /// entirely new vectors or to pass back slices into internally owned /// vectors. pub trait GraphWalk<'a, N, E> { diff --git a/src/librand/chacha.rs b/src/librand/chacha.rs index 2673649f344..71ace016d6b 100644 --- a/src/librand/chacha.rs +++ b/src/librand/chacha.rs @@ -12,6 +12,7 @@ use core::prelude::*; use core::num::Int; +use core::num::wrapping::WrappingOps; use {Rng, SeedableRng, Rand}; const KEY_WORDS : uint = 8; // 8 words for the 256-bit key @@ -43,10 +44,10 @@ static EMPTY: ChaChaRng = ChaChaRng { 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); + $a = $a.wrapping_add($b); $d = $d ^ $a; $d = $d.rotate_left(16); + $c = $c.wrapping_add($d); $b = $b ^ $c; $b = $b.rotate_left(12); + $a = $a.wrapping_add($b); $d = $d ^ $a; $d = $d.rotate_left( 8); + $c = $c.wrapping_add($d); $b = $b ^ $c; $b = $b.rotate_left( 7); }} } @@ -74,7 +75,7 @@ fn core(output: &mut [u32; STATE_WORDS], input: &[u32; STATE_WORDS]) { } for i in 0..STATE_WORDS { - output[i] += input[i]; + output[i] = output[i].wrapping_add(input[i]); } } diff --git a/src/librand/distributions/mod.rs b/src/librand/distributions/mod.rs index 5a85552dc38..12794ed69be 100644 --- a/src/librand/distributions/mod.rs +++ b/src/librand/distributions/mod.rs @@ -223,7 +223,7 @@ fn ziggurat<R: Rng, P, Z>( mut pdf: P, mut zero_case: Z) -> f64 where P: FnMut(f64) -> f64, Z: FnMut(&mut R, f64) -> f64 { - static SCALE: f64 = (1u64 << 53) as f64; + const SCALE: f64 = (1u64 << 53) as f64; loop { // reimplement the f64 generation as an optimisation suggested // by the Doornik paper: we have a lot of precision-space diff --git a/src/librand/distributions/range.rs b/src/librand/distributions/range.rs index 6eb1d68a081..fb73a44c2b9 100644 --- a/src/librand/distributions/range.rs +++ b/src/librand/distributions/range.rs @@ -14,6 +14,7 @@ use core::prelude::{PartialOrd}; use core::num::Int; +use core::num::wrapping::WrappingOps; use Rng; use distributions::{Sample, IndependentSample}; @@ -97,7 +98,7 @@ macro_rules! integer_impl { // bijection. fn construct_range(low: $ty, high: $ty) -> Range<$ty> { - let range = high as $unsigned - low as $unsigned; + let range = (high as $unsigned).wrapping_sub(low as $unsigned); let unsigned_max: $unsigned = Int::max_value(); // this is the largest number that fits into $unsigned @@ -122,7 +123,7 @@ macro_rules! integer_impl { // be uniformly distributed) if v < r.accept_zone as $unsigned { // and return it, with some adjustments - return r.low + (v % r.range as $unsigned) as $ty; + return r.low.wrapping_add((v % r.range as $unsigned) as $ty); } } } diff --git a/src/librand/isaac.rs b/src/librand/isaac.rs index 701749ff344..28f1ea872d7 100644 --- a/src/librand/isaac.rs +++ b/src/librand/isaac.rs @@ -13,6 +13,7 @@ use core::prelude::*; use core::slice; use core::iter::{range_step, repeat}; +use core::num::wrapping::Wrapping; use {Rng, SeedableRng, Rand}; @@ -60,7 +61,7 @@ impl IsaacRng { /// of `rsl` as a seed, otherwise construct one algorithmically (not /// randomly). fn init(&mut self, use_rsl: bool) { - let mut a = 0x9e3779b9; + let mut a = Wrapping(0x9e3779b9); let mut b = a; let mut c = a; let mut d = a; @@ -71,14 +72,14 @@ impl IsaacRng { macro_rules! mix { () => {{ - a^=b<<11; d+=a; b+=c; - b^=c>>2; e+=b; c+=d; - c^=d<<8; f+=c; d+=e; - d^=e>>16; g+=d; e+=f; - e^=f<<10; h+=e; f+=g; - f^=g>>4; a+=f; g+=h; - g^=h<<8; b+=g; h+=a; - h^=a>>9; c+=h; a+=b; + a=a^(b<<11); d=d+a; b=b+c; + b=b^(c>>2); e=e+b; c=c+d; + c=c^(d<<8); f=f+c; d=d+e; + d=d^(e>>16); g=g+d; e=e+f; + e=e^(f<<10); h=h+e; f=f+g; + f=f^(g>>4); a=a+f; g=g+h; + g=g^(h<<8); b=b+g; h=h+a; + h=h^(a>>9); c=c+h; a=a+b; }} } @@ -90,15 +91,15 @@ impl IsaacRng { macro_rules! memloop { ($arr:expr) => {{ for i in range_step(0, RAND_SIZE as uint, 8) { - a+=$arr[i ]; b+=$arr[i+1]; - c+=$arr[i+2]; d+=$arr[i+3]; - e+=$arr[i+4]; f+=$arr[i+5]; - g+=$arr[i+6]; h+=$arr[i+7]; + a=a+Wrapping($arr[i ]); b=b+Wrapping($arr[i+1]); + c=c+Wrapping($arr[i+2]); d=d+Wrapping($arr[i+3]); + e=e+Wrapping($arr[i+4]); f=f+Wrapping($arr[i+5]); + g=g+Wrapping($arr[i+6]); h=h+Wrapping($arr[i+7]); mix!(); - self.mem[i ]=a; self.mem[i+1]=b; - self.mem[i+2]=c; self.mem[i+3]=d; - self.mem[i+4]=e; self.mem[i+5]=f; - self.mem[i+6]=g; self.mem[i+7]=h; + self.mem[i ]=a.0; self.mem[i+1]=b.0; + self.mem[i+2]=c.0; self.mem[i+3]=d.0; + self.mem[i+4]=e.0; self.mem[i+5]=f.0; + self.mem[i+6]=g.0; self.mem[i+7]=h.0; } }} } @@ -108,10 +109,10 @@ impl IsaacRng { } else { for i in range_step(0, RAND_SIZE as uint, 8) { mix!(); - self.mem[i ]=a; self.mem[i+1]=b; - self.mem[i+2]=c; self.mem[i+3]=d; - self.mem[i+4]=e; self.mem[i+5]=f; - self.mem[i+6]=g; self.mem[i+7]=h; + self.mem[i ]=a.0; self.mem[i+1]=b.0; + self.mem[i+2]=c.0; self.mem[i+3]=d.0; + self.mem[i+4]=e.0; self.mem[i+5]=f.0; + self.mem[i+6]=g.0; self.mem[i+7]=h.0; } } @@ -127,10 +128,11 @@ impl IsaacRng { let mut a = self.a; let mut b = self.b + self.c; - static MIDPOINT: uint = (RAND_SIZE / 2) as uint; + const MIDPOINT: uint = (RAND_SIZE / 2) as uint; macro_rules! ind { - ($x:expr) => ( self.mem[(($x >> 2) as uint & ((RAND_SIZE - 1) as uint))] ) + ($x:expr) => (Wrapping( self.mem[(($x >> 2) as uint & + ((RAND_SIZE - 1) as uint))] )) } let r = [(0, MIDPOINT), (MIDPOINT, 0)]; @@ -142,11 +144,11 @@ impl IsaacRng { let mix = a << $shift as uint; let x = self.mem[base + mr_offset]; - a = (a ^ mix) + self.mem[base + m2_offset]; - let y = ind!(x) + a + b; - self.mem[base + mr_offset] = y; + a = (Wrapping(a ^ mix) + Wrapping(self.mem[base + m2_offset])).0; + let y = ind!(x) + Wrapping(a) + Wrapping(b); + self.mem[base + mr_offset] = y.0; - b = ind!(y >> RAND_SIZE_LEN as uint) + x; + b = (ind!(y.0 >> RAND_SIZE_LEN as uint) + Wrapping(x)).0; self.rsl[base + mr_offset] = b; }} } @@ -157,11 +159,11 @@ impl IsaacRng { let mix = a >> $shift as uint; let x = self.mem[base + mr_offset]; - a = (a ^ mix) + self.mem[base + m2_offset]; - let y = ind!(x) + a + b; - self.mem[base + mr_offset] = y; + a = (Wrapping(a ^ mix) + Wrapping(self.mem[base + m2_offset])).0; + let y = ind!(x) + Wrapping(a) + Wrapping(b); + self.mem[base + mr_offset] = y.0; - b = ind!(y >> RAND_SIZE_LEN as uint) + x; + b = (ind!(y.0 >> RAND_SIZE_LEN as uint) + Wrapping(x)).0; self.rsl[base + mr_offset] = b; }} } @@ -304,7 +306,7 @@ impl Isaac64Rng { fn init(&mut self, use_rsl: bool) { macro_rules! init { ($var:ident) => ( - let mut $var = 0x9e3779b97f4a7c13; + let mut $var = Wrapping(0x9e3779b97f4a7c13); ) } init!(a); init!(b); init!(c); init!(d); @@ -312,14 +314,14 @@ impl Isaac64Rng { macro_rules! mix { () => {{ - a-=e; f^=h>>9; h+=a; - b-=f; g^=a<<9; a+=b; - c-=g; h^=b>>23; b+=c; - d-=h; a^=c<<15; c+=d; - e-=a; b^=d>>14; d+=e; - f-=b; c^=e<<20; e+=f; - g-=c; d^=f>>17; f+=g; - h-=d; e^=g<<14; g+=h; + a=a-e; f=f^h>>9; h=h+a; + b=b-f; g=g^a<<9; a=a+b; + c=c-g; h=h^b>>23; b=b+c; + d=d-h; a=a^c<<15; c=c+d; + e=e-a; b=b^d>>14; d=d+e; + f=f-b; c=c^e<<20; e=e+f; + g=g-c; d=d^f>>17; f=f+g; + h=h-d; e=e^g<<14; g=g+h; }} } @@ -331,15 +333,15 @@ impl Isaac64Rng { macro_rules! memloop { ($arr:expr) => {{ for i in (0..RAND_SIZE_64 / 8).map(|i| i * 8) { - a+=$arr[i ]; b+=$arr[i+1]; - c+=$arr[i+2]; d+=$arr[i+3]; - e+=$arr[i+4]; f+=$arr[i+5]; - g+=$arr[i+6]; h+=$arr[i+7]; + a=a+Wrapping($arr[i ]); b=b+Wrapping($arr[i+1]); + c=c+Wrapping($arr[i+2]); d=d+Wrapping($arr[i+3]); + e=e+Wrapping($arr[i+4]); f=f+Wrapping($arr[i+5]); + g=g+Wrapping($arr[i+6]); h=h+Wrapping($arr[i+7]); mix!(); - self.mem[i ]=a; self.mem[i+1]=b; - self.mem[i+2]=c; self.mem[i+3]=d; - self.mem[i+4]=e; self.mem[i+5]=f; - self.mem[i+6]=g; self.mem[i+7]=h; + self.mem[i ]=a.0; self.mem[i+1]=b.0; + self.mem[i+2]=c.0; self.mem[i+3]=d.0; + self.mem[i+4]=e.0; self.mem[i+5]=f.0; + self.mem[i+6]=g.0; self.mem[i+7]=h.0; } }} } @@ -349,10 +351,10 @@ impl Isaac64Rng { } else { for i in (0..RAND_SIZE_64 / 8).map(|i| i * 8) { mix!(); - self.mem[i ]=a; self.mem[i+1]=b; - self.mem[i+2]=c; self.mem[i+3]=d; - self.mem[i+4]=e; self.mem[i+5]=f; - self.mem[i+6]=g; self.mem[i+7]=h; + self.mem[i ]=a.0; self.mem[i+1]=b.0; + self.mem[i+2]=c.0; self.mem[i+3]=d.0; + self.mem[i+4]=e.0; self.mem[i+5]=f.0; + self.mem[i+6]=g.0; self.mem[i+7]=h.0; } } @@ -363,8 +365,8 @@ impl Isaac64Rng { fn isaac64(&mut self) { self.c += 1; // abbreviations - let mut a = self.a; - let mut b = self.b + self.c; + let mut a = Wrapping(self.a); + let mut b = Wrapping(self.b) + Wrapping(self.c); const MIDPOINT: uint = RAND_SIZE_64 / 2; const MP_VEC: [(uint, uint); 2] = [(0,MIDPOINT), (MIDPOINT, 0)]; macro_rules! ind { @@ -383,13 +385,13 @@ impl Isaac64Rng { let mix = if $j == 0 {!mix} else {mix}; unsafe { - let x = *self.mem.get_unchecked(base + mr_offset); - a = mix + *self.mem.get_unchecked(base + m2_offset); - let y = ind!(x) + a + b; - *self.mem.get_unchecked_mut(base + mr_offset) = y; + let x = Wrapping(*self.mem.get_unchecked(base + mr_offset)); + a = mix + Wrapping(*self.mem.get_unchecked(base + m2_offset)); + let y = Wrapping(ind!(x.0)) + a + b; + *self.mem.get_unchecked_mut(base + mr_offset) = y.0; - b = ind!(y >> RAND_SIZE_64_LEN) + x; - *self.rsl.get_unchecked_mut(base + mr_offset) = b; + b = Wrapping(ind!(y.0 >> RAND_SIZE_64_LEN)) + x; + *self.rsl.get_unchecked_mut(base + mr_offset) = b.0; } }} } @@ -401,13 +403,13 @@ impl Isaac64Rng { let mix = if $j == 0 {!mix} else {mix}; unsafe { - let x = *self.mem.get_unchecked(base + mr_offset); - a = mix + *self.mem.get_unchecked(base + m2_offset); - let y = ind!(x) + a + b; - *self.mem.get_unchecked_mut(base + mr_offset) = y; + let x = Wrapping(*self.mem.get_unchecked(base + mr_offset)); + a = mix + Wrapping(*self.mem.get_unchecked(base + m2_offset)); + let y = Wrapping(ind!(x.0)) + a + b; + *self.mem.get_unchecked_mut(base + mr_offset) = y.0; - b = ind!(y >> RAND_SIZE_64_LEN) + x; - *self.rsl.get_unchecked_mut(base + mr_offset) = b; + b = Wrapping(ind!(y.0 >> RAND_SIZE_64_LEN)) + x; + *self.rsl.get_unchecked_mut(base + mr_offset) = b.0; } }} } @@ -419,8 +421,8 @@ impl Isaac64Rng { } } - self.a = a; - self.b = b; + self.a = a.0; + self.b = b.0; self.cnt = RAND_SIZE_64; } } diff --git a/src/librand/lib.rs b/src/librand/lib.rs index 583c658dfe0..3458d519af5 100644 --- a/src/librand/lib.rs +++ b/src/librand/lib.rs @@ -52,7 +52,7 @@ use distributions::{Range, IndependentSample}; use distributions::range::SampleRange; #[cfg(test)] -static RAND_BENCH_N: u64 = 100; +const RAND_BENCH_N: u64 = 100; pub mod distributions; pub mod isaac; @@ -342,7 +342,7 @@ impl<'a, R: Rng> Iterator for AsciiGenerator<'a, R> { type Item = char; fn next(&mut self) -> Option<char> { - static GEN_ASCII_STR_CHARSET: &'static [u8] = + const GEN_ASCII_STR_CHARSET: &'static [u8] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZ\ abcdefghijklmnopqrstuvwxyz\ 0123456789"; diff --git a/src/librand/rand_impls.rs b/src/librand/rand_impls.rs index 74d2c408060..c8a757079c3 100644 --- a/src/librand/rand_impls.rs +++ b/src/librand/rand_impls.rs @@ -141,7 +141,7 @@ impl Rand for char { #[inline] fn rand<R: Rng>(rng: &mut R) -> char { // a char is 21 bits - static CHAR_MASK: u32 = 0x001f_ffff; + const CHAR_MASK: u32 = 0x001f_ffff; loop { // Rejection sampling. About 0.2% of numbers with at most // 21-bits are invalid codepoints (surrogates), so this diff --git a/src/librand/reseeding.rs b/src/librand/reseeding.rs index 06828911471..0072c555d14 100644 --- a/src/librand/reseeding.rs +++ b/src/librand/reseeding.rs @@ -18,7 +18,7 @@ use core::default::Default; /// How many bytes of entropy the underling RNG is allowed to generate /// before it is reseeded. -static DEFAULT_GENERATION_THRESHOLD: uint = 32 * 1024; +const DEFAULT_GENERATION_THRESHOLD: uint = 32 * 1024; /// A wrapper around any RNG which reseeds the underlying RNG after it /// has generated a certain number of random bytes. @@ -212,7 +212,7 @@ mod test { assert_eq!(string1, string2); } - static FILL_BYTES_V_LEN: uint = 13579; + const FILL_BYTES_V_LEN: uint = 13579; #[test] fn test_rng_fill_bytes() { let mut v = repeat(0u8).take(FILL_BYTES_V_LEN).collect::<Vec<_>>(); diff --git a/src/librbml/io.rs b/src/librbml/io.rs index c52465a8899..4ef3c5bc206 100644 --- a/src/librbml/io.rs +++ b/src/librbml/io.rs @@ -13,7 +13,7 @@ use std::old_io; use std::slice; use std::iter::repeat; -static BUF_CAPACITY: uint = 128; +const BUF_CAPACITY: uint = 128; fn combine(seek: SeekStyle, cur: uint, end: uint, offset: i64) -> IoResult<u64> { // compute offset as signed and clamp to prevent overflow diff --git a/src/librustc/lint/context.rs b/src/librustc/lint/context.rs index f635c77af9b..a777e1f7f75 100644 --- a/src/librustc/lint/context.rs +++ b/src/librustc/lint/context.rs @@ -568,9 +568,9 @@ impl<'a, 'tcx, 'v> Visitor<'v> for Context<'a, 'tcx> { }) } - // FIXME(#10894) should continue recursing fn visit_ty(&mut self, t: &ast::Ty) { run_lints!(self, check_ty, t); + visit::walk_ty(self, t); } fn visit_ident(&mut self, sp: Span, id: ast::Ident) { diff --git a/src/librustc/metadata/decoder.rs b/src/librustc/metadata/decoder.rs index 251c5e6eac7..e32fcaec047 100644 --- a/src/librustc/metadata/decoder.rs +++ b/src/librustc/metadata/decoder.rs @@ -783,7 +783,7 @@ pub fn get_enum_variants<'tcx>(intr: Rc<IdentInterner>, cdata: Cmd, id: ast::Nod _ => { /* empty */ } } let old_disr_val = disr_val; - disr_val += 1; + disr_val = disr_val.wrapping_add(1); Rc::new(ty::VariantInfo { args: arg_tys, arg_names: arg_names, diff --git a/src/librustc/metadata/encoder.rs b/src/librustc/metadata/encoder.rs index 131a299cc50..8152a2bf16d 100644 --- a/src/librustc/metadata/encoder.rs +++ b/src/librustc/metadata/encoder.rs @@ -347,7 +347,7 @@ fn encode_enum_variant_info(ecx: &EncodeContext, ecx.tcx.map.with_path(variant.node.id, |path| encode_path(rbml_w, path)); rbml_w.end_tag(); - disr_val += 1; + disr_val = disr_val.wrapping_add(1); i += 1; } } diff --git a/src/librustc/metadata/filesearch.rs b/src/librustc/metadata/filesearch.rs index a8d39f95739..d1091b1d3f7 100644 --- a/src/librustc/metadata/filesearch.rs +++ b/src/librustc/metadata/filesearch.rs @@ -202,9 +202,9 @@ pub fn get_or_default_sysroot() -> Path { } #[cfg(windows)] -static PATH_ENTRY_SEPARATOR: &'static str = ";"; +const PATH_ENTRY_SEPARATOR: char = ';'; #[cfg(not(windows))] -static PATH_ENTRY_SEPARATOR: &'static str = ":"; +const PATH_ENTRY_SEPARATOR: char = ':'; /// Returns RUST_PATH as a string, without default paths added pub fn get_rust_path() -> Option<String> { diff --git a/src/librustc/middle/astencode.rs b/src/librustc/middle/astencode.rs index 599dde4b701..33c0fb8b031 100644 --- a/src/librustc/middle/astencode.rs +++ b/src/librustc/middle/astencode.rs @@ -204,7 +204,9 @@ impl<'a, 'b, 'tcx> DecodeContext<'a, 'b, 'tcx> { pub fn tr_id(&self, id: ast::NodeId) -> ast::NodeId { // from_id_range should be non-empty assert!(!self.from_id_range.empty()); - (id - self.from_id_range.min + self.to_id_range.min) + // Use wrapping arithmetic because otherwise it introduces control flow. + // Maybe we should just have the control flow? -- aatch + (id.wrapping_sub(self.from_id_range.min).wrapping_add(self.to_id_range.min)) } /// Translates an EXTERNAL def-id, converting the crate number from the one used in the encoded diff --git a/src/librustc/middle/check_const.rs b/src/librustc/middle/check_const.rs index 8401d25024d..497022ac6ac 100644 --- a/src/librustc/middle/check_const.rs +++ b/src/librustc/middle/check_const.rs @@ -307,8 +307,9 @@ impl<'a, 'tcx, 'v> Visitor<'v> for CheckCrateVisitor<'a, 'tcx> { match const_eval::eval_const_expr_partial(self.tcx, ex, None) { Ok(_) => {} Err(msg) => { - span_err!(self.tcx.sess, ex.span, E0020, - "{} in a constant expression", msg) + span_err!(self.tcx.sess, msg.span, E0020, + "{} in a constant expression", + msg.description()) } } } diff --git a/src/librustc/middle/check_match.rs b/src/librustc/middle/check_match.rs index c409c8fb13f..f8a2c507e42 100644 --- a/src/librustc/middle/check_match.rs +++ b/src/librustc/middle/check_match.rs @@ -13,7 +13,8 @@ use self::Usefulness::*; use self::WitnessPreference::*; use middle::const_eval::{compare_const_vals, const_bool, const_float, const_val}; -use middle::const_eval::{const_expr_to_pat, eval_const_expr, lookup_const_by_id}; +use middle::const_eval::{eval_const_expr, eval_const_expr_partial}; +use middle::const_eval::{const_expr_to_pat, lookup_const_by_id}; use middle::def::*; use middle::expr_use_visitor::{ConsumeMode, Delegate, ExprUseVisitor, Init}; use middle::expr_use_visitor::{JustWrite, LoanCause, MutateMode}; @@ -229,13 +230,6 @@ fn check_expr(cx: &mut MatchCheckCtxt, ex: &ast::Expr) { } } -fn is_expr_const_nan(tcx: &ty::ctxt, expr: &ast::Expr) -> bool { - match eval_const_expr(tcx, expr) { - const_float(f) => f.is_nan(), - _ => false - } -} - fn check_for_bindings_named_the_same_as_variants(cx: &MatchCheckCtxt, pat: &Pat) { ast_util::walk_pat(pat, |p| { match p.node { @@ -269,13 +263,26 @@ fn check_for_bindings_named_the_same_as_variants(cx: &MatchCheckCtxt, pat: &Pat) // Check that we do not match against a static NaN (#6804) fn check_for_static_nan(cx: &MatchCheckCtxt, pat: &Pat) { ast_util::walk_pat(pat, |p| { - match p.node { - ast::PatLit(ref expr) if is_expr_const_nan(cx.tcx, &**expr) => { - span_warn!(cx.tcx.sess, p.span, E0003, - "unmatchable NaN in pattern, \ - use the is_nan method in a guard instead"); + if let ast::PatLit(ref expr) = p.node { + match eval_const_expr_partial(cx.tcx, &**expr, None) { + Ok(const_float(f)) if f.is_nan() => { + span_warn!(cx.tcx.sess, p.span, E0003, + "unmatchable NaN in pattern, \ + use the is_nan method in a guard instead"); + } + Ok(_) => {} + + Err(err) => { + let subspan = p.span.lo <= err.span.lo && err.span.hi <= p.span.hi; + cx.tcx.sess.span_err(err.span, + &format!("constant evaluation error: {}", + err.description().as_slice())); + if !subspan { + cx.tcx.sess.span_note(p.span, + "in pattern here") + } + } } - _ => () } true }); diff --git a/src/librustc/middle/const_eval.rs b/src/librustc/middle/const_eval.rs index 0c9f9d2a530..9291f175777 100644 --- a/src/librustc/middle/const_eval.rs +++ b/src/librustc/middle/const_eval.rs @@ -25,6 +25,8 @@ use syntax::parse::token::InternedString; use syntax::ptr::P; use syntax::{ast_map, ast_util, codemap}; +use std::borrow::{Cow, IntoCow}; +use std::num::wrapping::OverflowingOps; use std::cmp::Ordering; use std::collections::hash_map::Entry::Vacant; use std::{i8, i16, i32, i64}; @@ -202,35 +204,153 @@ pub fn const_expr_to_pat(tcx: &ty::ctxt, expr: &Expr, span: Span) -> P<ast::Pat> pub fn eval_const_expr(tcx: &ty::ctxt, e: &Expr) -> const_val { match eval_const_expr_partial(tcx, e, None) { Ok(r) => r, - Err(s) => tcx.sess.span_fatal(e.span, &s[..]) + Err(s) => tcx.sess.span_fatal(s.span, s.description().as_slice()) } } + +#[derive(Clone)] +pub struct ConstEvalErr { + pub span: Span, + pub kind: ErrKind, +} + +#[derive(Clone)] +pub enum ErrKind { + CannotCast, + CannotCastTo(&'static str), + InvalidOpForBools(ast::BinOp_), + InvalidOpForFloats(ast::BinOp_), + InvalidOpForIntUint(ast::BinOp_), + InvalidOpForUintInt(ast::BinOp_), + NegateOnString, + NegateOnBoolean, + NegateOnBinary, + NotOnFloat, + NotOnString, + NotOnBinary, + + AddiWithOverflow(i64, i64), + SubiWithOverflow(i64, i64), + MuliWithOverflow(i64, i64), + AdduWithOverflow(u64, u64), + SubuWithOverflow(u64, u64), + MuluWithOverflow(u64, u64), + DivideByZero, + DivideWithOverflow, + ModuloByZero, + ModuloWithOverflow, + MissingStructField, + NonConstPath, + NonConstStruct, + TupleIndexOutOfBounds, + + MiscBinaryOp, + MiscCatchAll, +} + +impl ConstEvalErr { + pub fn description(&self) -> Cow<str> { + use self::ErrKind::*; + match self.kind { + CannotCast => "can't cast this type".into_cow(), + CannotCastTo(s) => format!("can't cast this type to {}", s).into_cow(), + InvalidOpForBools(_) => "can't do this op on bools".into_cow(), + InvalidOpForFloats(_) => "can't do this op on floats".into_cow(), + InvalidOpForIntUint(..) => "can't do this op on an int and uint".into_cow(), + InvalidOpForUintInt(..) => "can't do this op on a uint and int".into_cow(), + NegateOnString => "negate on string".into_cow(), + NegateOnBoolean => "negate on boolean".into_cow(), + NegateOnBinary => "negate on binary literal".into_cow(), + NotOnFloat => "not on float or string".into_cow(), + NotOnString => "not on float or string".into_cow(), + NotOnBinary => "not on binary literal".into_cow(), + + AddiWithOverflow(..) => "attempted to add with overflow".into_cow(), + SubiWithOverflow(..) => "attempted to sub with overflow".into_cow(), + MuliWithOverflow(..) => "attempted to mul with overflow".into_cow(), + AdduWithOverflow(..) => "attempted to add with overflow".into_cow(), + SubuWithOverflow(..) => "attempted to sub with overflow".into_cow(), + MuluWithOverflow(..) => "attempted to mul with overflow".into_cow(), + DivideByZero => "attempted to divide by zero".into_cow(), + DivideWithOverflow => "attempted to divide with overflow".into_cow(), + ModuloByZero => "attempted remainder with a divisor of zero".into_cow(), + ModuloWithOverflow => "attempted remainder with overflow".into_cow(), + MissingStructField => "nonexistent struct field".into_cow(), + NonConstPath => "non-constant path in constant expr".into_cow(), + NonConstStruct => "non-constant struct in constant expr".into_cow(), + TupleIndexOutOfBounds => "tuple index out of bounds".into_cow(), + + MiscBinaryOp => "bad operands for binary".into_cow(), + MiscCatchAll => "unsupported constant expr".into_cow(), + } + } +} + +macro_rules! signal { + ($e:expr, $ctor:ident) => { + return Err(ConstEvalErr { span: $e.span, kind: ErrKind::$ctor }) + }; + + ($e:expr, $ctor:ident($($arg:expr),*)) => { + return Err(ConstEvalErr { span: $e.span, kind: ErrKind::$ctor($($arg),*) }) + } +} + +fn checked_add_int(e: &Expr, a: i64, b: i64) -> Result<const_val, ConstEvalErr> { + let (ret, oflo) = a.overflowing_add(b); + if !oflo { Ok(const_int(ret)) } else { signal!(e, AddiWithOverflow(a, b)) } +} +fn checked_sub_int(e: &Expr, a: i64, b: i64) -> Result<const_val, ConstEvalErr> { + let (ret, oflo) = a.overflowing_sub(b); + if !oflo { Ok(const_int(ret)) } else { signal!(e, SubiWithOverflow(a, b)) } +} +fn checked_mul_int(e: &Expr, a: i64, b: i64) -> Result<const_val, ConstEvalErr> { + let (ret, oflo) = a.overflowing_mul(b); + if !oflo { Ok(const_int(ret)) } else { signal!(e, MuliWithOverflow(a, b)) } +} + +fn checked_add_uint(e: &Expr, a: u64, b: u64) -> Result<const_val, ConstEvalErr> { + let (ret, oflo) = a.overflowing_add(b); + if !oflo { Ok(const_uint(ret)) } else { signal!(e, AdduWithOverflow(a, b)) } +} +fn checked_sub_uint(e: &Expr, a: u64, b: u64) -> Result<const_val, ConstEvalErr> { + let (ret, oflo) = a.overflowing_sub(b); + if !oflo { Ok(const_uint(ret)) } else { signal!(e, SubuWithOverflow(a, b)) } +} +fn checked_mul_uint(e: &Expr, a: u64, b: u64) -> Result<const_val, ConstEvalErr> { + let (ret, oflo) = a.overflowing_mul(b); + if !oflo { Ok(const_uint(ret)) } else { signal!(e, MuluWithOverflow(a, b)) } +} + + pub fn eval_const_expr_partial<'tcx>(tcx: &ty::ctxt<'tcx>, e: &Expr, ty_hint: Option<Ty<'tcx>>) - -> Result<const_val, String> { - fn fromb(b: bool) -> Result<const_val, String> { Ok(const_int(b as i64)) } + -> Result<const_val, ConstEvalErr> { + fn fromb(b: bool) -> const_val { const_int(b as i64) } let ety = ty_hint.or_else(|| ty::expr_ty_opt(tcx, e)); - match e.node { + let result = match e.node { ast::ExprUnary(ast::UnNeg, ref inner) => { - match eval_const_expr_partial(tcx, &**inner, ety) { - Ok(const_float(f)) => Ok(const_float(-f)), - Ok(const_int(i)) => Ok(const_int(-i)), - Ok(const_uint(i)) => Ok(const_uint(-i)), - Ok(const_str(_)) => Err("negate on string".to_string()), - Ok(const_bool(_)) => Err("negate on boolean".to_string()), - ref err => ((*err).clone()) + match try!(eval_const_expr_partial(tcx, &**inner, ety)) { + const_float(f) => const_float(-f), + const_int(i) => const_int(-i), + const_uint(i) => const_uint(-i), + const_str(_) => signal!(e, NegateOnString), + const_bool(_) => signal!(e, NegateOnBoolean), + const_binary(_) => signal!(e, NegateOnBinary), } } ast::ExprUnary(ast::UnNot, ref inner) => { - match eval_const_expr_partial(tcx, &**inner, ety) { - Ok(const_int(i)) => Ok(const_int(!i)), - Ok(const_uint(i)) => Ok(const_uint(!i)), - Ok(const_bool(b)) => Ok(const_bool(!b)), - _ => Err("not on float or string".to_string()) + match try!(eval_const_expr_partial(tcx, &**inner, ety)) { + const_int(i) => const_int(!i), + const_uint(i) => const_uint(!i), + const_bool(b) => const_bool(!b), + const_str(_) => signal!(e, NotOnString), + const_float(_) => signal!(e, NotOnFloat), + const_binary(_) => signal!(e, NotOnBinary), } } ast::ExprBinary(op, ref a, ref b) => { @@ -238,25 +358,25 @@ pub fn eval_const_expr_partial<'tcx>(tcx: &ty::ctxt<'tcx>, ast::BiShl | ast::BiShr => Some(tcx.types.uint), _ => ety }; - match (eval_const_expr_partial(tcx, &**a, ety), - eval_const_expr_partial(tcx, &**b, b_ty)) { - (Ok(const_float(a)), Ok(const_float(b))) => { + match (try!(eval_const_expr_partial(tcx, &**a, ety)), + try!(eval_const_expr_partial(tcx, &**b, b_ty))) { + (const_float(a), const_float(b)) => { match op.node { - ast::BiAdd => Ok(const_float(a + b)), - ast::BiSub => Ok(const_float(a - b)), - ast::BiMul => Ok(const_float(a * b)), - ast::BiDiv => Ok(const_float(a / b)), - ast::BiRem => Ok(const_float(a % b)), + ast::BiAdd => const_float(a + b), + ast::BiSub => const_float(a - b), + ast::BiMul => const_float(a * b), + ast::BiDiv => const_float(a / b), + ast::BiRem => const_float(a % b), ast::BiEq => fromb(a == b), ast::BiLt => fromb(a < b), ast::BiLe => fromb(a <= b), ast::BiNe => fromb(a != b), ast::BiGe => fromb(a >= b), ast::BiGt => fromb(a > b), - _ => Err("can't do this op on floats".to_string()) + _ => signal!(e, InvalidOpForFloats(op.node)) } } - (Ok(const_int(a)), Ok(const_int(b))) => { + (const_int(a), const_int(b)) => { let is_a_min_value = || { let int_ty = match ty::expr_ty_opt(tcx, e).map(|ty| &ty.sty) { Some(&ty::ty_int(int_ty)) => int_ty, @@ -276,32 +396,32 @@ pub fn eval_const_expr_partial<'tcx>(tcx: &ty::ctxt<'tcx>, } }; match op.node { - ast::BiAdd => Ok(const_int(a + b)), - ast::BiSub => Ok(const_int(a - b)), - ast::BiMul => Ok(const_int(a * b)), + ast::BiAdd => try!(checked_add_int(e, a, b)), + ast::BiSub => try!(checked_sub_int(e, a, b)), + ast::BiMul => try!(checked_mul_int(e, a, b)), ast::BiDiv => { if b == 0 { - Err("attempted to divide by zero".to_string()) + signal!(e, DivideByZero); } else if b == -1 && is_a_min_value() { - Err("attempted to divide with overflow".to_string()) + signal!(e, DivideWithOverflow); } else { - Ok(const_int(a / b)) + const_int(a / b) } } ast::BiRem => { if b == 0 { - Err("attempted remainder with a divisor of zero".to_string()) + signal!(e, ModuloByZero) } else if b == -1 && is_a_min_value() { - Err("attempted remainder with overflow".to_string()) + signal!(e, ModuloWithOverflow) } else { - Ok(const_int(a % b)) + const_int(a % b) } } - ast::BiAnd | ast::BiBitAnd => Ok(const_int(a & b)), - ast::BiOr | ast::BiBitOr => Ok(const_int(a | b)), - ast::BiBitXor => Ok(const_int(a ^ b)), - ast::BiShl => Ok(const_int(a << b as uint)), - ast::BiShr => Ok(const_int(a >> b as uint)), + ast::BiAnd | ast::BiBitAnd => const_int(a & b), + ast::BiOr | ast::BiBitOr => const_int(a | b), + ast::BiBitXor => const_int(a ^ b), + ast::BiShl => const_int(a << b as uint), + ast::BiShr => const_int(a >> b as uint), ast::BiEq => fromb(a == b), ast::BiLt => fromb(a < b), ast::BiLe => fromb(a <= b), @@ -310,25 +430,20 @@ pub fn eval_const_expr_partial<'tcx>(tcx: &ty::ctxt<'tcx>, ast::BiGt => fromb(a > b) } } - (Ok(const_uint(a)), Ok(const_uint(b))) => { + (const_uint(a), const_uint(b)) => { match op.node { - ast::BiAdd => Ok(const_uint(a + b)), - ast::BiSub => Ok(const_uint(a - b)), - ast::BiMul => Ok(const_uint(a * b)), - ast::BiDiv if b == 0 => { - Err("attempted to divide by zero".to_string()) - } - ast::BiDiv => Ok(const_uint(a / b)), - ast::BiRem if b == 0 => { - Err("attempted remainder with a divisor of \ - zero".to_string()) - } - ast::BiRem => Ok(const_uint(a % b)), - ast::BiAnd | ast::BiBitAnd => Ok(const_uint(a & b)), - ast::BiOr | ast::BiBitOr => Ok(const_uint(a | b)), - ast::BiBitXor => Ok(const_uint(a ^ b)), - ast::BiShl => Ok(const_uint(a << b as uint)), - ast::BiShr => Ok(const_uint(a >> b as uint)), + ast::BiAdd => try!(checked_add_uint(e, a, b)), + ast::BiSub => try!(checked_sub_uint(e, a, b)), + ast::BiMul => try!(checked_mul_uint(e, a, b)), + ast::BiDiv if b == 0 => signal!(e, DivideByZero), + ast::BiDiv => const_uint(a / b), + ast::BiRem if b == 0 => signal!(e, ModuloByZero), + ast::BiRem => const_uint(a % b), + ast::BiAnd | ast::BiBitAnd => const_uint(a & b), + ast::BiOr | ast::BiBitOr => const_uint(a | b), + ast::BiBitXor => const_uint(a ^ b), + ast::BiShl => const_uint(a << b as uint), + ast::BiShr => const_uint(a >> b as uint), ast::BiEq => fromb(a == b), ast::BiLt => fromb(a < b), ast::BiLe => fromb(a <= b), @@ -338,22 +453,22 @@ pub fn eval_const_expr_partial<'tcx>(tcx: &ty::ctxt<'tcx>, } } // shifts can have any integral type as their rhs - (Ok(const_int(a)), Ok(const_uint(b))) => { + (const_int(a), const_uint(b)) => { match op.node { - ast::BiShl => Ok(const_int(a << b as uint)), - ast::BiShr => Ok(const_int(a >> b as uint)), - _ => Err("can't do this op on an int and uint".to_string()) + ast::BiShl => const_int(a << b as uint), + ast::BiShr => const_int(a >> b as uint), + _ => signal!(e, InvalidOpForIntUint(op.node)), } } - (Ok(const_uint(a)), Ok(const_int(b))) => { + (const_uint(a), const_int(b)) => { match op.node { - ast::BiShl => Ok(const_uint(a << b as uint)), - ast::BiShr => Ok(const_uint(a >> b as uint)), - _ => Err("can't do this op on a uint and int".to_string()) + ast::BiShl => const_uint(a << b as uint), + ast::BiShr => const_uint(a >> b as uint), + _ => signal!(e, InvalidOpForUintInt(op.node)), } } - (Ok(const_bool(a)), Ok(const_bool(b))) => { - Ok(const_bool(match op.node { + (const_bool(a), const_bool(b)) => { + const_bool(match op.node { ast::BiAnd => a && b, ast::BiOr => a || b, ast::BiBitXor => a ^ b, @@ -361,10 +476,11 @@ pub fn eval_const_expr_partial<'tcx>(tcx: &ty::ctxt<'tcx>, ast::BiBitOr => a | b, ast::BiEq => a == b, ast::BiNe => a != b, - _ => return Err("can't do this op on bools".to_string()) - })) + _ => signal!(e, InvalidOpForBools(op.node)), + }) } - _ => Err("bad operands for binary".to_string()) + + _ => signal!(e, MiscBinaryOp), } } ast::ExprCast(ref base, ref target_ty) => { @@ -379,7 +495,10 @@ pub fn eval_const_expr_partial<'tcx>(tcx: &ty::ctxt<'tcx>, // Prefer known type to noop, but always have a type hint. let base_hint = ty::expr_ty_opt(tcx, &**base).unwrap_or(ety); let val = try!(eval_const_expr_partial(tcx, &**base, Some(base_hint))); - cast_const(val, ety) + match cast_const(val, ety) { + Ok(val) => val, + Err(kind) => return Err(ConstEvalErr { span: e.span, kind: kind }), + } } ast::ExprPath(..) => { let opt_def = tcx.def_map.borrow().get(&e.id).map(|d| d.full_def()); @@ -406,19 +525,19 @@ pub fn eval_const_expr_partial<'tcx>(tcx: &ty::ctxt<'tcx>, }; let const_expr = match const_expr { Some(actual_e) => actual_e, - None => return Err("non-constant path in constant expr".to_string()) + None => signal!(e, NonConstPath) }; let ety = ety.or_else(|| const_ty.and_then(|ty| ast_ty_to_prim_ty(tcx, ty))); - eval_const_expr_partial(tcx, const_expr, ety) + try!(eval_const_expr_partial(tcx, const_expr, ety)) } ast::ExprLit(ref lit) => { - Ok(lit_to_const(&**lit, ety)) + lit_to_const(&**lit, ety) } - ast::ExprParen(ref e) => eval_const_expr_partial(tcx, &**e, ety), + ast::ExprParen(ref e) => try!(eval_const_expr_partial(tcx, &**e, ety)), ast::ExprBlock(ref block) => { match block.expr { - Some(ref expr) => eval_const_expr_partial(tcx, &**expr, ety), - None => Ok(const_int(0i64)) + Some(ref expr) => try!(eval_const_expr_partial(tcx, &**expr, ety)), + None => const_int(0i64) } } ast::ExprTupField(ref base, index) => { @@ -426,13 +545,13 @@ pub fn eval_const_expr_partial<'tcx>(tcx: &ty::ctxt<'tcx>, if let Some(&ast::ExprTup(ref fields)) = lookup_const(tcx, &**base).map(|s| &s.node) { // Check that the given index is within bounds and evaluate its value if fields.len() > index.node { - return eval_const_expr_partial(tcx, &*fields[index.node], None) + return eval_const_expr_partial(tcx, &*fields[index.node], None); } else { - return Err("tuple index out of bounds".to_string()) + signal!(e, TupleIndexOutOfBounds); } } - Err("non-constant struct in constant expr".to_string()) + signal!(e, NonConstStruct); } ast::ExprField(ref base, field_name) => { // Get the base expression if it is a struct and it is constant @@ -441,19 +560,21 @@ pub fn eval_const_expr_partial<'tcx>(tcx: &ty::ctxt<'tcx>, // Check that the given field exists and evaluate it if let Some(f) = fields.iter().find(|f| f.ident.node.as_str() == field_name.node.as_str()) { - return eval_const_expr_partial(tcx, &*f.expr, None) + return eval_const_expr_partial(tcx, &*f.expr, None); } else { - return Err("nonexistent struct field".to_string()) + signal!(e, MissingStructField); } } - Err("non-constant struct in constant expr".to_string()) + signal!(e, NonConstStruct); } - _ => Err("unsupported constant expr".to_string()) - } + _ => signal!(e, MiscCatchAll) + }; + + Ok(result) } -fn cast_const(val: const_val, ty: Ty) -> Result<const_val, String> { +fn cast_const(val: const_val, ty: Ty) -> Result<const_val, ErrKind> { macro_rules! define_casts { ($($ty_pat:pat => ( $intermediate_ty:ty, @@ -466,11 +587,10 @@ fn cast_const(val: const_val, ty: Ty) -> Result<const_val, String> { const_uint(u) => Ok($const_type(u as $intermediate_ty as $target_ty)), const_int(i) => Ok($const_type(i as $intermediate_ty as $target_ty)), const_float(f) => Ok($const_type(f as $intermediate_ty as $target_ty)), - _ => Err(concat!("can't cast this type to ", - stringify!($const_type)).to_string()) + _ => Err(ErrKind::CannotCastTo(stringify!($const_type))), } },)* - _ => Err("can't cast this type".to_string()) + _ => Err(ErrKind::CannotCast), }) } @@ -544,15 +664,15 @@ pub fn compare_lit_exprs<'tcx>(tcx: &ty::ctxt<'tcx>, -> Option<Ordering> { let a = match eval_const_expr_partial(tcx, a, ty_hint) { Ok(a) => a, - Err(s) => { - tcx.sess.span_err(a.span, &s[..]); + Err(e) => { + tcx.sess.span_err(a.span, e.description().as_slice()); return None; } }; let b = match eval_const_expr_partial(tcx, b, ty_hint) { Ok(b) => b, - Err(s) => { - tcx.sess.span_err(b.span, &s[..]); + Err(e) => { + tcx.sess.span_err(b.span, e.description().as_slice()); return None; } }; diff --git a/src/librustc/middle/liveness.rs b/src/librustc/middle/liveness.rs index 224a568c77f..892452ccc1c 100644 --- a/src/librustc/middle/liveness.rs +++ b/src/librustc/middle/liveness.rs @@ -540,9 +540,9 @@ struct Specials { clean_exit_var: Variable } -static ACC_READ: u32 = 1; -static ACC_WRITE: u32 = 2; -static ACC_USE: u32 = 4; +const ACC_READ: u32 = 1; +const ACC_WRITE: u32 = 2; +const ACC_USE: u32 = 4; struct Liveness<'a, 'tcx: 'a> { ir: &'a mut IrMaps<'a, 'tcx>, diff --git a/src/librustc/middle/ty.rs b/src/librustc/middle/ty.rs index aaba840825e..36c42b70795 100644 --- a/src/librustc/middle/ty.rs +++ b/src/librustc/middle/ty.rs @@ -76,7 +76,7 @@ use std::hash::{Hash, SipHasher, Hasher}; use std::mem; use std::ops; use std::rc::Rc; -use std::vec::{CowVec, IntoIter}; +use std::vec::IntoIter; use collections::enum_set::{EnumSet, CLike}; use std::collections::{HashMap, HashSet}; use syntax::abi; @@ -5333,6 +5333,7 @@ pub fn type_is_empty(cx: &ctxt, ty: Ty) -> bool { pub fn enum_variants<'tcx>(cx: &ctxt<'tcx>, id: ast::DefId) -> Rc<Vec<Rc<VariantInfo<'tcx>>>> { + use std::num::Int; // For checked_add memoized(&cx.enum_var_cache, id, |id: ast::DefId| { if ast::LOCAL_CRATE != id.krate { Rc::new(csearch::get_enum_variants(cx, id)) @@ -5349,11 +5350,7 @@ pub fn enum_variants<'tcx>(cx: &ctxt<'tcx>, id: ast::DefId) let mut last_discriminant: Option<Disr> = None; Rc::new(enum_definition.variants.iter().map(|variant| { - let mut discriminant = match last_discriminant { - Some(val) => val + 1, - None => INITIAL_DISCRIMINANT_VALUE - }; - + let mut discriminant = INITIAL_DISCRIMINANT_VALUE; if let Some(ref e) = variant.node.disr_expr { // Preserve all values, and prefer signed. let ty = Some(cx.types.i64); @@ -5369,11 +5366,24 @@ pub fn enum_variants<'tcx>(cx: &ctxt<'tcx>, id: ast::DefId) "expected signed integer constant"); } Err(err) => { - span_err!(cx.sess, e.span, E0305, - "expected constant: {}", err); + span_err!(cx.sess, err.span, E0305, + "constant evaluation error: {}", + err.description().as_slice()); + } + } + } else { + if let Some(val) = last_discriminant { + if let Some(v) = val.checked_add(1) { + discriminant = v + } else { + cx.sess.span_err( + variant.span, + &format!("Discriminant overflowed!")); } + } else { + discriminant = INITIAL_DISCRIMINANT_VALUE; } - }; + } last_discriminant = Some(discriminant); Rc::new(VariantInfo::from_ast_variant(cx, &**variant, @@ -5580,7 +5590,7 @@ pub fn predicates<'tcx>( /// Get the attributes of a definition. pub fn get_attrs<'tcx>(tcx: &'tcx ctxt, did: DefId) - -> CowVec<'tcx, ast::Attribute> { + -> Cow<'tcx, [ast::Attribute]> { if is_local(did) { let item = tcx.map.expect_item(did.node); Cow::Borrowed(&item.attrs) @@ -5753,22 +5763,22 @@ pub fn closure_upvars<'tcx>(typer: &mc::Typer<'tcx>, pub fn is_binopable<'tcx>(cx: &ctxt<'tcx>, ty: Ty<'tcx>, op: ast::BinOp) -> bool { #![allow(non_upper_case_globals)] - static tycat_other: int = 0; - static tycat_bool: int = 1; - static tycat_char: int = 2; - static tycat_int: int = 3; - static tycat_float: int = 4; - static tycat_raw_ptr: int = 6; - - static opcat_add: int = 0; - static opcat_sub: int = 1; - static opcat_mult: int = 2; - static opcat_shift: int = 3; - static opcat_rel: int = 4; - static opcat_eq: int = 5; - static opcat_bit: int = 6; - static opcat_logic: int = 7; - static opcat_mod: int = 8; + const tycat_other: int = 0; + const tycat_bool: int = 1; + const tycat_char: int = 2; + const tycat_int: int = 3; + const tycat_float: int = 4; + const tycat_raw_ptr: int = 6; + + const opcat_add: int = 0; + const opcat_sub: int = 1; + const opcat_mult: int = 2; + const opcat_shift: int = 3; + const opcat_rel: int = 4; + const opcat_eq: int = 5; + const opcat_bit: int = 6; + const opcat_logic: int = 7; + const opcat_mod: int = 8; fn opcat(op: ast::BinOp) -> int { match op.node { @@ -5807,8 +5817,8 @@ pub fn is_binopable<'tcx>(cx: &ctxt<'tcx>, ty: Ty<'tcx>, op: ast::BinOp) -> bool } } - static t: bool = true; - static f: bool = false; + const t: bool = true; + const f: bool = false; let tbl = [ // +, -, *, shift, rel, ==, bit, logic, mod diff --git a/src/librustc/session/config.rs b/src/librustc/session/config.rs index efcde8b2fa1..536caece21f 100644 --- a/src/librustc/session/config.rs +++ b/src/librustc/session/config.rs @@ -259,7 +259,6 @@ pub enum CrateType { CrateTypeStaticlib, } - #[derive(Clone)] pub enum Passes { SomePasses(Vec<String>), @@ -349,7 +348,8 @@ macro_rules! options { #[allow(non_upper_case_globals, dead_code)] mod $mod_desc { pub const parse_bool: Option<&'static str> = None; - pub const parse_opt_bool: Option<&'static str> = None; + pub const parse_opt_bool: Option<&'static str> = + Some("one of: `y`, `yes`, `on`, `n`, `no`, or `off`"); pub const parse_string: Option<&'static str> = Some("a string"); pub const parse_opt_string: Option<&'static str> = Some("a string"); pub const parse_list: Option<&'static str> = Some("a space-separated list of strings"); @@ -380,7 +380,19 @@ macro_rules! options { fn parse_opt_bool(slot: &mut Option<bool>, v: Option<&str>) -> bool { match v { - Some(..) => false, + Some(s) => { + match s { + "n" | "no" | "off" => { + *slot = Some(false); + } + "y" | "yes" | "on" => { + *slot = Some(true); + } + _ => { return false; } + } + + true + }, None => { *slot = Some(true); true } } } @@ -585,6 +597,8 @@ options! {DebuggingOptions, DebuggingSetter, basic_debugging_options, "Adds unstable command line options to rustc interface"), print_enum_sizes: bool = (false, parse_bool, "Print the size of enums and their variants"), + force_overflow_checks: Option<bool> = (None, parse_opt_bool, + "Force overflow checks on or off"), } pub fn default_lib_output() -> CrateType { diff --git a/src/librustc/util/nodemap.rs b/src/librustc/util/nodemap.rs index b15da7dab3e..0f69aa941a3 100644 --- a/src/librustc/util/nodemap.rs +++ b/src/librustc/util/nodemap.rs @@ -57,7 +57,7 @@ impl Hasher for FnvHasher { let FnvHasher(mut hash) = *self; for byte in bytes { hash = hash ^ (*byte as u64); - hash = hash * 0x100000001b3; + hash = hash.wrapping_mul(0x100000001b3); } *self = FnvHasher(hash); } diff --git a/src/librustc_back/archive.rs b/src/librustc_back/archive.rs index 3fcae6a8034..97b1a8aaaba 100644 --- a/src/librustc_back/archive.rs +++ b/src/librustc_back/archive.rs @@ -18,7 +18,7 @@ use std::os; use std::str; use syntax::diagnostic::Handler as ErrorHandler; -pub static METADATA_FILENAME: &'static str = "rust.metadata.bin"; +pub const METADATA_FILENAME: &'static str = "rust.metadata.bin"; pub struct ArchiveConfig<'a> { pub handler: &'a ErrorHandler, @@ -242,7 +242,7 @@ impl<'a> ArchiveBuilder<'a> { // Don't allow the total size of `args` to grow beyond 32,000 bytes. // Windows will raise an error if the argument string is longer than // 32,768, and we leave a bit of extra space for the program name. - static ARG_LENGTH_LIMIT: uint = 32000; + const ARG_LENGTH_LIMIT: uint = 32_000; for member_name in &self.members { let len = member_name.as_vec().len(); diff --git a/src/librustc_back/fs.rs b/src/librustc_back/fs.rs index 99a1df95a80..56d71820176 100644 --- a/src/librustc_back/fs.rs +++ b/src/librustc_back/fs.rs @@ -15,7 +15,7 @@ use std::os; /// Returns an absolute path in the filesystem that `path` points to. The /// returned path does not contain any symlinks in its hierarchy. pub fn realpath(original: &Path) -> old_io::IoResult<Path> { - static MAX_LINKS_FOLLOWED: uint = 256; + const MAX_LINKS_FOLLOWED: uint = 256; let original = try!(os::getcwd()).join(original); // Right now lstat on windows doesn't work quite well diff --git a/src/librustc_back/sha2.rs b/src/librustc_back/sha2.rs index 6654a46f7c3..8acb6851f11 100644 --- a/src/librustc_back/sha2.rs +++ b/src/librustc_back/sha2.rs @@ -347,17 +347,19 @@ impl Engine256State { // Sha-512 and Sha-256 use basically the same calculations which are implemented // by these macros. Inlining the calculations seems to result in better generated code. macro_rules! schedule_round { ($t:expr) => ( - w[$t] = sigma1(w[$t - 2]) + w[$t - 7] + sigma0(w[$t - 15]) + w[$t - 16]; - ) + w[$t] = sigma1(w[$t - 2]).wrapping_add(w[$t - 7]) + .wrapping_add(sigma0(w[$t - 15])).wrapping_add(w[$t - 16]); + ) } macro_rules! sha2_round { ($A:ident, $B:ident, $C:ident, $D:ident, $E:ident, $F:ident, $G:ident, $H:ident, $K:ident, $t:expr) => ( { - $H += sum1($E) + ch($E, $F, $G) + $K[$t] + w[$t]; - $D += $H; - $H += sum0($A) + maj($A, $B, $C); + $H = $H.wrapping_add(sum1($E)).wrapping_add(ch($E, $F, $G)) + .wrapping_add($K[$t]).wrapping_add(w[$t]); + $D = $D.wrapping_add($H); + $H = $H.wrapping_add(sum0($A)).wrapping_add(maj($A, $B, $C)); } ) } @@ -397,14 +399,14 @@ impl Engine256State { sha2_round!(b, c, d, e, f, g, h, a, K32, t + 7); } - self.h0 += a; - self.h1 += b; - self.h2 += c; - self.h3 += d; - self.h4 += e; - self.h5 += f; - self.h6 += g; - self.h7 += h; + self.h0 = self.h0.wrapping_add(a); + self.h1 = self.h1.wrapping_add(b); + self.h2 = self.h2.wrapping_add(c); + self.h3 = self.h3.wrapping_add(d); + self.h4 = self.h4.wrapping_add(e); + self.h5 = self.h5.wrapping_add(f); + self.h6 = self.h6.wrapping_add(g); + self.h7 = self.h7.wrapping_add(h); } } diff --git a/src/librustc_borrowck/borrowck/mod.rs b/src/librustc_borrowck/borrowck/mod.rs index 67462ab0100..f6df2acce59 100644 --- a/src/librustc_borrowck/borrowck/mod.rs +++ b/src/librustc_borrowck/borrowck/mod.rs @@ -312,7 +312,7 @@ impl<'tcx> LoanPath<'tcx> { // FIXME (pnkfelix): See discussion here // https://github.com/pnkfelix/rust/commit/ // b2b39e8700e37ad32b486b9a8409b50a8a53aa51#commitcomment-7892003 -static DOWNCAST_PRINTED_OPERATOR : &'static str = " as "; +const DOWNCAST_PRINTED_OPERATOR: &'static str = " as "; // A local, "cleaned" version of `mc::InteriorKind` that drops // information that is not relevant to loan-path analysis. (In diff --git a/src/librustc_borrowck/borrowck/move_data.rs b/src/librustc_borrowck/borrowck/move_data.rs index 0f7f8e61e37..8846f70fbd3 100644 --- a/src/librustc_borrowck/borrowck/move_data.rs +++ b/src/librustc_borrowck/borrowck/move_data.rs @@ -91,8 +91,7 @@ impl Clone for MovePathIndex { } #[allow(non_upper_case_globals)] -static InvalidMovePathIndex: MovePathIndex = - MovePathIndex(usize::MAX); +const InvalidMovePathIndex: MovePathIndex = MovePathIndex(usize::MAX); /// Index into `MoveData.moves`, used like a pointer #[derive(Copy, PartialEq)] @@ -105,8 +104,7 @@ impl MoveIndex { } #[allow(non_upper_case_globals)] -static InvalidMoveIndex: MoveIndex = - MoveIndex(usize::MAX); +const InvalidMoveIndex: MoveIndex = MoveIndex(usize::MAX); pub struct MovePath<'tcx> { /// Loan path corresponding to this move path diff --git a/src/librustc_driver/lib.rs b/src/librustc_driver/lib.rs index d08fb2b313e..15fae351ddb 100644 --- a/src/librustc_driver/lib.rs +++ b/src/librustc_driver/lib.rs @@ -93,7 +93,7 @@ pub mod driver; pub mod pretty; -static BUG_REPORT_URL: &'static str = +const BUG_REPORT_URL: &'static str = "https://github.com/rust-lang/rust/blob/master/CONTRIBUTING.md#bug-reports"; @@ -770,7 +770,7 @@ fn parse_crate_attrs(sess: &Session, input: &Input) -> /// The diagnostic emitter yielded to the procedure should be used for reporting /// errors of the compiler. pub fn monitor<F:FnOnce()+Send+'static>(f: F) { - static STACK_SIZE: uint = 8 * 1024 * 1024; // 8MB + const STACK_SIZE: uint = 8 * 1024 * 1024; // 8MB let (tx, rx) = channel(); let w = old_io::ChanWriter::new(tx); diff --git a/src/librustc_driver/test.rs b/src/librustc_driver/test.rs index cdbee9da334..23f07c8e25c 100644 --- a/src/librustc_driver/test.rs +++ b/src/librustc_driver/test.rs @@ -44,7 +44,7 @@ struct RH<'a> { sub: &'a [RH<'a>] } -static EMPTY_SOURCE_STR: &'static str = "#![feature(no_std)] #![no_std]"; +const EMPTY_SOURCE_STR: &'static str = "#![feature(no_std)] #![no_std]"; struct ExpectErrorEmitter { messages: Vec<String> diff --git a/src/librustc_lint/builtin.rs b/src/librustc_lint/builtin.rs index fe047d2334e..22311a71583 100644 --- a/src/librustc_lint/builtin.rs +++ b/src/librustc_lint/builtin.rs @@ -571,7 +571,7 @@ struct RawPtrDeriveVisitor<'a, 'tcx: 'a> { impl<'a, 'tcx, 'v> Visitor<'v> for RawPtrDeriveVisitor<'a, 'tcx> { fn visit_ty(&mut self, ty: &ast::Ty) { - static MSG: &'static str = "use of `#[derive]` with a raw pointer"; + const MSG: &'static str = "use of `#[derive]` with a raw pointer"; if let ast::TyPtr(..) = ty.node { self.cx.span_lint(RAW_POINTER_DERIVE, ty.span, MSG); } diff --git a/src/librustc_privacy/lib.rs b/src/librustc_privacy/lib.rs index 46729988bb6..ab3b56c31b6 100644 --- a/src/librustc_privacy/lib.rs +++ b/src/librustc_privacy/lib.rs @@ -1376,10 +1376,11 @@ impl<'a, 'tcx, 'v> Visitor<'v> for VisiblePrivateTypesVisitor<'a, 'tcx> { } } Some(ref tr) => { - // Any private types in a trait impl fall into two + // Any private types in a trait impl fall into three // categories. // 1. mentioned in the trait definition // 2. mentioned in the type params/generics + // 3. mentioned in the associated types of the impl // // Those in 1. can only occur if the trait is in // this crate and will've been warned about on the @@ -1389,6 +1390,16 @@ impl<'a, 'tcx, 'v> Visitor<'v> for VisiblePrivateTypesVisitor<'a, 'tcx> { // Those in 2. are warned via walk_generics and this // call here. visit::walk_path(self, &tr.path); + + // Those in 3. are warned with this call. + for impl_item in impl_items { + match *impl_item { + ast::MethodImplItem(..) => {}, + ast::TypeImplItem(ref typedef) => { + self.visit_ty(&typedef.typ); + } + } + } } } } else if trait_ref.is_none() && self_is_public_path { diff --git a/src/librustc_trans/back/link.rs b/src/librustc_trans/back/link.rs index ea5001aa814..7b377ac3611 100644 --- a/src/librustc_trans/back/link.rs +++ b/src/librustc_trans/back/link.rs @@ -317,7 +317,7 @@ pub fn mangle_exported_name<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, path: PathEl // e.g. `fn foo() { { fn a() {} } { fn a() {} } }`, so we // generate unique characters from the node id. For now // hopefully 3 characters is enough to avoid collisions. - static EXTRA_CHARS: &'static str = + const EXTRA_CHARS: &'static str = "abcdefghijklmnopqrstuvwxyz\ ABCDEFGHIJKLMNOPQRSTUVWXYZ\ 0123456789"; diff --git a/src/librustc_trans/trans/adt.rs b/src/librustc_trans/trans/adt.rs index 2fb0488cd70..61214f65c87 100644 --- a/src/librustc_trans/trans/adt.rs +++ b/src/librustc_trans/trans/adt.rs @@ -487,12 +487,12 @@ fn range_to_inttype(cx: &CrateContext, hint: Hint, bounds: &IntBounds) -> IntTyp debug!("range_to_inttype: {:?} {:?}", hint, bounds); // Lists of sizes to try. u64 is always allowed as a fallback. #[allow(non_upper_case_globals)] - static choose_shortest: &'static[IntType] = &[ + const 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_upper_case_globals)] - static at_least_32: &'static[IntType] = &[ + const at_least_32: &'static [IntType] = &[ attr::UnsignedInt(ast::TyU32), attr::SignedInt(ast::TyI32)]; let attempts; @@ -778,7 +778,9 @@ fn load_discr(bcx: Block, ity: IntType, ptr: ValueRef, min: Disr, max: Disr) assert!(bits <= 64); let bits = bits as uint; let mask = (-1u64 >> (64 - bits)) as Disr; - if (max + 1) & mask == min & mask { + // For a (max) discr of -1, max will be `-1 as usize`, which overflows. + // However, that is fine here (it would still represent the full range), + if (max.wrapping_add(1)) & mask == min & mask { // i.e., if the range is everything. The lo==hi case would be // rejected by the LLVM verifier (it would mean either an // empty set, which is impossible, or the entire range of the @@ -787,7 +789,7 @@ fn load_discr(bcx: Block, ity: IntType, ptr: ValueRef, min: Disr, max: Disr) } else { // llvm::ConstantRange can deal with ranges that wrap around, // so an overflow on (max + 1) is fine. - LoadRangeAssert(bcx, ptr, min, (max+1), /* signed: */ True) + LoadRangeAssert(bcx, ptr, min, (max.wrapping_add(1)), /* signed: */ True) } } @@ -1000,7 +1002,7 @@ pub fn trans_drop_flag_ptr<'blk, 'tcx>(mut bcx: Block<'blk, 'tcx>, r: &Repr<'tcx let fcx = bcx.fcx; let custom_cleanup_scope = fcx.push_custom_cleanup_scope(); let scratch = unpack_datum!(bcx, datum::lvalue_scratch_datum( - bcx, tcx.types.bool, "drop_flag", false, + bcx, tcx.types.bool, "drop_flag", cleanup::CustomScope(custom_cleanup_scope), (), |_, bcx, _| bcx )); bcx = fold_variants(bcx, r, val, |variant_cx, st, value| { diff --git a/src/librustc_trans/trans/base.rs b/src/librustc_trans/trans/base.rs index 7a6960d3790..2c92f11c4e7 100644 --- a/src/librustc_trans/trans/base.rs +++ b/src/librustc_trans/trans/base.rs @@ -1203,21 +1203,6 @@ pub fn alloca_no_lifetime(cx: Block, ty: Type, name: &str) -> ValueRef { Alloca(cx, ty, name) } -pub fn alloca_zeroed<'blk, 'tcx>(cx: Block<'blk, 'tcx>, ty: Ty<'tcx>, - name: &str) -> ValueRef { - let llty = type_of::type_of(cx.ccx(), ty); - if cx.unreachable.get() { - unsafe { - return llvm::LLVMGetUndef(llty.ptr_to().to_ref()); - } - } - let p = alloca_no_lifetime(cx, llty, name); - let b = cx.fcx.ccx.builder(); - b.position_before(cx.fcx.alloca_insert_pt.get().unwrap()); - memzero(&b, p, ty); - p -} - // Creates the alloca slot which holds the pointer to the slot for the final return value pub fn make_return_slot_pointer<'a, 'tcx>(fcx: &FunctionContext<'a, 'tcx>, output_type: Ty<'tcx>) -> ValueRef { @@ -1547,7 +1532,6 @@ fn create_datums_for_fn_args_under_call_abi<'blk, 'tcx>( datum::lvalue_scratch_datum(bcx, arg_ty, "tupled_args", - false, tuple_args_scope_id, (), |(), @@ -3102,6 +3086,12 @@ pub fn trans_crate<'tcx>(analysis: ty::CrateAnalysis<'tcx>) let ty::CrateAnalysis { ty_cx: tcx, export_map, reachable, name, .. } = analysis; let krate = tcx.map.krate(); + let check_overflow = if let Some(v) = tcx.sess.opts.debugging_opts.force_overflow_checks { + v + } else { + !attr::contains_name(&krate.config, "ndebug") + }; + // Before we touch LLVM, make sure that multithreading is enabled. unsafe { use std::sync::{Once, ONCE_INIT}; @@ -3129,7 +3119,8 @@ pub fn trans_crate<'tcx>(analysis: ty::CrateAnalysis<'tcx>) export_map, Sha256::new(), link_meta.clone(), - reachable); + reachable, + check_overflow); { let ccx = shared_ccx.get_ccx(0); diff --git a/src/librustc_trans/trans/consts.rs b/src/librustc_trans/trans/consts.rs index c1d22cc973c..a39f5d42b55 100644 --- a/src/librustc_trans/trans/consts.rs +++ b/src/librustc_trans/trans/consts.rs @@ -462,9 +462,9 @@ fn const_expr_unadjusted<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, ast::ExprIndex(ref base, ref index) => { let (bv, bt) = const_expr(cx, &**base, param_substs); - let iv = match const_eval::eval_const_expr(cx.tcx(), &**index) { - const_eval::const_int(i) => i as u64, - const_eval::const_uint(u) => u, + let iv = match const_eval::eval_const_expr_partial(cx.tcx(), &**index, None) { + Ok(const_eval::const_int(i)) => i as u64, + Ok(const_eval::const_uint(u)) => u, _ => cx.sess().span_bug(index.span, "index is not an integer-constant expression") }; @@ -650,9 +650,9 @@ fn const_expr_unadjusted<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, ast::ExprRepeat(ref elem, ref count) => { let unit_ty = ty::sequence_element_type(cx.tcx(), ety); let llunitty = type_of::type_of(cx, unit_ty); - let n = match const_eval::eval_const_expr(cx.tcx(), &**count) { - const_eval::const_int(i) => i as uint, - const_eval::const_uint(i) => i as uint, + let n = match const_eval::eval_const_expr_partial(cx.tcx(), &**count, None) { + Ok(const_eval::const_int(i)) => i as uint, + Ok(const_eval::const_uint(i)) => i as uint, _ => cx.sess().span_bug(count.span, "count must be integral const expression.") }; let unit_val = const_expr(cx, &**elem, param_substs).0; diff --git a/src/librustc_trans/trans/context.rs b/src/librustc_trans/trans/context.rs index 3586a9dda20..9777398bddc 100644 --- a/src/librustc_trans/trans/context.rs +++ b/src/librustc_trans/trans/context.rs @@ -69,6 +69,7 @@ pub struct SharedCrateContext<'tcx> { symbol_hasher: RefCell<Sha256>, tcx: ty::ctxt<'tcx>, stats: Stats, + check_overflow: bool, available_monomorphizations: RefCell<FnvHashSet<String>>, available_drop_glues: RefCell<FnvHashMap<Ty<'tcx>, String>>, @@ -245,7 +246,8 @@ impl<'tcx> SharedCrateContext<'tcx> { export_map: ExportMap, symbol_hasher: Sha256, link_meta: LinkMeta, - reachable: NodeSet) + reachable: NodeSet, + check_overflow: bool) -> SharedCrateContext<'tcx> { let (metadata_llcx, metadata_llmod) = unsafe { create_context_and_module(&tcx.sess, "metadata") @@ -274,6 +276,7 @@ impl<'tcx> SharedCrateContext<'tcx> { llvm_insns: RefCell::new(FnvHashMap()), fn_stats: RefCell::new(Vec::new()), }, + check_overflow: check_overflow, available_monomorphizations: RefCell::new(FnvHashSet()), available_drop_glues: RefCell::new(FnvHashMap()), }; @@ -743,6 +746,10 @@ impl<'b, 'tcx> CrateContext<'b, 'tcx> { &format!("the type `{}` is too big for the current architecture", obj.repr(self.tcx()))) } + + pub fn check_overflow(&self) -> bool { + self.shared.check_overflow + } } fn declare_intrinsic(ccx: &CrateContext, key: & &'static str) -> Option<ValueRef> { diff --git a/src/librustc_trans/trans/datum.rs b/src/librustc_trans/trans/datum.rs index 6ca71254868..e181df545e6 100644 --- a/src/librustc_trans/trans/datum.rs +++ b/src/librustc_trans/trans/datum.rs @@ -195,24 +195,18 @@ pub fn immediate_rvalue_bcx<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, /// Allocates temporary space on the stack using alloca() and returns a by-ref Datum pointing to /// it. The memory will be dropped upon exit from `scope`. The callback `populate` should -/// initialize the memory. If `zero` is true, the space will be zeroed when it is allocated; this -/// is not necessary unless `bcx` does not dominate the end of `scope`. +/// initialize the memory. pub fn lvalue_scratch_datum<'blk, 'tcx, A, F>(bcx: Block<'blk, 'tcx>, ty: Ty<'tcx>, name: &str, - zero: bool, scope: cleanup::ScopeId, arg: A, populate: F) -> DatumBlock<'blk, 'tcx, Lvalue> where F: FnOnce(A, Block<'blk, 'tcx>, ValueRef) -> Block<'blk, 'tcx>, { - let scratch = if zero { - alloca_zeroed(bcx, ty, name) - } else { - let llty = type_of::type_of(bcx.ccx(), ty); - alloca(bcx, llty, name) - }; + let llty = type_of::type_of(bcx.ccx(), ty); + let scratch = alloca(bcx, llty, name); // Subtle. Populate the scratch memory *before* scheduling cleanup. let bcx = populate(arg, bcx, scratch); @@ -383,7 +377,7 @@ impl<'tcx> Datum<'tcx, Rvalue> { ByValue => { lvalue_scratch_datum( - bcx, self.ty, name, false, scope, self, + bcx, self.ty, name, scope, self, |this, bcx, llval| this.store_to(bcx, llval)) } } diff --git a/src/librustc_trans/trans/expr.rs b/src/librustc_trans/trans/expr.rs index 27f9b9506a5..60455119d58 100644 --- a/src/librustc_trans/trans/expr.rs +++ b/src/librustc_trans/trans/expr.rs @@ -82,6 +82,7 @@ use trans::machine::{llsize_of, llsize_of_alloc}; use trans::type_::Type; use syntax::{ast, ast_util, codemap}; +use syntax::parse::token::InternedString; use syntax::ptr::P; use syntax::parse::token; use std::iter::repeat; @@ -1709,8 +1710,8 @@ fn trans_eager_binop<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, }; let is_float = ty::type_is_fp(intype); let is_signed = ty::type_is_signed(intype); - let rhs = base::cast_shift_expr_rhs(bcx, op, lhs, rhs); + let info = expr_info(binop_expr); let binop_debug_loc = binop_expr.debug_loc(); @@ -1720,21 +1721,30 @@ fn trans_eager_binop<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, if is_float { FAdd(bcx, lhs, rhs, binop_debug_loc) } else { - Add(bcx, lhs, rhs, binop_debug_loc) + let (newbcx, res) = with_overflow_check( + bcx, OverflowOp::Add, info, lhs_t, lhs, rhs, binop_debug_loc); + bcx = newbcx; + res } } ast::BiSub => { if is_float { FSub(bcx, lhs, rhs, binop_debug_loc) } else { - Sub(bcx, lhs, rhs, binop_debug_loc) + let (newbcx, res) = with_overflow_check( + bcx, OverflowOp::Sub, info, lhs_t, lhs, rhs, binop_debug_loc); + bcx = newbcx; + res } } ast::BiMul => { if is_float { FMul(bcx, lhs, rhs, binop_debug_loc) } else { - Mul(bcx, lhs, rhs, binop_debug_loc) + let (newbcx, res) = with_overflow_check( + bcx, OverflowOp::Mul, info, lhs_t, lhs, rhs, binop_debug_loc); + bcx = newbcx; + res } } ast::BiDiv => { @@ -2314,3 +2324,110 @@ fn deref_once<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, DatumBlock { bcx: bcx, datum: datum } } } + +enum OverflowOp { + Add, + Sub, + Mul, +} + +impl OverflowOp { + fn to_intrinsic_name(&self, tcx: &ty::ctxt, ty: Ty) -> &'static str { + use syntax::ast::IntTy::*; + use syntax::ast::UintTy::*; + use middle::ty::{ty_int, ty_uint}; + + let new_sty = match ty.sty { + ty_int(TyIs(_)) => match &tcx.sess.target.target.target_pointer_width[..] { + "32" => ty_int(TyI32), + "64" => ty_int(TyI64), + _ => panic!("unsupported target word size") + }, + ty_uint(TyUs(_)) => match &tcx.sess.target.target.target_pointer_width[..] { + "32" => ty_uint(TyU32), + "64" => ty_uint(TyU64), + _ => panic!("unsupported target word size") + }, + ref t @ ty_uint(_) | ref t @ ty_int(_) => t.clone(), + _ => panic!("tried to get overflow intrinsic for non-int type") + }; + + match *self { + OverflowOp::Add => match new_sty { + ty_int(TyI8) => "llvm.sadd.with.overflow.i8", + ty_int(TyI16) => "llvm.sadd.with.overflow.i16", + ty_int(TyI32) => "llvm.sadd.with.overflow.i32", + ty_int(TyI64) => "llvm.sadd.with.overflow.i64", + + ty_uint(TyU8) => "llvm.uadd.with.overflow.i8", + ty_uint(TyU16) => "llvm.uadd.with.overflow.i16", + ty_uint(TyU32) => "llvm.uadd.with.overflow.i32", + ty_uint(TyU64) => "llvm.uadd.with.overflow.i64", + + _ => unreachable!(), + }, + OverflowOp::Sub => match new_sty { + ty_int(TyI8) => "llvm.ssub.with.overflow.i8", + ty_int(TyI16) => "llvm.ssub.with.overflow.i16", + ty_int(TyI32) => "llvm.ssub.with.overflow.i32", + ty_int(TyI64) => "llvm.ssub.with.overflow.i64", + + ty_uint(TyU8) => "llvm.usub.with.overflow.i8", + ty_uint(TyU16) => "llvm.usub.with.overflow.i16", + ty_uint(TyU32) => "llvm.usub.with.overflow.i32", + ty_uint(TyU64) => "llvm.usub.with.overflow.i64", + + _ => unreachable!(), + }, + OverflowOp::Mul => match new_sty { + ty_int(TyI8) => "llvm.smul.with.overflow.i8", + ty_int(TyI16) => "llvm.smul.with.overflow.i16", + ty_int(TyI32) => "llvm.smul.with.overflow.i32", + ty_int(TyI64) => "llvm.smul.with.overflow.i64", + + ty_uint(TyU8) => "llvm.umul.with.overflow.i8", + ty_uint(TyU16) => "llvm.umul.with.overflow.i16", + ty_uint(TyU32) => "llvm.umul.with.overflow.i32", + ty_uint(TyU64) => "llvm.umul.with.overflow.i64", + + _ => unreachable!(), + }, + } + } +} + + +fn with_overflow_check<'a, 'b>(bcx: Block<'a, 'b>, oop: OverflowOp, info: NodeIdAndSpan, + lhs_t: Ty, lhs: ValueRef, rhs: ValueRef, binop_debug_loc: DebugLoc) + -> (Block<'a, 'b>, ValueRef) { + if bcx.unreachable.get() { return (bcx, _Undef(lhs)); } + if bcx.ccx().check_overflow() { + let name = oop.to_intrinsic_name(bcx.tcx(), lhs_t); + let llfn = bcx.ccx().get_intrinsic(&name); + + let val = Call(bcx, llfn, &[lhs, rhs], None, binop_debug_loc); + let result = ExtractValue(bcx, val, 0); // iN operation result + let overflow = ExtractValue(bcx, val, 1); // i1 "did it overflow?" + + let cond = ICmp(bcx, llvm::IntEQ, overflow, C_integral(Type::i1(bcx.ccx()), 1, false), + binop_debug_loc); + + let expect = bcx.ccx().get_intrinsic(&"llvm.expect.i1"); + Call(bcx, expect, &[cond, C_integral(Type::i1(bcx.ccx()), 0, false)], + None, binop_debug_loc); + + let bcx = + base::with_cond(bcx, cond, |bcx| + controlflow::trans_fail(bcx, info, + InternedString::new("arithmetic operation overflowed"))); + + (bcx, result) + } else { + let res = match oop { + OverflowOp::Add => Add(bcx, lhs, rhs, binop_debug_loc), + OverflowOp::Sub => Sub(bcx, lhs, rhs, binop_debug_loc), + OverflowOp::Mul => Mul(bcx, lhs, rhs, binop_debug_loc), + }; + (bcx, res) + } +} diff --git a/src/librustc_trans/trans/intrinsic.rs b/src/librustc_trans/trans/intrinsic.rs index 54644c92869..916492195c2 100644 --- a/src/librustc_trans/trans/intrinsic.rs +++ b/src/librustc_trans/trans/intrinsic.rs @@ -660,6 +660,11 @@ pub fn trans_intrinsic_call<'a, 'blk, 'tcx>(mut bcx: Block<'blk, 'tcx>, llargs[0], llargs[1], call_debug_location), + + (_, "overflowing_add") => Add(bcx, llargs[0], llargs[1], call_debug_location), + (_, "overflowing_sub") => Sub(bcx, llargs[0], llargs[1], call_debug_location), + (_, "overflowing_mul") => Mul(bcx, llargs[0], llargs[1], call_debug_location), + (_, "return_address") => { if !fcx.caller_expects_out_pointer { tcx.sess.span_err(call_info.span, diff --git a/src/librustc_trans/trans/meth.rs b/src/librustc_trans/trans/meth.rs index 67f1c39c6e0..c07de3a87ec 100644 --- a/src/librustc_trans/trans/meth.rs +++ b/src/librustc_trans/trans/meth.rs @@ -45,7 +45,7 @@ use syntax::ast_util::PostExpansionMethod; use syntax::codemap::DUMMY_SP; // drop_glue pointer, size, align. -static VTABLE_OFFSET: uint = 3; +const VTABLE_OFFSET: uint = 3; /// The main "translation" pass for methods. Generates code /// for non-monomorphized methods only. Other methods will diff --git a/src/librustc_typeck/astconv.rs b/src/librustc_typeck/astconv.rs index d9dc050aebf..1e7b90d5a18 100644 --- a/src/librustc_typeck/astconv.rs +++ b/src/librustc_typeck/astconv.rs @@ -205,9 +205,9 @@ pub fn opt_ast_region_to_region<'tcx>( if len == 2 && i == 0 { m.push_str(" or "); - } else if i == len - 2 { + } else if i + 2 == len { m.push_str(", or "); - } else if i != len - 1 { + } else if i + 1 != len { m.push_str(", "); } } @@ -1233,17 +1233,18 @@ pub fn finish_resolving_def_to_ty<'tcx>(this: &AstConv<'tcx>, if segments.is_empty() { opt_self_ty.expect("missing T in <T>::a::b::c") } else { - tcx.sess.span_bug(span, - &format!("found module name used as a type: {}", - tcx.map.node_to_string(id.node))); + span_err!(tcx.sess, span, E0247, "found module name used as a type: {}", + tcx.map.node_to_string(id.node)); + return this.tcx().types.err; } } def::DefPrimTy(prim_ty) => { prim_ty_to_ty(tcx, segments, prim_ty) } _ => { - span_fatal!(tcx.sess, span, E0248, - "found value name used as a type: {:?}", *def); + span_err!(tcx.sess, span, E0248, + "found value name used as a type: {:?}", *def); + return this.tcx().types.err; } }; @@ -1278,10 +1279,11 @@ pub fn ast_ty_to_ty<'tcx>(this: &AstConv<'tcx>, match ast_ty_to_ty_cache.get(&ast_ty.id) { Some(&ty::atttce_resolved(ty)) => return ty, Some(&ty::atttce_unresolved) => { - span_fatal!(tcx.sess, ast_ty.span, E0246, + span_err!(tcx.sess, ast_ty.span, E0246, "illegal recursive type; insert an enum \ or struct in the cycle, if this is \ desired"); + return this.tcx().types.err; } None => { /* go on */ } } @@ -1388,14 +1390,22 @@ pub fn ast_ty_to_ty<'tcx>(this: &AstConv<'tcx>, ty::mk_vec(tcx, ast_ty_to_ty(this, rscope, &**ty), Some(i as uint)), _ => { - span_fatal!(tcx.sess, ast_ty.span, E0249, - "expected constant expr for array length"); + span_err!(tcx.sess, ast_ty.span, E0249, + "expected constant expr for array length"); + this.tcx().types.err } } } - Err(r) => { - span_fatal!(tcx.sess, ast_ty.span, E0250, - "expected constant expr for array length: {}", r); + Err(ref r) => { + let subspan = + ast_ty.span.lo <= r.span.lo && r.span.hi <= ast_ty.span.hi; + span_err!(tcx.sess, r.span, E0250, + "array length constant evaluation error: {}", + r.description().as_slice()); + if !subspan { + span_note!(tcx.sess, ast_ty.span, "for array length here") + } + this.tcx().types.err } } } diff --git a/src/librustc_typeck/check/mod.rs b/src/librustc_typeck/check/mod.rs index fd6ba79ec21..a12ff04912c 100644 --- a/src/librustc_typeck/check/mod.rs +++ b/src/librustc_typeck/check/mod.rs @@ -1363,10 +1363,10 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { match self.inh.locals.borrow().get(&nid) { Some(&t) => t, None => { - self.tcx().sess.span_bug( + self.tcx().sess.span_err( span, - &format!("no type for local variable {}", - nid)); + &format!("no type for local variable {}", nid)); + self.tcx().types.err } } } @@ -4554,6 +4554,7 @@ pub fn check_enum_variants<'a,'tcx>(ccx: &CrateCtxt<'a,'tcx>, id: ast::NodeId, hint: attr::ReprAttr) -> Vec<Rc<ty::VariantInfo<'tcx>>> { + use std::num::Int; let rty = ty::node_id_to_type(ccx.tcx, id); let mut variants: Vec<Rc<ty::VariantInfo>> = Vec::new(); @@ -4565,7 +4566,13 @@ pub fn check_enum_variants<'a,'tcx>(ccx: &CrateCtxt<'a,'tcx>, // If the discriminant value is specified explicitly in the enum check whether the // initialization expression is valid, otherwise use the last value plus one. let mut current_disr_val = match prev_disr_val { - Some(prev_disr_val) => prev_disr_val + 1, + Some(prev_disr_val) => { + if let Some(v) = prev_disr_val.checked_add(1) { + v + } else { + ty::INITIAL_DISCRIMINANT_VALUE + } + } None => ty::INITIAL_DISCRIMINANT_VALUE }; @@ -4597,8 +4604,9 @@ pub fn check_enum_variants<'a,'tcx>(ccx: &CrateCtxt<'a,'tcx>, "expected signed integer constant"); } Err(ref err) => { - span_err!(ccx.tcx.sess, e.span, E0080, - "expected constant: {}", *err); + span_err!(ccx.tcx.sess, err.span, E0080, + "constant evaluation error: {}", + err.description().as_slice()); } } }, @@ -5491,6 +5499,9 @@ pub fn check_intrinsic_type(ccx: &CrateCtxt, it: &ast::ForeignItem) { (0, vec!(tcx.types.u64, tcx.types.u64), ty::mk_tup(tcx, vec!(tcx.types.u64, tcx.types.bool))), + "overflowing_add" | "overflowing_sub" | "overflowing_mul" => + (1, vec![param(ccx, 0), param(ccx, 0)], param(ccx, 0)), + "return_address" => (0, vec![], ty::mk_imm_ptr(tcx, tcx.types.u8)), "assume" => (0, vec![tcx.types.bool], ty::mk_nil(tcx)), diff --git a/src/librustdoc/flock.rs b/src/librustdoc/flock.rs index 6b2676eca3d..79e348cb03e 100644 --- a/src/librustdoc/flock.rs +++ b/src/librustdoc/flock.rs @@ -167,7 +167,7 @@ mod imp { use std::os; use std::ptr; - static LOCKFILE_EXCLUSIVE_LOCK: libc::DWORD = 0x00000002; + const LOCKFILE_EXCLUSIVE_LOCK: libc::DWORD = 0x00000002; #[allow(non_snake_case)] extern "system" { diff --git a/src/librustdoc/lib.rs b/src/librustdoc/lib.rs index e58239a82c6..fc304884ec9 100644 --- a/src/librustdoc/lib.rs +++ b/src/librustdoc/lib.rs @@ -94,7 +94,7 @@ type Pass = (&'static str, // name fn(clean::Crate) -> plugins::PluginResult, // fn &'static str); // description -static PASSES: &'static [Pass] = &[ +const PASSES: &'static [Pass] = &[ ("strip-hidden", passes::strip_hidden, "strips all doc(hidden) items from the output"), ("unindent-comments", passes::unindent_comments, @@ -105,7 +105,7 @@ static PASSES: &'static [Pass] = &[ "strips all private items from a crate which cannot be seen externally"), ]; -static DEFAULT_PASSES: &'static [&'static str] = &[ +const DEFAULT_PASSES: &'static [&'static str] = &[ "strip-hidden", "strip-private", "collapse-docs", diff --git a/src/libserialize/hex.rs b/src/libserialize/hex.rs index a3cc2d6b935..970ae06763c 100644 --- a/src/libserialize/hex.rs +++ b/src/libserialize/hex.rs @@ -24,7 +24,7 @@ pub trait ToHex { fn to_hex(&self) -> String; } -static CHARS: &'static[u8] = b"0123456789abcdef"; +const CHARS: &'static [u8] = b"0123456789abcdef"; impl ToHex for [u8] { /// Turn a vector of `u8` bytes into a hexadecimal string. diff --git a/src/libserialize/json.rs b/src/libserialize/json.rs index 14930f91c91..bf4d006fcfa 100644 --- a/src/libserialize/json.rs +++ b/src/libserialize/json.rs @@ -1569,8 +1569,8 @@ impl<T: Iterator<Item=char>> Parser<T> { while !self.eof() { match self.ch_or_null() { c @ '0' ... '9' => { - accum *= 10; - accum += (c as u64) - ('0' as u64); + accum = accum.wrapping_mul(10); + accum = accum.wrapping_add((c as u64) - ('0' as u64)); // Detect overflow by comparing to the last value. if accum <= last_accum { return self.error(InvalidNumber); } diff --git a/src/libstd/collections/hash/map.rs b/src/libstd/collections/hash/map.rs index faddbba5059..8eb29a8327a 100644 --- a/src/libstd/collections/hash/map.rs +++ b/src/libstd/collections/hash/map.rs @@ -314,6 +314,13 @@ fn search_hashed<K, V, M, F>(table: M, M: Deref<Target=RawTable<K, V>>, F: FnMut(&K) -> bool, { + // This is the only function where capacity can be zero. To avoid + // undefined behaviour when Bucket::new gets the raw bucket in this + // case, immediately return the appropriate search result. + if table.capacity() == 0 { + return TableRef(table); + } + let size = table.size(); let mut probe = Bucket::new(table, hash); let ib = probe.index(); diff --git a/src/libstd/collections/hash/table.rs b/src/libstd/collections/hash/table.rs index 4c03d8915eb..2670cd0c003 100644 --- a/src/libstd/collections/hash/table.rs +++ b/src/libstd/collections/hash/table.rs @@ -20,6 +20,7 @@ use marker::{Copy, Send, Sync, Sized, self}; use mem::{min_align_of, size_of}; use mem; use num::{Int, UnsignedInt}; +use num::wrapping::{OverflowingOps, WrappingOps}; use ops::{Deref, DerefMut, Drop}; use option::Option; use option::Option::{Some, None}; @@ -224,6 +225,9 @@ impl<K, V, M: Deref<Target=RawTable<K, V>>> Bucket<K, V, M> { } pub fn at_index(table: M, ib_index: usize) -> Bucket<K, V, M> { + // if capacity is 0, then the RawBucket will be populated with bogus pointers. + // This is an uncommon case though, so avoid it in release builds. + debug_assert!(table.capacity() > 0, "Table should have capacity at this point"); let ib_index = ib_index & (table.capacity() - 1); Bucket { raw: unsafe { @@ -371,7 +375,7 @@ impl<K, V, M: Deref<Target=RawTable<K, V>>> FullBucket<K, V, M> { // Calculates the distance one has to travel when going from // `hash mod capacity` onwards to `idx mod capacity`, wrapping around // if the destination is not reached before the end of the table. - (self.idx - self.hash().inspect() as usize) & (self.table.capacity() - 1) + (self.idx.wrapping_sub(self.hash().inspect() as usize)) & (self.table.capacity() - 1) } #[inline] @@ -524,13 +528,13 @@ fn test_rounding() { fn calculate_offsets(hashes_size: usize, keys_size: usize, keys_align: usize, vals_align: usize) - -> (usize, usize) { + -> (usize, usize, bool) { let keys_offset = round_up_to_next(hashes_size, keys_align); - let end_of_keys = keys_offset + keys_size; + let (end_of_keys, oflo) = keys_offset.overflowing_add(keys_size); let vals_offset = round_up_to_next(end_of_keys, vals_align); - (keys_offset, vals_offset) + (keys_offset, vals_offset, oflo) } // Returns a tuple of (minimum required malloc alignment, hash_offset, @@ -538,26 +542,26 @@ fn calculate_offsets(hashes_size: usize, fn calculate_allocation(hash_size: usize, hash_align: usize, keys_size: usize, keys_align: usize, vals_size: usize, vals_align: usize) - -> (usize, usize, usize) { + -> (usize, usize, usize, bool) { let hash_offset = 0; - let (_, vals_offset) = calculate_offsets(hash_size, - keys_size, keys_align, - vals_align); - let end_of_vals = vals_offset + vals_size; + let (_, vals_offset, oflo) = calculate_offsets(hash_size, + keys_size, keys_align, + vals_align); + let (end_of_vals, oflo2) = vals_offset.overflowing_add(vals_size); let min_align = cmp::max(hash_align, cmp::max(keys_align, vals_align)); - (min_align, hash_offset, end_of_vals) + (min_align, hash_offset, end_of_vals, oflo || oflo2) } #[test] fn test_offset_calculation() { - assert_eq!(calculate_allocation(128, 8, 15, 1, 4, 4), (8, 0, 148)); - assert_eq!(calculate_allocation(3, 1, 2, 1, 1, 1), (1, 0, 6)); - assert_eq!(calculate_allocation(6, 2, 12, 4, 24, 8), (8, 0, 48)); - assert_eq!(calculate_offsets(128, 15, 1, 4), (128, 144)); - assert_eq!(calculate_offsets(3, 2, 1, 1), (3, 5)); - assert_eq!(calculate_offsets(6, 12, 4, 8), (8, 24)); + assert_eq!(calculate_allocation(128, 8, 15, 1, 4, 4), (8, 0, 148, false)); + assert_eq!(calculate_allocation(3, 1, 2, 1, 1, 1), (1, 0, 6, false)); + assert_eq!(calculate_allocation(6, 2, 12, 4, 24, 8), (8, 0, 48, false)); + assert_eq!(calculate_offsets(128, 15, 1, 4), (128, 144, false)); + assert_eq!(calculate_offsets(3, 2, 1, 1), (3, 5, false)); + assert_eq!(calculate_offsets(6, 12, 4, 8), (8, 24, false)); } impl<K, V> RawTable<K, V> { @@ -587,12 +591,14 @@ impl<K, V> RawTable<K, V> { // This is great in theory, but in practice getting the alignment // right is a little subtle. Therefore, calculating offsets has been // factored out into a different function. - let (malloc_alignment, hash_offset, size) = + let (malloc_alignment, hash_offset, size, oflo) = calculate_allocation( hashes_size, min_align_of::<u64>(), keys_size, min_align_of::< K >(), vals_size, min_align_of::< V >()); + assert!(!oflo, "capacity overflow"); + // One check for overflow that covers calculation and rounding of size. let size_of_bucket = size_of::<u64>().checked_add(size_of::<K>()).unwrap() .checked_add(size_of::<V>()).unwrap(); @@ -618,10 +624,11 @@ impl<K, V> RawTable<K, V> { let keys_size = self.capacity * size_of::<K>(); let buffer = *self.hashes as *mut u8; - let (keys_offset, vals_offset) = calculate_offsets(hashes_size, - keys_size, min_align_of::<K>(), - min_align_of::<V>()); - + let (keys_offset, vals_offset, oflo) = + calculate_offsets(hashes_size, + keys_size, min_align_of::<K>(), + min_align_of::<V>()); + debug_assert!(!oflo, "capacity overflow"); unsafe { RawBucket { hash: *self.hashes, @@ -995,9 +1002,12 @@ impl<K, V> Drop for RawTable<K, V> { let hashes_size = self.capacity * size_of::<u64>(); let keys_size = self.capacity * size_of::<K>(); let vals_size = self.capacity * size_of::<V>(); - let (align, _, size) = calculate_allocation(hashes_size, min_align_of::<u64>(), - keys_size, min_align_of::<K>(), - vals_size, min_align_of::<V>()); + let (align, _, size, oflo) = + calculate_allocation(hashes_size, min_align_of::<u64>(), + keys_size, min_align_of::<K>(), + vals_size, min_align_of::<V>()); + + debug_assert!(!oflo, "should be impossible"); unsafe { deallocate(*self.hashes as *mut u8, size, align); diff --git a/src/libstd/ffi/os_str.rs b/src/libstd/ffi/os_str.rs index fe0df1728ef..926d8e03f2c 100644 --- a/src/libstd/ffi/os_str.rs +++ b/src/libstd/ffi/os_str.rs @@ -34,10 +34,10 @@ use core::prelude::*; -use borrow::{Borrow, ToOwned}; +use borrow::{Borrow, Cow, ToOwned}; use fmt::{self, Debug}; use mem; -use string::{String, CowString}; +use string::String; use ops; use cmp; use hash::{Hash, Hasher}; @@ -183,10 +183,10 @@ impl OsStr { self.inner.to_str() } - /// Convert an `OsStr` to a `CowString`. + /// Convert an `OsStr` to a `Cow<str>`. /// /// Any non-Unicode sequences are replaced with U+FFFD REPLACEMENT CHARACTER. - pub fn to_string_lossy(&self) -> CowString { + pub fn to_string_lossy(&self) -> Cow<str> { self.inner.to_string_lossy() } diff --git a/src/libstd/lib.rs b/src/libstd/lib.rs index 7957bc35b76..c890af631f0 100644 --- a/src/libstd/lib.rs +++ b/src/libstd/lib.rs @@ -123,6 +123,7 @@ #![feature(unsafe_no_drop_flag)] #![feature(macro_reexport)] #![feature(hash)] +#![feature(int_uint)] #![feature(unique)] #![cfg_attr(test, feature(test, rustc_private, env))] diff --git a/src/libstd/net/tcp.rs b/src/libstd/net/tcp.rs index f99cd2b1d1b..6ce3a939c6a 100644 --- a/src/libstd/net/tcp.rs +++ b/src/libstd/net/tcp.rs @@ -425,7 +425,7 @@ mod tests { #[test] fn multiple_connect_interleaved_lazy_schedule_ip4() { - static MAX: usize = 10; + const MAX: usize = 10; each_ip(&mut |addr| { let acceptor = t!(TcpListener::bind(&addr)); diff --git a/src/libstd/num/mod.rs b/src/libstd/num/mod.rs index d776079efae..0bca60ed1a0 100644 --- a/src/libstd/num/mod.rs +++ b/src/libstd/num/mod.rs @@ -30,6 +30,7 @@ pub use core::num::{from_uint, from_u8, from_u16, from_u32, from_u64}; pub use core::num::{from_f32, from_f64}; pub use core::num::{FromStrRadix, from_str_radix}; pub use core::num::{FpCategory, ParseIntError, ParseFloatError}; +pub use core::num::wrapping; use option::Option; @@ -1757,25 +1758,25 @@ mod tests { let mut u8_val: u8 = 255_u8; assert_eq!(u8_val.to_string(), "255"); - u8_val += 1 as u8; + u8_val = u8_val.wrapping_add(1); assert_eq!(u8_val.to_string(), "0"); let mut u16_val: u16 = 65_535_u16; assert_eq!(u16_val.to_string(), "65535"); - u16_val += 1 as u16; + u16_val = u16_val.wrapping_add(1); assert_eq!(u16_val.to_string(), "0"); let mut u32_val: u32 = 4_294_967_295_u32; assert_eq!(u32_val.to_string(), "4294967295"); - u32_val += 1 as u32; + u32_val = u32_val.wrapping_add(1); assert_eq!(u32_val.to_string(), "0"); let mut u64_val: u64 = 18_446_744_073_709_551_615_u64; assert_eq!(u64_val.to_string(), "18446744073709551615"); - u64_val += 1 as u64; + u64_val = u64_val.wrapping_add(1); assert_eq!(u64_val.to_string(), "0"); } @@ -1789,7 +1790,7 @@ mod tests { assert_eq!(from_str::<u8>("255"), Some(u8_val)); assert_eq!(from_str::<u8>("256"), None); - u8_val += 1 as u8; + u8_val = u8_val.wrapping_add(1); assert_eq!(from_str::<u8>("0"), Some(u8_val)); assert_eq!(from_str::<u8>("-1"), None); @@ -1797,7 +1798,7 @@ mod tests { assert_eq!(from_str::<u16>("65535"), Some(u16_val)); assert_eq!(from_str::<u16>("65536"), None); - u16_val += 1 as u16; + u16_val = u16_val.wrapping_add(1); assert_eq!(from_str::<u16>("0"), Some(u16_val)); assert_eq!(from_str::<u16>("-1"), None); @@ -1805,7 +1806,7 @@ mod tests { assert_eq!(from_str::<u32>("4294967295"), Some(u32_val)); assert_eq!(from_str::<u32>("4294967296"), None); - u32_val += 1 as u32; + u32_val = u32_val.wrapping_add(1); assert_eq!(from_str::<u32>("0"), Some(u32_val)); assert_eq!(from_str::<u32>("-1"), None); @@ -1813,7 +1814,7 @@ mod tests { assert_eq!(from_str::<u64>("18446744073709551615"), Some(u64_val)); assert_eq!(from_str::<u64>("18446744073709551616"), None); - u64_val += 1 as u64; + u64_val = u64_val.wrapping_add(1); assert_eq!(from_str::<u64>("0"), Some(u64_val)); assert_eq!(from_str::<u64>("-1"), None); } diff --git a/src/libstd/num/strconv.rs b/src/libstd/num/strconv.rs index ca2e6ba5d5d..b38c52dad1a 100644 --- a/src/libstd/num/strconv.rs +++ b/src/libstd/num/strconv.rs @@ -422,11 +422,12 @@ pub fn float_to_str_common<T: Float>( // Some constants for from_str_bytes_common's input validation, // they define minimum radix values for which the character is a valid digit. -static DIGIT_P_RADIX: u32 = ('p' as u32) - ('a' as u32) + 11; -static DIGIT_E_RADIX: u32 = ('e' as u32) - ('a' as u32) + 11; +const DIGIT_P_RADIX: u32 = ('p' as u32) - ('a' as u32) + 11; +const DIGIT_E_RADIX: u32 = ('e' as u32) - ('a' as u32) + 11; #[cfg(test)] mod tests { + use core::num::wrapping::WrappingOps; use string::ToString; #[test] @@ -434,25 +435,25 @@ mod tests { let mut i8_val: i8 = 127_i8; assert_eq!(i8_val.to_string(), "127"); - i8_val += 1 as i8; + i8_val = i8_val.wrapping_add(1); assert_eq!(i8_val.to_string(), "-128"); let mut i16_val: i16 = 32_767_i16; assert_eq!(i16_val.to_string(), "32767"); - i16_val += 1 as i16; + i16_val = i16_val.wrapping_add(1); assert_eq!(i16_val.to_string(), "-32768"); let mut i32_val: i32 = 2_147_483_647_i32; assert_eq!(i32_val.to_string(), "2147483647"); - i32_val += 1 as i32; + i32_val = i32_val.wrapping_add(1); assert_eq!(i32_val.to_string(), "-2147483648"); let mut i64_val: i64 = 9_223_372_036_854_775_807_i64; assert_eq!(i64_val.to_string(), "9223372036854775807"); - i64_val += 1 as i64; + i64_val = i64_val.wrapping_add(1); assert_eq!(i64_val.to_string(), "-9223372036854775808"); } } diff --git a/src/libstd/prelude/v1.rs b/src/libstd/prelude/v1.rs index dad0ff0a15e..60e1354482c 100644 --- a/src/libstd/prelude/v1.rs +++ b/src/libstd/prelude/v1.rs @@ -58,3 +58,5 @@ #[doc(no_inline)] pub use old_io::{Buffer, Writer, Reader, Seek, BufferPrelude}; // NB: remove when range syntax lands #[doc(no_inline)] pub use iter::range; + +#[doc(no_inline)] pub use num::wrapping::{Wrapping, WrappingOps}; diff --git a/src/libstd/rand/mod.rs b/src/libstd/rand/mod.rs index 5c891441198..a49db012882 100644 --- a/src/libstd/rand/mod.rs +++ b/src/libstd/rand/mod.rs @@ -321,7 +321,7 @@ impl reseeding::Reseeder<StdRng> for ThreadRngReseeder { } } } -static THREAD_RNG_RESEED_THRESHOLD: usize = 32_768; +const THREAD_RNG_RESEED_THRESHOLD: usize = 32_768; type ThreadRngInner = reseeding::ReseedingRng<StdRng, ThreadRngReseeder>; /// The thread-local RNG. @@ -386,8 +386,8 @@ impl Rng for ThreadRng { /// ``` /// use std::rand; /// -/// let x = rand::random(); -/// println!("{}", 2u8 * x); +/// let x: u8 = rand::random(); +/// println!("{}", 2 * x as u16); /// /// let y = rand::random::<f64>(); /// println!("{}", y); @@ -639,18 +639,17 @@ mod test { } #[cfg(test)] -static RAND_BENCH_N: u64 = 100; - -#[cfg(test)] mod bench { extern crate test; use prelude::v1::*; use self::test::Bencher; - use super::{XorShiftRng, StdRng, IsaacRng, Isaac64Rng, Rng, RAND_BENCH_N}; + use super::{XorShiftRng, StdRng, IsaacRng, Isaac64Rng, Rng}; use super::{OsRng, weak_rng}; use mem::size_of; + const RAND_BENCH_N: u64 = 100; + #[bench] fn rand_xorshift(b: &mut Bencher) { let mut rng: XorShiftRng = OsRng::new().unwrap().gen(); diff --git a/src/libstd/rand/os.rs b/src/libstd/rand/os.rs index 1a13405633d..c2ead267578 100644 --- a/src/libstd/rand/os.rs +++ b/src/libstd/rand/os.rs @@ -281,9 +281,9 @@ mod imp { hcryptprov: HCRYPTPROV } - static PROV_RSA_FULL: DWORD = 1; - static CRYPT_SILENT: DWORD = 64; - static CRYPT_VERIFYCONTEXT: DWORD = 0xF0000000; + const PROV_RSA_FULL: DWORD = 1; + const CRYPT_SILENT: DWORD = 64; + const CRYPT_VERIFYCONTEXT: DWORD = 0xF0000000; #[allow(non_snake_case)] extern "system" { diff --git a/src/libstd/rt/mod.rs b/src/libstd/rt/mod.rs index 42cca73e5e2..fe32a51e81c 100644 --- a/src/libstd/rt/mod.rs +++ b/src/libstd/rt/mod.rs @@ -27,6 +27,7 @@ use marker::Send; use ops::FnOnce; use sys; use thunk::Thunk; +use usize; // Reexport some of our utilities which are expected by other crates. pub use self::util::{default_sched_threads, min_stack, running_on_valgrind}; @@ -78,7 +79,20 @@ fn lang_start(main: *const u8, argc: int, argv: *const *const u8) -> int { // FIXME #11359 we just assume that this thread has a stack of a // certain size, and estimate that there's at most 20KB of stack // frames above our current position. - let my_stack_bottom = my_stack_top + 20000 - OS_DEFAULT_STACK_ESTIMATE; + const TWENTY_KB: uint = 20000; + + // saturating-add to sidestep overflow + let top_plus_spill = if usize::MAX - TWENTY_KB < my_stack_top { + usize::MAX + } else { + my_stack_top + TWENTY_KB + }; + // saturating-sub to sidestep underflow + let my_stack_bottom = if top_plus_spill < OS_DEFAULT_STACK_ESTIMATE { + 0 + } else { + top_plus_spill - OS_DEFAULT_STACK_ESTIMATE + }; let failed = unsafe { // First, make sure we don't trigger any __morestack overflow checks, diff --git a/src/libstd/sync/mpsc/mod.rs b/src/libstd/sync/mpsc/mod.rs index 1310d476f8e..ee8bef50d89 100644 --- a/src/libstd/sync/mpsc/mod.rs +++ b/src/libstd/sync/mpsc/mod.rs @@ -1157,8 +1157,8 @@ mod test { #[test] fn stress_shared() { - static AMT: u32 = 10000; - static NTHREADS: u32 = 8; + const AMT: u32 = 10000; + const NTHREADS: u32 = 8; let (tx, rx) = channel::<i32>(); let t = thread::spawn(move|| { @@ -1663,8 +1663,8 @@ mod sync_tests { #[test] fn stress_shared() { - static AMT: u32 = 1000; - static NTHREADS: u32 = 8; + const AMT: u32 = 1000; + const NTHREADS: u32 = 8; let (tx, rx) = sync_channel::<i32>(0); let (dtx, drx) = sync_channel::<()>(0); diff --git a/src/libstd/sync/mpsc/select.rs b/src/libstd/sync/mpsc/select.rs index 8de5bbc6206..2c14c9fe3f1 100644 --- a/src/libstd/sync/mpsc/select.rs +++ b/src/libstd/sync/mpsc/select.rs @@ -473,7 +473,7 @@ mod test { #[test] fn stress() { - static AMT: i32 = 10000; + const AMT: i32 = 10000; let (tx1, rx1) = channel::<i32>(); let (tx2, rx2) = channel::<i32>(); let (tx3, rx3) = channel::<()>(); diff --git a/src/libstd/sync/mutex.rs b/src/libstd/sync/mutex.rs index 4c3b5d98a3c..6f0febd61e8 100644 --- a/src/libstd/sync/mutex.rs +++ b/src/libstd/sync/mutex.rs @@ -390,8 +390,8 @@ mod test { fn lots_and_lots() { static M: StaticMutex = MUTEX_INIT; static mut CNT: u32 = 0; - static J: u32 = 1000; - static K: u32 = 3; + const J: u32 = 1000; + const K: u32 = 3; fn inc() { for _ in 0..J { diff --git a/src/libstd/sync/rwlock.rs b/src/libstd/sync/rwlock.rs index 454c5b4f0cf..e9ff6c0bf9d 100644 --- a/src/libstd/sync/rwlock.rs +++ b/src/libstd/sync/rwlock.rs @@ -436,8 +436,8 @@ mod tests { #[test] fn frob() { static R: StaticRwLock = RW_LOCK_INIT; - static N: usize = 10; - static M: usize = 1000; + const N: usize = 10; + const M: usize = 1000; let (tx, rx) = channel::<()>(); for _ in 0..N { diff --git a/src/libstd/sys/common/wtf8.rs b/src/libstd/sys/common/wtf8.rs index fb9d6fef1fa..31bdaee1e34 100644 --- a/src/libstd/sys/common/wtf8.rs +++ b/src/libstd/sys/common/wtf8.rs @@ -38,12 +38,12 @@ use num::Int; use ops; use slice; use str; -use string::{String, CowString}; +use string::String; use sys_common::AsInner; use unicode::str::{Utf16Item, utf16_items}; use vec::Vec; -static UTF8_REPLACEMENT_CHARACTER: &'static [u8] = b"\xEF\xBF\xBD"; +const UTF8_REPLACEMENT_CHARACTER: &'static [u8] = b"\xEF\xBF\xBD"; /// A Unicode code point: from U+0000 to U+10FFFF. /// @@ -530,7 +530,7 @@ impl Wtf8 { /// Surrogates are replaced with `"\u{FFFD}"` (the replacement character “�”). /// /// This only copies the data if necessary (if it contains any surrogate). - pub fn to_string_lossy(&self) -> CowString { + pub fn to_string_lossy(&self) -> Cow<str> { let surrogate_pos = match self.next_surrogate(0) { None => return Cow::Borrowed(unsafe { str::from_utf8_unchecked(&self.bytes) }), Some((pos, _)) => pos, @@ -844,7 +844,6 @@ mod tests { use borrow::Cow; use super::*; use mem::transmute; - use string::CowString; #[test] fn code_point_from_u32() { @@ -1224,7 +1223,7 @@ mod tests { assert_eq!(Wtf8::from_str("aé 💩").to_string_lossy(), Cow::Borrowed("aé 💩")); let mut string = Wtf8Buf::from_str("aé 💩"); string.push(CodePoint::from_u32(0xD800).unwrap()); - let expected: CowString = Cow::Owned(String::from_str("aé 💩�")); + let expected: Cow<str> = Cow::Owned(String::from_str("aé 💩�")); assert_eq!(string.to_string_lossy(), expected); } diff --git a/src/libstd/sys/unix/backtrace.rs b/src/libstd/sys/unix/backtrace.rs index 3695b615f62..e7ac6e2cd01 100644 --- a/src/libstd/sys/unix/backtrace.rs +++ b/src/libstd/sys/unix/backtrace.rs @@ -176,7 +176,7 @@ pub fn write(w: &mut Writer) -> IoResult<()> { let mut ip = unsafe { uw::_Unwind_GetIPInfo(ctx, &mut ip_before_insn) as *mut libc::c_void }; - if ip_before_insn == 0 { + if !ip.is_null() && ip_before_insn == 0 { // this is a non-signaling frame, so `ip` refers to the address // after the calling instruction. account for that. ip = (ip as usize - 1) as *mut _; @@ -566,7 +566,7 @@ mod uw { // This function doesn't exist on Android or ARM/Linux, so make it same // to _Unwind_GetIP - #[cfg(any(target_os = "android", + #[cfg(any(all(target_os = "android", target_arch = "arm"), all(target_os = "linux", target_arch = "arm")))] pub unsafe fn _Unwind_GetIPInfo(ctx: *mut _Unwind_Context, ip_before_insn: *mut libc::c_int) diff --git a/src/libstd/sys/unix/os_str.rs b/src/libstd/sys/unix/os_str.rs index 023d951dc4f..c8ac524876b 100644 --- a/src/libstd/sys/unix/os_str.rs +++ b/src/libstd/sys/unix/os_str.rs @@ -13,11 +13,12 @@ use core::prelude::*; +use borrow::Cow; use fmt::{self, Debug}; use vec::Vec; use slice::SliceExt as StdSliceExt; use str; -use string::{String, CowString}; +use string::String; use mem; #[derive(Clone, Hash)] @@ -76,7 +77,7 @@ impl Slice { str::from_utf8(&self.inner).ok() } - pub fn to_string_lossy(&self) -> CowString { + pub fn to_string_lossy(&self) -> Cow<str> { String::from_utf8_lossy(&self.inner) } diff --git a/src/libstd/sys/windows/os.rs b/src/libstd/sys/windows/os.rs index 587ab7924fd..89cf8a08a68 100644 --- a/src/libstd/sys/windows/os.rs +++ b/src/libstd/sys/windows/os.rs @@ -59,8 +59,8 @@ pub fn error_string(errnum: i32) -> String { -> DWORD; } - static FORMAT_MESSAGE_FROM_SYSTEM: DWORD = 0x00001000; - static FORMAT_MESSAGE_IGNORE_INSERTS: DWORD = 0x00000200; + const FORMAT_MESSAGE_FROM_SYSTEM: DWORD = 0x00001000; + const FORMAT_MESSAGE_IGNORE_INSERTS: DWORD = 0x00000200; // This value is calculated from the macro // MAKELANGID(LANG_SYSTEM_DEFAULT, SUBLANG_SYS_DEFAULT) diff --git a/src/libstd/sys/windows/os_str.rs b/src/libstd/sys/windows/os_str.rs index af94b56bf1f..ad1e6c4b0e7 100644 --- a/src/libstd/sys/windows/os_str.rs +++ b/src/libstd/sys/windows/os_str.rs @@ -11,9 +11,10 @@ /// The underlying OsString/OsStr implementation on Windows is a /// wrapper around the "WTF-8" encoding; see the `wtf8` module for more. +use borrow::Cow; use fmt::{self, Debug}; use sys_common::wtf8::{Wtf8, Wtf8Buf}; -use string::{String, CowString}; +use string::String; use result::Result; use option::Option; use mem; @@ -70,7 +71,7 @@ impl Slice { self.inner.as_str() } - pub fn to_string_lossy(&self) -> CowString { + pub fn to_string_lossy(&self) -> Cow<str> { self.inner.to_string_lossy() } diff --git a/src/libstd/thread.rs b/src/libstd/thread.rs index 883c1bbbbe5..e8330820906 100644 --- a/src/libstd/thread.rs +++ b/src/libstd/thread.rs @@ -277,7 +277,7 @@ impl Builder { // address at which our stack started). let main = move || { let something_around_the_top_of_the_stack = 1; - let addr = &something_around_the_top_of_the_stack as *const isize; + let addr = &something_around_the_top_of_the_stack as *const i32; let my_stack_top = addr as usize; let my_stack_bottom = my_stack_top - stack_size + 1024; unsafe { @@ -802,13 +802,13 @@ mod test { } fn avoid_copying_the_body<F>(spawnfn: F) where F: FnOnce(Thunk<'static>) { - let (tx, rx) = channel::<u32>(); + let (tx, rx) = channel(); let x = box 1; - let x_in_parent = (&*x) as *const isize as u32; + let x_in_parent = (&*x) as *const i32 as usize; spawnfn(Thunk::new(move|| { - let x_in_child = (&*x) as *const isize as u32; + let x_in_child = (&*x) as *const i32 as usize; tx.send(x_in_child).unwrap(); })); @@ -847,8 +847,8 @@ 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: usize = 16; - fn child_no(x: usize) -> Thunk<'static> { + const GENERATIONS: u32 = 16; + fn child_no(x: u32) -> Thunk<'static> { return Thunk::new(move|| { if x < GENERATIONS { thread::spawn(move|| child_no(x+1).invoke(())); diff --git a/src/libstd/thread_local/scoped.rs b/src/libstd/thread_local/scoped.rs index a2a5d8b81f4..d89d69e9497 100644 --- a/src/libstd/thread_local/scoped.rs +++ b/src/libstd/thread_local/scoped.rs @@ -119,7 +119,7 @@ macro_rules! __scoped_thread_local_inner { const _INIT: __Key<$t> = __Key { inner: ::std::thread_local::scoped::__impl::KeyInner { inner: ::std::thread_local::scoped::__impl::OS_INIT, - marker: ::std::marker::InvariantType, + marker: ::std::marker::PhantomData::<::std::cell::Cell<$t>>, } }; @@ -244,12 +244,13 @@ mod imp { target_arch = "aarch64"))] mod imp { use marker; + use std::cell::Cell; use sys_common::thread_local::StaticKey as OsStaticKey; #[doc(hidden)] pub struct KeyInner<T> { pub inner: OsStaticKey, - pub marker: marker::InvariantType<T>, + pub marker: marker::PhantomData<Cell<T>>, } unsafe impl<T> ::marker::Sync for KeyInner<T> { } diff --git a/src/libsyntax/abi.rs b/src/libsyntax/abi.rs index 2cf157bd245..896e638deb4 100644 --- a/src/libsyntax/abi.rs +++ b/src/libsyntax/abi.rs @@ -77,11 +77,11 @@ pub enum AbiArchitecture { } #[allow(non_upper_case_globals)] -static AbiDatas: &'static [AbiData] = &[ +const AbiDatas: &'static [AbiData] = &[ // Platform-specific ABIs AbiData {abi: Cdecl, name: "cdecl" }, AbiData {abi: Stdcall, name: "stdcall" }, - AbiData {abi: Fastcall, name:"fastcall" }, + AbiData {abi: Fastcall, name: "fastcall" }, AbiData {abi: Aapcs, name: "aapcs" }, AbiData {abi: Win64, name: "win64" }, diff --git a/src/libsyntax/diagnostic.rs b/src/libsyntax/diagnostic.rs index 27219774cf1..a6f4974502c 100644 --- a/src/libsyntax/diagnostic.rs +++ b/src/libsyntax/diagnostic.rs @@ -25,7 +25,7 @@ use term::WriterWrapper; use term; /// maximum number of lines we will print for each error; arbitrary. -static MAX_LINES: usize = 6; +const MAX_LINES: usize = 6; #[derive(Clone, Copy)] pub enum RenderSpan { diff --git a/src/libsyntax/ext/asm.rs b/src/libsyntax/ext/asm.rs index ae48084947e..e58a3de41c0 100644 --- a/src/libsyntax/ext/asm.rs +++ b/src/libsyntax/ext/asm.rs @@ -45,7 +45,7 @@ impl State { } } -static OPTIONS: &'static [&'static str] = &["volatile", "alignstack", "intel"]; +const OPTIONS: &'static [&'static str] = &["volatile", "alignstack", "intel"]; pub fn expand_asm<'cx>(cx: &'cx mut ExtCtxt, sp: Span, tts: &[ast::TokenTree]) -> Box<base::MacResult+'cx> { diff --git a/src/libsyntax/ext/deriving/encodable.rs b/src/libsyntax/ext/deriving/encodable.rs index 8038074cee1..17687534d75 100644 --- a/src/libsyntax/ext/deriving/encodable.rs +++ b/src/libsyntax/ext/deriving/encodable.rs @@ -181,7 +181,6 @@ fn encodable_substructure(cx: &mut ExtCtxt, trait_span: Span, Struct(ref fields) => { let emit_struct_field = cx.ident_of("emit_struct_field"); let mut stmts = Vec::new(); - let last = fields.len() - 1; for (i, &FieldInfo { name, ref self_, @@ -204,6 +203,7 @@ fn encodable_substructure(cx: &mut ExtCtxt, trait_span: Span, lambda)); // last call doesn't need a try! + let last = fields.len() - 1; let call = if i != last { cx.expr_try(span, call) } else { @@ -240,25 +240,24 @@ fn encodable_substructure(cx: &mut ExtCtxt, trait_span: Span, let encoder = cx.expr_ident(trait_span, blkarg); let emit_variant_arg = cx.ident_of("emit_enum_variant_arg"); let mut stmts = Vec::new(); - let last = fields.len() - 1; - for (i, &FieldInfo { ref self_, span, .. }) in fields.iter().enumerate() { - let enc = cx.expr_method_call(span, self_.clone(), - encode, vec!(blkencoder.clone())); - let lambda = cx.lambda_expr_1(span, enc, blkarg); - let call = cx.expr_method_call(span, blkencoder.clone(), - emit_variant_arg, - vec!(cx.expr_usize(span, i), - lambda)); - let call = if i != last { - cx.expr_try(span, call) - } else { - cx.expr(span, ExprRet(Some(call))) - }; - stmts.push(cx.stmt_expr(call)); - } - - // enums with no fields need to return Ok() - if stmts.len() == 0 { + if fields.len() > 0 { + let last = fields.len() - 1; + for (i, &FieldInfo { ref self_, span, .. }) in fields.iter().enumerate() { + let enc = cx.expr_method_call(span, self_.clone(), + encode, vec!(blkencoder.clone())); + let lambda = cx.lambda_expr_1(span, enc, blkarg); + let call = cx.expr_method_call(span, blkencoder.clone(), + emit_variant_arg, + vec!(cx.expr_usize(span, i), + lambda)); + let call = if i != last { + cx.expr_try(span, call) + } else { + cx.expr(span, ExprRet(Some(call))) + }; + stmts.push(cx.stmt_expr(call)); + } + } else { let ret_ok = cx.expr(trait_span, ExprRet(Some(cx.expr_ok(trait_span, cx.expr_tuple(trait_span, vec![]))))); diff --git a/src/libsyntax/feature_gate.rs b/src/libsyntax/feature_gate.rs index 8043bd9bd70..18d3f85f4b5 100644 --- a/src/libsyntax/feature_gate.rs +++ b/src/libsyntax/feature_gate.rs @@ -45,7 +45,7 @@ use std::ascii::AsciiExt; // stable (active). // NB: The featureck.py script parses this information directly out of the source // so take care when modifying it. -static KNOWN_FEATURES: &'static [(&'static str, &'static str, Status)] = &[ +const KNOWN_FEATURES: &'static [(&'static str, &'static str, Status)] = &[ ("globs", "1.0.0", Accepted), ("macro_rules", "1.0.0", Accepted), ("struct_variant", "1.0.0", Accepted), @@ -139,6 +139,9 @@ static KNOWN_FEATURES: &'static [(&'static str, &'static str, Status)] = &[ // Allows the use of rustc_* attributes; RFC 572 ("rustc_attrs", "1.0.0", Active), + + // Allows the use of `static_assert` + ("static_assert", "1.0.0", Active), ]; // (changing above list without updating src/doc/reference.md makes @cmr sad) @@ -159,7 +162,7 @@ enum Status { } // Attributes that have a special meaning to rustc or rustdoc -pub static KNOWN_ATTRIBUTES: &'static [(&'static str, AttributeType)] = &[ +pub const KNOWN_ATTRIBUTES: &'static [(&'static str, AttributeType)] = &[ // Normal attributes ("warn", Normal), @@ -242,7 +245,8 @@ pub static KNOWN_ATTRIBUTES: &'static [(&'static str, AttributeType)] = &[ ("no_split_stack", Whitelisted), ("no_stack_check", Whitelisted), ("packed", Whitelisted), - ("static_assert", Whitelisted), + ("static_assert", Gated("static_assert", + "`#[static_assert]` is an experimental feature, and has a poor API")), ("no_debug", Whitelisted), ("omit_gdb_pretty_printer_section", Whitelisted), ("unsafe_no_drop_flag", Gated("unsafe_no_drop_flag", @@ -770,4 +774,3 @@ pub fn check_crate(cm: &CodeMap, span_handler: &SpanHandler, krate: &ast::Crate) |ctx, krate| visit::walk_crate(&mut PostExpansionVisitor { context: ctx }, krate)) } - diff --git a/src/libsyntax/parse/lexer/comments.rs b/src/libsyntax/parse/lexer/comments.rs index 7a5d75581a5..3ad1d96a45d 100644 --- a/src/libsyntax/parse/lexer/comments.rs +++ b/src/libsyntax/parse/lexer/comments.rs @@ -124,8 +124,8 @@ pub fn strip_doc_comment_decoration(comment: &str) -> String { } // one-line comments lose their prefix - static ONLINERS: &'static [&'static str] = &["///!", "///", "//!", "//"]; - for prefix in ONLINERS { + const ONELINERS: &'static [&'static str] = &["///!", "///", "//!", "//"]; + for prefix in ONELINERS { if comment.starts_with(*prefix) { return (&comment[prefix.len()..]).to_string(); } diff --git a/src/libsyntax/parse/token.rs b/src/libsyntax/parse/token.rs index 2797ef084d9..61a3a5ca82a 100644 --- a/src/libsyntax/parse/token.rs +++ b/src/libsyntax/parse/token.rs @@ -425,10 +425,10 @@ macro_rules! declare_special_idents_and_keywords {( $( ($rk_name:expr, $rk_variant:ident, $rk_str:expr); )* } ) => { - static STRICT_KEYWORD_START: ast::Name = first!($( ast::Name($sk_name), )*); - static STRICT_KEYWORD_FINAL: ast::Name = last!($( ast::Name($sk_name), )*); - static RESERVED_KEYWORD_START: ast::Name = first!($( ast::Name($rk_name), )*); - static RESERVED_KEYWORD_FINAL: ast::Name = last!($( ast::Name($rk_name), )*); + const STRICT_KEYWORD_START: ast::Name = first!($( ast::Name($sk_name), )*); + const STRICT_KEYWORD_FINAL: ast::Name = last!($( ast::Name($sk_name), )*); + const RESERVED_KEYWORD_START: ast::Name = first!($( ast::Name($rk_name), )*); + const RESERVED_KEYWORD_FINAL: ast::Name = last!($( ast::Name($rk_name), )*); pub mod special_idents { use ast; diff --git a/src/libsyntax/print/pp.rs b/src/libsyntax/print/pp.rs index 5b3fde8535b..4cef7ed469f 100644 --- a/src/libsyntax/print/pp.rs +++ b/src/libsyntax/print/pp.rs @@ -159,7 +159,7 @@ pub struct PrintStackElem { pbreak: PrintStackBreak } -static SIZE_INFINITY: isize = 0xffff; +const SIZE_INFINITY: isize = 0xffff; pub fn mk_printer(out: Box<old_io::Writer+'static>, linewidth: usize) -> Printer { // Yes 3, it makes the ring buffers big enough to never diff --git a/src/libunicode/tables.rs b/src/libunicode/tables.rs index 61f447a3dd3..99a6b6aa180 100644 --- a/src/libunicode/tables.rs +++ b/src/libunicode/tables.rs @@ -27,7 +27,7 @@ fn bsearch_range_table(c: char, r: &'static [(char,char)]) -> bool { } pub mod general_category { - pub static C_table: &'static [(char, char)] = &[ + pub const C_table: &'static [(char, char)] = &[ ('\u{0}', '\u{1f}'), ('\u{7f}', '\u{9f}'), ('\u{ad}', '\u{ad}'), ('\u{378}', '\u{379}'), ('\u{380}', '\u{383}'), ('\u{38b}', '\u{38b}'), ('\u{38d}', '\u{38d}'), ('\u{3a2}', '\u{3a2}'), ('\u{530}', '\u{530}'), ('\u{557}', '\u{558}'), ('\u{560}', '\u{560}'), @@ -216,7 +216,7 @@ pub mod general_category { ('\u{e01f0}', '\u{10ffff}') ]; - pub static Cc_table: &'static [(char, char)] = &[ + pub const Cc_table: &'static [(char, char)] = &[ ('\u{0}', '\u{1f}'), ('\u{7f}', '\u{9f}') ]; @@ -224,7 +224,7 @@ pub mod general_category { super::bsearch_range_table(c, Cc_table) } - pub static Cf_table: &'static [(char, char)] = &[ + pub const Cf_table: &'static [(char, char)] = &[ ('\u{ad}', '\u{ad}'), ('\u{600}', '\u{605}'), ('\u{61c}', '\u{61c}'), ('\u{6dd}', '\u{6dd}'), ('\u{70f}', '\u{70f}'), ('\u{180e}', '\u{180e}'), ('\u{200b}', '\u{200f}'), ('\u{202a}', '\u{202e}'), ('\u{2060}', '\u{2064}'), ('\u{2066}', '\u{206f}'), ('\u{feff}', @@ -233,7 +233,7 @@ pub mod general_category { '\u{e007f}') ]; - pub static Cn_table: &'static [(char, char)] = &[ + pub const Cn_table: &'static [(char, char)] = &[ ('\u{378}', '\u{379}'), ('\u{380}', '\u{383}'), ('\u{38b}', '\u{38b}'), ('\u{38d}', '\u{38d}'), ('\u{3a2}', '\u{3a2}'), ('\u{530}', '\u{530}'), ('\u{557}', '\u{558}'), ('\u{560}', '\u{560}'), ('\u{588}', '\u{588}'), ('\u{58b}', '\u{58c}'), ('\u{590}', @@ -422,12 +422,12 @@ pub mod general_category { ('\u{10fffe}', '\u{10ffff}') ]; - pub static Co_table: &'static [(char, char)] = &[ + pub const Co_table: &'static [(char, char)] = &[ ('\u{e000}', '\u{e000}'), ('\u{f8ff}', '\u{f8ff}'), ('\u{f0000}', '\u{f0000}'), ('\u{ffffd}', '\u{ffffd}'), ('\u{100000}', '\u{100000}'), ('\u{10fffd}', '\u{10fffd}') ]; - pub static L_table: &'static [(char, char)] = &[ + pub const L_table: &'static [(char, char)] = &[ ('\u{41}', '\u{5a}'), ('\u{61}', '\u{7a}'), ('\u{aa}', '\u{aa}'), ('\u{b5}', '\u{b5}'), ('\u{ba}', '\u{ba}'), ('\u{c0}', '\u{d6}'), ('\u{d8}', '\u{f6}'), ('\u{f8}', '\u{2c1}'), ('\u{2c6}', '\u{2d1}'), ('\u{2e0}', '\u{2e4}'), ('\u{2ec}', '\u{2ec}'), ('\u{2ee}', @@ -593,7 +593,7 @@ pub mod general_category { ('\u{2b81d}', '\u{2b81d}'), ('\u{2f800}', '\u{2fa1d}') ]; - pub static LC_table: &'static [(char, char)] = &[ + pub const LC_table: &'static [(char, char)] = &[ ('\u{41}', '\u{5a}'), ('\u{61}', '\u{7a}'), ('\u{b5}', '\u{b5}'), ('\u{c0}', '\u{d6}'), ('\u{d8}', '\u{f6}'), ('\u{f8}', '\u{1ba}'), ('\u{1bc}', '\u{1bf}'), ('\u{1c4}', '\u{293}'), ('\u{295}', '\u{2af}'), ('\u{370}', '\u{373}'), ('\u{376}', '\u{377}'), ('\u{37b}', @@ -631,7 +631,7 @@ pub mod general_category { ('\u{1d7aa}', '\u{1d7c2}'), ('\u{1d7c4}', '\u{1d7cb}') ]; - pub static Ll_table: &'static [(char, char)] = &[ + pub const Ll_table: &'static [(char, char)] = &[ ('\u{61}', '\u{7a}'), ('\u{b5}', '\u{b5}'), ('\u{df}', '\u{f6}'), ('\u{f8}', '\u{ff}'), ('\u{101}', '\u{101}'), ('\u{103}', '\u{103}'), ('\u{105}', '\u{105}'), ('\u{107}', '\u{107}'), ('\u{109}', '\u{109}'), ('\u{10b}', '\u{10b}'), ('\u{10d}', '\u{10d}'), @@ -814,7 +814,7 @@ pub mod general_category { '\u{1d7c2}'), ('\u{1d7c4}', '\u{1d7c9}'), ('\u{1d7cb}', '\u{1d7cb}') ]; - pub static Lm_table: &'static [(char, char)] = &[ + pub const Lm_table: &'static [(char, char)] = &[ ('\u{2b0}', '\u{2c1}'), ('\u{2c6}', '\u{2d1}'), ('\u{2e0}', '\u{2e4}'), ('\u{2ec}', '\u{2ec}'), ('\u{2ee}', '\u{2ee}'), ('\u{374}', '\u{374}'), ('\u{37a}', '\u{37a}'), ('\u{559}', '\u{559}'), ('\u{640}', '\u{640}'), ('\u{6e5}', '\u{6e6}'), ('\u{7f4}', @@ -834,7 +834,7 @@ pub mod general_category { '\u{16f9f}') ]; - pub static Lo_table: &'static [(char, char)] = &[ + pub const Lo_table: &'static [(char, char)] = &[ ('\u{aa}', '\u{aa}'), ('\u{ba}', '\u{ba}'), ('\u{1bb}', '\u{1bb}'), ('\u{1c0}', '\u{1c3}'), ('\u{294}', '\u{294}'), ('\u{5d0}', '\u{5ea}'), ('\u{5f0}', '\u{5f2}'), ('\u{620}', '\u{63f}'), ('\u{641}', '\u{64a}'), ('\u{66e}', '\u{66f}'), ('\u{671}', '\u{6d3}'), @@ -964,13 +964,13 @@ pub mod general_category { ('\u{2b740}', '\u{2b740}'), ('\u{2b81d}', '\u{2b81d}'), ('\u{2f800}', '\u{2fa1d}') ]; - pub static Lt_table: &'static [(char, char)] = &[ + pub const Lt_table: &'static [(char, char)] = &[ ('\u{1c5}', '\u{1c5}'), ('\u{1c8}', '\u{1c8}'), ('\u{1cb}', '\u{1cb}'), ('\u{1f2}', '\u{1f2}'), ('\u{1f88}', '\u{1f8f}'), ('\u{1f98}', '\u{1f9f}'), ('\u{1fa8}', '\u{1faf}'), ('\u{1fbc}', '\u{1fbc}'), ('\u{1fcc}', '\u{1fcc}'), ('\u{1ffc}', '\u{1ffc}') ]; - pub static Lu_table: &'static [(char, char)] = &[ + pub const Lu_table: &'static [(char, char)] = &[ ('\u{41}', '\u{5a}'), ('\u{c0}', '\u{d6}'), ('\u{d8}', '\u{de}'), ('\u{100}', '\u{100}'), ('\u{102}', '\u{102}'), ('\u{104}', '\u{104}'), ('\u{106}', '\u{106}'), ('\u{108}', '\u{108}'), ('\u{10a}', '\u{10a}'), ('\u{10c}', '\u{10c}'), ('\u{10e}', '\u{10e}'), @@ -1153,7 +1153,7 @@ pub mod general_category { '\u{1d7ca}') ]; - pub static M_table: &'static [(char, char)] = &[ + pub const M_table: &'static [(char, char)] = &[ ('\u{300}', '\u{36f}'), ('\u{483}', '\u{489}'), ('\u{591}', '\u{5bd}'), ('\u{5bf}', '\u{5bf}'), ('\u{5c1}', '\u{5c2}'), ('\u{5c4}', '\u{5c5}'), ('\u{5c7}', '\u{5c7}'), ('\u{610}', '\u{61a}'), ('\u{64b}', '\u{65f}'), ('\u{670}', '\u{670}'), ('\u{6d6}', @@ -1224,7 +1224,7 @@ pub mod general_category { ('\u{1e8d0}', '\u{1e8d6}'), ('\u{e0100}', '\u{e01ef}') ]; - pub static Mc_table: &'static [(char, char)] = &[ + pub const Mc_table: &'static [(char, char)] = &[ ('\u{903}', '\u{903}'), ('\u{93b}', '\u{93b}'), ('\u{93e}', '\u{940}'), ('\u{949}', '\u{94c}'), ('\u{94e}', '\u{94f}'), ('\u{982}', '\u{983}'), ('\u{9be}', '\u{9c0}'), ('\u{9c7}', '\u{9c8}'), ('\u{9cb}', '\u{9cc}'), ('\u{9d7}', '\u{9d7}'), ('\u{a03}', @@ -1271,12 +1271,12 @@ pub mod general_category { ('\u{1d165}', '\u{1d166}'), ('\u{1d16d}', '\u{1d172}') ]; - pub static Me_table: &'static [(char, char)] = &[ + pub const Me_table: &'static [(char, char)] = &[ ('\u{488}', '\u{489}'), ('\u{1abe}', '\u{1abe}'), ('\u{20dd}', '\u{20e0}'), ('\u{20e2}', '\u{20e4}'), ('\u{a670}', '\u{a672}') ]; - pub static Mn_table: &'static [(char, char)] = &[ + pub const Mn_table: &'static [(char, char)] = &[ ('\u{300}', '\u{36f}'), ('\u{483}', '\u{487}'), ('\u{591}', '\u{5bd}'), ('\u{5bf}', '\u{5bf}'), ('\u{5c1}', '\u{5c2}'), ('\u{5c4}', '\u{5c5}'), ('\u{5c7}', '\u{5c7}'), ('\u{610}', '\u{61a}'), ('\u{64b}', '\u{65f}'), ('\u{670}', '\u{670}'), ('\u{6d6}', @@ -1355,7 +1355,7 @@ pub mod general_category { '\u{1e8d6}'), ('\u{e0100}', '\u{e01ef}') ]; - pub static N_table: &'static [(char, char)] = &[ + pub const N_table: &'static [(char, char)] = &[ ('\u{30}', '\u{39}'), ('\u{660}', '\u{669}'), ('\u{6f0}', '\u{6f9}'), ('\u{7c0}', '\u{7c9}'), ('\u{966}', '\u{96f}'), ('\u{9e6}', '\u{9ef}'), ('\u{a66}', '\u{a6f}'), ('\u{ae6}', '\u{aef}'), ('\u{b66}', '\u{b6f}'), ('\u{be6}', '\u{bef}'), ('\u{c66}', @@ -1381,7 +1381,7 @@ pub mod general_category { super::bsearch_range_table(c, N_table) } - pub static Nd_table: &'static [(char, char)] = &[ + pub const Nd_table: &'static [(char, char)] = &[ ('\u{30}', '\u{39}'), ('\u{660}', '\u{669}'), ('\u{6f0}', '\u{6f9}'), ('\u{7c0}', '\u{7c9}'), ('\u{966}', '\u{96f}'), ('\u{9e6}', '\u{9ef}'), ('\u{a66}', '\u{a6f}'), ('\u{ae6}', '\u{aef}'), ('\u{b66}', '\u{b6f}'), ('\u{be6}', '\u{bef}'), ('\u{c66}', @@ -1399,14 +1399,14 @@ pub mod general_category { ('\u{16a60}', '\u{16a69}'), ('\u{16b50}', '\u{16b59}'), ('\u{1d7ce}', '\u{1d7ff}') ]; - pub static Nl_table: &'static [(char, char)] = &[ + pub const Nl_table: &'static [(char, char)] = &[ ('\u{16ee}', '\u{16f0}'), ('\u{2160}', '\u{2182}'), ('\u{2185}', '\u{2188}'), ('\u{3007}', '\u{3007}'), ('\u{3021}', '\u{3029}'), ('\u{3038}', '\u{303a}'), ('\u{a6e6}', '\u{a6ef}'), ('\u{10140}', '\u{10174}'), ('\u{10341}', '\u{10341}'), ('\u{1034a}', '\u{1034a}'), ('\u{103d1}', '\u{103d5}'), ('\u{12400}', '\u{1246e}') ]; - pub static No_table: &'static [(char, char)] = &[ + pub const No_table: &'static [(char, char)] = &[ ('\u{b2}', '\u{b3}'), ('\u{b9}', '\u{b9}'), ('\u{bc}', '\u{be}'), ('\u{9f4}', '\u{9f9}'), ('\u{b72}', '\u{b77}'), ('\u{bf0}', '\u{bf2}'), ('\u{c78}', '\u{c7e}'), ('\u{d70}', '\u{d75}'), ('\u{f2a}', '\u{f33}'), ('\u{1369}', '\u{137c}'), ('\u{17f0}', '\u{17f9}'), @@ -1425,7 +1425,7 @@ pub mod general_category { '\u{1d371}'), ('\u{1e8c7}', '\u{1e8cf}'), ('\u{1f100}', '\u{1f10c}') ]; - pub static P_table: &'static [(char, char)] = &[ + pub const P_table: &'static [(char, char)] = &[ ('\u{21}', '\u{23}'), ('\u{25}', '\u{2a}'), ('\u{2c}', '\u{2f}'), ('\u{3a}', '\u{3b}'), ('\u{3f}', '\u{40}'), ('\u{5b}', '\u{5d}'), ('\u{5f}', '\u{5f}'), ('\u{7b}', '\u{7b}'), ('\u{7d}', '\u{7d}'), ('\u{a1}', '\u{a1}'), ('\u{a7}', '\u{a7}'), ('\u{ab}', '\u{ab}'), @@ -1474,12 +1474,12 @@ pub mod general_category { '\u{1bc9f}') ]; - pub static Pc_table: &'static [(char, char)] = &[ + pub const Pc_table: &'static [(char, char)] = &[ ('\u{5f}', '\u{5f}'), ('\u{203f}', '\u{2040}'), ('\u{2054}', '\u{2054}'), ('\u{fe33}', '\u{fe34}'), ('\u{fe4d}', '\u{fe4f}'), ('\u{ff3f}', '\u{ff3f}') ]; - pub static Pd_table: &'static [(char, char)] = &[ + pub const Pd_table: &'static [(char, char)] = &[ ('\u{2d}', '\u{2d}'), ('\u{58a}', '\u{58a}'), ('\u{5be}', '\u{5be}'), ('\u{1400}', '\u{1400}'), ('\u{1806}', '\u{1806}'), ('\u{2010}', '\u{2015}'), ('\u{2e17}', '\u{2e17}'), ('\u{2e1a}', '\u{2e1a}'), ('\u{2e3a}', '\u{2e3b}'), ('\u{2e40}', '\u{2e40}'), ('\u{301c}', @@ -1487,7 +1487,7 @@ pub mod general_category { ('\u{fe58}', '\u{fe58}'), ('\u{fe63}', '\u{fe63}'), ('\u{ff0d}', '\u{ff0d}') ]; - pub static Pe_table: &'static [(char, char)] = &[ + pub const Pe_table: &'static [(char, char)] = &[ ('\u{29}', '\u{29}'), ('\u{5d}', '\u{5d}'), ('\u{7d}', '\u{7d}'), ('\u{f3b}', '\u{f3b}'), ('\u{f3d}', '\u{f3d}'), ('\u{169c}', '\u{169c}'), ('\u{2046}', '\u{2046}'), ('\u{207e}', '\u{207e}'), ('\u{208e}', '\u{208e}'), ('\u{2309}', '\u{2309}'), ('\u{230b}', '\u{230b}'), @@ -1511,20 +1511,20 @@ pub mod general_category { '\u{ff60}'), ('\u{ff63}', '\u{ff63}') ]; - pub static Pf_table: &'static [(char, char)] = &[ + pub const Pf_table: &'static [(char, char)] = &[ ('\u{bb}', '\u{bb}'), ('\u{2019}', '\u{2019}'), ('\u{201d}', '\u{201d}'), ('\u{203a}', '\u{203a}'), ('\u{2e03}', '\u{2e03}'), ('\u{2e05}', '\u{2e05}'), ('\u{2e0a}', '\u{2e0a}'), ('\u{2e0d}', '\u{2e0d}'), ('\u{2e1d}', '\u{2e1d}'), ('\u{2e21}', '\u{2e21}') ]; - pub static Pi_table: &'static [(char, char)] = &[ + pub const Pi_table: &'static [(char, char)] = &[ ('\u{ab}', '\u{ab}'), ('\u{2018}', '\u{2018}'), ('\u{201b}', '\u{201c}'), ('\u{201f}', '\u{201f}'), ('\u{2039}', '\u{2039}'), ('\u{2e02}', '\u{2e02}'), ('\u{2e04}', '\u{2e04}'), ('\u{2e09}', '\u{2e09}'), ('\u{2e0c}', '\u{2e0c}'), ('\u{2e1c}', '\u{2e1c}'), ('\u{2e20}', '\u{2e20}') ]; - pub static Po_table: &'static [(char, char)] = &[ + pub const Po_table: &'static [(char, char)] = &[ ('\u{21}', '\u{23}'), ('\u{25}', '\u{27}'), ('\u{2a}', '\u{2a}'), ('\u{2c}', '\u{2c}'), ('\u{2e}', '\u{2f}'), ('\u{3a}', '\u{3b}'), ('\u{3f}', '\u{40}'), ('\u{5c}', '\u{5c}'), ('\u{a1}', '\u{a1}'), ('\u{a7}', '\u{a7}'), ('\u{b6}', '\u{b7}'), ('\u{bf}', '\u{bf}'), @@ -1572,7 +1572,7 @@ pub mod general_category { '\u{1bc9f}') ]; - pub static Ps_table: &'static [(char, char)] = &[ + pub const Ps_table: &'static [(char, char)] = &[ ('\u{28}', '\u{28}'), ('\u{5b}', '\u{5b}'), ('\u{7b}', '\u{7b}'), ('\u{f3a}', '\u{f3a}'), ('\u{f3c}', '\u{f3c}'), ('\u{169b}', '\u{169b}'), ('\u{201a}', '\u{201a}'), ('\u{201e}', '\u{201e}'), ('\u{2045}', '\u{2045}'), ('\u{207d}', '\u{207d}'), ('\u{208d}', '\u{208d}'), @@ -1597,7 +1597,7 @@ pub mod general_category { ('\u{ff62}', '\u{ff62}') ]; - pub static S_table: &'static [(char, char)] = &[ + pub const S_table: &'static [(char, char)] = &[ ('\u{24}', '\u{24}'), ('\u{2b}', '\u{2b}'), ('\u{3c}', '\u{3e}'), ('\u{5e}', '\u{5e}'), ('\u{60}', '\u{60}'), ('\u{7c}', '\u{7c}'), ('\u{7e}', '\u{7e}'), ('\u{a2}', '\u{a6}'), ('\u{a8}', '\u{a9}'), ('\u{ac}', '\u{ac}'), ('\u{ae}', '\u{b1}'), ('\u{b4}', '\u{b4}'), @@ -1663,7 +1663,7 @@ pub mod general_category { '\u{1f887}'), ('\u{1f890}', '\u{1f8ad}') ]; - pub static Sc_table: &'static [(char, char)] = &[ + pub const Sc_table: &'static [(char, char)] = &[ ('\u{24}', '\u{24}'), ('\u{a2}', '\u{a5}'), ('\u{58f}', '\u{58f}'), ('\u{60b}', '\u{60b}'), ('\u{9f2}', '\u{9f3}'), ('\u{9fb}', '\u{9fb}'), ('\u{af1}', '\u{af1}'), ('\u{bf9}', '\u{bf9}'), ('\u{e3f}', '\u{e3f}'), ('\u{17db}', '\u{17db}'), ('\u{20a0}', '\u{20bd}'), @@ -1671,7 +1671,7 @@ pub mod general_category { '\u{ff04}'), ('\u{ffe0}', '\u{ffe1}'), ('\u{ffe5}', '\u{ffe6}') ]; - pub static Sk_table: &'static [(char, char)] = &[ + pub const Sk_table: &'static [(char, char)] = &[ ('\u{5e}', '\u{5e}'), ('\u{60}', '\u{60}'), ('\u{a8}', '\u{a8}'), ('\u{af}', '\u{af}'), ('\u{b4}', '\u{b4}'), ('\u{b8}', '\u{b8}'), ('\u{2c2}', '\u{2c5}'), ('\u{2d2}', '\u{2df}'), ('\u{2e5}', '\u{2eb}'), ('\u{2ed}', '\u{2ed}'), ('\u{2ef}', '\u{2ff}'), ('\u{375}', @@ -1682,7 +1682,7 @@ pub mod general_category { '\u{ff3e}'), ('\u{ff40}', '\u{ff40}'), ('\u{ffe3}', '\u{ffe3}') ]; - pub static Sm_table: &'static [(char, char)] = &[ + pub const Sm_table: &'static [(char, char)] = &[ ('\u{2b}', '\u{2b}'), ('\u{3c}', '\u{3e}'), ('\u{7c}', '\u{7c}'), ('\u{7e}', '\u{7e}'), ('\u{ac}', '\u{ac}'), ('\u{b1}', '\u{b1}'), ('\u{d7}', '\u{d7}'), ('\u{f7}', '\u{f7}'), ('\u{3f6}', '\u{3f6}'), ('\u{606}', '\u{608}'), ('\u{2044}', '\u{2044}'), ('\u{2052}', @@ -1704,7 +1704,7 @@ pub mod general_category { '\u{1d7c3}'), ('\u{1eef0}', '\u{1eef1}') ]; - pub static So_table: &'static [(char, char)] = &[ + pub const So_table: &'static [(char, char)] = &[ ('\u{a6}', '\u{a6}'), ('\u{a9}', '\u{a9}'), ('\u{ae}', '\u{ae}'), ('\u{b0}', '\u{b0}'), ('\u{482}', '\u{482}'), ('\u{58d}', '\u{58e}'), ('\u{60e}', '\u{60f}'), ('\u{6de}', '\u{6de}'), ('\u{6e9}', '\u{6e9}'), ('\u{6fd}', '\u{6fe}'), ('\u{7f6}', '\u{7f6}'), @@ -1757,21 +1757,21 @@ pub mod general_category { '\u{1f887}'), ('\u{1f890}', '\u{1f8ad}') ]; - pub static Z_table: &'static [(char, char)] = &[ + pub const Z_table: &'static [(char, char)] = &[ ('\u{20}', '\u{20}'), ('\u{a0}', '\u{a0}'), ('\u{1680}', '\u{1680}'), ('\u{2000}', '\u{200a}'), ('\u{2028}', '\u{2029}'), ('\u{202f}', '\u{202f}'), ('\u{205f}', '\u{205f}'), ('\u{3000}', '\u{3000}') ]; - pub static Zl_table: &'static [(char, char)] = &[ + pub const Zl_table: &'static [(char, char)] = &[ ('\u{2028}', '\u{2028}') ]; - pub static Zp_table: &'static [(char, char)] = &[ + pub const Zp_table: &'static [(char, char)] = &[ ('\u{2029}', '\u{2029}') ]; - pub static Zs_table: &'static [(char, char)] = &[ + pub const Zs_table: &'static [(char, char)] = &[ ('\u{20}', '\u{20}'), ('\u{a0}', '\u{a0}'), ('\u{1680}', '\u{1680}'), ('\u{2000}', '\u{200a}'), ('\u{202f}', '\u{202f}'), ('\u{205f}', '\u{205f}'), ('\u{3000}', '\u{3000}') ]; @@ -1779,7 +1779,7 @@ pub mod general_category { } pub mod derived_property { - pub static Alphabetic_table: &'static [(char, char)] = &[ + pub const Alphabetic_table: &'static [(char, char)] = &[ ('\u{41}', '\u{5a}'), ('\u{61}', '\u{7a}'), ('\u{aa}', '\u{aa}'), ('\u{b5}', '\u{b5}'), ('\u{ba}', '\u{ba}'), ('\u{c0}', '\u{d6}'), ('\u{d8}', '\u{f6}'), ('\u{f8}', '\u{1ba}'), ('\u{1bb}', '\u{1bb}'), ('\u{1bc}', '\u{1bf}'), ('\u{1c0}', '\u{1c3}'), ('\u{1c4}', @@ -2057,7 +2057,7 @@ pub mod derived_property { super::bsearch_range_table(c, Alphabetic_table) } - pub static Default_Ignorable_Code_Point_table: &'static [(char, char)] = &[ + pub const Default_Ignorable_Code_Point_table: &'static [(char, char)] = &[ ('\u{ad}', '\u{ad}'), ('\u{34f}', '\u{34f}'), ('\u{61c}', '\u{61c}'), ('\u{115f}', '\u{1160}'), ('\u{17b4}', '\u{17b5}'), ('\u{180b}', '\u{180d}'), ('\u{180e}', '\u{180e}'), ('\u{200b}', '\u{200f}'), ('\u{202a}', '\u{202e}'), ('\u{2060}', '\u{2064}'), ('\u{2065}', @@ -2068,7 +2068,7 @@ pub mod derived_property { '\u{e00ff}'), ('\u{e0100}', '\u{e01ef}'), ('\u{e01f0}', '\u{e0fff}') ]; - pub static Lowercase_table: &'static [(char, char)] = &[ + pub const Lowercase_table: &'static [(char, char)] = &[ ('\u{61}', '\u{7a}'), ('\u{aa}', '\u{aa}'), ('\u{b5}', '\u{b5}'), ('\u{ba}', '\u{ba}'), ('\u{df}', '\u{f6}'), ('\u{f8}', '\u{ff}'), ('\u{101}', '\u{101}'), ('\u{103}', '\u{103}'), ('\u{105}', '\u{105}'), ('\u{107}', '\u{107}'), ('\u{109}', '\u{109}'), ('\u{10b}', @@ -2261,7 +2261,7 @@ pub mod derived_property { super::bsearch_range_table(c, Lowercase_table) } - pub static Uppercase_table: &'static [(char, char)] = &[ + pub const Uppercase_table: &'static [(char, char)] = &[ ('\u{41}', '\u{5a}'), ('\u{c0}', '\u{d6}'), ('\u{d8}', '\u{de}'), ('\u{100}', '\u{100}'), ('\u{102}', '\u{102}'), ('\u{104}', '\u{104}'), ('\u{106}', '\u{106}'), ('\u{108}', '\u{108}'), ('\u{10a}', '\u{10a}'), ('\u{10c}', '\u{10c}'), ('\u{10e}', '\u{10e}'), @@ -2449,7 +2449,7 @@ pub mod derived_property { super::bsearch_range_table(c, Uppercase_table) } - pub static XID_Continue_table: &'static [(char, char)] = &[ + pub const XID_Continue_table: &'static [(char, char)] = &[ ('\u{30}', '\u{39}'), ('\u{41}', '\u{5a}'), ('\u{5f}', '\u{5f}'), ('\u{61}', '\u{7a}'), ('\u{aa}', '\u{aa}'), ('\u{b5}', '\u{b5}'), ('\u{b7}', '\u{b7}'), ('\u{ba}', '\u{ba}'), ('\u{c0}', '\u{d6}'), ('\u{d8}', '\u{f6}'), ('\u{f8}', '\u{1ba}'), ('\u{1bb}', '\u{1bb}'), @@ -2775,7 +2775,7 @@ pub mod derived_property { super::bsearch_range_table(c, XID_Continue_table) } - pub static XID_Start_table: &'static [(char, char)] = &[ + pub const XID_Start_table: &'static [(char, char)] = &[ ('\u{41}', '\u{5a}'), ('\u{61}', '\u{7a}'), ('\u{aa}', '\u{aa}'), ('\u{b5}', '\u{b5}'), ('\u{ba}', '\u{ba}'), ('\u{c0}', '\u{d6}'), ('\u{d8}', '\u{f6}'), ('\u{f8}', '\u{1ba}'), ('\u{1bb}', '\u{1bb}'), ('\u{1bc}', '\u{1bf}'), ('\u{1c0}', '\u{1c3}'), ('\u{1c4}', @@ -2967,7 +2967,7 @@ pub mod derived_property { } pub mod script { - pub static Arabic_table: &'static [(char, char)] = &[ + pub const Arabic_table: &'static [(char, char)] = &[ ('\u{600}', '\u{604}'), ('\u{606}', '\u{608}'), ('\u{609}', '\u{60a}'), ('\u{60b}', '\u{60b}'), ('\u{60d}', '\u{60d}'), ('\u{60e}', '\u{60f}'), ('\u{610}', '\u{61a}'), ('\u{61e}', '\u{61e}'), ('\u{620}', '\u{63f}'), ('\u{641}', '\u{64a}'), ('\u{656}', @@ -2994,17 +2994,17 @@ pub mod script { ('\u{1eef0}', '\u{1eef1}') ]; - pub static Armenian_table: &'static [(char, char)] = &[ + pub const Armenian_table: &'static [(char, char)] = &[ ('\u{531}', '\u{556}'), ('\u{559}', '\u{559}'), ('\u{55a}', '\u{55f}'), ('\u{561}', '\u{587}'), ('\u{58a}', '\u{58a}'), ('\u{58d}', '\u{58e}'), ('\u{58f}', '\u{58f}'), ('\u{fb13}', '\u{fb17}') ]; - pub static Avestan_table: &'static [(char, char)] = &[ + pub const Avestan_table: &'static [(char, char)] = &[ ('\u{10b00}', '\u{10b35}'), ('\u{10b39}', '\u{10b3f}') ]; - pub static Balinese_table: &'static [(char, char)] = &[ + pub const Balinese_table: &'static [(char, char)] = &[ ('\u{1b00}', '\u{1b03}'), ('\u{1b04}', '\u{1b04}'), ('\u{1b05}', '\u{1b33}'), ('\u{1b34}', '\u{1b34}'), ('\u{1b35}', '\u{1b35}'), ('\u{1b36}', '\u{1b3a}'), ('\u{1b3b}', '\u{1b3b}'), ('\u{1b3c}', '\u{1b3c}'), ('\u{1b3d}', '\u{1b41}'), ('\u{1b42}', '\u{1b42}'), ('\u{1b43}', @@ -3012,22 +3012,22 @@ pub mod script { ('\u{1b61}', '\u{1b6a}'), ('\u{1b6b}', '\u{1b73}'), ('\u{1b74}', '\u{1b7c}') ]; - pub static Bamum_table: &'static [(char, char)] = &[ + pub const Bamum_table: &'static [(char, char)] = &[ ('\u{a6a0}', '\u{a6e5}'), ('\u{a6e6}', '\u{a6ef}'), ('\u{a6f0}', '\u{a6f1}'), ('\u{a6f2}', '\u{a6f7}'), ('\u{16800}', '\u{16a38}') ]; - pub static Bassa_Vah_table: &'static [(char, char)] = &[ + pub const Bassa_Vah_table: &'static [(char, char)] = &[ ('\u{16ad0}', '\u{16aed}'), ('\u{16af0}', '\u{16af4}'), ('\u{16af5}', '\u{16af5}') ]; - pub static Batak_table: &'static [(char, char)] = &[ + pub const Batak_table: &'static [(char, char)] = &[ ('\u{1bc0}', '\u{1be5}'), ('\u{1be6}', '\u{1be6}'), ('\u{1be7}', '\u{1be7}'), ('\u{1be8}', '\u{1be9}'), ('\u{1bea}', '\u{1bec}'), ('\u{1bed}', '\u{1bed}'), ('\u{1bee}', '\u{1bee}'), ('\u{1bef}', '\u{1bf1}'), ('\u{1bf2}', '\u{1bf3}'), ('\u{1bfc}', '\u{1bff}') ]; - pub static Bengali_table: &'static [(char, char)] = &[ + pub const Bengali_table: &'static [(char, char)] = &[ ('\u{980}', '\u{980}'), ('\u{981}', '\u{981}'), ('\u{982}', '\u{983}'), ('\u{985}', '\u{98c}'), ('\u{98f}', '\u{990}'), ('\u{993}', '\u{9a8}'), ('\u{9aa}', '\u{9b0}'), ('\u{9b2}', '\u{9b2}'), ('\u{9b6}', '\u{9b9}'), ('\u{9bc}', '\u{9bc}'), ('\u{9bd}', @@ -3038,60 +3038,60 @@ pub mod script { '\u{9f9}'), ('\u{9fa}', '\u{9fa}'), ('\u{9fb}', '\u{9fb}') ]; - pub static Bopomofo_table: &'static [(char, char)] = &[ + pub const Bopomofo_table: &'static [(char, char)] = &[ ('\u{2ea}', '\u{2eb}'), ('\u{3105}', '\u{312d}'), ('\u{31a0}', '\u{31ba}') ]; - pub static Brahmi_table: &'static [(char, char)] = &[ + pub const Brahmi_table: &'static [(char, char)] = &[ ('\u{11000}', '\u{11000}'), ('\u{11001}', '\u{11001}'), ('\u{11002}', '\u{11002}'), ('\u{11003}', '\u{11037}'), ('\u{11038}', '\u{11046}'), ('\u{11047}', '\u{1104d}'), ('\u{11052}', '\u{11065}'), ('\u{11066}', '\u{1106f}'), ('\u{1107f}', '\u{1107f}') ]; - pub static Braille_table: &'static [(char, char)] = &[ + pub const Braille_table: &'static [(char, char)] = &[ ('\u{2800}', '\u{28ff}') ]; - pub static Buginese_table: &'static [(char, char)] = &[ + pub const Buginese_table: &'static [(char, char)] = &[ ('\u{1a00}', '\u{1a16}'), ('\u{1a17}', '\u{1a18}'), ('\u{1a19}', '\u{1a1a}'), ('\u{1a1b}', '\u{1a1b}'), ('\u{1a1e}', '\u{1a1f}') ]; - pub static Buhid_table: &'static [(char, char)] = &[ + pub const Buhid_table: &'static [(char, char)] = &[ ('\u{1740}', '\u{1751}'), ('\u{1752}', '\u{1753}') ]; - pub static Canadian_Aboriginal_table: &'static [(char, char)] = &[ + pub const Canadian_Aboriginal_table: &'static [(char, char)] = &[ ('\u{1400}', '\u{1400}'), ('\u{1401}', '\u{166c}'), ('\u{166d}', '\u{166e}'), ('\u{166f}', '\u{167f}'), ('\u{18b0}', '\u{18f5}') ]; - pub static Carian_table: &'static [(char, char)] = &[ + pub const Carian_table: &'static [(char, char)] = &[ ('\u{102a0}', '\u{102d0}') ]; - pub static Caucasian_Albanian_table: &'static [(char, char)] = &[ + pub const Caucasian_Albanian_table: &'static [(char, char)] = &[ ('\u{10530}', '\u{10563}'), ('\u{1056f}', '\u{1056f}') ]; - pub static Chakma_table: &'static [(char, char)] = &[ + pub const Chakma_table: &'static [(char, char)] = &[ ('\u{11100}', '\u{11102}'), ('\u{11103}', '\u{11126}'), ('\u{11127}', '\u{1112b}'), ('\u{1112c}', '\u{1112c}'), ('\u{1112d}', '\u{11134}'), ('\u{11136}', '\u{1113f}'), ('\u{11140}', '\u{11143}') ]; - pub static Cham_table: &'static [(char, char)] = &[ + pub const Cham_table: &'static [(char, char)] = &[ ('\u{aa00}', '\u{aa28}'), ('\u{aa29}', '\u{aa2e}'), ('\u{aa2f}', '\u{aa30}'), ('\u{aa31}', '\u{aa32}'), ('\u{aa33}', '\u{aa34}'), ('\u{aa35}', '\u{aa36}'), ('\u{aa40}', '\u{aa42}'), ('\u{aa43}', '\u{aa43}'), ('\u{aa44}', '\u{aa4b}'), ('\u{aa4c}', '\u{aa4c}'), ('\u{aa4d}', '\u{aa4d}'), ('\u{aa50}', '\u{aa59}'), ('\u{aa5c}', '\u{aa5f}') ]; - pub static Cherokee_table: &'static [(char, char)] = &[ + pub const Cherokee_table: &'static [(char, char)] = &[ ('\u{13a0}', '\u{13f4}') ]; - pub static Common_table: &'static [(char, char)] = &[ + pub const Common_table: &'static [(char, char)] = &[ ('\u{0}', '\u{1f}'), ('\u{20}', '\u{20}'), ('\u{21}', '\u{23}'), ('\u{24}', '\u{24}'), ('\u{25}', '\u{27}'), ('\u{28}', '\u{28}'), ('\u{29}', '\u{29}'), ('\u{2a}', '\u{2a}'), ('\u{2b}', '\u{2b}'), ('\u{2c}', '\u{2c}'), ('\u{2d}', '\u{2d}'), ('\u{2e}', '\u{2f}'), @@ -3261,22 +3261,22 @@ pub mod script { ('\u{1f890}', '\u{1f8ad}'), ('\u{e0001}', '\u{e0001}'), ('\u{e0020}', '\u{e007f}') ]; - pub static Coptic_table: &'static [(char, char)] = &[ + pub const Coptic_table: &'static [(char, char)] = &[ ('\u{3e2}', '\u{3ef}'), ('\u{2c80}', '\u{2ce4}'), ('\u{2ce5}', '\u{2cea}'), ('\u{2ceb}', '\u{2cee}'), ('\u{2cef}', '\u{2cf1}'), ('\u{2cf2}', '\u{2cf3}'), ('\u{2cf9}', '\u{2cfc}'), ('\u{2cfd}', '\u{2cfd}'), ('\u{2cfe}', '\u{2cff}') ]; - pub static Cuneiform_table: &'static [(char, char)] = &[ + pub const Cuneiform_table: &'static [(char, char)] = &[ ('\u{12000}', '\u{12398}'), ('\u{12400}', '\u{1246e}'), ('\u{12470}', '\u{12474}') ]; - pub static Cypriot_table: &'static [(char, char)] = &[ + pub const Cypriot_table: &'static [(char, char)] = &[ ('\u{10800}', '\u{10805}'), ('\u{10808}', '\u{10808}'), ('\u{1080a}', '\u{10835}'), ('\u{10837}', '\u{10838}'), ('\u{1083c}', '\u{1083c}'), ('\u{1083f}', '\u{1083f}') ]; - pub static Cyrillic_table: &'static [(char, char)] = &[ + pub const Cyrillic_table: &'static [(char, char)] = &[ ('\u{400}', '\u{481}'), ('\u{482}', '\u{482}'), ('\u{483}', '\u{484}'), ('\u{487}', '\u{487}'), ('\u{488}', '\u{489}'), ('\u{48a}', '\u{52f}'), ('\u{1d2b}', '\u{1d2b}'), ('\u{1d78}', '\u{1d78}'), ('\u{2de0}', '\u{2dff}'), ('\u{a640}', '\u{a66d}'), ('\u{a66e}', @@ -3285,11 +3285,11 @@ pub mod script { '\u{a69b}'), ('\u{a69c}', '\u{a69d}'), ('\u{a69f}', '\u{a69f}') ]; - pub static Deseret_table: &'static [(char, char)] = &[ + pub const Deseret_table: &'static [(char, char)] = &[ ('\u{10400}', '\u{1044f}') ]; - pub static Devanagari_table: &'static [(char, char)] = &[ + pub const Devanagari_table: &'static [(char, char)] = &[ ('\u{900}', '\u{902}'), ('\u{903}', '\u{903}'), ('\u{904}', '\u{939}'), ('\u{93a}', '\u{93a}'), ('\u{93b}', '\u{93b}'), ('\u{93c}', '\u{93c}'), ('\u{93d}', '\u{93d}'), ('\u{93e}', '\u{940}'), ('\u{941}', '\u{948}'), ('\u{949}', '\u{94c}'), ('\u{94d}', @@ -3299,21 +3299,21 @@ pub mod script { ('\u{a8f2}', '\u{a8f7}'), ('\u{a8f8}', '\u{a8fa}'), ('\u{a8fb}', '\u{a8fb}') ]; - pub static Duployan_table: &'static [(char, char)] = &[ + pub const Duployan_table: &'static [(char, char)] = &[ ('\u{1bc00}', '\u{1bc6a}'), ('\u{1bc70}', '\u{1bc7c}'), ('\u{1bc80}', '\u{1bc88}'), ('\u{1bc90}', '\u{1bc99}'), ('\u{1bc9c}', '\u{1bc9c}'), ('\u{1bc9d}', '\u{1bc9e}'), ('\u{1bc9f}', '\u{1bc9f}') ]; - pub static Egyptian_Hieroglyphs_table: &'static [(char, char)] = &[ + pub const Egyptian_Hieroglyphs_table: &'static [(char, char)] = &[ ('\u{13000}', '\u{1342e}') ]; - pub static Elbasan_table: &'static [(char, char)] = &[ + pub const Elbasan_table: &'static [(char, char)] = &[ ('\u{10500}', '\u{10527}') ]; - pub static Ethiopic_table: &'static [(char, char)] = &[ + pub const Ethiopic_table: &'static [(char, char)] = &[ ('\u{1200}', '\u{1248}'), ('\u{124a}', '\u{124d}'), ('\u{1250}', '\u{1256}'), ('\u{1258}', '\u{1258}'), ('\u{125a}', '\u{125d}'), ('\u{1260}', '\u{1288}'), ('\u{128a}', '\u{128d}'), ('\u{1290}', '\u{12b0}'), ('\u{12b2}', '\u{12b5}'), ('\u{12b8}', '\u{12be}'), ('\u{12c0}', @@ -3326,22 +3326,22 @@ pub mod script { '\u{ab0e}'), ('\u{ab11}', '\u{ab16}'), ('\u{ab20}', '\u{ab26}'), ('\u{ab28}', '\u{ab2e}') ]; - pub static Georgian_table: &'static [(char, char)] = &[ + pub const Georgian_table: &'static [(char, char)] = &[ ('\u{10a0}', '\u{10c5}'), ('\u{10c7}', '\u{10c7}'), ('\u{10cd}', '\u{10cd}'), ('\u{10d0}', '\u{10fa}'), ('\u{10fc}', '\u{10fc}'), ('\u{10fd}', '\u{10ff}'), ('\u{2d00}', '\u{2d25}'), ('\u{2d27}', '\u{2d27}'), ('\u{2d2d}', '\u{2d2d}') ]; - pub static Glagolitic_table: &'static [(char, char)] = &[ + pub const Glagolitic_table: &'static [(char, char)] = &[ ('\u{2c00}', '\u{2c2e}'), ('\u{2c30}', '\u{2c5e}') ]; - pub static Gothic_table: &'static [(char, char)] = &[ + pub const Gothic_table: &'static [(char, char)] = &[ ('\u{10330}', '\u{10340}'), ('\u{10341}', '\u{10341}'), ('\u{10342}', '\u{10349}'), ('\u{1034a}', '\u{1034a}') ]; - pub static Grantha_table: &'static [(char, char)] = &[ + pub const Grantha_table: &'static [(char, char)] = &[ ('\u{11301}', '\u{11301}'), ('\u{11302}', '\u{11303}'), ('\u{11305}', '\u{1130c}'), ('\u{1130f}', '\u{11310}'), ('\u{11313}', '\u{11328}'), ('\u{1132a}', '\u{11330}'), ('\u{11332}', '\u{11333}'), ('\u{11335}', '\u{11339}'), ('\u{1133c}', '\u{1133c}'), @@ -3351,7 +3351,7 @@ pub mod script { ('\u{11366}', '\u{1136c}'), ('\u{11370}', '\u{11374}') ]; - pub static Greek_table: &'static [(char, char)] = &[ + pub const Greek_table: &'static [(char, char)] = &[ ('\u{370}', '\u{373}'), ('\u{375}', '\u{375}'), ('\u{376}', '\u{377}'), ('\u{37a}', '\u{37a}'), ('\u{37b}', '\u{37d}'), ('\u{37f}', '\u{37f}'), ('\u{384}', '\u{384}'), ('\u{386}', '\u{386}'), ('\u{388}', '\u{38a}'), ('\u{38c}', '\u{38c}'), ('\u{38e}', @@ -3371,7 +3371,7 @@ pub mod script { '\u{1d245}') ]; - pub static Gujarati_table: &'static [(char, char)] = &[ + pub const Gujarati_table: &'static [(char, char)] = &[ ('\u{a81}', '\u{a82}'), ('\u{a83}', '\u{a83}'), ('\u{a85}', '\u{a8d}'), ('\u{a8f}', '\u{a91}'), ('\u{a93}', '\u{aa8}'), ('\u{aaa}', '\u{ab0}'), ('\u{ab2}', '\u{ab3}'), ('\u{ab5}', '\u{ab9}'), ('\u{abc}', '\u{abc}'), ('\u{abd}', '\u{abd}'), ('\u{abe}', @@ -3381,7 +3381,7 @@ pub mod script { ('\u{af1}', '\u{af1}') ]; - pub static Gurmukhi_table: &'static [(char, char)] = &[ + pub const Gurmukhi_table: &'static [(char, char)] = &[ ('\u{a01}', '\u{a02}'), ('\u{a03}', '\u{a03}'), ('\u{a05}', '\u{a0a}'), ('\u{a0f}', '\u{a10}'), ('\u{a13}', '\u{a28}'), ('\u{a2a}', '\u{a30}'), ('\u{a32}', '\u{a33}'), ('\u{a35}', '\u{a36}'), ('\u{a38}', '\u{a39}'), ('\u{a3c}', '\u{a3c}'), ('\u{a3e}', @@ -3390,7 +3390,7 @@ pub mod script { '\u{a6f}'), ('\u{a70}', '\u{a71}'), ('\u{a72}', '\u{a74}'), ('\u{a75}', '\u{a75}') ]; - pub static Han_table: &'static [(char, char)] = &[ + pub const Han_table: &'static [(char, char)] = &[ ('\u{2e80}', '\u{2e99}'), ('\u{2e9b}', '\u{2ef3}'), ('\u{2f00}', '\u{2fd5}'), ('\u{3005}', '\u{3005}'), ('\u{3007}', '\u{3007}'), ('\u{3021}', '\u{3029}'), ('\u{3038}', '\u{303a}'), ('\u{303b}', '\u{303b}'), ('\u{3400}', '\u{4db5}'), ('\u{4e00}', '\u{9fcc}'), ('\u{f900}', @@ -3398,18 +3398,18 @@ pub mod script { '\u{2b734}'), ('\u{2b740}', '\u{2b81d}'), ('\u{2f800}', '\u{2fa1d}') ]; - pub static Hangul_table: &'static [(char, char)] = &[ + pub const Hangul_table: &'static [(char, char)] = &[ ('\u{1100}', '\u{11ff}'), ('\u{302e}', '\u{302f}'), ('\u{3131}', '\u{318e}'), ('\u{3200}', '\u{321e}'), ('\u{3260}', '\u{327e}'), ('\u{a960}', '\u{a97c}'), ('\u{ac00}', '\u{d7a3}'), ('\u{d7b0}', '\u{d7c6}'), ('\u{d7cb}', '\u{d7fb}'), ('\u{ffa0}', '\u{ffbe}'), ('\u{ffc2}', '\u{ffc7}'), ('\u{ffca}', '\u{ffcf}'), ('\u{ffd2}', '\u{ffd7}'), ('\u{ffda}', '\u{ffdc}') ]; - pub static Hanunoo_table: &'static [(char, char)] = &[ + pub const Hanunoo_table: &'static [(char, char)] = &[ ('\u{1720}', '\u{1731}'), ('\u{1732}', '\u{1734}') ]; - pub static Hebrew_table: &'static [(char, char)] = &[ + pub const Hebrew_table: &'static [(char, char)] = &[ ('\u{591}', '\u{5bd}'), ('\u{5be}', '\u{5be}'), ('\u{5bf}', '\u{5bf}'), ('\u{5c0}', '\u{5c0}'), ('\u{5c1}', '\u{5c2}'), ('\u{5c3}', '\u{5c3}'), ('\u{5c4}', '\u{5c5}'), ('\u{5c6}', '\u{5c6}'), ('\u{5c7}', '\u{5c7}'), ('\u{5d0}', '\u{5ea}'), ('\u{5f0}', @@ -3419,16 +3419,16 @@ pub mod script { ('\u{fb46}', '\u{fb4f}') ]; - pub static Hiragana_table: &'static [(char, char)] = &[ + pub const Hiragana_table: &'static [(char, char)] = &[ ('\u{3041}', '\u{3096}'), ('\u{309d}', '\u{309e}'), ('\u{309f}', '\u{309f}'), ('\u{1b001}', '\u{1b001}'), ('\u{1f200}', '\u{1f200}') ]; - pub static Imperial_Aramaic_table: &'static [(char, char)] = &[ + pub const Imperial_Aramaic_table: &'static [(char, char)] = &[ ('\u{10840}', '\u{10855}'), ('\u{10857}', '\u{10857}'), ('\u{10858}', '\u{1085f}') ]; - pub static Inherited_table: &'static [(char, char)] = &[ + pub const Inherited_table: &'static [(char, char)] = &[ ('\u{300}', '\u{36f}'), ('\u{485}', '\u{486}'), ('\u{64b}', '\u{655}'), ('\u{670}', '\u{670}'), ('\u{951}', '\u{952}'), ('\u{1ab0}', '\u{1abd}'), ('\u{1abe}', '\u{1abe}'), ('\u{1cd0}', '\u{1cd2}'), ('\u{1cd4}', '\u{1ce0}'), ('\u{1ce2}', '\u{1ce8}'), ('\u{1ced}', @@ -3441,29 +3441,29 @@ pub mod script { '\u{1d1ad}'), ('\u{e0100}', '\u{e01ef}') ]; - pub static Inscriptional_Pahlavi_table: &'static [(char, char)] = &[ + pub const Inscriptional_Pahlavi_table: &'static [(char, char)] = &[ ('\u{10b60}', '\u{10b72}'), ('\u{10b78}', '\u{10b7f}') ]; - pub static Inscriptional_Parthian_table: &'static [(char, char)] = &[ + pub const Inscriptional_Parthian_table: &'static [(char, char)] = &[ ('\u{10b40}', '\u{10b55}'), ('\u{10b58}', '\u{10b5f}') ]; - pub static Javanese_table: &'static [(char, char)] = &[ + pub const Javanese_table: &'static [(char, char)] = &[ ('\u{a980}', '\u{a982}'), ('\u{a983}', '\u{a983}'), ('\u{a984}', '\u{a9b2}'), ('\u{a9b3}', '\u{a9b3}'), ('\u{a9b4}', '\u{a9b5}'), ('\u{a9b6}', '\u{a9b9}'), ('\u{a9ba}', '\u{a9bb}'), ('\u{a9bc}', '\u{a9bc}'), ('\u{a9bd}', '\u{a9c0}'), ('\u{a9c1}', '\u{a9cd}'), ('\u{a9d0}', '\u{a9d9}'), ('\u{a9de}', '\u{a9df}') ]; - pub static Kaithi_table: &'static [(char, char)] = &[ + pub const Kaithi_table: &'static [(char, char)] = &[ ('\u{11080}', '\u{11081}'), ('\u{11082}', '\u{11082}'), ('\u{11083}', '\u{110af}'), ('\u{110b0}', '\u{110b2}'), ('\u{110b3}', '\u{110b6}'), ('\u{110b7}', '\u{110b8}'), ('\u{110b9}', '\u{110ba}'), ('\u{110bb}', '\u{110bc}'), ('\u{110bd}', '\u{110bd}'), ('\u{110be}', '\u{110c1}') ]; - pub static Kannada_table: &'static [(char, char)] = &[ + pub const Kannada_table: &'static [(char, char)] = &[ ('\u{c81}', '\u{c81}'), ('\u{c82}', '\u{c83}'), ('\u{c85}', '\u{c8c}'), ('\u{c8e}', '\u{c90}'), ('\u{c92}', '\u{ca8}'), ('\u{caa}', '\u{cb3}'), ('\u{cb5}', '\u{cb9}'), ('\u{cbc}', '\u{cbc}'), ('\u{cbd}', '\u{cbd}'), ('\u{cbe}', '\u{cbe}'), ('\u{cbf}', @@ -3473,25 +3473,25 @@ pub mod script { ('\u{cf1}', '\u{cf2}') ]; - pub static Katakana_table: &'static [(char, char)] = &[ + pub const Katakana_table: &'static [(char, char)] = &[ ('\u{30a1}', '\u{30fa}'), ('\u{30fd}', '\u{30fe}'), ('\u{30ff}', '\u{30ff}'), ('\u{31f0}', '\u{31ff}'), ('\u{32d0}', '\u{32fe}'), ('\u{3300}', '\u{3357}'), ('\u{ff66}', '\u{ff6f}'), ('\u{ff71}', '\u{ff9d}'), ('\u{1b000}', '\u{1b000}') ]; - pub static Kayah_Li_table: &'static [(char, char)] = &[ + pub const Kayah_Li_table: &'static [(char, char)] = &[ ('\u{a900}', '\u{a909}'), ('\u{a90a}', '\u{a925}'), ('\u{a926}', '\u{a92d}'), ('\u{a92f}', '\u{a92f}') ]; - pub static Kharoshthi_table: &'static [(char, char)] = &[ + pub const Kharoshthi_table: &'static [(char, char)] = &[ ('\u{10a00}', '\u{10a00}'), ('\u{10a01}', '\u{10a03}'), ('\u{10a05}', '\u{10a06}'), ('\u{10a0c}', '\u{10a0f}'), ('\u{10a10}', '\u{10a13}'), ('\u{10a15}', '\u{10a17}'), ('\u{10a19}', '\u{10a33}'), ('\u{10a38}', '\u{10a3a}'), ('\u{10a3f}', '\u{10a3f}'), ('\u{10a40}', '\u{10a47}'), ('\u{10a50}', '\u{10a58}') ]; - pub static Khmer_table: &'static [(char, char)] = &[ + pub const Khmer_table: &'static [(char, char)] = &[ ('\u{1780}', '\u{17b3}'), ('\u{17b4}', '\u{17b5}'), ('\u{17b6}', '\u{17b6}'), ('\u{17b7}', '\u{17bd}'), ('\u{17be}', '\u{17c5}'), ('\u{17c6}', '\u{17c6}'), ('\u{17c7}', '\u{17c8}'), ('\u{17c9}', '\u{17d3}'), ('\u{17d4}', '\u{17d6}'), ('\u{17d7}', '\u{17d7}'), ('\u{17d8}', @@ -3499,18 +3499,18 @@ pub mod script { ('\u{17e0}', '\u{17e9}'), ('\u{17f0}', '\u{17f9}'), ('\u{19e0}', '\u{19ff}') ]; - pub static Khojki_table: &'static [(char, char)] = &[ + pub const Khojki_table: &'static [(char, char)] = &[ ('\u{11200}', '\u{11211}'), ('\u{11213}', '\u{1122b}'), ('\u{1122c}', '\u{1122e}'), ('\u{1122f}', '\u{11231}'), ('\u{11232}', '\u{11233}'), ('\u{11234}', '\u{11234}'), ('\u{11235}', '\u{11235}'), ('\u{11236}', '\u{11237}'), ('\u{11238}', '\u{1123d}') ]; - pub static Khudawadi_table: &'static [(char, char)] = &[ + pub const Khudawadi_table: &'static [(char, char)] = &[ ('\u{112b0}', '\u{112de}'), ('\u{112df}', '\u{112df}'), ('\u{112e0}', '\u{112e2}'), ('\u{112e3}', '\u{112ea}'), ('\u{112f0}', '\u{112f9}') ]; - pub static Lao_table: &'static [(char, char)] = &[ + pub const Lao_table: &'static [(char, char)] = &[ ('\u{e81}', '\u{e82}'), ('\u{e84}', '\u{e84}'), ('\u{e87}', '\u{e88}'), ('\u{e8a}', '\u{e8a}'), ('\u{e8d}', '\u{e8d}'), ('\u{e94}', '\u{e97}'), ('\u{e99}', '\u{e9f}'), ('\u{ea1}', '\u{ea3}'), ('\u{ea5}', '\u{ea5}'), ('\u{ea7}', '\u{ea7}'), ('\u{eaa}', @@ -3520,7 +3520,7 @@ pub mod script { ('\u{edc}', '\u{edf}') ]; - pub static Latin_table: &'static [(char, char)] = &[ + pub const Latin_table: &'static [(char, char)] = &[ ('\u{41}', '\u{5a}'), ('\u{61}', '\u{7a}'), ('\u{aa}', '\u{aa}'), ('\u{ba}', '\u{ba}'), ('\u{c0}', '\u{d6}'), ('\u{d8}', '\u{f6}'), ('\u{f8}', '\u{1ba}'), ('\u{1bb}', '\u{1bb}'), ('\u{1bc}', '\u{1bf}'), ('\u{1c0}', '\u{1c3}'), ('\u{1c4}', '\u{293}'), ('\u{294}', @@ -3537,47 +3537,47 @@ pub mod script { '\u{ab64}'), ('\u{fb00}', '\u{fb06}'), ('\u{ff21}', '\u{ff3a}'), ('\u{ff41}', '\u{ff5a}') ]; - pub static Lepcha_table: &'static [(char, char)] = &[ + pub const Lepcha_table: &'static [(char, char)] = &[ ('\u{1c00}', '\u{1c23}'), ('\u{1c24}', '\u{1c2b}'), ('\u{1c2c}', '\u{1c33}'), ('\u{1c34}', '\u{1c35}'), ('\u{1c36}', '\u{1c37}'), ('\u{1c3b}', '\u{1c3f}'), ('\u{1c40}', '\u{1c49}'), ('\u{1c4d}', '\u{1c4f}') ]; - pub static Limbu_table: &'static [(char, char)] = &[ + pub const Limbu_table: &'static [(char, char)] = &[ ('\u{1900}', '\u{191e}'), ('\u{1920}', '\u{1922}'), ('\u{1923}', '\u{1926}'), ('\u{1927}', '\u{1928}'), ('\u{1929}', '\u{192b}'), ('\u{1930}', '\u{1931}'), ('\u{1932}', '\u{1932}'), ('\u{1933}', '\u{1938}'), ('\u{1939}', '\u{193b}'), ('\u{1940}', '\u{1940}'), ('\u{1944}', '\u{1945}'), ('\u{1946}', '\u{194f}') ]; - pub static Linear_A_table: &'static [(char, char)] = &[ + pub const Linear_A_table: &'static [(char, char)] = &[ ('\u{10600}', '\u{10736}'), ('\u{10740}', '\u{10755}'), ('\u{10760}', '\u{10767}') ]; - pub static Linear_B_table: &'static [(char, char)] = &[ + pub const Linear_B_table: &'static [(char, char)] = &[ ('\u{10000}', '\u{1000b}'), ('\u{1000d}', '\u{10026}'), ('\u{10028}', '\u{1003a}'), ('\u{1003c}', '\u{1003d}'), ('\u{1003f}', '\u{1004d}'), ('\u{10050}', '\u{1005d}'), ('\u{10080}', '\u{100fa}') ]; - pub static Lisu_table: &'static [(char, char)] = &[ + pub const Lisu_table: &'static [(char, char)] = &[ ('\u{a4d0}', '\u{a4f7}'), ('\u{a4f8}', '\u{a4fd}'), ('\u{a4fe}', '\u{a4ff}') ]; - pub static Lycian_table: &'static [(char, char)] = &[ + pub const Lycian_table: &'static [(char, char)] = &[ ('\u{10280}', '\u{1029c}') ]; - pub static Lydian_table: &'static [(char, char)] = &[ + pub const Lydian_table: &'static [(char, char)] = &[ ('\u{10920}', '\u{10939}'), ('\u{1093f}', '\u{1093f}') ]; - pub static Mahajani_table: &'static [(char, char)] = &[ + pub const Mahajani_table: &'static [(char, char)] = &[ ('\u{11150}', '\u{11172}'), ('\u{11173}', '\u{11173}'), ('\u{11174}', '\u{11175}'), ('\u{11176}', '\u{11176}') ]; - pub static Malayalam_table: &'static [(char, char)] = &[ + pub const Malayalam_table: &'static [(char, char)] = &[ ('\u{d01}', '\u{d01}'), ('\u{d02}', '\u{d03}'), ('\u{d05}', '\u{d0c}'), ('\u{d0e}', '\u{d10}'), ('\u{d12}', '\u{d3a}'), ('\u{d3d}', '\u{d3d}'), ('\u{d3e}', '\u{d40}'), ('\u{d41}', '\u{d44}'), ('\u{d46}', '\u{d48}'), ('\u{d4a}', '\u{d4c}'), ('\u{d4d}', @@ -3586,16 +3586,16 @@ pub mod script { '\u{d79}'), ('\u{d7a}', '\u{d7f}') ]; - pub static Mandaic_table: &'static [(char, char)] = &[ + pub const Mandaic_table: &'static [(char, char)] = &[ ('\u{840}', '\u{858}'), ('\u{859}', '\u{85b}'), ('\u{85e}', '\u{85e}') ]; - pub static Manichaean_table: &'static [(char, char)] = &[ + pub const Manichaean_table: &'static [(char, char)] = &[ ('\u{10ac0}', '\u{10ac7}'), ('\u{10ac8}', '\u{10ac8}'), ('\u{10ac9}', '\u{10ae4}'), ('\u{10ae5}', '\u{10ae6}'), ('\u{10aeb}', '\u{10aef}'), ('\u{10af0}', '\u{10af6}') ]; - pub static Meetei_Mayek_table: &'static [(char, char)] = &[ + pub const Meetei_Mayek_table: &'static [(char, char)] = &[ ('\u{aae0}', '\u{aaea}'), ('\u{aaeb}', '\u{aaeb}'), ('\u{aaec}', '\u{aaed}'), ('\u{aaee}', '\u{aaef}'), ('\u{aaf0}', '\u{aaf1}'), ('\u{aaf2}', '\u{aaf2}'), ('\u{aaf3}', '\u{aaf4}'), ('\u{aaf5}', '\u{aaf5}'), ('\u{aaf6}', '\u{aaf6}'), ('\u{abc0}', '\u{abe2}'), ('\u{abe3}', @@ -3604,42 +3604,42 @@ pub mod script { '\u{abed}'), ('\u{abf0}', '\u{abf9}') ]; - pub static Mende_Kikakui_table: &'static [(char, char)] = &[ + pub const Mende_Kikakui_table: &'static [(char, char)] = &[ ('\u{1e800}', '\u{1e8c4}'), ('\u{1e8c7}', '\u{1e8cf}'), ('\u{1e8d0}', '\u{1e8d6}') ]; - pub static Meroitic_Cursive_table: &'static [(char, char)] = &[ + pub const Meroitic_Cursive_table: &'static [(char, char)] = &[ ('\u{109a0}', '\u{109b7}'), ('\u{109be}', '\u{109bf}') ]; - pub static Meroitic_Hieroglyphs_table: &'static [(char, char)] = &[ + pub const Meroitic_Hieroglyphs_table: &'static [(char, char)] = &[ ('\u{10980}', '\u{1099f}') ]; - pub static Miao_table: &'static [(char, char)] = &[ + pub const Miao_table: &'static [(char, char)] = &[ ('\u{16f00}', '\u{16f44}'), ('\u{16f50}', '\u{16f50}'), ('\u{16f51}', '\u{16f7e}'), ('\u{16f8f}', '\u{16f92}'), ('\u{16f93}', '\u{16f9f}') ]; - pub static Modi_table: &'static [(char, char)] = &[ + pub const Modi_table: &'static [(char, char)] = &[ ('\u{11600}', '\u{1162f}'), ('\u{11630}', '\u{11632}'), ('\u{11633}', '\u{1163a}'), ('\u{1163b}', '\u{1163c}'), ('\u{1163d}', '\u{1163d}'), ('\u{1163e}', '\u{1163e}'), ('\u{1163f}', '\u{11640}'), ('\u{11641}', '\u{11643}'), ('\u{11644}', '\u{11644}'), ('\u{11650}', '\u{11659}') ]; - pub static Mongolian_table: &'static [(char, char)] = &[ + pub const Mongolian_table: &'static [(char, char)] = &[ ('\u{1800}', '\u{1801}'), ('\u{1804}', '\u{1804}'), ('\u{1806}', '\u{1806}'), ('\u{1807}', '\u{180a}'), ('\u{180b}', '\u{180d}'), ('\u{180e}', '\u{180e}'), ('\u{1810}', '\u{1819}'), ('\u{1820}', '\u{1842}'), ('\u{1843}', '\u{1843}'), ('\u{1844}', '\u{1877}'), ('\u{1880}', '\u{18a8}'), ('\u{18a9}', '\u{18a9}'), ('\u{18aa}', '\u{18aa}') ]; - pub static Mro_table: &'static [(char, char)] = &[ + pub const Mro_table: &'static [(char, char)] = &[ ('\u{16a40}', '\u{16a5e}'), ('\u{16a60}', '\u{16a69}'), ('\u{16a6e}', '\u{16a6f}') ]; - pub static Myanmar_table: &'static [(char, char)] = &[ + pub const Myanmar_table: &'static [(char, char)] = &[ ('\u{1000}', '\u{102a}'), ('\u{102b}', '\u{102c}'), ('\u{102d}', '\u{1030}'), ('\u{1031}', '\u{1031}'), ('\u{1032}', '\u{1037}'), ('\u{1038}', '\u{1038}'), ('\u{1039}', '\u{103a}'), ('\u{103b}', '\u{103c}'), ('\u{103d}', '\u{103e}'), ('\u{103f}', '\u{103f}'), ('\u{1040}', @@ -3657,56 +3657,56 @@ pub mod script { ('\u{aa7e}', '\u{aa7f}') ]; - pub static Nabataean_table: &'static [(char, char)] = &[ + pub const Nabataean_table: &'static [(char, char)] = &[ ('\u{10880}', '\u{1089e}'), ('\u{108a7}', '\u{108af}') ]; - pub static New_Tai_Lue_table: &'static [(char, char)] = &[ + pub const New_Tai_Lue_table: &'static [(char, char)] = &[ ('\u{1980}', '\u{19ab}'), ('\u{19b0}', '\u{19c0}'), ('\u{19c1}', '\u{19c7}'), ('\u{19c8}', '\u{19c9}'), ('\u{19d0}', '\u{19d9}'), ('\u{19da}', '\u{19da}'), ('\u{19de}', '\u{19df}') ]; - pub static Nko_table: &'static [(char, char)] = &[ + pub const Nko_table: &'static [(char, char)] = &[ ('\u{7c0}', '\u{7c9}'), ('\u{7ca}', '\u{7ea}'), ('\u{7eb}', '\u{7f3}'), ('\u{7f4}', '\u{7f5}'), ('\u{7f6}', '\u{7f6}'), ('\u{7f7}', '\u{7f9}'), ('\u{7fa}', '\u{7fa}') ]; - pub static Ogham_table: &'static [(char, char)] = &[ + pub const Ogham_table: &'static [(char, char)] = &[ ('\u{1680}', '\u{1680}'), ('\u{1681}', '\u{169a}'), ('\u{169b}', '\u{169b}'), ('\u{169c}', '\u{169c}') ]; - pub static Ol_Chiki_table: &'static [(char, char)] = &[ + pub const Ol_Chiki_table: &'static [(char, char)] = &[ ('\u{1c50}', '\u{1c59}'), ('\u{1c5a}', '\u{1c77}'), ('\u{1c78}', '\u{1c7d}'), ('\u{1c7e}', '\u{1c7f}') ]; - pub static Old_Italic_table: &'static [(char, char)] = &[ + pub const Old_Italic_table: &'static [(char, char)] = &[ ('\u{10300}', '\u{1031f}'), ('\u{10320}', '\u{10323}') ]; - pub static Old_North_Arabian_table: &'static [(char, char)] = &[ + pub const Old_North_Arabian_table: &'static [(char, char)] = &[ ('\u{10a80}', '\u{10a9c}'), ('\u{10a9d}', '\u{10a9f}') ]; - pub static Old_Permic_table: &'static [(char, char)] = &[ + pub const Old_Permic_table: &'static [(char, char)] = &[ ('\u{10350}', '\u{10375}'), ('\u{10376}', '\u{1037a}') ]; - pub static Old_Persian_table: &'static [(char, char)] = &[ + pub const Old_Persian_table: &'static [(char, char)] = &[ ('\u{103a0}', '\u{103c3}'), ('\u{103c8}', '\u{103cf}'), ('\u{103d0}', '\u{103d0}'), ('\u{103d1}', '\u{103d5}') ]; - pub static Old_South_Arabian_table: &'static [(char, char)] = &[ + pub const Old_South_Arabian_table: &'static [(char, char)] = &[ ('\u{10a60}', '\u{10a7c}'), ('\u{10a7d}', '\u{10a7e}'), ('\u{10a7f}', '\u{10a7f}') ]; - pub static Old_Turkic_table: &'static [(char, char)] = &[ + pub const Old_Turkic_table: &'static [(char, char)] = &[ ('\u{10c00}', '\u{10c48}') ]; - pub static Oriya_table: &'static [(char, char)] = &[ + pub const Oriya_table: &'static [(char, char)] = &[ ('\u{b01}', '\u{b01}'), ('\u{b02}', '\u{b03}'), ('\u{b05}', '\u{b0c}'), ('\u{b0f}', '\u{b10}'), ('\u{b13}', '\u{b28}'), ('\u{b2a}', '\u{b30}'), ('\u{b32}', '\u{b33}'), ('\u{b35}', '\u{b39}'), ('\u{b3c}', '\u{b3c}'), ('\u{b3d}', '\u{b3d}'), ('\u{b3e}', @@ -3717,75 +3717,75 @@ pub mod script { '\u{b71}'), ('\u{b72}', '\u{b77}') ]; - pub static Osmanya_table: &'static [(char, char)] = &[ + pub const Osmanya_table: &'static [(char, char)] = &[ ('\u{10480}', '\u{1049d}'), ('\u{104a0}', '\u{104a9}') ]; - pub static Pahawh_Hmong_table: &'static [(char, char)] = &[ + pub const Pahawh_Hmong_table: &'static [(char, char)] = &[ ('\u{16b00}', '\u{16b2f}'), ('\u{16b30}', '\u{16b36}'), ('\u{16b37}', '\u{16b3b}'), ('\u{16b3c}', '\u{16b3f}'), ('\u{16b40}', '\u{16b43}'), ('\u{16b44}', '\u{16b44}'), ('\u{16b45}', '\u{16b45}'), ('\u{16b50}', '\u{16b59}'), ('\u{16b5b}', '\u{16b61}'), ('\u{16b63}', '\u{16b77}'), ('\u{16b7d}', '\u{16b8f}') ]; - pub static Palmyrene_table: &'static [(char, char)] = &[ + pub const Palmyrene_table: &'static [(char, char)] = &[ ('\u{10860}', '\u{10876}'), ('\u{10877}', '\u{10878}'), ('\u{10879}', '\u{1087f}') ]; - pub static Pau_Cin_Hau_table: &'static [(char, char)] = &[ + pub const Pau_Cin_Hau_table: &'static [(char, char)] = &[ ('\u{11ac0}', '\u{11af8}') ]; - pub static Phags_Pa_table: &'static [(char, char)] = &[ + pub const Phags_Pa_table: &'static [(char, char)] = &[ ('\u{a840}', '\u{a873}'), ('\u{a874}', '\u{a877}') ]; - pub static Phoenician_table: &'static [(char, char)] = &[ + pub const Phoenician_table: &'static [(char, char)] = &[ ('\u{10900}', '\u{10915}'), ('\u{10916}', '\u{1091b}'), ('\u{1091f}', '\u{1091f}') ]; - pub static Psalter_Pahlavi_table: &'static [(char, char)] = &[ + pub const Psalter_Pahlavi_table: &'static [(char, char)] = &[ ('\u{10b80}', '\u{10b91}'), ('\u{10b99}', '\u{10b9c}'), ('\u{10ba9}', '\u{10baf}') ]; - pub static Rejang_table: &'static [(char, char)] = &[ + pub const Rejang_table: &'static [(char, char)] = &[ ('\u{a930}', '\u{a946}'), ('\u{a947}', '\u{a951}'), ('\u{a952}', '\u{a953}'), ('\u{a95f}', '\u{a95f}') ]; - pub static Runic_table: &'static [(char, char)] = &[ + pub const Runic_table: &'static [(char, char)] = &[ ('\u{16a0}', '\u{16ea}'), ('\u{16ee}', '\u{16f0}'), ('\u{16f1}', '\u{16f8}') ]; - pub static Samaritan_table: &'static [(char, char)] = &[ + pub const Samaritan_table: &'static [(char, char)] = &[ ('\u{800}', '\u{815}'), ('\u{816}', '\u{819}'), ('\u{81a}', '\u{81a}'), ('\u{81b}', '\u{823}'), ('\u{824}', '\u{824}'), ('\u{825}', '\u{827}'), ('\u{828}', '\u{828}'), ('\u{829}', '\u{82d}'), ('\u{830}', '\u{83e}') ]; - pub static Saurashtra_table: &'static [(char, char)] = &[ + pub const Saurashtra_table: &'static [(char, char)] = &[ ('\u{a880}', '\u{a881}'), ('\u{a882}', '\u{a8b3}'), ('\u{a8b4}', '\u{a8c3}'), ('\u{a8c4}', '\u{a8c4}'), ('\u{a8ce}', '\u{a8cf}'), ('\u{a8d0}', '\u{a8d9}') ]; - pub static Sharada_table: &'static [(char, char)] = &[ + pub const Sharada_table: &'static [(char, char)] = &[ ('\u{11180}', '\u{11181}'), ('\u{11182}', '\u{11182}'), ('\u{11183}', '\u{111b2}'), ('\u{111b3}', '\u{111b5}'), ('\u{111b6}', '\u{111be}'), ('\u{111bf}', '\u{111c0}'), ('\u{111c1}', '\u{111c4}'), ('\u{111c5}', '\u{111c8}'), ('\u{111cd}', '\u{111cd}'), ('\u{111d0}', '\u{111d9}'), ('\u{111da}', '\u{111da}') ]; - pub static Shavian_table: &'static [(char, char)] = &[ + pub const Shavian_table: &'static [(char, char)] = &[ ('\u{10450}', '\u{1047f}') ]; - pub static Siddham_table: &'static [(char, char)] = &[ + pub const Siddham_table: &'static [(char, char)] = &[ ('\u{11580}', '\u{115ae}'), ('\u{115af}', '\u{115b1}'), ('\u{115b2}', '\u{115b5}'), ('\u{115b8}', '\u{115bb}'), ('\u{115bc}', '\u{115bd}'), ('\u{115be}', '\u{115be}'), ('\u{115bf}', '\u{115c0}'), ('\u{115c1}', '\u{115c9}') ]; - pub static Sinhala_table: &'static [(char, char)] = &[ + pub const Sinhala_table: &'static [(char, char)] = &[ ('\u{d82}', '\u{d83}'), ('\u{d85}', '\u{d96}'), ('\u{d9a}', '\u{db1}'), ('\u{db3}', '\u{dbb}'), ('\u{dbd}', '\u{dbd}'), ('\u{dc0}', '\u{dc6}'), ('\u{dca}', '\u{dca}'), ('\u{dcf}', '\u{dd1}'), ('\u{dd2}', '\u{dd4}'), ('\u{dd6}', '\u{dd6}'), ('\u{dd8}', @@ -3793,42 +3793,42 @@ pub mod script { ('\u{111e1}', '\u{111f4}') ]; - pub static Sora_Sompeng_table: &'static [(char, char)] = &[ + pub const Sora_Sompeng_table: &'static [(char, char)] = &[ ('\u{110d0}', '\u{110e8}'), ('\u{110f0}', '\u{110f9}') ]; - pub static Sundanese_table: &'static [(char, char)] = &[ + pub const Sundanese_table: &'static [(char, char)] = &[ ('\u{1b80}', '\u{1b81}'), ('\u{1b82}', '\u{1b82}'), ('\u{1b83}', '\u{1ba0}'), ('\u{1ba1}', '\u{1ba1}'), ('\u{1ba2}', '\u{1ba5}'), ('\u{1ba6}', '\u{1ba7}'), ('\u{1ba8}', '\u{1ba9}'), ('\u{1baa}', '\u{1baa}'), ('\u{1bab}', '\u{1bad}'), ('\u{1bae}', '\u{1baf}'), ('\u{1bb0}', '\u{1bb9}'), ('\u{1bba}', '\u{1bbf}'), ('\u{1cc0}', '\u{1cc7}') ]; - pub static Syloti_Nagri_table: &'static [(char, char)] = &[ + pub const Syloti_Nagri_table: &'static [(char, char)] = &[ ('\u{a800}', '\u{a801}'), ('\u{a802}', '\u{a802}'), ('\u{a803}', '\u{a805}'), ('\u{a806}', '\u{a806}'), ('\u{a807}', '\u{a80a}'), ('\u{a80b}', '\u{a80b}'), ('\u{a80c}', '\u{a822}'), ('\u{a823}', '\u{a824}'), ('\u{a825}', '\u{a826}'), ('\u{a827}', '\u{a827}'), ('\u{a828}', '\u{a82b}') ]; - pub static Syriac_table: &'static [(char, char)] = &[ + pub const Syriac_table: &'static [(char, char)] = &[ ('\u{700}', '\u{70d}'), ('\u{70f}', '\u{70f}'), ('\u{710}', '\u{710}'), ('\u{711}', '\u{711}'), ('\u{712}', '\u{72f}'), ('\u{730}', '\u{74a}'), ('\u{74d}', '\u{74f}') ]; - pub static Tagalog_table: &'static [(char, char)] = &[ + pub const Tagalog_table: &'static [(char, char)] = &[ ('\u{1700}', '\u{170c}'), ('\u{170e}', '\u{1711}'), ('\u{1712}', '\u{1714}') ]; - pub static Tagbanwa_table: &'static [(char, char)] = &[ + pub const Tagbanwa_table: &'static [(char, char)] = &[ ('\u{1760}', '\u{176c}'), ('\u{176e}', '\u{1770}'), ('\u{1772}', '\u{1773}') ]; - pub static Tai_Le_table: &'static [(char, char)] = &[ + pub const Tai_Le_table: &'static [(char, char)] = &[ ('\u{1950}', '\u{196d}'), ('\u{1970}', '\u{1974}') ]; - pub static Tai_Tham_table: &'static [(char, char)] = &[ + pub const Tai_Tham_table: &'static [(char, char)] = &[ ('\u{1a20}', '\u{1a54}'), ('\u{1a55}', '\u{1a55}'), ('\u{1a56}', '\u{1a56}'), ('\u{1a57}', '\u{1a57}'), ('\u{1a58}', '\u{1a5e}'), ('\u{1a60}', '\u{1a60}'), ('\u{1a61}', '\u{1a61}'), ('\u{1a62}', '\u{1a62}'), ('\u{1a63}', '\u{1a64}'), ('\u{1a65}', '\u{1a6c}'), ('\u{1a6d}', @@ -3837,20 +3837,20 @@ pub mod script { '\u{1aad}') ]; - pub static Tai_Viet_table: &'static [(char, char)] = &[ + pub const Tai_Viet_table: &'static [(char, char)] = &[ ('\u{aa80}', '\u{aaaf}'), ('\u{aab0}', '\u{aab0}'), ('\u{aab1}', '\u{aab1}'), ('\u{aab2}', '\u{aab4}'), ('\u{aab5}', '\u{aab6}'), ('\u{aab7}', '\u{aab8}'), ('\u{aab9}', '\u{aabd}'), ('\u{aabe}', '\u{aabf}'), ('\u{aac0}', '\u{aac0}'), ('\u{aac1}', '\u{aac1}'), ('\u{aac2}', '\u{aac2}'), ('\u{aadb}', '\u{aadc}'), ('\u{aadd}', '\u{aadd}'), ('\u{aade}', '\u{aadf}') ]; - pub static Takri_table: &'static [(char, char)] = &[ + pub const Takri_table: &'static [(char, char)] = &[ ('\u{11680}', '\u{116aa}'), ('\u{116ab}', '\u{116ab}'), ('\u{116ac}', '\u{116ac}'), ('\u{116ad}', '\u{116ad}'), ('\u{116ae}', '\u{116af}'), ('\u{116b0}', '\u{116b5}'), ('\u{116b6}', '\u{116b6}'), ('\u{116b7}', '\u{116b7}'), ('\u{116c0}', '\u{116c9}') ]; - pub static Tamil_table: &'static [(char, char)] = &[ + pub const Tamil_table: &'static [(char, char)] = &[ ('\u{b82}', '\u{b82}'), ('\u{b83}', '\u{b83}'), ('\u{b85}', '\u{b8a}'), ('\u{b8e}', '\u{b90}'), ('\u{b92}', '\u{b95}'), ('\u{b99}', '\u{b9a}'), ('\u{b9c}', '\u{b9c}'), ('\u{b9e}', '\u{b9f}'), ('\u{ba3}', '\u{ba4}'), ('\u{ba8}', '\u{baa}'), ('\u{bae}', @@ -3860,7 +3860,7 @@ pub mod script { ('\u{bf3}', '\u{bf8}'), ('\u{bf9}', '\u{bf9}'), ('\u{bfa}', '\u{bfa}') ]; - pub static Telugu_table: &'static [(char, char)] = &[ + pub const Telugu_table: &'static [(char, char)] = &[ ('\u{c00}', '\u{c00}'), ('\u{c01}', '\u{c03}'), ('\u{c05}', '\u{c0c}'), ('\u{c0e}', '\u{c10}'), ('\u{c12}', '\u{c28}'), ('\u{c2a}', '\u{c39}'), ('\u{c3d}', '\u{c3d}'), ('\u{c3e}', '\u{c40}'), ('\u{c41}', '\u{c44}'), ('\u{c46}', '\u{c48}'), ('\u{c4a}', @@ -3869,17 +3869,17 @@ pub mod script { '\u{c7f}') ]; - pub static Thaana_table: &'static [(char, char)] = &[ + pub const Thaana_table: &'static [(char, char)] = &[ ('\u{780}', '\u{7a5}'), ('\u{7a6}', '\u{7b0}'), ('\u{7b1}', '\u{7b1}') ]; - pub static Thai_table: &'static [(char, char)] = &[ + pub const Thai_table: &'static [(char, char)] = &[ ('\u{e01}', '\u{e30}'), ('\u{e31}', '\u{e31}'), ('\u{e32}', '\u{e33}'), ('\u{e34}', '\u{e3a}'), ('\u{e40}', '\u{e45}'), ('\u{e46}', '\u{e46}'), ('\u{e47}', '\u{e4e}'), ('\u{e4f}', '\u{e4f}'), ('\u{e50}', '\u{e59}'), ('\u{e5a}', '\u{e5b}') ]; - pub static Tibetan_table: &'static [(char, char)] = &[ + pub const Tibetan_table: &'static [(char, char)] = &[ ('\u{f00}', '\u{f00}'), ('\u{f01}', '\u{f03}'), ('\u{f04}', '\u{f12}'), ('\u{f13}', '\u{f13}'), ('\u{f14}', '\u{f14}'), ('\u{f15}', '\u{f17}'), ('\u{f18}', '\u{f19}'), ('\u{f1a}', '\u{f1f}'), ('\u{f20}', '\u{f29}'), ('\u{f2a}', '\u{f33}'), ('\u{f34}', @@ -3893,12 +3893,12 @@ pub mod script { ('\u{fd0}', '\u{fd4}'), ('\u{fd9}', '\u{fda}') ]; - pub static Tifinagh_table: &'static [(char, char)] = &[ + pub const Tifinagh_table: &'static [(char, char)] = &[ ('\u{2d30}', '\u{2d67}'), ('\u{2d6f}', '\u{2d6f}'), ('\u{2d70}', '\u{2d70}'), ('\u{2d7f}', '\u{2d7f}') ]; - pub static Tirhuta_table: &'static [(char, char)] = &[ + pub const Tirhuta_table: &'static [(char, char)] = &[ ('\u{11480}', '\u{114af}'), ('\u{114b0}', '\u{114b2}'), ('\u{114b3}', '\u{114b8}'), ('\u{114b9}', '\u{114b9}'), ('\u{114ba}', '\u{114ba}'), ('\u{114bb}', '\u{114be}'), ('\u{114bf}', '\u{114c0}'), ('\u{114c1}', '\u{114c1}'), ('\u{114c2}', '\u{114c3}'), @@ -3906,21 +3906,21 @@ pub mod script { ('\u{114d0}', '\u{114d9}') ]; - pub static Ugaritic_table: &'static [(char, char)] = &[ + pub const Ugaritic_table: &'static [(char, char)] = &[ ('\u{10380}', '\u{1039d}'), ('\u{1039f}', '\u{1039f}') ]; - pub static Vai_table: &'static [(char, char)] = &[ + pub const Vai_table: &'static [(char, char)] = &[ ('\u{a500}', '\u{a60b}'), ('\u{a60c}', '\u{a60c}'), ('\u{a60d}', '\u{a60f}'), ('\u{a610}', '\u{a61f}'), ('\u{a620}', '\u{a629}'), ('\u{a62a}', '\u{a62b}') ]; - pub static Warang_Citi_table: &'static [(char, char)] = &[ + pub const Warang_Citi_table: &'static [(char, char)] = &[ ('\u{118a0}', '\u{118df}'), ('\u{118e0}', '\u{118e9}'), ('\u{118ea}', '\u{118f2}'), ('\u{118ff}', '\u{118ff}') ]; - pub static Yi_table: &'static [(char, char)] = &[ + pub const Yi_table: &'static [(char, char)] = &[ ('\u{a000}', '\u{a014}'), ('\u{a015}', '\u{a015}'), ('\u{a016}', '\u{a48c}'), ('\u{a490}', '\u{a4c6}') ]; @@ -3928,11 +3928,11 @@ pub mod script { } pub mod property { - pub static Join_Control_table: &'static [(char, char)] = &[ + pub const Join_Control_table: &'static [(char, char)] = &[ ('\u{200c}', '\u{200d}') ]; - pub static Noncharacter_Code_Point_table: &'static [(char, char)] = &[ + pub const Noncharacter_Code_Point_table: &'static [(char, char)] = &[ ('\u{fdd0}', '\u{fdef}'), ('\u{fffe}', '\u{ffff}'), ('\u{1fffe}', '\u{1ffff}'), ('\u{2fffe}', '\u{2ffff}'), ('\u{3fffe}', '\u{3ffff}'), ('\u{4fffe}', '\u{4ffff}'), ('\u{5fffe}', '\u{5ffff}'), ('\u{6fffe}', '\u{6ffff}'), ('\u{7fffe}', '\u{7ffff}'), @@ -3941,7 +3941,7 @@ pub mod property { ('\u{efffe}', '\u{effff}'), ('\u{ffffe}', '\u{fffff}') ]; - pub static White_Space_table: &'static [(char, char)] = &[ + pub const White_Space_table: &'static [(char, char)] = &[ ('\u{9}', '\u{d}'), ('\u{20}', '\u{20}'), ('\u{85}', '\u{85}'), ('\u{a0}', '\u{a0}'), ('\u{1680}', '\u{1680}'), ('\u{2000}', '\u{200a}'), ('\u{2028}', '\u{2028}'), ('\u{2029}', '\u{2029}'), ('\u{202f}', '\u{202f}'), ('\u{205f}', '\u{205f}'), ('\u{3000}', '\u{3000}') @@ -3954,111 +3954,110 @@ pub mod property { } pub mod regex { - pub static UNICODE_CLASSES: &'static [(&'static str, &'static &'static [(char, char)])] = &[ - ("Alphabetic", &super::derived_property::Alphabetic_table), ("Arabic", - &super::script::Arabic_table), ("Armenian", &super::script::Armenian_table), ("Avestan", - &super::script::Avestan_table), ("Balinese", &super::script::Balinese_table), ("Bamum", - &super::script::Bamum_table), ("Bassa_Vah", &super::script::Bassa_Vah_table), ("Batak", - &super::script::Batak_table), ("Bengali", &super::script::Bengali_table), ("Bopomofo", - &super::script::Bopomofo_table), ("Brahmi", &super::script::Brahmi_table), ("Braille", - &super::script::Braille_table), ("Buginese", &super::script::Buginese_table), ("Buhid", - &super::script::Buhid_table), ("C", &super::general_category::C_table), - ("Canadian_Aboriginal", &super::script::Canadian_Aboriginal_table), ("Carian", - &super::script::Carian_table), ("Caucasian_Albanian", - &super::script::Caucasian_Albanian_table), ("Cc", &super::general_category::Cc_table), - ("Cf", &super::general_category::Cf_table), ("Chakma", &super::script::Chakma_table), - ("Cham", &super::script::Cham_table), ("Cherokee", &super::script::Cherokee_table), ("Cn", - &super::general_category::Cn_table), ("Co", &super::general_category::Co_table), ("Common", - &super::script::Common_table), ("Coptic", &super::script::Coptic_table), ("Cuneiform", - &super::script::Cuneiform_table), ("Cypriot", &super::script::Cypriot_table), ("Cyrillic", - &super::script::Cyrillic_table), ("Default_Ignorable_Code_Point", - &super::derived_property::Default_Ignorable_Code_Point_table), ("Deseret", - &super::script::Deseret_table), ("Devanagari", &super::script::Devanagari_table), - ("Duployan", &super::script::Duployan_table), ("Egyptian_Hieroglyphs", - &super::script::Egyptian_Hieroglyphs_table), ("Elbasan", &super::script::Elbasan_table), - ("Ethiopic", &super::script::Ethiopic_table), ("Georgian", &super::script::Georgian_table), - ("Glagolitic", &super::script::Glagolitic_table), ("Gothic", &super::script::Gothic_table), - ("Grantha", &super::script::Grantha_table), ("Greek", &super::script::Greek_table), - ("Gujarati", &super::script::Gujarati_table), ("Gurmukhi", &super::script::Gurmukhi_table), - ("Han", &super::script::Han_table), ("Hangul", &super::script::Hangul_table), ("Hanunoo", - &super::script::Hanunoo_table), ("Hebrew", &super::script::Hebrew_table), ("Hiragana", - &super::script::Hiragana_table), ("Imperial_Aramaic", - &super::script::Imperial_Aramaic_table), ("Inherited", &super::script::Inherited_table), - ("Inscriptional_Pahlavi", &super::script::Inscriptional_Pahlavi_table), - ("Inscriptional_Parthian", &super::script::Inscriptional_Parthian_table), ("Javanese", - &super::script::Javanese_table), ("Join_Control", &super::property::Join_Control_table), - ("Kaithi", &super::script::Kaithi_table), ("Kannada", &super::script::Kannada_table), - ("Katakana", &super::script::Katakana_table), ("Kayah_Li", &super::script::Kayah_Li_table), - ("Kharoshthi", &super::script::Kharoshthi_table), ("Khmer", &super::script::Khmer_table), - ("Khojki", &super::script::Khojki_table), ("Khudawadi", &super::script::Khudawadi_table), - ("L", &super::general_category::L_table), ("LC", &super::general_category::LC_table), - ("Lao", &super::script::Lao_table), ("Latin", &super::script::Latin_table), ("Lepcha", - &super::script::Lepcha_table), ("Limbu", &super::script::Limbu_table), ("Linear_A", - &super::script::Linear_A_table), ("Linear_B", &super::script::Linear_B_table), ("Lisu", - &super::script::Lisu_table), ("Ll", &super::general_category::Ll_table), ("Lm", - &super::general_category::Lm_table), ("Lo", &super::general_category::Lo_table), - ("Lowercase", &super::derived_property::Lowercase_table), ("Lt", - &super::general_category::Lt_table), ("Lu", &super::general_category::Lu_table), ("Lycian", - &super::script::Lycian_table), ("Lydian", &super::script::Lydian_table), ("M", - &super::general_category::M_table), ("Mahajani", &super::script::Mahajani_table), - ("Malayalam", &super::script::Malayalam_table), ("Mandaic", &super::script::Mandaic_table), - ("Manichaean", &super::script::Manichaean_table), ("Mc", - &super::general_category::Mc_table), ("Me", &super::general_category::Me_table), - ("Meetei_Mayek", &super::script::Meetei_Mayek_table), ("Mende_Kikakui", - &super::script::Mende_Kikakui_table), ("Meroitic_Cursive", - &super::script::Meroitic_Cursive_table), ("Meroitic_Hieroglyphs", - &super::script::Meroitic_Hieroglyphs_table), ("Miao", &super::script::Miao_table), ("Mn", - &super::general_category::Mn_table), ("Modi", &super::script::Modi_table), ("Mongolian", - &super::script::Mongolian_table), ("Mro", &super::script::Mro_table), ("Myanmar", - &super::script::Myanmar_table), ("N", &super::general_category::N_table), ("Nabataean", - &super::script::Nabataean_table), ("Nd", &super::general_category::Nd_table), - ("New_Tai_Lue", &super::script::New_Tai_Lue_table), ("Nko", &super::script::Nko_table), - ("Nl", &super::general_category::Nl_table), ("No", &super::general_category::No_table), - ("Noncharacter_Code_Point", &super::property::Noncharacter_Code_Point_table), ("Ogham", - &super::script::Ogham_table), ("Ol_Chiki", &super::script::Ol_Chiki_table), ("Old_Italic", - &super::script::Old_Italic_table), ("Old_North_Arabian", - &super::script::Old_North_Arabian_table), ("Old_Permic", &super::script::Old_Permic_table), - ("Old_Persian", &super::script::Old_Persian_table), ("Old_South_Arabian", - &super::script::Old_South_Arabian_table), ("Old_Turkic", &super::script::Old_Turkic_table), - ("Oriya", &super::script::Oriya_table), ("Osmanya", &super::script::Osmanya_table), ("P", - &super::general_category::P_table), ("Pahawh_Hmong", &super::script::Pahawh_Hmong_table), - ("Palmyrene", &super::script::Palmyrene_table), ("Pau_Cin_Hau", - &super::script::Pau_Cin_Hau_table), ("Pc", &super::general_category::Pc_table), ("Pd", - &super::general_category::Pd_table), ("Pe", &super::general_category::Pe_table), ("Pf", - &super::general_category::Pf_table), ("Phags_Pa", &super::script::Phags_Pa_table), - ("Phoenician", &super::script::Phoenician_table), ("Pi", - &super::general_category::Pi_table), ("Po", &super::general_category::Po_table), ("Ps", - &super::general_category::Ps_table), ("Psalter_Pahlavi", - &super::script::Psalter_Pahlavi_table), ("Rejang", &super::script::Rejang_table), ("Runic", - &super::script::Runic_table), ("S", &super::general_category::S_table), ("Samaritan", - &super::script::Samaritan_table), ("Saurashtra", &super::script::Saurashtra_table), ("Sc", - &super::general_category::Sc_table), ("Sharada", &super::script::Sharada_table), ("Shavian", - &super::script::Shavian_table), ("Siddham", &super::script::Siddham_table), ("Sinhala", - &super::script::Sinhala_table), ("Sk", &super::general_category::Sk_table), ("Sm", - &super::general_category::Sm_table), ("So", &super::general_category::So_table), - ("Sora_Sompeng", &super::script::Sora_Sompeng_table), ("Sundanese", - &super::script::Sundanese_table), ("Syloti_Nagri", &super::script::Syloti_Nagri_table), - ("Syriac", &super::script::Syriac_table), ("Tagalog", &super::script::Tagalog_table), - ("Tagbanwa", &super::script::Tagbanwa_table), ("Tai_Le", &super::script::Tai_Le_table), - ("Tai_Tham", &super::script::Tai_Tham_table), ("Tai_Viet", &super::script::Tai_Viet_table), - ("Takri", &super::script::Takri_table), ("Tamil", &super::script::Tamil_table), ("Telugu", - &super::script::Telugu_table), ("Thaana", &super::script::Thaana_table), ("Thai", - &super::script::Thai_table), ("Tibetan", &super::script::Tibetan_table), ("Tifinagh", - &super::script::Tifinagh_table), ("Tirhuta", &super::script::Tirhuta_table), ("Ugaritic", - &super::script::Ugaritic_table), ("Uppercase", &super::derived_property::Uppercase_table), - ("Vai", &super::script::Vai_table), ("Warang_Citi", &super::script::Warang_Citi_table), - ("White_Space", &super::property::White_Space_table), ("XID_Continue", - &super::derived_property::XID_Continue_table), ("XID_Start", - &super::derived_property::XID_Start_table), ("Yi", &super::script::Yi_table), ("Z", - &super::general_category::Z_table), ("Zl", &super::general_category::Zl_table), ("Zp", - &super::general_category::Zp_table), ("Zs", &super::general_category::Zs_table) - ]; - - pub static PERLD: &'static &'static [(char, char)] = &super::general_category::Nd_table; - - pub static PERLS: &'static &'static [(char, char)] = &super::property::White_Space_table; - - pub static PERLW: &'static [(char, char)] = &[ + pub const UNICODE_CLASSES: &'static [(&'static str, &'static [(char, char)])] = &[ + ("Alphabetic", super::derived_property::Alphabetic_table), ("Arabic", + super::script::Arabic_table), ("Armenian", super::script::Armenian_table), ("Avestan", + super::script::Avestan_table), ("Balinese", super::script::Balinese_table), ("Bamum", + super::script::Bamum_table), ("Bassa_Vah", super::script::Bassa_Vah_table), ("Batak", + super::script::Batak_table), ("Bengali", super::script::Bengali_table), ("Bopomofo", + super::script::Bopomofo_table), ("Brahmi", super::script::Brahmi_table), ("Braille", + super::script::Braille_table), ("Buginese", super::script::Buginese_table), ("Buhid", + super::script::Buhid_table), ("C", super::general_category::C_table), + ("Canadian_Aboriginal", super::script::Canadian_Aboriginal_table), ("Carian", + super::script::Carian_table), ("Caucasian_Albanian", + super::script::Caucasian_Albanian_table), ("Cc", super::general_category::Cc_table), ("Cf", + super::general_category::Cf_table), ("Chakma", super::script::Chakma_table), ("Cham", + super::script::Cham_table), ("Cherokee", super::script::Cherokee_table), ("Cn", + super::general_category::Cn_table), ("Co", super::general_category::Co_table), ("Common", + super::script::Common_table), ("Coptic", super::script::Coptic_table), ("Cuneiform", + super::script::Cuneiform_table), ("Cypriot", super::script::Cypriot_table), ("Cyrillic", + super::script::Cyrillic_table), ("Default_Ignorable_Code_Point", + super::derived_property::Default_Ignorable_Code_Point_table), ("Deseret", + super::script::Deseret_table), ("Devanagari", super::script::Devanagari_table), ("Duployan", + super::script::Duployan_table), ("Egyptian_Hieroglyphs", + super::script::Egyptian_Hieroglyphs_table), ("Elbasan", super::script::Elbasan_table), + ("Ethiopic", super::script::Ethiopic_table), ("Georgian", super::script::Georgian_table), + ("Glagolitic", super::script::Glagolitic_table), ("Gothic", super::script::Gothic_table), + ("Grantha", super::script::Grantha_table), ("Greek", super::script::Greek_table), + ("Gujarati", super::script::Gujarati_table), ("Gurmukhi", super::script::Gurmukhi_table), + ("Han", super::script::Han_table), ("Hangul", super::script::Hangul_table), ("Hanunoo", + super::script::Hanunoo_table), ("Hebrew", super::script::Hebrew_table), ("Hiragana", + super::script::Hiragana_table), ("Imperial_Aramaic", super::script::Imperial_Aramaic_table), + ("Inherited", super::script::Inherited_table), ("Inscriptional_Pahlavi", + super::script::Inscriptional_Pahlavi_table), ("Inscriptional_Parthian", + super::script::Inscriptional_Parthian_table), ("Javanese", super::script::Javanese_table), + ("Join_Control", super::property::Join_Control_table), ("Kaithi", + super::script::Kaithi_table), ("Kannada", super::script::Kannada_table), ("Katakana", + super::script::Katakana_table), ("Kayah_Li", super::script::Kayah_Li_table), ("Kharoshthi", + super::script::Kharoshthi_table), ("Khmer", super::script::Khmer_table), ("Khojki", + super::script::Khojki_table), ("Khudawadi", super::script::Khudawadi_table), ("L", + super::general_category::L_table), ("LC", super::general_category::LC_table), ("Lao", + super::script::Lao_table), ("Latin", super::script::Latin_table), ("Lepcha", + super::script::Lepcha_table), ("Limbu", super::script::Limbu_table), ("Linear_A", + super::script::Linear_A_table), ("Linear_B", super::script::Linear_B_table), ("Lisu", + super::script::Lisu_table), ("Ll", super::general_category::Ll_table), ("Lm", + super::general_category::Lm_table), ("Lo", super::general_category::Lo_table), ("Lowercase", + super::derived_property::Lowercase_table), ("Lt", super::general_category::Lt_table), ("Lu", + super::general_category::Lu_table), ("Lycian", super::script::Lycian_table), ("Lydian", + super::script::Lydian_table), ("M", super::general_category::M_table), ("Mahajani", + super::script::Mahajani_table), ("Malayalam", super::script::Malayalam_table), ("Mandaic", + super::script::Mandaic_table), ("Manichaean", super::script::Manichaean_table), ("Mc", + super::general_category::Mc_table), ("Me", super::general_category::Me_table), + ("Meetei_Mayek", super::script::Meetei_Mayek_table), ("Mende_Kikakui", + super::script::Mende_Kikakui_table), ("Meroitic_Cursive", + super::script::Meroitic_Cursive_table), ("Meroitic_Hieroglyphs", + super::script::Meroitic_Hieroglyphs_table), ("Miao", super::script::Miao_table), ("Mn", + super::general_category::Mn_table), ("Modi", super::script::Modi_table), ("Mongolian", + super::script::Mongolian_table), ("Mro", super::script::Mro_table), ("Myanmar", + super::script::Myanmar_table), ("N", super::general_category::N_table), ("Nabataean", + super::script::Nabataean_table), ("Nd", super::general_category::Nd_table), ("New_Tai_Lue", + super::script::New_Tai_Lue_table), ("Nko", super::script::Nko_table), ("Nl", + super::general_category::Nl_table), ("No", super::general_category::No_table), + ("Noncharacter_Code_Point", super::property::Noncharacter_Code_Point_table), ("Ogham", + super::script::Ogham_table), ("Ol_Chiki", super::script::Ol_Chiki_table), ("Old_Italic", + super::script::Old_Italic_table), ("Old_North_Arabian", + super::script::Old_North_Arabian_table), ("Old_Permic", super::script::Old_Permic_table), + ("Old_Persian", super::script::Old_Persian_table), ("Old_South_Arabian", + super::script::Old_South_Arabian_table), ("Old_Turkic", super::script::Old_Turkic_table), + ("Oriya", super::script::Oriya_table), ("Osmanya", super::script::Osmanya_table), ("P", + super::general_category::P_table), ("Pahawh_Hmong", super::script::Pahawh_Hmong_table), + ("Palmyrene", super::script::Palmyrene_table), ("Pau_Cin_Hau", + super::script::Pau_Cin_Hau_table), ("Pc", super::general_category::Pc_table), ("Pd", + super::general_category::Pd_table), ("Pe", super::general_category::Pe_table), ("Pf", + super::general_category::Pf_table), ("Phags_Pa", super::script::Phags_Pa_table), + ("Phoenician", super::script::Phoenician_table), ("Pi", super::general_category::Pi_table), + ("Po", super::general_category::Po_table), ("Ps", super::general_category::Ps_table), + ("Psalter_Pahlavi", super::script::Psalter_Pahlavi_table), ("Rejang", + super::script::Rejang_table), ("Runic", super::script::Runic_table), ("S", + super::general_category::S_table), ("Samaritan", super::script::Samaritan_table), + ("Saurashtra", super::script::Saurashtra_table), ("Sc", super::general_category::Sc_table), + ("Sharada", super::script::Sharada_table), ("Shavian", super::script::Shavian_table), + ("Siddham", super::script::Siddham_table), ("Sinhala", super::script::Sinhala_table), ("Sk", + super::general_category::Sk_table), ("Sm", super::general_category::Sm_table), ("So", + super::general_category::So_table), ("Sora_Sompeng", super::script::Sora_Sompeng_table), + ("Sundanese", super::script::Sundanese_table), ("Syloti_Nagri", + super::script::Syloti_Nagri_table), ("Syriac", super::script::Syriac_table), ("Tagalog", + super::script::Tagalog_table), ("Tagbanwa", super::script::Tagbanwa_table), ("Tai_Le", + super::script::Tai_Le_table), ("Tai_Tham", super::script::Tai_Tham_table), ("Tai_Viet", + super::script::Tai_Viet_table), ("Takri", super::script::Takri_table), ("Tamil", + super::script::Tamil_table), ("Telugu", super::script::Telugu_table), ("Thaana", + super::script::Thaana_table), ("Thai", super::script::Thai_table), ("Tibetan", + super::script::Tibetan_table), ("Tifinagh", super::script::Tifinagh_table), ("Tirhuta", + super::script::Tirhuta_table), ("Ugaritic", super::script::Ugaritic_table), ("Uppercase", + super::derived_property::Uppercase_table), ("Vai", super::script::Vai_table), + ("Warang_Citi", super::script::Warang_Citi_table), ("White_Space", + super::property::White_Space_table), ("XID_Continue", + super::derived_property::XID_Continue_table), ("XID_Start", + super::derived_property::XID_Start_table), ("Yi", super::script::Yi_table), ("Z", + super::general_category::Z_table), ("Zl", super::general_category::Zl_table), ("Zp", + super::general_category::Zp_table), ("Zs", super::general_category::Zs_table) + ]; + + pub const PERLD: &'static [(char, char)] = super::general_category::Nd_table; + + pub const PERLS: &'static [(char, char)] = super::property::White_Space_table; + + pub const PERLW: &'static [(char, char)] = &[ ('\u{30}', '\u{39}'), ('\u{41}', '\u{5a}'), ('\u{5f}', '\u{5f}'), ('\u{61}', '\u{7a}'), ('\u{aa}', '\u{aa}'), ('\u{b5}', '\u{b5}'), ('\u{ba}', '\u{ba}'), ('\u{c0}', '\u{d6}'), ('\u{d8}', '\u{f6}'), ('\u{f8}', '\u{2c1}'), ('\u{2c6}', '\u{2d1}'), ('\u{2e0}', '\u{2e4}'), @@ -4254,7 +4253,7 @@ pub mod regex { pub mod normalization { // Canonical decompositions - pub static canonical_table: &'static [(char, &'static [char])] = &[ + pub const canonical_table: &'static [(char, &'static [char])] = &[ ('\u{c0}', &['\u{41}', '\u{300}']), ('\u{c1}', &['\u{41}', '\u{301}']), ('\u{c2}', &['\u{41}', '\u{302}']), ('\u{c3}', &['\u{41}', '\u{303}']), ('\u{c4}', &['\u{41}', '\u{308}']), ('\u{c5}', &['\u{41}', '\u{30a}']), ('\u{c7}', &['\u{43}', '\u{327}']), @@ -5056,7 +5055,7 @@ pub mod normalization { ]; // Compatibility decompositions - pub static compatibility_table: &'static [(char, &'static [char])] = &[ + pub const compatibility_table: &'static [(char, &'static [char])] = &[ ('\u{a0}', &['\u{20}']), ('\u{a8}', &['\u{20}', '\u{308}']), ('\u{aa}', &['\u{61}']), ('\u{af}', &['\u{20}', '\u{304}']), ('\u{b2}', &['\u{32}']), ('\u{b3}', &['\u{33}']), ('\u{b4}', &['\u{20}', '\u{301}']), ('\u{b5}', &['\u{3bc}']), ('\u{b8}', &['\u{20}', @@ -6480,7 +6479,7 @@ pub mod normalization { ]; // Canonical compositions - pub static composition_table: &'static [(char, &'static [(char, char)])] = &[ + pub const composition_table: &'static [(char, &'static [(char, char)])] = &[ ('\u{3c}', &[('\u{338}', '\u{226e}')]), ('\u{3d}', &[('\u{338}', '\u{2260}')]), ('\u{3e}', &[('\u{338}', '\u{226f}')]), ('\u{41}', &[('\u{300}', '\u{c0}'), ('\u{301}', '\u{c1}'), ('\u{302}', '\u{c2}'), ('\u{303}', '\u{c3}'), ('\u{304}', '\u{100}'), ('\u{306}', @@ -6840,7 +6839,7 @@ pub mod normalization { } } - static combining_class_table: &'static [(char, char, u8)] = &[ + const combining_class_table: &'static [(char, char, u8)] = &[ ('\u{300}', '\u{314}', 230), ('\u{315}', '\u{315}', 232), ('\u{316}', '\u{319}', 220), ('\u{31a}', '\u{31a}', 232), ('\u{31b}', '\u{31b}', 216), ('\u{31c}', '\u{320}', 220), ('\u{321}', '\u{322}', 202), ('\u{323}', '\u{326}', 220), ('\u{327}', '\u{328}', 202), @@ -6988,7 +6987,7 @@ pub mod conversions { } } - static LuLl_table: &'static [(char, char)] = &[ + const LuLl_table: &'static [(char, char)] = &[ ('\u{41}', '\u{61}'), ('\u{42}', '\u{62}'), ('\u{43}', '\u{63}'), ('\u{44}', '\u{64}'), ('\u{45}', '\u{65}'), ('\u{46}', '\u{66}'), ('\u{47}', '\u{67}'), ('\u{48}', '\u{68}'), ('\u{49}', '\u{69}'), ('\u{4a}', '\u{6a}'), ('\u{4b}', '\u{6b}'), ('\u{4c}', '\u{6c}'), @@ -7284,7 +7283,7 @@ pub mod conversions { ('\u{118be}', '\u{118de}'), ('\u{118bf}', '\u{118df}') ]; - static LlLu_table: &'static [(char, char)] = &[ + const LlLu_table: &'static [(char, char)] = &[ ('\u{61}', '\u{41}'), ('\u{62}', '\u{42}'), ('\u{63}', '\u{43}'), ('\u{64}', '\u{44}'), ('\u{65}', '\u{45}'), ('\u{66}', '\u{46}'), ('\u{67}', '\u{47}'), ('\u{68}', '\u{48}'), ('\u{69}', '\u{49}'), ('\u{6a}', '\u{4a}'), ('\u{6b}', '\u{4b}'), ('\u{6c}', '\u{4c}'), @@ -7625,7 +7624,7 @@ pub mod charwidth { // character width table. Based on Markus Kuhn's free wcwidth() implementation, // http://www.cl.cam.ac.uk/~mgk25/ucs/wcwidth.c - static charwidth_table: &'static [(char, char, u8, u8)] = &[ + const charwidth_table: &'static [(char, char, u8, u8)] = &[ ('\u{a1}', '\u{a1}', 1, 2), ('\u{a4}', '\u{a4}', 1, 2), ('\u{a7}', '\u{a8}', 1, 2), ('\u{aa}', '\u{aa}', 1, 2), ('\u{ae}', '\u{ae}', 1, 2), ('\u{b0}', '\u{b4}', 1, 2), ('\u{b6}', '\u{ba}', 1, 2), ('\u{bc}', '\u{bf}', 1, 2), ('\u{c6}', '\u{c6}', 1, 2), @@ -7839,7 +7838,7 @@ pub mod grapheme { bsearch_range_value_table(c, grapheme_cat_table) } - static grapheme_cat_table: &'static [(char, char, GraphemeCat)] = &[ + const grapheme_cat_table: &'static [(char, char, GraphemeCat)] = &[ ('\u{0}', '\u{1f}', GC_Control), ('\u{7f}', '\u{9f}', GC_Control), ('\u{ad}', '\u{ad}', GC_Control), ('\u{300}', '\u{36f}', GC_Extend), ('\u{483}', '\u{487}', GC_Extend), ('\u{488}', '\u{489}', GC_Extend), ('\u{591}', '\u{5bd}', GC_Extend), ('\u{5bf}', '\u{5bf}', diff --git a/src/test/auxiliary/lint_for_crate.rs b/src/test/auxiliary/lint_for_crate.rs new file mode 100644 index 00000000000..1be37ce1780 --- /dev/null +++ b/src/test/auxiliary/lint_for_crate.rs @@ -0,0 +1,43 @@ +// Copyright 2015 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. + +// force-host + +#![feature(plugin_registrar)] +#![feature(box_syntax)] + +extern crate syntax; +#[macro_use] extern crate rustc; + +use syntax::{ast, attr}; +use rustc::lint::{Context, LintPass, LintPassObject, LintArray}; +use rustc::plugin::Registry; + +declare_lint!(CRATE_NOT_OKAY, Warn, "crate not marked with #![crate_okay]"); + +struct Pass; + +impl LintPass for Pass { + fn get_lints(&self) -> LintArray { + lint_array!(CRATE_NOT_OKAY) + } + + fn check_crate(&mut self, cx: &Context, krate: &ast::Crate) { + if !attr::contains_name(&krate.attrs, "crate_okay") { + cx.span_lint(CRATE_NOT_OKAY, krate.span, + "crate is not marked with #![crate_okay]"); + } + } +} + +#[plugin_registrar] +pub fn plugin_registrar(reg: &mut Registry) { + reg.register_lint_pass(box Pass as LintPassObject); +} diff --git a/src/test/compile-fail-fulldeps/issue-15778-fail.rs b/src/test/compile-fail-fulldeps/issue-15778-fail.rs new file mode 100644 index 00000000000..8c6889f715f --- /dev/null +++ b/src/test/compile-fail-fulldeps/issue-15778-fail.rs @@ -0,0 +1,18 @@ +// Copyright 2015 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. + +// aux-build:lint_for_crate.rs +// ignore-stage1 +// compile-flags: -D crate-not-okay + +#![feature(plugin, custom_attribute)] //~ ERROR crate is not marked with #![crate_okay] +#![plugin(lint_for_crate)] + +pub fn main() { } diff --git a/src/test/compile-fail/asm-misplaced-option.rs b/src/test/compile-fail/asm-misplaced-option.rs index 02d06c4e1bf..43a0ad6b5f6 100644 --- a/src/test/compile-fail/asm-misplaced-option.rs +++ b/src/test/compile-fail/asm-misplaced-option.rs @@ -10,13 +10,14 @@ // ignore-android -#![feature(asm)] +#![feature(asm, rustc_attrs)] #![allow(dead_code, non_upper_case_globals)] #[cfg(any(target_arch = "x86", target_arch = "x86_64"))] -pub fn main() { +#[rustc_error] +pub fn main() { //~ ERROR compilation successful // assignment not dead let mut x: isize = 0; unsafe { @@ -33,7 +34,3 @@ pub fn main() { } assert_eq!(x, 13); } - -// At least one error is needed so that compilation fails -#[static_assert] -static b: bool = false; //~ ERROR static assertion failed diff --git a/src/test/compile-fail/const-len-underflow-separate-spans.rs b/src/test/compile-fail/const-len-underflow-separate-spans.rs new file mode 100644 index 00000000000..cd021a0d3b1 --- /dev/null +++ b/src/test/compile-fail/const-len-underflow-separate-spans.rs @@ -0,0 +1,23 @@ +// Copyright 2012-2013 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. + +// Check that an constant-evaluation underflow highlights the correct +// spot (where the underflow occurred), while also providing the +// overall context for what caused the evaluation. + +const ONE: usize = 1; +const TWO: usize = 2; +const LEN: usize = ONE - TWO; +//~^ ERROR array length constant evaluation error: attempted to sub with overflow [E0250] + +fn main() { + let a: [i8; LEN] = unimplemented!(); + //~^ NOTE for array length here +} diff --git a/src/test/compile-fail/const-len-underflow-subspans.rs b/src/test/compile-fail/const-len-underflow-subspans.rs new file mode 100644 index 00000000000..a31da114679 --- /dev/null +++ b/src/test/compile-fail/const-len-underflow-subspans.rs @@ -0,0 +1,20 @@ +// Copyright 2012-2013 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. + +// Check that an constant-evaluation underflow highlights the correct +// spot (where the underflow occurred). + +const ONE: usize = 1; +const TWO: usize = 2; + +fn main() { + let a: [i8; ONE - TWO] = unimplemented!(); + //~^ ERROR array length constant evaluation error: attempted to sub with overflow [E0250] +} diff --git a/src/test/compile-fail/eval-enum.rs b/src/test/compile-fail/eval-enum.rs index 92b7b601e4d..ed1327f3118 100644 --- a/src/test/compile-fail/eval-enum.rs +++ b/src/test/compile-fail/eval-enum.rs @@ -9,8 +9,8 @@ // except according to those terms. enum test { - div_zero = 1/0, //~ERROR expected constant: attempted to divide by zero - rem_zero = 1%0 //~ERROR expected constant: attempted remainder with a divisor of zero + div_zero = 1/0, //~ERROR constant evaluation error: attempted to divide by zero + rem_zero = 1%0 //~ERROR constant evaluation error: attempted remainder with a divisor of zero } fn main() {} diff --git a/src/test/compile-fail/feature-gate-static-assert.rs b/src/test/compile-fail/feature-gate-static-assert.rs new file mode 100644 index 00000000000..25740397d7a --- /dev/null +++ b/src/test/compile-fail/feature-gate-static-assert.rs @@ -0,0 +1,14 @@ +// Copyright 2015 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. + +#[static_assert] //~ ERROR `#[static_assert]` is an experimental feature +static X: bool = true; + +fn main() {} diff --git a/src/test/compile-fail/huge-array-simple.rs b/src/test/compile-fail/huge-array-simple.rs index 1e04e685e41..105f885f287 100644 --- a/src/test/compile-fail/huge-array-simple.rs +++ b/src/test/compile-fail/huge-array-simple.rs @@ -9,6 +9,7 @@ // except according to those terms. // error-pattern: too big for the current +#![allow(exceeding_bitshifts)] fn main() { let fat : [u8; (1<<61)+(1<<31)] = [0; (1u64<<61) as usize +(1u64<<31) as usize]; diff --git a/src/test/compile-fail/issue-18389.rs b/src/test/compile-fail/issue-18389.rs index 20323e99003..9065a5b9605 100644 --- a/src/test/compile-fail/issue-18389.rs +++ b/src/test/compile-fail/issue-18389.rs @@ -23,6 +23,7 @@ pub trait Public: Private< <Self as Public>::P, //~^ ERROR illegal recursive type; insert an enum or struct in the cycle, if this is desired <Self as Public>::R +//~^ ERROR unsupported cyclic reference between types/traits detected > { type P; type R; diff --git a/src/test/compile-fail/issue-19244-1.rs b/src/test/compile-fail/issue-19244-1.rs index 0850705aee6..5c11787d467 100644 --- a/src/test/compile-fail/issue-19244-1.rs +++ b/src/test/compile-fail/issue-19244-1.rs @@ -12,5 +12,7 @@ const TUP: (usize,) = (42,); fn main() { let a: [isize; TUP.1]; - //~^ ERROR expected constant expr for array length: tuple index out of bounds + //~^ ERROR array length constant evaluation error: tuple index out of bounds + //~| ERROR attempted out-of-bounds tuple index + //~| ERROR attempted out-of-bounds tuple index } diff --git a/src/test/compile-fail/issue-19244-2.rs b/src/test/compile-fail/issue-19244-2.rs index 93a3fc87eb0..d896f768659 100644 --- a/src/test/compile-fail/issue-19244-2.rs +++ b/src/test/compile-fail/issue-19244-2.rs @@ -13,5 +13,7 @@ const STRUCT: MyStruct = MyStruct { field: 42 }; fn main() { let a: [isize; STRUCT.nonexistent_field]; - //~^ ERROR expected constant expr for array length: nonexistent struct field + //~^ ERROR array length constant evaluation error: nonexistent struct field + //~| ERROR attempted access of field `nonexistent_field` + //~| ERROR attempted access of field `nonexistent_field` } diff --git a/src/test/compile-fail/issue-22912.rs b/src/test/compile-fail/issue-22912.rs new file mode 100644 index 00000000000..f4536ceb8ed --- /dev/null +++ b/src/test/compile-fail/issue-22912.rs @@ -0,0 +1,41 @@ +// Copyright 2015 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 struct PublicType; +struct PrivateType; + +pub trait PublicTrait { + type Item; +} + +trait PrivateTrait { + type Item; +} + +impl PublicTrait for PublicType { + type Item = PrivateType; //~ ERROR private type in exported type signature +} + +// OK +impl PublicTrait for PrivateType { + type Item = PrivateType; +} + +// OK +impl PrivateTrait for PublicType { + type Item = PrivateType; +} + +// OK +impl PrivateTrait for PrivateType { + type Item = PrivateType; +} + +fn main() {} diff --git a/src/test/compile-fail/issue-6804.rs b/src/test/compile-fail/issue-6804.rs index 30d3ab17a46..08c5cae9f5f 100644 --- a/src/test/compile-fail/issue-6804.rs +++ b/src/test/compile-fail/issue-6804.rs @@ -8,13 +8,15 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![feature(rustc_attrs)] #![allow(dead_code)] // Matching against NaN should result in a warning use std::f64::NAN; -fn main() { +#[rustc_error] +fn main() { //~ ERROR compilation successful let x = NAN; match x { NAN => {}, @@ -27,7 +29,3 @@ fn main() { }; //~^^^ WARNING unmatchable NaN in pattern, use the is_nan method in a guard instead } - -// At least one error is needed so that compilation fails -#[static_assert] -static B: bool = false; //~ ERROR static assertion failed diff --git a/src/test/compile-fail/non-constant-expr-for-fixed-len-vec.rs b/src/test/compile-fail/non-constant-expr-for-fixed-len-vec.rs index 14d2c8d0326..59e910ec6af 100644 --- a/src/test/compile-fail/non-constant-expr-for-fixed-len-vec.rs +++ b/src/test/compile-fail/non-constant-expr-for-fixed-len-vec.rs @@ -13,6 +13,7 @@ fn main() { fn bar(n: isize) { let _x: [isize; n]; - //~^ ERROR expected constant expr for array length: non-constant path in constant expr + //~^ ERROR no type for local variable + //~| ERROR array length constant evaluation error: non-constant path in constant expr } } diff --git a/src/test/compile-fail/nonbool_static_assert.rs b/src/test/compile-fail/nonbool_static_assert.rs index d85f58edc90..7a7912b06f8 100644 --- a/src/test/compile-fail/nonbool_static_assert.rs +++ b/src/test/compile-fail/nonbool_static_assert.rs @@ -8,6 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![feature(static_assert)] #![allow(dead_code)] #[static_assert] diff --git a/src/test/compile-fail/static-assert.rs b/src/test/compile-fail/static-assert.rs index 349e5f4cb51..d0cfbfbbccc 100644 --- a/src/test/compile-fail/static-assert.rs +++ b/src/test/compile-fail/static-assert.rs @@ -8,6 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![feature(static_assert)] #![allow(dead_code)] #[static_assert] diff --git a/src/test/compile-fail/static-assert2.rs b/src/test/compile-fail/static-assert2.rs index d5e70205e95..35f840dab0c 100644 --- a/src/test/compile-fail/static-assert2.rs +++ b/src/test/compile-fail/static-assert2.rs @@ -8,6 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![feature(static_assert)] #![allow(dead_code)] #[static_assert] diff --git a/src/test/run-fail/overflowing-add.rs b/src/test/run-fail/overflowing-add.rs new file mode 100644 index 00000000000..34a03e5f008 --- /dev/null +++ b/src/test/run-fail/overflowing-add.rs @@ -0,0 +1,18 @@ +// Copyright 2015 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. + +// error-pattern:thread '<main>' panicked at 'arithmetic operation overflowed' + +// (Work around constant-evaluation) +fn value() -> u8 { 200 } + +fn main() { + let _x = value() + value() + value(); +} diff --git a/src/test/run-fail/overflowing-mul.rs b/src/test/run-fail/overflowing-mul.rs new file mode 100644 index 00000000000..b18d99cd232 --- /dev/null +++ b/src/test/run-fail/overflowing-mul.rs @@ -0,0 +1,18 @@ +// Copyright 2015 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. + +// error-pattern:thread '<main>' panicked at 'arithmetic operation overflowed' + +// (Work around constant-evaluation) +fn value() -> u8 { 200 } + +fn main() { + let x = value() * 4; +} diff --git a/src/test/run-fail/overflowing-sub.rs b/src/test/run-fail/overflowing-sub.rs new file mode 100644 index 00000000000..ee32291eca6 --- /dev/null +++ b/src/test/run-fail/overflowing-sub.rs @@ -0,0 +1,18 @@ +// Copyright 2015 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. + +// error-pattern:thread '<main>' panicked at 'arithmetic operation overflowed' + +// (Work around constant-evaluation) +fn value() -> u8 { 42 } + +fn main() { + let _x = value() - (value() + 1); +} diff --git a/src/test/run-pass-fulldeps/issue-15778-pass.rs b/src/test/run-pass-fulldeps/issue-15778-pass.rs new file mode 100644 index 00000000000..a767779687a --- /dev/null +++ b/src/test/run-pass-fulldeps/issue-15778-pass.rs @@ -0,0 +1,19 @@ +// Copyright 2015 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. + +// aux-build:lint_for_crate.rs +// ignore-stage1 +// compile-flags: -D crate-not-okay + +#![feature(plugin, custom_attribute)] +#![plugin(lint_for_crate)] +#![crate_okay] + +pub fn main() { } diff --git a/src/test/run-pass/associated-types-binding-in-where-clause.rs b/src/test/run-pass/associated-types-binding-in-where-clause.rs index 2f9a0b328b5..c6c66f1c75c 100644 --- a/src/test/run-pass/associated-types-binding-in-where-clause.rs +++ b/src/test/run-pass/associated-types-binding-in-where-clause.rs @@ -16,7 +16,7 @@ pub trait Foo { } #[derive(PartialEq)] -struct Bar; +pub struct Bar; impl Foo for int { type A = uint; diff --git a/src/test/run-pass/associated-types-eq-obj.rs b/src/test/run-pass/associated-types-eq-obj.rs index 0ec8a366190..901b3c0d96b 100644 --- a/src/test/run-pass/associated-types-eq-obj.rs +++ b/src/test/run-pass/associated-types-eq-obj.rs @@ -15,7 +15,7 @@ pub trait Foo { fn boo(&self) -> <Self as Foo>::A; } -struct Bar; +pub struct Bar; impl Foo for char { type A = Bar; diff --git a/src/test/run-pass/associated-types-return.rs b/src/test/run-pass/associated-types-return.rs index fe24ab6bbeb..8ae550be3fc 100644 --- a/src/test/run-pass/associated-types-return.rs +++ b/src/test/run-pass/associated-types-return.rs @@ -16,7 +16,7 @@ pub trait Foo { } #[derive(PartialEq)] -struct Bar; +pub struct Bar; impl Foo for int { type A = uint; diff --git a/src/test/run-pass/backtrace-debuginfo.rs b/src/test/run-pass/backtrace-debuginfo.rs index a2a63d44a78..23aadbc7053 100644 --- a/src/test/run-pass/backtrace-debuginfo.rs +++ b/src/test/run-pass/backtrace-debuginfo.rs @@ -68,7 +68,7 @@ fn dump_filelines(filelines: &[Pos]) { } #[inline(never)] -fn inner(counter: &mut u32, main_pos: Pos, outer_pos: Pos) { +fn inner(counter: &mut i32, main_pos: Pos, outer_pos: Pos) { check!(counter; main_pos, outer_pos); check!(counter; main_pos, outer_pos); let inner_pos = pos!(); aux::callback(|aux_pos| { @@ -80,12 +80,12 @@ fn inner(counter: &mut u32, main_pos: Pos, outer_pos: Pos) { } #[inline(always)] -fn inner_inlined(counter: &mut u32, main_pos: Pos, outer_pos: Pos) { +fn inner_inlined(counter: &mut i32, main_pos: Pos, outer_pos: Pos) { check!(counter; main_pos, outer_pos); check!(counter; main_pos, outer_pos); #[inline(always)] - fn inner_further_inlined(counter: &mut u32, main_pos: Pos, outer_pos: Pos, inner_pos: Pos) { + fn inner_further_inlined(counter: &mut i32, main_pos: Pos, outer_pos: Pos, inner_pos: Pos) { check!(counter; main_pos, outer_pos, inner_pos); } inner_further_inlined(counter, main_pos, outer_pos, pos!()); @@ -103,7 +103,7 @@ fn inner_inlined(counter: &mut u32, main_pos: Pos, outer_pos: Pos) { } #[inline(never)] -fn outer(mut counter: u32, main_pos: Pos) { +fn outer(mut counter: i32, main_pos: Pos) { inner(&mut counter, main_pos, pos!()); inner_inlined(&mut counter, main_pos, pos!()); } diff --git a/src/test/run-pass/backtrace.rs b/src/test/run-pass/backtrace.rs index 6f76322cb77..879b3e920ab 100644 --- a/src/test/run-pass/backtrace.rs +++ b/src/test/run-pass/backtrace.rs @@ -53,7 +53,9 @@ fn runtest(me: &str) { "bad output: {}", s); // Make sure the stack trace is *not* printed - let p = template.clone().arg("fail").spawn().unwrap(); + // (Remove RUST_BACKTRACE from our own environment, in case developer + // is running `make check` with it on.) + let p = template.clone().arg("fail").env_remove("RUST_BACKTRACE").spawn().unwrap(); let out = p.wait_with_output().unwrap(); assert!(!out.status.success()); let s = str::from_utf8(&out.error).unwrap(); diff --git a/src/test/run-pass/generic-extern-mangle.rs b/src/test/run-pass/generic-extern-mangle.rs index 6e3d19b05d4..062ee507864 100644 --- a/src/test/run-pass/generic-extern-mangle.rs +++ b/src/test/run-pass/generic-extern-mangle.rs @@ -10,7 +10,7 @@ use std::num::Int; -extern "C" fn foo<T: Int>(a: T, b: T) -> T { a + b } +extern "C" fn foo<T: WrappingOps>(a: T, b: T) -> T { a.wrapping_add(b) } fn main() { assert_eq!(99u8, foo(255u8, 100u8)); diff --git a/src/test/run-pass/static-assert.rs b/src/test/run-pass/static-assert.rs index f8fd81b9365..f650e56bb6b 100644 --- a/src/test/run-pass/static-assert.rs +++ b/src/test/run-pass/static-assert.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![feature(static_assert)] + #[static_assert] static b: bool = true; |