From e656081b700b949bc914fedd6ad29b1ca3197660 Mon Sep 17 00:00:00 2001 From: Nick Cameron Date: Wed, 24 Dec 2014 19:38:10 +1300 Subject: Accept `?Sized` as well as `Sized?` Includes a bit of refactoring to store `?` unbounds as bounds with a modifier, rather than in their own world, in the AST at least. --- src/libsyntax/parse/parser.rs | 95 +++++++++++++++++++++++++++++++++---------- 1 file changed, 74 insertions(+), 21 deletions(-) (limited to 'src/libsyntax/parse') diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs index 94b61ba56d2..4d1bf50f25f 100644 --- a/src/libsyntax/parse/parser.rs +++ b/src/libsyntax/parse/parser.rs @@ -15,7 +15,7 @@ use self::ItemOrViewItem::*; use abi; use ast::{AssociatedType, BareFnTy, ClosureTy}; -use ast::{RegionTyParamBound, TraitTyParamBound}; +use ast::{RegionTyParamBound, TraitTyParamBound, TraitBoundModifier}; use ast::{ProvidedMethod, Public, Unsafety}; use ast::{Mod, BiAdd, Arg, Arm, Attribute, BindByRef, BindByValue}; use ast::{BiBitAnd, BiBitOr, BiBitXor, BiRem, Block}; @@ -117,6 +117,13 @@ pub enum PathParsingMode { LifetimeAndTypesWithColons, } +/// How to parse a bound, whether to allow bound modifiers such as `?`. +#[deriving(Copy, PartialEq)] +pub enum BoundParsingMode { + Bare, + Modified, +} + enum ItemOrViewItem { /// Indicates a failure to parse any kind of item. The attributes are /// returned. @@ -1087,12 +1094,12 @@ impl<'a> Parser<'a> { let poly_trait_ref = ast::PolyTraitRef { bound_lifetimes: lifetime_defs, trait_ref: trait_ref }; let other_bounds = if self.eat(&token::BinOp(token::Plus)) { - self.parse_ty_param_bounds() + self.parse_ty_param_bounds(BoundParsingMode::Bare) } else { OwnedSlice::empty() }; let all_bounds = - Some(TraitTyParamBound(poly_trait_ref)).into_iter() + Some(TraitTyParamBound(poly_trait_ref, TraitBoundModifier::None)).into_iter() .chain(other_bounds.into_vec().into_iter()) .collect(); ast::TyPolyTraitRef(all_bounds) @@ -1165,7 +1172,7 @@ impl<'a> Parser<'a> { // To be helpful, parse the proc as ever let _ = self.parse_legacy_lifetime_defs(lifetime_defs); let _ = self.parse_fn_args(false, false); - let _ = self.parse_colon_then_ty_param_bounds(); + let _ = self.parse_colon_then_ty_param_bounds(BoundParsingMode::Bare); let _ = self.parse_ret_ty(); self.obsolete(proc_span, ObsoleteProcType); @@ -1255,7 +1262,7 @@ impl<'a> Parser<'a> { inputs }; - let bounds = self.parse_colon_then_ty_param_bounds(); + let bounds = self.parse_colon_then_ty_param_bounds(BoundParsingMode::Bare); let output = self.parse_ret_ty(); let decl = P(FnDecl { @@ -1481,7 +1488,7 @@ impl<'a> Parser<'a> { return lhs; } - let bounds = self.parse_ty_param_bounds(); + let bounds = self.parse_ty_param_bounds(BoundParsingMode::Bare); // In type grammar, `+` is treated like a binary operator, // and hence both L and R side are required. @@ -4022,13 +4029,14 @@ impl<'a> Parser<'a> { // Parses a sequence of bounds if a `:` is found, // otherwise returns empty list. - fn parse_colon_then_ty_param_bounds(&mut self) + fn parse_colon_then_ty_param_bounds(&mut self, + mode: BoundParsingMode) -> OwnedSlice { if !self.eat(&token::Colon) { OwnedSlice::empty() } else { - self.parse_ty_param_bounds() + self.parse_ty_param_bounds(mode) } } @@ -4036,14 +4044,20 @@ impl<'a> Parser<'a> { // where boundseq = ( polybound + boundseq ) | polybound // and polybound = ( 'for' '<' 'region '>' )? bound // and bound = 'region | trait_ref - // NB: The None/Some distinction is important for issue #7264. - fn parse_ty_param_bounds(&mut self) + fn parse_ty_param_bounds(&mut self, + mode: BoundParsingMode) -> OwnedSlice { let mut result = vec!(); loop { + let question_span = self.span; + let ate_question = self.eat(&token::Question); match self.token { token::Lifetime(lifetime) => { + if ate_question { + self.span_err(question_span, + "`?` may only modify trait bounds, not lifetime bounds"); + } result.push(RegionTyParamBound(ast::Lifetime { id: ast::DUMMY_NODE_ID, span: self.span, @@ -4053,7 +4067,18 @@ impl<'a> Parser<'a> { } token::ModSep | token::Ident(..) => { let poly_trait_ref = self.parse_poly_trait_ref(); - result.push(TraitTyParamBound(poly_trait_ref)) + let modifier = if ate_question { + if mode == BoundParsingMode::Modified { + TraitBoundModifier::Maybe + } else { + self.span_err(question_span, + "unexpected `?`"); + TraitBoundModifier::None + } + } else { + TraitBoundModifier::None + }; + result.push(TraitTyParamBound(poly_trait_ref, modifier)) } _ => break, } @@ -4082,13 +4107,14 @@ impl<'a> Parser<'a> { } } - /// Matches typaram = (unbound`?`)? IDENT optbounds ( EQ ty )? + /// Matches typaram = (unbound `?`)? IDENT (`?` unbound)? optbounds ( EQ ty )? fn parse_ty_param(&mut self) -> TyParam { // This is a bit hacky. Currently we are only interested in a single // unbound, and it may only be `Sized`. To avoid backtracking and other // complications, we parse an ident, then check for `?`. If we find it, // we use the ident as the unbound, otherwise, we use it as the name of - // type param. + // type param. Even worse, for now, we need to check for `?` before or + // after the bound. let mut span = self.span; let mut ident = self.parse_ident(); let mut unbound = None; @@ -4099,7 +4125,14 @@ impl<'a> Parser<'a> { ident = self.parse_ident(); } - let bounds = self.parse_colon_then_ty_param_bounds(); + let mut bounds = self.parse_colon_then_ty_param_bounds(BoundParsingMode::Modified); + if let Some(unbound) = unbound { + let mut bounds_as_vec = bounds.into_vec(); + bounds_as_vec.push(TraitTyParamBound(PolyTraitRef { bound_lifetimes: vec![], + trait_ref: unbound }, + TraitBoundModifier::Maybe)); + bounds = OwnedSlice::from_vec(bounds_as_vec); + }; let default = if self.check(&token::Eq) { self.bump(); @@ -4111,7 +4144,6 @@ impl<'a> Parser<'a> { ident: ident, id: ast::DUMMY_NODE_ID, bounds: bounds, - unbound: unbound, default: default, span: span, } @@ -4253,7 +4285,7 @@ impl<'a> Parser<'a> { let bounded_ty = self.parse_ty(); if self.eat(&token::Colon) { - let bounds = self.parse_ty_param_bounds(); + let bounds = self.parse_ty_param_bounds(BoundParsingMode::Bare); let hi = self.span.hi; let span = mk_sp(lo, hi); @@ -4740,15 +4772,23 @@ impl<'a> Parser<'a> { fn parse_item_trait(&mut self, unsafety: Unsafety) -> ItemInfo { let ident = self.parse_ident(); let mut tps = self.parse_generics(); - let sized = self.parse_for_sized(); + let unbound = self.parse_for_sized(); // Parse supertrait bounds. - let bounds = self.parse_colon_then_ty_param_bounds(); + let mut bounds = self.parse_colon_then_ty_param_bounds(BoundParsingMode::Bare); + + if let Some(unbound) = unbound { + let mut bounds_as_vec = bounds.into_vec(); + bounds_as_vec.push(TraitTyParamBound(PolyTraitRef { bound_lifetimes: vec![], + trait_ref: unbound }, + TraitBoundModifier::Maybe)); + bounds = OwnedSlice::from_vec(bounds_as_vec); + }; self.parse_where_clause(&mut tps); let meths = self.parse_trait_items(); - (ident, ItemTrait(unsafety, tps, sized, bounds, meths), None) + (ident, ItemTrait(unsafety, tps, bounds, meths), None) } fn parse_impl_items(&mut self) -> (Vec, Vec) { @@ -4967,12 +5007,25 @@ impl<'a> Parser<'a> { } fn parse_for_sized(&mut self) -> Option { + // FIXME, this should really use TraitBoundModifier, but it will get + // re-jigged shortly in any case, so leaving the hacky version for now. if self.eat_keyword(keywords::For) { let span = self.span; + let mut ate_question = false; + if self.eat(&token::Question) { + ate_question = true; + } let ident = self.parse_ident(); - if !self.eat(&token::Question) { + if self.eat(&token::Question) { + if ate_question { + self.span_err(span, + "unexpected `?`"); + } + ate_question = true; + } + if !ate_question { self.span_err(span, - "expected 'Sized?' after `for` in trait item"); + "expected `?Sized` after `for` in trait item"); return None; } let tref = Parser::trait_ref_from_ident(ident, span); -- cgit 1.4.1-3-g733a5 From 35a6f6247ba930425b5ffb8e6f33fbbe1da278cc Mon Sep 17 00:00:00 2001 From: Nick Cameron Date: Sat, 27 Dec 2014 23:45:50 +1300 Subject: Fix spans for `use` view statements and their treatment in save-analysis --- src/librustc_trans/save/mod.rs | 6 +++--- src/librustc_trans/save/span_utils.rs | 4 ++-- src/libsyntax/parse/parser.rs | 7 ++++--- 3 files changed, 9 insertions(+), 8 deletions(-) (limited to 'src/libsyntax/parse') diff --git a/src/librustc_trans/save/mod.rs b/src/librustc_trans/save/mod.rs index f491bc84b62..2a977b1085a 100644 --- a/src/librustc_trans/save/mod.rs +++ b/src/librustc_trans/save/mod.rs @@ -1162,8 +1162,8 @@ impl<'l, 'tcx, 'v> Visitor<'v> for DxrVisitor<'l, 'tcx> { } match i.node { - ast::ViewItemUse(ref path) => { - match path.node { + ast::ViewItemUse(ref item) => { + match item.node { ast::ViewPathSimple(ident, ref path, id) => { let sub_span = self.span.span_for_last_ident(path.span); let mod_id = match self.lookup_type_ref(id) { @@ -1184,7 +1184,7 @@ impl<'l, 'tcx, 'v> Visitor<'v> for DxrVisitor<'l, 'tcx> { // 'use' always introduces an alias, if there is not an explicit // one, there is an implicit one. let sub_span = - match self.span.sub_span_before_token(path.span, token::Eq) { + match self.span.sub_span_after_keyword(item.span, keywords::As) { Some(sub_span) => Some(sub_span), None => sub_span, }; diff --git a/src/librustc_trans/save/span_utils.rs b/src/librustc_trans/save/span_utils.rs index e9d862d3781..244d0476832 100644 --- a/src/librustc_trans/save/span_utils.rs +++ b/src/librustc_trans/save/span_utils.rs @@ -294,8 +294,8 @@ impl<'a> SpanUtils<'a> { } pub fn sub_span_after_keyword(&self, - span: Span, - keyword: keywords::Keyword) -> Option { + span: Span, + keyword: keywords::Keyword) -> Option { let mut toks = self.retokenise_span(span); loop { let ts = toks.real_token(); diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs index 94b61ba56d2..8011507c512 100644 --- a/src/libsyntax/parse/parser.rs +++ b/src/libsyntax/parse/parser.rs @@ -5917,7 +5917,7 @@ impl<'a> Parser<'a> { } - /// Matches view_path : MOD? IDENT EQ non_global_path + /// Matches view_path : MOD? non_global_path as IDENT /// | MOD? non_global_path MOD_SEP LBRACE RBRACE /// | MOD? non_global_path MOD_SEP LBRACE ident_seq RBRACE /// | MOD? non_global_path MOD_SEP STAR @@ -6029,7 +6029,7 @@ impl<'a> Parser<'a> { } let mut rename_to = path[path.len() - 1u]; let path = ast::Path { - span: mk_sp(lo, self.span.hi), + span: mk_sp(lo, self.last_span.hi), global: false, segments: path.into_iter().map(|identifier| { ast::PathSegment { @@ -6041,7 +6041,8 @@ impl<'a> Parser<'a> { if self.eat_keyword(keywords::As) { rename_to = self.parse_ident() } - P(spanned(lo, self.last_span.hi, + P(spanned(lo, + self.last_span.hi, ViewPathSimple(rename_to, path, ast::DUMMY_NODE_ID))) } -- cgit 1.4.1-3-g733a5 From 1e89bbcb67020892bc0af5af218c35f0fd453fa4 Mon Sep 17 00:00:00 2001 From: Simonas Kazlauskas Date: Sun, 28 Dec 2014 02:20:47 +0200 Subject: Rename TaskRng to ThreadRng MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Since runtime is removed, rust has no tasks anymore and everything is moving from being task-* to thread-*. Let’s rename TaskRng as well! * Rename TaskRng to ThreadRng * Rename task_rng to thread_rng [breaking-change] --- src/libcollections/slice.rs | 6 +- src/libflate/lib.rs | 2 +- src/librand/distributions/exponential.rs | 2 +- src/librand/distributions/gamma.rs | 8 +-- src/librand/distributions/mod.rs | 2 +- src/librand/distributions/normal.rs | 4 +- src/librand/distributions/range.rs | 2 +- src/librand/lib.rs | 36 +++++----- src/librand/rand_impls.rs | 6 +- src/libregex/test/bench.rs | 4 +- src/libserialize/base64.rs | 4 +- src/libstd/hash.rs | 2 +- src/libstd/os.rs | 2 +- src/libstd/rand/mod.rs | 88 +++++++++++------------ src/libstd/sync/rwlock.rs | 2 +- src/libsyntax/parse/token.rs | 2 +- src/test/bench/core-std.rs | 6 +- src/test/compile-fail/task-rng-isnt-sendable.rs | 4 +- src/test/run-make/unicode-input/multiple_files.rs | 4 +- src/test/run-make/unicode-input/span_length.rs | 6 +- src/test/run-pass/vector-sort-panic-safe.rs | 4 +- 21 files changed, 98 insertions(+), 98 deletions(-) (limited to 'src/libsyntax/parse') diff --git a/src/libcollections/slice.rs b/src/libcollections/slice.rs index d6d94f57acf..60c360de094 100644 --- a/src/libcollections/slice.rs +++ b/src/libcollections/slice.rs @@ -1347,7 +1347,7 @@ mod tests { use core::cell::Cell; use core::default::Default; use core::mem; - use std::rand::{Rng, task_rng}; + use std::rand::{Rng, thread_rng}; use std::rc::Rc; use super::ElementSwaps; @@ -1963,7 +1963,7 @@ mod tests { fn test_sort() { for len in range(4u, 25) { for _ in range(0i, 100) { - let mut v = task_rng().gen_iter::().take(len) + let mut v = thread_rng().gen_iter::().take(len) .collect::>(); let mut v1 = v.clone(); @@ -1999,7 +1999,7 @@ mod tests { // number this element is, i.e. the second elements // will occur in sorted order. let mut v = range(0, len).map(|_| { - let n = task_rng().gen::() % 10; + let n = thread_rng().gen::() % 10; counts[n] += 1; (n, counts[n]) }).collect::>(); diff --git a/src/libflate/lib.rs b/src/libflate/lib.rs index 8c4f74027a5..aa1550ae5b8 100644 --- a/src/libflate/lib.rs +++ b/src/libflate/lib.rs @@ -112,7 +112,7 @@ mod tests { #[test] fn test_flate_round_trip() { - let mut r = rand::task_rng(); + let mut r = rand::thread_rng(); let mut words = vec!(); for _ in range(0u, 20) { let range = r.gen_range(1u, 10); diff --git a/src/librand/distributions/exponential.rs b/src/librand/distributions/exponential.rs index 431a530726a..f31f3468a4c 100644 --- a/src/librand/distributions/exponential.rs +++ b/src/librand/distributions/exponential.rs @@ -64,7 +64,7 @@ impl Rand for Exp1 { /// use std::rand::distributions::{Exp, IndependentSample}; /// /// let exp = Exp::new(2.0); -/// let v = exp.ind_sample(&mut rand::task_rng()); +/// let v = exp.ind_sample(&mut rand::thread_rng()); /// println!("{} is from a Exp(2) distribution", v); /// ``` #[deriving(Copy)] diff --git a/src/librand/distributions/gamma.rs b/src/librand/distributions/gamma.rs index d33d838766f..618db380db8 100644 --- a/src/librand/distributions/gamma.rs +++ b/src/librand/distributions/gamma.rs @@ -44,7 +44,7 @@ use super::{IndependentSample, Sample, Exp}; /// use std::rand::distributions::{IndependentSample, Gamma}; /// /// let gamma = Gamma::new(2.0, 5.0); -/// let v = gamma.ind_sample(&mut rand::task_rng()); +/// let v = gamma.ind_sample(&mut rand::thread_rng()); /// println!("{} is from a Gamma(2, 5) distribution", v); /// ``` /// @@ -191,7 +191,7 @@ impl IndependentSample for GammaLargeShape { /// use std::rand::distributions::{ChiSquared, IndependentSample}; /// /// let chi = ChiSquared::new(11.0); -/// let v = chi.ind_sample(&mut rand::task_rng()); +/// let v = chi.ind_sample(&mut rand::thread_rng()); /// println!("{} is from a χ²(11) distribution", v) /// ``` pub struct ChiSquared { @@ -248,7 +248,7 @@ impl IndependentSample for ChiSquared { /// use std::rand::distributions::{FisherF, IndependentSample}; /// /// let f = FisherF::new(2.0, 32.0); -/// let v = f.ind_sample(&mut rand::task_rng()); +/// let v = f.ind_sample(&mut rand::thread_rng()); /// println!("{} is from an F(2, 32) distribution", v) /// ``` pub struct FisherF { @@ -292,7 +292,7 @@ impl IndependentSample for FisherF { /// use std::rand::distributions::{StudentT, IndependentSample}; /// /// let t = StudentT::new(11.0); -/// let v = t.ind_sample(&mut rand::task_rng()); +/// let v = t.ind_sample(&mut rand::thread_rng()); /// println!("{} is from a t(11) distribution", v) /// ``` pub struct StudentT { diff --git a/src/librand/distributions/mod.rs b/src/librand/distributions/mod.rs index 58125c67fda..54cb8ae1907 100644 --- a/src/librand/distributions/mod.rs +++ b/src/librand/distributions/mod.rs @@ -96,7 +96,7 @@ pub struct Weighted { /// Weighted { weight: 4, item: 'b' }, /// Weighted { weight: 1, item: 'c' }); /// let wc = WeightedChoice::new(items.as_mut_slice()); -/// let mut rng = rand::task_rng(); +/// let mut rng = rand::thread_rng(); /// for _ in range(0u, 16) { /// // on average prints 'a' 4 times, 'b' 8 and 'c' twice. /// println!("{}", wc.ind_sample(&mut rng)); diff --git a/src/librand/distributions/normal.rs b/src/librand/distributions/normal.rs index 16413af6267..3507282ec48 100644 --- a/src/librand/distributions/normal.rs +++ b/src/librand/distributions/normal.rs @@ -81,7 +81,7 @@ impl Rand for StandardNormal { /// /// // mean 2, standard deviation 3 /// let normal = Normal::new(2.0, 3.0); -/// let v = normal.ind_sample(&mut rand::task_rng()); +/// let v = normal.ind_sample(&mut rand::thread_rng()); /// println!("{} is from a N(2, 9) distribution", v) /// ``` #[deriving(Copy)] @@ -129,7 +129,7 @@ impl IndependentSample for Normal { /// /// // mean 2, standard deviation 3 /// let log_normal = LogNormal::new(2.0, 3.0); -/// let v = log_normal.ind_sample(&mut rand::task_rng()); +/// let v = log_normal.ind_sample(&mut rand::thread_rng()); /// println!("{} is from an ln N(2, 9) distribution", v) /// ``` #[deriving(Copy)] diff --git a/src/librand/distributions/range.rs b/src/librand/distributions/range.rs index 6301623bbdc..20ba3566d5b 100644 --- a/src/librand/distributions/range.rs +++ b/src/librand/distributions/range.rs @@ -39,7 +39,7 @@ use distributions::{Sample, IndependentSample}; /// /// fn main() { /// let between = Range::new(10u, 10000u); -/// let mut rng = std::rand::task_rng(); +/// let mut rng = std::rand::thread_rng(); /// let mut sum = 0; /// for _ in range(0u, 1000) { /// sum += between.ind_sample(&mut rng); diff --git a/src/librand/lib.rs b/src/librand/lib.rs index 514ff81da51..273b991bc22 100644 --- a/src/librand/lib.rs +++ b/src/librand/lib.rs @@ -138,10 +138,10 @@ pub trait Rng { /// # Example /// /// ```rust - /// use std::rand::{task_rng, Rng}; + /// use std::rand::{thread_rng, Rng}; /// /// let mut v = [0u8, .. 13579]; - /// task_rng().fill_bytes(&mut v); + /// thread_rng().fill_bytes(&mut v); /// println!("{}", v.as_slice()); /// ``` fn fill_bytes(&mut self, dest: &mut [u8]) { @@ -173,9 +173,9 @@ pub trait Rng { /// # Example /// /// ```rust - /// use std::rand::{task_rng, Rng}; + /// use std::rand::{thread_rng, Rng}; /// - /// let mut rng = task_rng(); + /// let mut rng = thread_rng(); /// let x: uint = rng.gen(); /// println!("{}", x); /// println!("{}", rng.gen::<(f64, bool)>()); @@ -191,9 +191,9 @@ pub trait Rng { /// # Example /// /// ``` - /// use std::rand::{task_rng, Rng}; + /// use std::rand::{thread_rng, Rng}; /// - /// let mut rng = task_rng(); + /// let mut rng = thread_rng(); /// let x = rng.gen_iter::().take(10).collect::>(); /// println!("{}", x); /// println!("{}", rng.gen_iter::<(f64, bool)>().take(5) @@ -218,9 +218,9 @@ pub trait Rng { /// # Example /// /// ```rust - /// use std::rand::{task_rng, Rng}; + /// use std::rand::{thread_rng, Rng}; /// - /// let mut rng = task_rng(); + /// let mut rng = thread_rng(); /// let n: uint = rng.gen_range(0u, 10); /// println!("{}", n); /// let m: f64 = rng.gen_range(-40.0f64, 1.3e5f64); @@ -236,9 +236,9 @@ pub trait Rng { /// # Example /// /// ```rust - /// use std::rand::{task_rng, Rng}; + /// use std::rand::{thread_rng, Rng}; /// - /// let mut rng = task_rng(); + /// let mut rng = thread_rng(); /// println!("{}", rng.gen_weighted_bool(3)); /// ``` fn gen_weighted_bool(&mut self, n: uint) -> bool { @@ -250,9 +250,9 @@ pub trait Rng { /// # Example /// /// ```rust - /// use std::rand::{task_rng, Rng}; + /// use std::rand::{thread_rng, Rng}; /// - /// let s: String = task_rng().gen_ascii_chars().take(10).collect(); + /// let s: String = thread_rng().gen_ascii_chars().take(10).collect(); /// println!("{}", s); /// ``` fn gen_ascii_chars<'a>(&'a mut self) -> AsciiGenerator<'a, Self> { @@ -266,10 +266,10 @@ pub trait Rng { /// # Example /// /// ``` - /// use std::rand::{task_rng, Rng}; + /// use std::rand::{thread_rng, Rng}; /// /// let choices = [1i, 2, 4, 8, 16, 32]; - /// let mut rng = task_rng(); + /// let mut rng = thread_rng(); /// println!("{}", rng.choose(&choices)); /// assert_eq!(rng.choose(choices[..0]), None); /// ``` @@ -286,9 +286,9 @@ pub trait Rng { /// # Example /// /// ```rust - /// use std::rand::{task_rng, Rng}; + /// use std::rand::{thread_rng, Rng}; /// - /// let mut rng = task_rng(); + /// let mut rng = thread_rng(); /// let mut y = [1i, 2, 3]; /// rng.shuffle(&mut y); /// println!("{}", y.as_slice()); @@ -520,8 +520,8 @@ mod test { } } - pub fn rng() -> MyRng { - MyRng { inner: rand::task_rng() } + pub fn rng() -> MyRng { + MyRng { inner: rand::thread_rng() } } pub fn weak_rng() -> MyRng { diff --git a/src/librand/rand_impls.rs b/src/librand/rand_impls.rs index 3b38fde3884..e50153076c3 100644 --- a/src/librand/rand_impls.rs +++ b/src/librand/rand_impls.rs @@ -215,7 +215,7 @@ impl Rand for Option { #[cfg(test)] mod tests { use std::prelude::*; - use std::rand::{Rng, task_rng, Open01, Closed01}; + use std::rand::{Rng, thread_rng, Open01, Closed01}; struct ConstantRng(u64); impl Rng for ConstantRng { @@ -240,7 +240,7 @@ mod tests { fn rand_open() { // this is unlikely to catch an incorrect implementation that // generates exactly 0 or 1, but it keeps it sane. - let mut rng = task_rng(); + let mut rng = thread_rng(); for _ in range(0u, 1_000) { // strict inequalities let Open01(f) = rng.gen::>(); @@ -253,7 +253,7 @@ mod tests { #[test] fn rand_closed() { - let mut rng = task_rng(); + let mut rng = thread_rng(); for _ in range(0u, 1_000) { // strict inequalities let Closed01(f) = rng.gen::>(); diff --git a/src/libregex/test/bench.rs b/src/libregex/test/bench.rs index 0c204f759e6..38f030c3bda 100644 --- a/src/libregex/test/bench.rs +++ b/src/libregex/test/bench.rs @@ -9,7 +9,7 @@ // except according to those terms. #![allow(non_snake_case)] -use std::rand::{Rng, task_rng}; +use std::rand::{Rng, thread_rng}; use stdtest::Bencher; use regex::{Regex, NoExpand}; @@ -154,7 +154,7 @@ fn medium() -> Regex { regex!("[XYZ]ABCDEFGHIJKLMNOPQRSTUVWXYZ$") } fn hard() -> Regex { regex!("[ -~]*ABCDEFGHIJKLMNOPQRSTUVWXYZ$") } fn gen_text(n: uint) -> String { - let mut rng = task_rng(); + let mut rng = thread_rng(); let mut bytes = rng.gen_ascii_chars().map(|n| n as u8).take(n) .collect::>(); for (i, b) in bytes.iter_mut().enumerate() { diff --git a/src/libserialize/base64.rs b/src/libserialize/base64.rs index f1dffa55bb0..fae73cc834f 100644 --- a/src/libserialize/base64.rs +++ b/src/libserialize/base64.rs @@ -392,10 +392,10 @@ mod tests { #[test] fn test_base64_random() { - use std::rand::{task_rng, random, Rng}; + use std::rand::{thread_rng, random, Rng}; for _ in range(0u, 1000) { - let times = task_rng().gen_range(1u, 100); + let times = thread_rng().gen_range(1u, 100); let v = Vec::from_fn(times, |_| random::()); assert_eq!(v.to_base64(STANDARD) .from_base64() diff --git a/src/libstd/hash.rs b/src/libstd/hash.rs index 52e3c718b2d..737fef23c74 100644 --- a/src/libstd/hash.rs +++ b/src/libstd/hash.rs @@ -79,7 +79,7 @@ impl RandomSipHasher { /// Construct a new `RandomSipHasher` that is initialized with random keys. #[inline] pub fn new() -> RandomSipHasher { - let mut r = rand::task_rng(); + let mut r = rand::thread_rng(); let r0 = r.gen(); let r1 = r.gen(); RandomSipHasher { diff --git a/src/libstd/os.rs b/src/libstd/os.rs index ceb9a4102f6..822ba643f83 100644 --- a/src/libstd/os.rs +++ b/src/libstd/os.rs @@ -1438,7 +1438,7 @@ mod tests { } fn make_rand_name() -> String { - let mut rng = rand::task_rng(); + let mut rng = rand::thread_rng(); let n = format!("TEST{}", rng.gen_ascii_chars().take(10u) .collect::()); assert!(getenv(n.as_slice()).is_none()); diff --git a/src/libstd/rand/mod.rs b/src/libstd/rand/mod.rs index c590c0f575e..d4f72a53aec 100644 --- a/src/libstd/rand/mod.rs +++ b/src/libstd/rand/mod.rs @@ -18,10 +18,10 @@ //! See the `distributions` submodule for sampling random numbers from //! distributions like normal and exponential. //! -//! # Task-local RNG +//! # Thread-local RNG //! -//! There is built-in support for a RNG associated with each task stored -//! in task-local storage. This RNG can be accessed via `task_rng`, or +//! There is built-in support for a RNG associated with each thread stored +//! in thread-local storage. This RNG can be accessed via `thread_rng`, or //! used implicitly via `random`. This RNG is normally randomly seeded //! from an operating-system source of randomness, e.g. `/dev/urandom` on //! Unix systems, and will automatically reseed itself from this source @@ -61,7 +61,7 @@ //! use std::rand; //! use std::rand::Rng; //! -//! let mut rng = rand::task_rng(); +//! let mut rng = rand::thread_rng(); //! if rng.gen() { // random bool //! println!("int: {}, uint: {}", rng.gen::(), rng.gen::()) //! } @@ -97,7 +97,7 @@ //! //! fn main() { //! let between = Range::new(-1f64, 1.); -//! let mut rng = rand::task_rng(); +//! let mut rng = rand::thread_rng(); //! //! let total = 1_000_000u; //! let mut in_circle = 0u; @@ -183,7 +183,7 @@ //! // The estimation will be more accurate with more simulations //! let num_simulations = 10000u; //! -//! let mut rng = rand::task_rng(); +//! let mut rng = rand::thread_rng(); //! let random_door = Range::new(0u, 3); //! //! let (mut switch_wins, mut switch_losses) = (0u, 0u); @@ -257,7 +257,7 @@ impl StdRng { /// randomness from the operating system and use this in an /// expensive seeding operation. If one is only generating a small /// number of random numbers, or doesn't need the utmost speed for - /// generating each number, `task_rng` and/or `random` may be more + /// generating each number, `thread_rng` and/or `random` may be more /// appropriate. /// /// Reading the randomness from the OS may fail, and any error is @@ -307,28 +307,28 @@ pub fn weak_rng() -> XorShiftRng { } } -/// Controls how the task-local RNG is reseeded. -struct TaskRngReseeder; +/// Controls how the thread-local RNG is reseeded. +struct ThreadRngReseeder; -impl reseeding::Reseeder for TaskRngReseeder { +impl reseeding::Reseeder for ThreadRngReseeder { fn reseed(&mut self, rng: &mut StdRng) { *rng = match StdRng::new() { Ok(r) => r, - Err(e) => panic!("could not reseed task_rng: {}", e) + Err(e) => panic!("could not reseed thread_rng: {}", e) } } } -static TASK_RNG_RESEED_THRESHOLD: uint = 32_768; -type TaskRngInner = reseeding::ReseedingRng; +static THREAD_RNG_RESEED_THRESHOLD: uint = 32_768; +type ThreadRngInner = reseeding::ReseedingRng; -/// The task-local RNG. -pub struct TaskRng { - rng: Rc>, +/// The thread-local RNG. +pub struct ThreadRng { + rng: Rc>, } -/// Retrieve the lazily-initialized task-local random number +/// Retrieve the lazily-initialized thread-local random number /// generator, seeded by the system. Intended to be used in method -/// chaining style, e.g. `task_rng().gen::()`. +/// chaining style, e.g. `thread_rng().gen::()`. /// /// The RNG provided will reseed itself from the operating system /// after generating a certain amount of randomness. @@ -337,23 +337,23 @@ pub struct TaskRng { /// if the operating system random number generator is rigged to give /// the same sequence always. If absolute consistency is required, /// explicitly select an RNG, e.g. `IsaacRng` or `Isaac64Rng`. -pub fn task_rng() -> TaskRng { +pub fn thread_rng() -> ThreadRng { // used to make space in TLS for a random number generator - thread_local!(static TASK_RNG_KEY: Rc> = { + thread_local!(static THREAD_RNG_KEY: Rc> = { let r = match StdRng::new() { Ok(r) => r, - Err(e) => panic!("could not initialize task_rng: {}", e) + Err(e) => panic!("could not initialize thread_rng: {}", e) }; let rng = reseeding::ReseedingRng::new(r, - TASK_RNG_RESEED_THRESHOLD, - TaskRngReseeder); + THREAD_RNG_RESEED_THRESHOLD, + ThreadRngReseeder); Rc::new(RefCell::new(rng)) }); - TaskRng { rng: TASK_RNG_KEY.with(|t| t.clone()) } + ThreadRng { rng: THREAD_RNG_KEY.with(|t| t.clone()) } } -impl Rng for TaskRng { +impl Rng for ThreadRng { fn next_u32(&mut self) -> u32 { self.rng.borrow_mut().next_u32() } @@ -368,7 +368,7 @@ impl Rng for TaskRng { } } -/// Generates a random value using the task-local random number generator. +/// Generates a random value using the thread-local random number generator. /// /// `random()` can generate various types of random things, and so may require /// type hinting to generate the specific type you want. @@ -390,7 +390,7 @@ impl Rng for TaskRng { /// ``` #[inline] pub fn random() -> T { - task_rng().gen() + thread_rng().gen() } /// Randomly sample up to `amount` elements from an iterator. @@ -398,9 +398,9 @@ pub fn random() -> T { /// # Example /// /// ```rust -/// use std::rand::{task_rng, sample}; +/// use std::rand::{thread_rng, sample}; /// -/// let mut rng = task_rng(); +/// let mut rng = thread_rng(); /// let sample = sample(&mut rng, range(1i, 100), 5); /// println!("{}", sample); /// ``` @@ -420,7 +420,7 @@ pub fn sample, R: Rng>(rng: &mut R, #[cfg(test)] mod test { use prelude::*; - use super::{Rng, task_rng, random, SeedableRng, StdRng, sample}; + use super::{Rng, thread_rng, random, SeedableRng, StdRng, sample}; use iter::order; struct ConstRng { i: u64 } @@ -453,7 +453,7 @@ mod test { #[test] fn test_gen_range() { - let mut r = task_rng(); + let mut r = thread_rng(); for _ in range(0u, 1000) { let a = r.gen_range(-3i, 42); assert!(a >= -3 && a < 42); @@ -473,20 +473,20 @@ mod test { #[test] #[should_fail] fn test_gen_range_panic_int() { - let mut r = task_rng(); + let mut r = thread_rng(); r.gen_range(5i, -2); } #[test] #[should_fail] fn test_gen_range_panic_uint() { - let mut r = task_rng(); + let mut r = thread_rng(); r.gen_range(5u, 2u); } #[test] fn test_gen_f64() { - let mut r = task_rng(); + let mut r = thread_rng(); let a = r.gen::(); let b = r.gen::(); debug!("{}", (a, b)); @@ -494,14 +494,14 @@ mod test { #[test] fn test_gen_weighted_bool() { - let mut r = task_rng(); + let mut r = thread_rng(); assert_eq!(r.gen_weighted_bool(0u), true); assert_eq!(r.gen_weighted_bool(1u), true); } #[test] fn test_gen_ascii_str() { - let mut r = task_rng(); + let mut r = thread_rng(); assert_eq!(r.gen_ascii_chars().take(0).count(), 0u); assert_eq!(r.gen_ascii_chars().take(10).count(), 10u); assert_eq!(r.gen_ascii_chars().take(16).count(), 16u); @@ -509,7 +509,7 @@ mod test { #[test] fn test_gen_vec() { - let mut r = task_rng(); + let mut r = thread_rng(); assert_eq!(r.gen_iter::().take(0).count(), 0u); assert_eq!(r.gen_iter::().take(10).count(), 10u); assert_eq!(r.gen_iter::().take(16).count(), 16u); @@ -517,7 +517,7 @@ mod test { #[test] fn test_choose() { - let mut r = task_rng(); + let mut r = thread_rng(); assert_eq!(r.choose(&[1i, 1, 1]).map(|&x|x), Some(1)); let v: &[int] = &[]; @@ -526,7 +526,7 @@ mod test { #[test] fn test_shuffle() { - let mut r = task_rng(); + let mut r = thread_rng(); let empty: &mut [int] = &mut []; r.shuffle(empty); let mut one = [1i]; @@ -545,8 +545,8 @@ mod test { } #[test] - fn test_task_rng() { - let mut r = task_rng(); + fn test_thread_rng() { + let mut r = thread_rng(); r.gen::(); let mut v = [1i, 1, 1]; r.shuffle(&mut v); @@ -574,7 +574,7 @@ mod test { let min_val = 1i; let max_val = 100i; - let mut r = task_rng(); + let mut r = thread_rng(); let vals = range(min_val, max_val).collect::>(); let small_sample = sample(&mut r, vals.iter(), 5); let large_sample = sample(&mut r, vals.iter(), vals.len() + 5); @@ -589,7 +589,7 @@ mod test { #[test] fn test_std_rng_seeded() { - let s = task_rng().gen_iter::().take(256).collect::>(); + let s = thread_rng().gen_iter::().take(256).collect::>(); let mut ra: StdRng = SeedableRng::from_seed(s.as_slice()); let mut rb: StdRng = SeedableRng::from_seed(s.as_slice()); assert!(order::equals(ra.gen_ascii_chars().take(100), @@ -598,7 +598,7 @@ mod test { #[test] fn test_std_rng_reseed() { - let s = task_rng().gen_iter::().take(256).collect::>(); + let s = thread_rng().gen_iter::().take(256).collect::>(); let mut r: StdRng = SeedableRng::from_seed(s.as_slice()); let string1 = r.gen_ascii_chars().take(100).collect::(); diff --git a/src/libstd/sync/rwlock.rs b/src/libstd/sync/rwlock.rs index 76d05d9bfd4..7b6a6be7885 100644 --- a/src/libstd/sync/rwlock.rs +++ b/src/libstd/sync/rwlock.rs @@ -394,7 +394,7 @@ mod tests { for _ in range(0, N) { let tx = tx.clone(); spawn(move|| { - let mut rng = rand::task_rng(); + let mut rng = rand::thread_rng(); for _ in range(0, M) { if rng.gen_weighted_bool(N) { drop(R.write()); diff --git a/src/libsyntax/parse/token.rs b/src/libsyntax/parse/token.rs index f575d3d6c67..f22a4b5c6ed 100644 --- a/src/libsyntax/parse/token.rs +++ b/src/libsyntax/parse/token.rs @@ -724,7 +724,7 @@ pub fn fresh_name(src: &ast::Ident) -> ast::Name { // following: debug version. Could work in final except that it's incompatible with // good error messages and uses of struct names in ambiguous could-be-binding // locations. Also definitely destroys the guarantee given above about ptr_eq. - /*let num = rand::task_rng().gen_uint_range(0,0xffff); + /*let num = rand::thread_rng().gen_uint_range(0,0xffff); gensym(format!("{}_{}",ident_to_string(src),num))*/ } diff --git a/src/test/bench/core-std.rs b/src/test/bench/core-std.rs index 16129593485..d9a4aede7d7 100644 --- a/src/test/bench/core-std.rs +++ b/src/test/bench/core-std.rs @@ -83,7 +83,7 @@ fn read_line() { } fn vec_plus() { - let mut r = rand::task_rng(); + let mut r = rand::thread_rng(); let mut v = Vec::new(); let mut i = 0; @@ -101,7 +101,7 @@ fn vec_plus() { } fn vec_append() { - let mut r = rand::task_rng(); + let mut r = rand::thread_rng(); let mut v = Vec::new(); let mut i = 0; @@ -122,7 +122,7 @@ fn vec_append() { } fn vec_push_all() { - let mut r = rand::task_rng(); + let mut r = rand::thread_rng(); let mut v = Vec::new(); for i in range(0u, 1500) { diff --git a/src/test/compile-fail/task-rng-isnt-sendable.rs b/src/test/compile-fail/task-rng-isnt-sendable.rs index d96599404de..f673c3b7978 100644 --- a/src/test/compile-fail/task-rng-isnt-sendable.rs +++ b/src/test/compile-fail/task-rng-isnt-sendable.rs @@ -8,14 +8,14 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// ensure that the TaskRng isn't/doesn't become accidentally sendable. +// ensure that the ThreadRng isn't/doesn't become accidentally sendable. use std::rand; fn test_send() {} pub fn main() { - test_send::(); + test_send::(); //~^ ERROR `core::kinds::Send` is not implemented //~^^ ERROR `core::kinds::Send` is not implemented } diff --git a/src/test/run-make/unicode-input/multiple_files.rs b/src/test/run-make/unicode-input/multiple_files.rs index 2aa4264225c..88d8f10e709 100644 --- a/src/test/run-make/unicode-input/multiple_files.rs +++ b/src/test/run-make/unicode-input/multiple_files.rs @@ -10,7 +10,7 @@ use std::{char, os}; use std::io::{File, Command}; -use std::rand::{task_rng, Rng}; +use std::rand::{thread_rng, Rng}; // creates unicode_input_multiple_files_{main,chars}.rs, where the // former imports the latter. `_chars` just contains an identifier @@ -19,7 +19,7 @@ use std::rand::{task_rng, Rng}; // this span used to upset the compiler). fn random_char() -> char { - let mut rng = task_rng(); + let mut rng = thread_rng(); // a subset of the XID_start Unicode table (ensuring that the // compiler doesn't fail with an "unrecognised token" error) let (lo, hi): (u32, u32) = match rng.gen_range(1u32, 4u32 + 1) { diff --git a/src/test/run-make/unicode-input/span_length.rs b/src/test/run-make/unicode-input/span_length.rs index 7b096d7d583..f83734b1502 100644 --- a/src/test/run-make/unicode-input/span_length.rs +++ b/src/test/run-make/unicode-input/span_length.rs @@ -10,7 +10,7 @@ use std::{char, os}; use std::io::{File, Command}; -use std::rand::{task_rng, Rng}; +use std::rand::{thread_rng, Rng}; // creates a file with `fn main() { }` and checks the // compiler emits a span of the appropriate length (for the @@ -18,7 +18,7 @@ use std::rand::{task_rng, Rng}; // points, but should be the number of graphemes (FIXME #7043) fn random_char() -> char { - let mut rng = task_rng(); + let mut rng = thread_rng(); // a subset of the XID_start Unicode table (ensuring that the // compiler doesn't fail with an "unrecognised token" error) let (lo, hi): (u32, u32) = match rng.gen_range(1u32, 4u32 + 1) { @@ -38,7 +38,7 @@ fn main() { let main_file = tmpdir.join("span_main.rs"); for _ in range(0u, 100) { - let n = task_rng().gen_range(3u, 20); + let n = thread_rng().gen_range(3u, 20); { let _ = write!(&mut File::create(&main_file).unwrap(), diff --git a/src/test/run-pass/vector-sort-panic-safe.rs b/src/test/run-pass/vector-sort-panic-safe.rs index fe89c7532ee..6ff1cffb4a4 100644 --- a/src/test/run-pass/vector-sort-panic-safe.rs +++ b/src/test/run-pass/vector-sort-panic-safe.rs @@ -10,7 +10,7 @@ use std::task; use std::sync::atomic::{AtomicUint, INIT_ATOMIC_UINT, Relaxed}; -use std::rand::{task_rng, Rng, Rand}; +use std::rand::{thread_rng, Rng, Rand}; const REPEATS: uint = 5; const MAX_LEN: uint = 32; @@ -59,7 +59,7 @@ pub fn main() { // IDs start from 0. creation_count.store(0, Relaxed); - let main = task_rng().gen_iter::() + let main = thread_rng().gen_iter::() .take(len) .collect::>(); -- cgit 1.4.1-3-g733a5