diff options
70 files changed, 1128 insertions, 526 deletions
diff --git a/src/libextra/dlist.rs b/src/libextra/dlist.rs index 076e86dd5b0..8e641073637 100644 --- a/src/libextra/dlist.rs +++ b/src/libextra/dlist.rs @@ -661,7 +661,7 @@ mod tests { #[test] fn test_basic() { - let mut m = DList::new::<~int>(); + let mut m: DList<~int> = DList::new(); assert_eq!(m.pop_front(), None); assert_eq!(m.pop_back(), None); assert_eq!(m.pop_front(), None); @@ -768,7 +768,7 @@ mod tests { #[test] fn test_rotate() { - let mut n = DList::new::<int>(); + let mut n: DList<int> = DList::new(); n.rotate_backward(); check_links(&n); assert_eq!(n.len(), 0); n.rotate_forward(); check_links(&n); @@ -1033,7 +1033,7 @@ mod tests { #[cfg(test)] fn fuzz_test(sz: int) { - let mut m = DList::new::<int>(); + let mut m: DList<int> = DList::new(); let mut v = ~[]; for i in range(0, sz) { check_links(&m); @@ -1078,7 +1078,7 @@ mod tests { #[bench] fn bench_push_front(b: &mut test::BenchHarness) { - let mut m = DList::new::<int>(); + let mut m: DList<int> = DList::new(); do b.iter { m.push_front(0); } @@ -1086,7 +1086,7 @@ mod tests { #[bench] fn bench_push_back(b: &mut test::BenchHarness) { - let mut m = DList::new::<int>(); + let mut m: DList<int> = DList::new(); do b.iter { m.push_back(0); } @@ -1094,7 +1094,7 @@ mod tests { #[bench] fn bench_push_back_pop_back(b: &mut test::BenchHarness) { - let mut m = DList::new::<int>(); + let mut m: DList<int> = DList::new(); do b.iter { m.push_back(0); m.pop_back(); @@ -1103,7 +1103,7 @@ mod tests { #[bench] fn bench_push_front_pop_front(b: &mut test::BenchHarness) { - let mut m = DList::new::<int>(); + let mut m: DList<int> = DList::new(); do b.iter { m.push_front(0); m.pop_front(); @@ -1112,7 +1112,7 @@ mod tests { #[bench] fn bench_rotate_forward(b: &mut test::BenchHarness) { - let mut m = DList::new::<int>(); + let mut m: DList<int> = DList::new(); m.push_front(0); m.push_front(1); do b.iter { @@ -1122,7 +1122,7 @@ mod tests { #[bench] fn bench_rotate_backward(b: &mut test::BenchHarness) { - let mut m = DList::new::<int>(); + let mut m: DList<int> = DList::new(); m.push_front(0); m.push_front(1); do b.iter { diff --git a/src/libextra/num/bigint.rs b/src/libextra/num/bigint.rs index 9222dea13c4..ed35f2b6179 100644 --- a/src/libextra/num/bigint.rs +++ b/src/libextra/num/bigint.rs @@ -359,7 +359,7 @@ impl Integer for BigUint { fn div_mod_floor_inner(a: BigUint, b: BigUint) -> (BigUint, BigUint) { let mut m = a; - let mut d = Zero::zero::<BigUint>(); + let mut d: BigUint = Zero::zero(); let mut n = 1; while m >= b { let (d0, d_unit, b_unit) = div_estimate(&m, &b, n); @@ -411,8 +411,9 @@ impl Integer for BigUint { if shift == 0 { return (BigUint::new(d), One::one(), (*b).clone()); } + let one: BigUint = One::one(); return (BigUint::from_slice(d).shl_unit(shift), - One::one::<BigUint>().shl_unit(shift), + one.shl_unit(shift), b.shl_unit(shift)); } } @@ -1445,11 +1446,18 @@ mod biguint_tests { #[test] fn test_is_even() { - assert!(FromStr::from_str::<BigUint>("1").unwrap().is_odd()); - assert!(FromStr::from_str::<BigUint>("2").unwrap().is_even()); - assert!(FromStr::from_str::<BigUint>("1000").unwrap().is_even()); - assert!(FromStr::from_str::<BigUint>("1000000000000000000000").unwrap().is_even()); - assert!(FromStr::from_str::<BigUint>("1000000000000000000001").unwrap().is_odd()); + let one: Option<BigUint> = FromStr::from_str("1"); + let two: Option<BigUint> = FromStr::from_str("2"); + let thousand: Option<BigUint> = FromStr::from_str("1000"); + let big: Option<BigUint> = + FromStr::from_str("1000000000000000000000"); + let bigger: Option<BigUint> = + FromStr::from_str("1000000000000000000001"); + assert!(one.unwrap().is_odd()); + assert!(two.unwrap().is_even()); + assert!(thousand.unwrap().is_even()); + assert!(big.unwrap().is_even()); + assert!(bigger.unwrap().is_odd()); assert!((BigUint::from_uint(1) << 64).is_even()); assert!(((BigUint::from_uint(1) << 64) + BigUint::from_uint(1)).is_odd()); } @@ -1534,15 +1542,19 @@ mod biguint_tests { } } - assert_eq!(FromStrRadix::from_str_radix::<BigUint>("Z", 10), None); - assert_eq!(FromStrRadix::from_str_radix::<BigUint>("_", 2), None); - assert_eq!(FromStrRadix::from_str_radix::<BigUint>("-1", 10), None); + let zed: Option<BigUint> = FromStrRadix::from_str_radix("Z", 10); + assert_eq!(zed, None); + let blank: Option<BigUint> = FromStrRadix::from_str_radix("_", 2); + assert_eq!(blank, None); + let minus_one: Option<BigUint> = FromStrRadix::from_str_radix("-1", + 10); + assert_eq!(minus_one, None); } #[test] fn test_factor() { fn factor(n: uint) -> BigUint { - let mut f= One::one::<BigUint>(); + let mut f: BigUint = One::one(); for i in range(2, n + 1) { // FIXME(#6102): Assignment operator for BigInt causes ICE // f *= BigUint::from_uint(i); @@ -1939,17 +1951,24 @@ mod bigint_tests { #[test] fn test_abs_sub() { - assert_eq!((-One::one::<BigInt>()).abs_sub(&One::one()), Zero::zero()); - assert_eq!(One::one::<BigInt>().abs_sub(&One::one()), Zero::zero()); - assert_eq!(One::one::<BigInt>().abs_sub(&Zero::zero()), One::one()); - assert_eq!(One::one::<BigInt>().abs_sub(&-One::one::<BigInt>()), - IntConvertible::from_int(2)); + let zero: BigInt = Zero::zero(); + let one: BigInt = One::one(); + assert_eq!((-one).abs_sub(&one), zero); + let one: BigInt = One::one(); + let zero: BigInt = Zero::zero(); + assert_eq!(one.abs_sub(&one), zero); + let one: BigInt = One::one(); + let zero: BigInt = Zero::zero(); + assert_eq!(one.abs_sub(&zero), one); + let one: BigInt = One::one(); + assert_eq!(one.abs_sub(&-one), IntConvertible::from_int(2)); } #[test] fn test_to_str_radix() { fn check(n: int, ans: &str) { - assert!(ans == IntConvertible::from_int::<BigInt>(n).to_str_radix(10)); + let n: BigInt = IntConvertible::from_int(n); + assert!(ans == n.to_str_radix(10)); } check(10, "10"); check(1, "1"); @@ -1962,7 +1981,10 @@ mod bigint_tests { #[test] fn test_from_str_radix() { fn check(s: &str, ans: Option<int>) { - let ans = ans.map_move(|n| IntConvertible::from_int::<BigInt>(n)); + let ans = ans.map_move(|n| { + let x: BigInt = IntConvertible::from_int(n); + x + }); assert_eq!(FromStrRadix::from_str_radix(s, 10), ans); } check("10", Some(10)); @@ -1980,7 +2002,8 @@ mod bigint_tests { BigInt::new(Minus, ~[1, 1, 1])); assert!(-BigInt::new(Minus, ~[1, 1, 1]) == BigInt::new(Plus, ~[1, 1, 1])); - assert_eq!(-Zero::zero::<BigInt>(), Zero::zero::<BigInt>()); + let zero: BigInt = Zero::zero(); + assert_eq!(-zero, zero); } } diff --git a/src/libextra/num/rational.rs b/src/libextra/num/rational.rs index 60dd36a3b88..41e9a488bf8 100644 --- a/src/libextra/num/rational.rs +++ b/src/libextra/num/rational.rs @@ -269,9 +269,13 @@ impl<T: FromStr + Clone + Integer + Ord> /// Parses `numer/denom`. fn from_str(s: &str) -> Option<Ratio<T>> { let split: ~[&str] = s.splitn_iter('/', 1).collect(); - if split.len() < 2 { return None; } - do FromStr::from_str::<T>(split[0]).chain |a| { - do FromStr::from_str::<T>(split[1]).chain |b| { + if split.len() < 2 { + return None + } + let a_option: Option<T> = FromStr::from_str(split[0]); + do a_option.chain |a| { + let b_option: Option<T> = FromStr::from_str(split[1]); + do b_option.chain |b| { Some(Ratio::new(a.clone(), b.clone())) } } @@ -282,10 +286,15 @@ impl<T: FromStrRadix + Clone + Integer + Ord> /// Parses `numer/denom` where the numbers are in base `radix`. fn from_str_radix(s: &str, radix: uint) -> Option<Ratio<T>> { let split: ~[&str] = s.splitn_iter('/', 1).collect(); - if split.len() < 2 { None } - else { - do FromStrRadix::from_str_radix::<T>(split[0], radix).chain |a| { - do FromStrRadix::from_str_radix::<T>(split[1], radix).chain |b| { + if split.len() < 2 { + None + } else { + let a_option: Option<T> = FromStrRadix::from_str_radix(split[0], + radix); + do a_option.chain |a| { + let b_option: Option<T> = + FromStrRadix::from_str_radix(split[1], radix); + do b_option.chain |b| { Some(Ratio::new(a.clone(), b.clone())) } } @@ -496,7 +505,8 @@ mod test { #[test] fn test_from_str_fail() { fn test(s: &str) { - assert_eq!(FromStr::from_str::<Rational>(s), None); + let rational: Option<Rational> = FromStr::from_str(s); + assert_eq!(rational, None); } let xs = ["0 /1", "abc", "", "1/", "--1/2","3/2/1"]; @@ -536,7 +546,8 @@ mod test { #[test] fn test_from_str_radix_fail() { fn test(s: &str) { - assert_eq!(FromStrRadix::from_str_radix::<Rational>(s, 3), None); + let radix: Option<Rational> = FromStrRadix::from_str_radix(s, 3); + assert_eq!(radix, None); } let xs = ["0 /1", "abc", "", "1/", "--1/2","3/2/1", "3/2"]; diff --git a/src/libextra/priority_queue.rs b/src/libextra/priority_queue.rs index a9341a8075d..b085981aabb 100644 --- a/src/libextra/priority_queue.rs +++ b/src/libextra/priority_queue.rs @@ -338,27 +338,36 @@ mod tests { #[test] #[should_fail] - fn test_empty_pop() { let mut heap = PriorityQueue::new::<int>(); heap.pop(); } + fn test_empty_pop() { + let mut heap: PriorityQueue<int> = PriorityQueue::new(); + heap.pop(); + } #[test] fn test_empty_maybe_pop() { - let mut heap = PriorityQueue::new::<int>(); + let mut heap: PriorityQueue<int> = PriorityQueue::new(); assert!(heap.maybe_pop().is_none()); } #[test] #[should_fail] - fn test_empty_top() { let empty = PriorityQueue::new::<int>(); empty.top(); } + fn test_empty_top() { + let empty: PriorityQueue<int> = PriorityQueue::new(); + empty.top(); + } #[test] fn test_empty_maybe_top() { - let empty = PriorityQueue::new::<int>(); + let empty: PriorityQueue<int> = PriorityQueue::new(); assert!(empty.maybe_top().is_none()); } #[test] #[should_fail] - fn test_empty_replace() { let mut heap = PriorityQueue::new(); heap.replace(5); } + fn test_empty_replace() { + let mut heap: PriorityQueue<int> = PriorityQueue::new(); + heap.replace(5); + } #[test] fn test_from_iter() { diff --git a/src/libextra/ringbuf.rs b/src/libextra/ringbuf.rs index a38cb580c50..4f2755374af 100644 --- a/src/libextra/ringbuf.rs +++ b/src/libextra/ringbuf.rs @@ -483,7 +483,7 @@ mod tests { #[bench] fn bench_new(b: &mut test::BenchHarness) { do b.iter { - let _ = RingBuf::new::<u64>(); + let _: RingBuf<u64> = RingBuf::new(); } } diff --git a/src/libextra/treemap.rs b/src/libextra/treemap.rs index 118754ec028..307de43a067 100644 --- a/src/libextra/treemap.rs +++ b/src/libextra/treemap.rs @@ -879,7 +879,8 @@ mod test_treemap { #[test] fn find_empty() { - let m = TreeMap::new::<int, int>(); assert!(m.find(&5) == None); + let m: TreeMap<int,int> = TreeMap::new(); + assert!(m.find(&5) == None); } #[test] @@ -1006,7 +1007,7 @@ mod test_treemap { #[test] fn test_rand_int() { - let mut map = TreeMap::new::<int, int>(); + let mut map: TreeMap<int,int> = TreeMap::new(); let mut ctrl = ~[]; check_equal(ctrl, &map); diff --git a/src/librustc/front/test.rs b/src/librustc/front/test.rs index e70e58342eb..a341db75393 100644 --- a/src/librustc/front/test.rs +++ b/src/librustc/front/test.rs @@ -387,7 +387,7 @@ fn path_node(ids: ~[ast::ident]) -> ast::Path { ast::Path { span: dummy_sp(), global: false, - segments: ids.consume_iter().transform(|identifier| ast::PathSegment { + segments: ids.move_iter().map(|identifier| ast::PathSegment { identifier: identifier, lifetime: None, types: opt_vec::Empty, @@ -399,7 +399,7 @@ fn path_node_global(ids: ~[ast::ident]) -> ast::Path { ast::Path { span: dummy_sp(), global: true, - segments: ids.consume_iter().transform(|identifier| ast::PathSegment { + segments: ids.move_iter().map(|identifier| ast::PathSegment { identifier: identifier, lifetime: None, types: opt_vec::Empty, diff --git a/src/librustc/metadata/decoder.rs b/src/librustc/metadata/decoder.rs index 0536a5e0227..96249cc88ab 100644 --- a/src/librustc/metadata/decoder.rs +++ b/src/librustc/metadata/decoder.rs @@ -335,15 +335,19 @@ fn item_to_def_like(item: ebml::Doc, did: ast::def_id, cnum: ast::CrateNum) let purity = if fam == UnsafeStaticMethod { ast::unsafe_fn } else { ast::impure_fn }; // def_static_method carries an optional field of its enclosing - // *trait*, but not an inclosing Impl (if this is an inherent - // static method). So we need to detect whether this is in - // a trait or not, which we do through the mildly hacky - // way of checking whether there is a trait_method_sort. - let trait_did_opt = if reader::maybe_get_doc( + // trait or enclosing impl (if this is an inherent static method). + // So we need to detect whether this is in a trait or not, which + // we do through the mildly hacky way of checking whether there is + // a trait_method_sort. + let provenance = if reader::maybe_get_doc( item, tag_item_trait_method_sort).is_some() { - Some(item_reqd_and_translated_parent_item(cnum, item)) - } else { None }; - dl_def(ast::def_static_method(did, trait_did_opt, purity)) + ast::FromTrait(item_reqd_and_translated_parent_item(cnum, + item)) + } else { + ast::FromImpl(item_reqd_and_translated_parent_item(cnum, + item)) + }; + dl_def(ast::def_static_method(did, provenance, purity)) } Type | ForeignType => dl_def(ast::def_ty(did)), Mod => dl_def(ast::def_mod(did)), diff --git a/src/librustc/metadata/tydecode.rs b/src/librustc/metadata/tydecode.rs index 3606ecd8d24..f5bad88b1ca 100644 --- a/src/librustc/metadata/tydecode.rs +++ b/src/librustc/metadata/tydecode.rs @@ -141,7 +141,7 @@ fn parse_path(st: &mut PState) -> @ast::Path { return @ast::Path { span: dummy_sp(), global: false, - segments: idents.consume_iter().transform(|identifier| { + segments: idents.move_iter().map(|identifier| { ast::PathSegment { identifier: identifier, lifetime: None, diff --git a/src/librustc/middle/astencode.rs b/src/librustc/middle/astencode.rs index 857579b5bf0..d6b22381192 100644 --- a/src/librustc/middle/astencode.rs +++ b/src/librustc/middle/astencode.rs @@ -374,9 +374,16 @@ impl tr for ast::def { fn tr(&self, xcx: @ExtendedDecodeContext) -> ast::def { match *self { ast::def_fn(did, p) => ast::def_fn(did.tr(xcx), p), - ast::def_static_method(did, did2_opt, p) => { + ast::def_static_method(did, wrapped_did2, p) => { ast::def_static_method(did.tr(xcx), - did2_opt.map(|did2| did2.tr(xcx)), + match wrapped_did2 { + ast::FromTrait(did2) => { + ast::FromTrait(did2.tr(xcx)) + } + ast::FromImpl(did2) => { + ast::FromImpl(did2.tr(xcx)) + } + }, p) } ast::def_method(did0, did1) => { diff --git a/src/librustc/middle/borrowck/gather_loans/mod.rs b/src/librustc/middle/borrowck/gather_loans/mod.rs index 8c5da2f3d0f..dbe5214e0eb 100644 --- a/src/librustc/middle/borrowck/gather_loans/mod.rs +++ b/src/librustc/middle/borrowck/gather_loans/mod.rs @@ -392,10 +392,12 @@ impl GatherLoanCtxt { } ty::AutoBorrowObj(r, m) => { let cmt_deref = mcx.cat_deref_fn_or_obj(expr, cmt, 0); + let loan_mutability = + LoanMutability::from_ast_mutability(m); self.guarantee_valid(expr.id, expr.span, cmt_deref, - m, + loan_mutability, r) } ty::AutoUnsafe(_) => {} diff --git a/src/librustc/middle/privacy.rs b/src/librustc/middle/privacy.rs index ec6bb17fb24..8f95d123288 100644 --- a/src/librustc/middle/privacy.rs +++ b/src/librustc/middle/privacy.rs @@ -8,9 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// A pass that checks to make sure private fields and methods aren't used -// outside their scopes. - +//! A pass that checks to make sure private fields and methods aren't used +//! outside their scopes. use metadata::csearch; use middle::ty::{ty_struct, ty_enum}; diff --git a/src/librustc/middle/resolve.rs b/src/librustc/middle/resolve.rs index 6ae2ac8cffc..cb987c69a5b 100644 --- a/src/librustc/middle/resolve.rs +++ b/src/librustc/middle/resolve.rs @@ -55,6 +55,12 @@ pub type BindingMap = HashMap<ident,binding_info>; // Trait method resolution pub type TraitMap = HashMap<NodeId,@mut ~[def_id]>; +// A summary of the generics on a trait. +struct TraitGenerics { + has_lifetime: bool, + type_parameter_count: uint, +} + // This is the replacement export map. It maps a module to all of the exports // within. pub type ExportMap2 = @mut HashMap<NodeId, ~[Export2]>; @@ -1321,9 +1327,12 @@ impl Resolver { method.span); let def = match method.explicit_self.node { sty_static => { - // Static methods become `def_fn`s. - def_fn(local_def(method.id), - method.purity) + // Static methods become + // `def_static_method`s. + def_static_method(local_def(method.id), + FromImpl(local_def( + item.id)), + method.purity) } _ => { // Non-static methods become @@ -1373,7 +1382,7 @@ impl Resolver { sty_static => { // Static methods become `def_static_method`s. def_static_method(local_def(ty_m.id), - Some(local_def(item.id)), + FromTrait(local_def(item.id)), ty_m.purity) } _ => { @@ -2115,7 +2124,7 @@ impl Resolver { fn path_idents_to_str(@mut self, path: &Path) -> ~str { let identifiers: ~[ast::ident] = path.segments .iter() - .transform(|seg| seg.identifier) + .map(|seg| seg.identifier) .collect(); self.idents_to_str(identifiers) } @@ -4161,6 +4170,22 @@ impl Resolver { Some(&primitive_type) => { result_def = Some(def_prim_ty(primitive_type)); + + if path.segments + .iter() + .any(|s| s.lifetime.is_some()) { + self.session.span_err(path.span, + "lifetime parameters \ + are not allowed on \ + this type") + } else if path.segments + .iter() + .any(|s| s.types.len() > 0) { + self.session.span_err(path.span, + "type parameters are \ + not allowed on this \ + type") + } } None => { // Continue. @@ -4170,12 +4195,17 @@ impl Resolver { match result_def { None => { - match self.resolve_path(ty.id, path, TypeNS, true, visitor) { + match self.resolve_path(ty.id, + path, + TypeNS, + true, + visitor) { Some(def) => { debug!("(resolving type) resolved `%s` to \ type %?", - self.session.str_of( - path.segments.last().identifier), + self.session.str_of(path.segments + .last() + .identifier), def); result_def = Some(def); } @@ -4184,9 +4214,7 @@ impl Resolver { } } } - Some(_) => { - // Continue. - } + Some(_) => {} // Continue. } match result_def { @@ -4364,7 +4392,7 @@ impl Resolver { // Check the types in the path pattern. for ty in path.segments .iter() - .flat_map_(|seg| seg.types.iter()) { + .flat_map(|seg| seg.types.iter()) { self.resolve_type(ty, visitor); } } @@ -4399,7 +4427,7 @@ impl Resolver { // Check the types in the path pattern. for ty in path.segments .iter() - .flat_map_(|s| s.types.iter()) { + .flat_map(|s| s.types.iter()) { self.resolve_type(ty, visitor); } } @@ -4432,7 +4460,7 @@ impl Resolver { // Check the types in the path pattern. for ty in path.segments .iter() - .flat_map_(|s| s.types.iter()) { + .flat_map(|s| s.types.iter()) { self.resolve_type(ty, visitor); } } @@ -4529,7 +4557,7 @@ impl Resolver { visitor: &mut ResolveVisitor) -> Option<def> { // First, resolve the types. - for ty in path.segments.iter().flat_map_(|s| s.types.iter()) { + for ty in path.segments.iter().flat_map(|s| s.types.iter()) { self.resolve_type(ty, visitor); } @@ -4553,11 +4581,13 @@ impl Resolver { match (def, unqualified_def) { (Some(d), Some(ud)) if d == ud => { self.session.add_lint(unnecessary_qualification, - id, path.span, + id, + path.span, ~"unnecessary qualification"); } _ => () } + return def; } diff --git a/src/librustc/middle/trans/callee.rs b/src/librustc/middle/trans/callee.rs index e72a568cba0..f1d98713124 100644 --- a/src/librustc/middle/trans/callee.rs +++ b/src/librustc/middle/trans/callee.rs @@ -117,10 +117,13 @@ pub fn trans(bcx: @mut Block, expr: @ast::expr) -> Callee { fn trans_def(bcx: @mut Block, def: ast::def, ref_expr: @ast::expr) -> Callee { match def { - ast::def_fn(did, _) | ast::def_static_method(did, None, _) => { + ast::def_fn(did, _) | + ast::def_static_method(did, ast::FromImpl(_), _) => { fn_callee(bcx, trans_fn_ref(bcx, did, ref_expr.id)) } - ast::def_static_method(impl_did, Some(trait_did), _) => { + ast::def_static_method(impl_did, + ast::FromTrait(trait_did), + _) => { fn_callee(bcx, meth::trans_static_method_callee(bcx, impl_did, trait_did, ref_expr.id)) diff --git a/src/librustc/middle/trans/expr.rs b/src/librustc/middle/trans/expr.rs index 6f981123f5f..57464fa4cc4 100644 --- a/src/librustc/middle/trans/expr.rs +++ b/src/librustc/middle/trans/expr.rs @@ -824,14 +824,17 @@ fn trans_def_datum_unadjusted(bcx: @mut Block, { let _icx = push_ctxt("trans_def_datum_unadjusted"); - let fn_data = match def { - ast::def_fn(did, _) | ast::def_static_method(did, None, _) => { + match def { + ast::def_fn(did, _) | + ast::def_static_method(did, ast::FromImpl(_), _) => { callee::trans_fn_ref(bcx, did, ref_expr.id) } - ast::def_static_method(impl_did, Some(trait_did), _) => { - meth::trans_static_method_callee(bcx, impl_did, - trait_did, - ref_expr.id) + ast::def_static_method(impl_did, ast::FromTrait(trait_did), _) => { + let fn_data = meth::trans_static_method_callee(bcx, + impl_did, + trait_did, + ref_expr.id); + return fn_data_to_datum(bcx, ref_expr, impl_did, fn_data); } _ => { bcx.tcx().sess.span_bug(ref_expr.span, fmt!( diff --git a/src/librustc/middle/typeck/astconv.rs b/src/librustc/middle/typeck/astconv.rs index 6425867425f..17b4716ad50 100644 --- a/src/librustc/middle/typeck/astconv.rs +++ b/src/librustc/middle/typeck/astconv.rs @@ -178,7 +178,7 @@ fn ast_path_substs<AC:AstConv,RS:region_scope + Clone + 'static>( // Convert the type parameters supplied by the user. let supplied_type_parameter_count = - path.segments.iter().flat_map_(|s| s.types.iter()).len_(); + path.segments.iter().flat_map(|s| s.types.iter()).len(); if decl_generics.type_param_defs.len() != supplied_type_parameter_count { this.tcx().sess.span_fatal( path.span, @@ -188,8 +188,8 @@ fn ast_path_substs<AC:AstConv,RS:region_scope + Clone + 'static>( } let tps = path.segments .iter() - .flat_map_(|s| s.types.iter()) - .transform(|a_t| ast_ty_to_ty(this, rscope, a_t)) + .flat_map(|s| s.types.iter()) + .map(|a_t| ast_ty_to_ty(this, rscope, a_t)) .collect(); substs { diff --git a/src/librustc/middle/typeck/check/_match.rs b/src/librustc/middle/typeck/check/_match.rs index b7114e60283..628ceccd61e 100644 --- a/src/librustc/middle/typeck/check/_match.rs +++ b/src/librustc/middle/typeck/check/_match.rs @@ -128,7 +128,12 @@ pub fn check_pat_variant(pcx: &pat_ctxt, pat: @ast::pat, path: &ast::Path, Some((enm, var)) => { // Assign the pattern the type of the *enum*, not the variant. let enum_tpt = ty::lookup_item_type(tcx, enm); - instantiate_path(pcx.fcx, path, enum_tpt, pat.span, pat.id); + instantiate_path(pcx.fcx, + path, + enum_tpt, + v_def, + pat.span, + pat.id); // check that the type of the value being matched is a subtype // of the type of the pattern: @@ -185,7 +190,12 @@ pub fn check_pat_variant(pcx: &pat_ctxt, pat: @ast::pat, path: &ast::Path, } else { ctor_tpt }; - instantiate_path(pcx.fcx, path, struct_tpt, pat.span, pat.id); + instantiate_path(pcx.fcx, + path, + struct_tpt, + s_def, + pat.span, + pat.id); // Check that the type of the value being matched is a subtype of // the type of the pattern. diff --git a/src/librustc/middle/typeck/check/mod.rs b/src/librustc/middle/typeck/check/mod.rs index fcd62eb92b5..214fb1f2f07 100644 --- a/src/librustc/middle/typeck/check/mod.rs +++ b/src/librustc/middle/typeck/check/mod.rs @@ -1132,8 +1132,160 @@ pub enum DerefArgs { DoDerefArgs } -pub fn break_here() { - debug!("break here!"); +// Given the provenance of a static method, returns the generics of the static +// method's container. +fn generics_of_static_method_container(type_context: ty::ctxt, + provenance: ast::MethodProvenance) + -> ty::Generics { + match provenance { + ast::FromTrait(trait_def_id) => { + ty::lookup_trait_def(type_context, trait_def_id).generics + } + ast::FromImpl(impl_def_id) => { + ty::lookup_item_type(type_context, impl_def_id).generics + } + } +} + +// Verifies that type parameters supplied in paths are in the right +// locations. +fn check_type_parameter_positions_in_path(function_context: @mut FnCtxt, + path: &ast::Path, + def: ast::def) { + // We only care about checking the case in which the path has two or + // more segments. + if path.segments.len() < 2 { + return + } + + // Verify that no lifetimes or type parameters are present anywhere + // except the final two elements of the path. + for i in range(0, path.segments.len() - 2) { + match path.segments[i].lifetime { + None => {} + Some(lifetime) => { + function_context.tcx() + .sess + .span_err(lifetime.span, + "lifetime parameters may not \ + appear here") + } + } + + for typ in path.segments[i].types.iter() { + function_context.tcx() + .sess + .span_err(typ.span, + "type parameters may not appear here") + } + } + + // If there are no parameters at all, there is nothing more to do; the + // rest of typechecking will (attempt to) infer everything. + if path.segments + .iter() + .all(|s| s.lifetime.is_none() && s.types.is_empty()) { + return + } + + match def { + // If this is a static method of a trait or implementation, then + // ensure that the segment of the path which names the trait or + // implementation (the penultimate segment) is annotated with the + // right number of type parameters. + ast::def_static_method(_, provenance, _) => { + let generics = + generics_of_static_method_container(function_context.ccx.tcx, + provenance); + let name = match provenance { + ast::FromTrait(_) => "trait", + ast::FromImpl(_) => "impl", + }; + + let trait_segment = &path.segments[path.segments.len() - 2]; + + // Make sure lifetime parameterization agrees with the trait or + // implementation type. + match (generics.region_param, trait_segment.lifetime) { + (Some(_), None) => { + function_context.tcx() + .sess + .span_err(path.span, + fmt!("this %s has a lifetime \ + parameter but no \ + lifetime was specified", + name)) + } + (None, Some(_)) => { + function_context.tcx() + .sess + .span_err(path.span, + fmt!("this %s has no lifetime \ + parameter but a lifetime \ + was specified", + name)) + } + (Some(_), Some(_)) | (None, None) => {} + } + + // Make sure the number of type parameters supplied on the trait + // or implementation segment equals the number of type parameters + // on the trait or implementation definition. + let trait_type_parameter_count = generics.type_param_defs.len(); + let supplied_type_parameter_count = trait_segment.types.len(); + if trait_type_parameter_count != supplied_type_parameter_count { + let trait_count_suffix = if trait_type_parameter_count == 1 { + "" + } else { + "s" + }; + let supplied_count_suffix = + if supplied_type_parameter_count == 1 { + "" + } else { + "s" + }; + function_context.tcx() + .sess + .span_err(path.span, + fmt!("the %s referenced by this \ + path has %u type \ + parameter%s, but %u type \ + parameter%s were supplied", + name, + trait_type_parameter_count, + trait_count_suffix, + supplied_type_parameter_count, + supplied_count_suffix)) + } + } + _ => { + // Verify that no lifetimes or type parameters are present on + // the penultimate segment of the path. + let segment = &path.segments[path.segments.len() - 2]; + match segment.lifetime { + None => {} + Some(lifetime) => { + function_context.tcx() + .sess + .span_err(lifetime.span, + "lifetime parameters may not + appear here") + } + } + for typ in segment.types.iter() { + function_context.tcx() + .sess + .span_err(typ.span, + "type parameters may not appear \ + here"); + function_context.tcx() + .sess + .span_note(typ.span, + fmt!("this is a %?", def)); + } + } + } } /// Invariant: @@ -2333,8 +2485,9 @@ pub fn check_expr_with_unifier(fcx: @mut FnCtxt, ast::expr_path(ref pth) => { let defn = lookup_def(fcx, pth.span, id); + check_type_parameter_positions_in_path(fcx, pth, defn); let tpt = ty_param_bounds_and_ty_for_def(fcx, expr.span, defn); - instantiate_path(fcx, pth, tpt, expr.span, expr.id); + instantiate_path(fcx, pth, tpt, defn, expr.span, expr.id); } ast::expr_self => { let definition = lookup_def(fcx, expr.span, id); @@ -3141,11 +3294,12 @@ pub fn ty_param_bounds_and_ty_for_def(fcx: @mut FnCtxt, pub fn instantiate_path(fcx: @mut FnCtxt, pth: &ast::Path, tpt: ty_param_bounds_and_ty, + def: ast::def, span: span, node_id: ast::NodeId) { debug!(">>> instantiate_path"); - let ty_param_count = tpt.generics.type_param_defs.len(); + let mut ty_param_count = tpt.generics.type_param_defs.len(); let mut ty_substs_len = 0; for segment in pth.segments.iter() { ty_substs_len += segment.types.len() @@ -3180,6 +3334,21 @@ pub fn instantiate_path(fcx: @mut FnCtxt, } }; + // Special case: If there is a self parameter, omit it from the list of + // type parameters. + // + // Here we calculate the "user type parameter count", which is the number + // of type parameters actually manifest in the AST. This will differ from + // the internal type parameter count when there are self types involved. + let (user_type_parameter_count, self_parameter_index) = match def { + ast::def_static_method(_, provenance @ ast::FromTrait(_), _) => { + let generics = generics_of_static_method_container(fcx.ccx.tcx, + provenance); + (ty_param_count - 1, Some(generics.type_param_defs.len())) + } + _ => (ty_param_count, None), + }; + // determine values for type parameters, using the values given by // the user (if any) and otherwise using fresh type variables let tps = if ty_substs_len == 0 { @@ -3188,33 +3357,44 @@ pub fn instantiate_path(fcx: @mut FnCtxt, fcx.ccx.tcx.sess.span_err (span, "this item does not take type parameters"); fcx.infcx().next_ty_vars(ty_param_count) - } else if ty_substs_len > ty_param_count { + } else if ty_substs_len > user_type_parameter_count { fcx.ccx.tcx.sess.span_err (span, fmt!("too many type parameters provided: expected %u, found %u", - ty_param_count, ty_substs_len)); + user_type_parameter_count, ty_substs_len)); fcx.infcx().next_ty_vars(ty_param_count) - } else if ty_substs_len < ty_param_count { - let is_static_method = match fcx.ccx.tcx.def_map.find(&node_id) { - Some(&ast::def_static_method(*)) => true, - _ => false - }; + } else if ty_substs_len < user_type_parameter_count { fcx.ccx.tcx.sess.span_err (span, fmt!("not enough type parameters provided: expected %u, found %u", - ty_param_count, ty_substs_len)); - if is_static_method { - fcx.ccx.tcx.sess.span_note - (span, "Static methods have an extra implicit type parameter -- \ - did you omit the type parameter for the `Self` type?"); - } + user_type_parameter_count, ty_substs_len)); fcx.infcx().next_ty_vars(ty_param_count) } else { - pth.segments - .iter() - .flat_map_(|s| s.types.iter()) - .transform(|aty| fcx.to_ty(aty)) - .collect() + // Build up the list of type parameters, inserting the self parameter + // at the appropriate position. + let mut result = ~[]; + let mut pushed = false; + for (i, ast_type) in pth.segments + .iter() + .flat_map(|segment| segment.types.iter()) + .enumerate() { + match self_parameter_index { + Some(index) if index == i => { + result.push(fcx.infcx().next_ty_vars(1)[0]); + pushed = true; + } + _ => {} + } + result.push(fcx.to_ty(ast_type)) + } + + // If the self parameter goes at the end, insert it there. + if !pushed && self_parameter_index.is_some() { + result.push(fcx.infcx().next_ty_vars(1)[0]) + } + + assert_eq!(result.len(), ty_param_count) + result }; let substs = substs { diff --git a/src/libstd/at_vec.rs b/src/libstd/at_vec.rs index d001e2c6970..c192803efff 100644 --- a/src/libstd/at_vec.rs +++ b/src/libstd/at_vec.rs @@ -276,7 +276,7 @@ pub mod raw { use rt::local::Local; use rt::task::Task; - do Local::borrow::<Task, *()> |task| { + do Local::borrow |task: &mut Task| { task.heap.realloc(ptr as *libc::c_void, size) as *() } } diff --git a/src/libstd/cell.rs b/src/libstd/cell.rs index f9f5b66acb6..a1459b780df 100644 --- a/src/libstd/cell.rs +++ b/src/libstd/cell.rs @@ -100,7 +100,7 @@ fn test_basic() { #[test] #[should_fail] fn test_take_empty() { - let value_cell = Cell::new_empty::<~int>(); + let value_cell: Cell<~int> = Cell::new_empty(); value_cell.take(); } diff --git a/src/libstd/fmt/mod.rs b/src/libstd/fmt/mod.rs index daf8c4afb07..6d85b968f2a 100644 --- a/src/libstd/fmt/mod.rs +++ b/src/libstd/fmt/mod.rs @@ -884,10 +884,17 @@ impl<T> Poly for T { } } -// n.b. use 'const' to get an implementation for both '*mut' and '*' at the same -// time. -impl<T> Pointer for *const T { - fn fmt(t: &*const T, f: &mut Formatter) { +impl<T> Pointer for *T { + fn fmt(t: &*T, f: &mut Formatter) { + f.flags |= 1 << (parse::FlagAlternate as uint); + do ::uint::to_str_bytes(*t as uint, 16) |buf| { + f.pad_integral(buf, "0x", true); + } + } +} + +impl<T> Pointer for *mut T { + fn fmt(t: &*mut T, f: &mut Formatter) { f.flags |= 1 << (parse::FlagAlternate as uint); do ::uint::to_str_bytes(*t as uint, 16) |buf| { f.pad_integral(buf, "0x", true); diff --git a/src/libstd/hashmap.rs b/src/libstd/hashmap.rs index 50e59cf438d..bcd658ece66 100644 --- a/src/libstd/hashmap.rs +++ b/src/libstd/hashmap.rs @@ -869,21 +869,21 @@ mod test_map { #[test] fn test_find_or_insert() { - let mut m = HashMap::new::<int, int>(); + let mut m: HashMap<int,int> = HashMap::new(); assert_eq!(*m.find_or_insert(1, 2), 2); assert_eq!(*m.find_or_insert(1, 3), 2); } #[test] fn test_find_or_insert_with() { - let mut m = HashMap::new::<int, int>(); + let mut m: HashMap<int,int> = HashMap::new(); assert_eq!(*m.find_or_insert_with(1, |_| 2), 2); assert_eq!(*m.find_or_insert_with(1, |_| 3), 2); } #[test] fn test_insert_or_update_with() { - let mut m = HashMap::new::<int, int>(); + let mut m: HashMap<int,int> = HashMap::new(); assert_eq!(*m.insert_or_update_with(1, 2, |_,x| *x+=1), 2); assert_eq!(*m.insert_or_update_with(1, 2, |_,x| *x+=1), 3); } diff --git a/src/libstd/iterator.rs b/src/libstd/iterator.rs index 1af49ecd208..4af7b3e2425 100644 --- a/src/libstd/iterator.rs +++ b/src/libstd/iterator.rs @@ -660,7 +660,10 @@ pub trait AdditiveIterator<A> { impl<A: Add<A, A> + Zero, T: Iterator<A>> AdditiveIterator<A> for T { #[inline] - fn sum(&mut self) -> A { self.fold(Zero::zero::<A>(), |s, x| s + x) } + fn sum(&mut self) -> A { + let zero: A = Zero::zero(); + self.fold(zero, |s, x| s + x) + } } /// A trait for iterators over elements whose elements can be multiplied @@ -685,7 +688,10 @@ pub trait MultiplicativeIterator<A> { impl<A: Mul<A, A> + One, T: Iterator<A>> MultiplicativeIterator<A> for T { #[inline] - fn product(&mut self) -> A { self.fold(One::one::<A>(), |p, x| p * x) } + fn product(&mut self) -> A { + let one: A = One::one(); + self.fold(one, |p, x| p * x) + } } /// A trait for iterators over elements which can be compared to one another. diff --git a/src/libstd/logging.rs b/src/libstd/logging.rs index 7de55f48317..215067ea729 100644 --- a/src/libstd/logging.rs +++ b/src/libstd/logging.rs @@ -59,7 +59,8 @@ fn newsched_log_str(msg: ~str) { use rt::local::Local; unsafe { - match Local::try_unsafe_borrow::<Task>() { + let optional_task: Option<*mut Task> = Local::try_unsafe_borrow(); + match optional_task { Some(local) => { // Use the available logger (*local).logger.log(Left(msg)); diff --git a/src/libstd/num/f32.rs b/src/libstd/num/f32.rs index a493dba467e..1c59eaf0219 100644 --- a/src/libstd/num/f32.rs +++ b/src/libstd/num/f32.rs @@ -182,7 +182,7 @@ impl ApproxEq<f32> for f32 { #[inline] fn approx_eq(&self, other: &f32) -> bool { - self.approx_eq_eps(other, &ApproxEq::approx_epsilon::<f32, f32>()) + self.approx_eq_eps(other, &1.0e-6) } #[inline] @@ -561,11 +561,14 @@ impl Real for f32 { /// Converts to degrees, assuming the number is in radians #[inline] - fn to_degrees(&self) -> f32 { *self * (180.0 / Real::pi::<f32>()) } + fn to_degrees(&self) -> f32 { *self * (180.0f32 / Real::pi()) } /// Converts to radians, assuming the number is in degrees #[inline] - fn to_radians(&self) -> f32 { *self * (Real::pi::<f32>() / 180.0) } + fn to_radians(&self) -> f32 { + let value: f32 = Real::pi(); + *self * (value / 180.0f32) + } } impl Bounded for f32 { @@ -578,10 +581,10 @@ impl Bounded for f32 { impl Primitive for f32 { #[inline] - fn bits() -> uint { 32 } + fn bits(_: Option<f32>) -> uint { 32 } #[inline] - fn bytes() -> uint { Primitive::bits::<f32>() / 8 } + fn bytes(_: Option<f32>) -> uint { Primitive::bits(Some(0f32)) / 8 } } impl Float for f32 { @@ -638,25 +641,25 @@ impl Float for f32 { } #[inline] - fn mantissa_digits() -> uint { 24 } + fn mantissa_digits(_: Option<f32>) -> uint { 24 } #[inline] - fn digits() -> uint { 6 } + fn digits(_: Option<f32>) -> uint { 6 } #[inline] fn epsilon() -> f32 { 1.19209290e-07 } #[inline] - fn min_exp() -> int { -125 } + fn min_exp(_: Option<f32>) -> int { -125 } #[inline] - fn max_exp() -> int { 128 } + fn max_exp(_: Option<f32>) -> int { 128 } #[inline] - fn min_10_exp() -> int { -37 } + fn min_10_exp(_: Option<f32>) -> int { -37 } #[inline] - fn max_10_exp() -> int { 38 } + fn max_10_exp(_: Option<f32>) -> int { 38 } /// Constructs a floating point number by multiplying `x` by 2 raised to the power of `exp` #[inline] @@ -949,9 +952,11 @@ mod tests { assert_eq!(1f32.clamp(&2f32, &4f32), 2f32); assert_eq!(8f32.clamp(&2f32, &4f32), 4f32); assert_eq!(3f32.clamp(&2f32, &4f32), 3f32); - assert!(3f32.clamp(&Float::NaN::<f32>(), &4f32).is_NaN()); - assert!(3f32.clamp(&2f32, &Float::NaN::<f32>()).is_NaN()); - assert!(Float::NaN::<f32>().clamp(&2f32, &4f32).is_NaN()); + + let nan: f32 = Float::NaN(); + assert!(3f32.clamp(&nan, &4f32).is_NaN()); + assert!(3f32.clamp(&2f32, &nan).is_NaN()); + assert!(nan.clamp(&2f32, &4f32).is_NaN()); } #[test] @@ -1028,9 +1033,13 @@ mod tests { fn test_asinh() { assert_eq!(0.0f32.asinh(), 0.0f32); assert_eq!((-0.0f32).asinh(), -0.0f32); - assert_eq!(Float::infinity::<f32>().asinh(), Float::infinity::<f32>()); - assert_eq!(Float::neg_infinity::<f32>().asinh(), Float::neg_infinity::<f32>()); - assert!(Float::NaN::<f32>().asinh().is_NaN()); + + let inf: f32 = Float::infinity(); + let neg_inf: f32 = Float::neg_infinity(); + let nan: f32 = Float::NaN(); + assert_eq!(inf.asinh(), inf); + assert_eq!(neg_inf.asinh(), neg_inf); + assert!(nan.asinh().is_NaN()); assert_approx_eq!(2.0f32.asinh(), 1.443635475178810342493276740273105f32); assert_approx_eq!((-2.0f32).asinh(), -1.443635475178810342493276740273105f32); } @@ -1039,9 +1048,13 @@ mod tests { fn test_acosh() { assert_eq!(1.0f32.acosh(), 0.0f32); assert!(0.999f32.acosh().is_NaN()); - assert_eq!(Float::infinity::<f32>().acosh(), Float::infinity::<f32>()); - assert!(Float::neg_infinity::<f32>().acosh().is_NaN()); - assert!(Float::NaN::<f32>().acosh().is_NaN()); + + let inf: f32 = Float::infinity(); + let neg_inf: f32 = Float::neg_infinity(); + let nan: f32 = Float::NaN(); + assert_eq!(inf.acosh(), inf); + assert!(neg_inf.acosh().is_NaN()); + assert!(nan.acosh().is_NaN()); assert_approx_eq!(2.0f32.acosh(), 1.31695789692481670862504634730796844f32); assert_approx_eq!(3.0f32.acosh(), 1.76274717403908605046521864995958461f32); } @@ -1050,34 +1063,61 @@ mod tests { fn test_atanh() { assert_eq!(0.0f32.atanh(), 0.0f32); assert_eq!((-0.0f32).atanh(), -0.0f32); - assert_eq!(1.0f32.atanh(), Float::infinity::<f32>()); - assert_eq!((-1.0f32).atanh(), Float::neg_infinity::<f32>()); + + let inf32: f32 = Float::infinity(); + let neg_inf32: f32 = Float::neg_infinity(); + assert_eq!(1.0f32.atanh(), inf32); + assert_eq!((-1.0f32).atanh(), neg_inf32); + assert!(2f64.atanh().atanh().is_NaN()); assert!((-2f64).atanh().atanh().is_NaN()); - assert!(Float::infinity::<f64>().atanh().is_NaN()); - assert!(Float::neg_infinity::<f64>().atanh().is_NaN()); - assert!(Float::NaN::<f32>().atanh().is_NaN()); + + let inf64: f32 = Float::infinity(); + let neg_inf64: f32 = Float::neg_infinity(); + let nan32: f32 = Float::NaN(); + assert!(inf64.atanh().is_NaN()); + assert!(neg_inf64.atanh().is_NaN()); + assert!(nan32.atanh().is_NaN()); + assert_approx_eq!(0.5f32.atanh(), 0.54930614433405484569762261846126285f32); assert_approx_eq!((-0.5f32).atanh(), -0.54930614433405484569762261846126285f32); } #[test] fn test_real_consts() { - assert_approx_eq!(Real::two_pi::<f32>(), 2f32 * Real::pi::<f32>()); - assert_approx_eq!(Real::frac_pi_2::<f32>(), Real::pi::<f32>() / 2f32); - assert_approx_eq!(Real::frac_pi_3::<f32>(), Real::pi::<f32>() / 3f32); - assert_approx_eq!(Real::frac_pi_4::<f32>(), Real::pi::<f32>() / 4f32); - assert_approx_eq!(Real::frac_pi_6::<f32>(), Real::pi::<f32>() / 6f32); - assert_approx_eq!(Real::frac_pi_8::<f32>(), Real::pi::<f32>() / 8f32); - assert_approx_eq!(Real::frac_1_pi::<f32>(), 1f32 / Real::pi::<f32>()); - assert_approx_eq!(Real::frac_2_pi::<f32>(), 2f32 / Real::pi::<f32>()); - assert_approx_eq!(Real::frac_2_sqrtpi::<f32>(), 2f32 / Real::pi::<f32>().sqrt()); - assert_approx_eq!(Real::sqrt2::<f32>(), 2f32.sqrt()); - assert_approx_eq!(Real::frac_1_sqrt2::<f32>(), 1f32 / 2f32.sqrt()); - assert_approx_eq!(Real::log2_e::<f32>(), Real::e::<f32>().log2()); - assert_approx_eq!(Real::log10_e::<f32>(), Real::e::<f32>().log10()); - assert_approx_eq!(Real::ln_2::<f32>(), 2f32.ln()); - assert_approx_eq!(Real::ln_10::<f32>(), 10f32.ln()); + let pi: f32 = Real::pi(); + let two_pi: f32 = Real::two_pi(); + let frac_pi_2: f32 = Real::frac_pi_2(); + let frac_pi_3: f32 = Real::frac_pi_3(); + let frac_pi_4: f32 = Real::frac_pi_4(); + let frac_pi_6: f32 = Real::frac_pi_6(); + let frac_pi_8: f32 = Real::frac_pi_8(); + let frac_1_pi: f32 = Real::frac_1_pi(); + let frac_2_pi: f32 = Real::frac_2_pi(); + let frac_2_sqrtpi: f32 = Real::frac_2_sqrtpi(); + let sqrt2: f32 = Real::sqrt2(); + let frac_1_sqrt2: f32 = Real::frac_1_sqrt2(); + let e: f32 = Real::e(); + let log2_e: f32 = Real::log2_e(); + let log10_e: f32 = Real::log10_e(); + let ln_2: f32 = Real::ln_2(); + let ln_10: f32 = Real::ln_10(); + + assert_approx_eq!(two_pi, 2f32 * pi); + assert_approx_eq!(frac_pi_2, pi / 2f32); + assert_approx_eq!(frac_pi_3, pi / 3f32); + assert_approx_eq!(frac_pi_4, pi / 4f32); + assert_approx_eq!(frac_pi_6, pi / 6f32); + assert_approx_eq!(frac_pi_8, pi / 8f32); + assert_approx_eq!(frac_1_pi, 1f32 / pi); + assert_approx_eq!(frac_2_pi, 2f32 / pi); + assert_approx_eq!(frac_2_sqrtpi, 2f32 / pi.sqrt()); + assert_approx_eq!(sqrt2, 2f32.sqrt()); + assert_approx_eq!(frac_1_sqrt2, 1f32 / 2f32.sqrt()); + assert_approx_eq!(log2_e, e.log2()); + assert_approx_eq!(log10_e, e.log10()); + assert_approx_eq!(ln_2, 2f32.ln()); + assert_approx_eq!(ln_10, 10f32.ln()); } #[test] @@ -1153,17 +1193,23 @@ mod tests { #[test] fn test_primitive() { - assert_eq!(Primitive::bits::<f32>(), sys::size_of::<f32>() * 8); - assert_eq!(Primitive::bytes::<f32>(), sys::size_of::<f32>()); + let none: Option<f32> = None; + assert_eq!(Primitive::bits(none), sys::size_of::<f32>() * 8); + assert_eq!(Primitive::bytes(none), sys::size_of::<f32>()); } #[test] fn test_is_normal() { - assert!(!Float::NaN::<f32>().is_normal()); - assert!(!Float::infinity::<f32>().is_normal()); - assert!(!Float::neg_infinity::<f32>().is_normal()); - assert!(!Zero::zero::<f32>().is_normal()); - assert!(!Float::neg_zero::<f32>().is_normal()); + let nan: f32 = Float::NaN(); + let inf: f32 = Float::infinity(); + let neg_inf: f32 = Float::neg_infinity(); + let zero: f32 = Zero::zero(); + let neg_zero: f32 = Float::neg_zero(); + assert!(!nan.is_normal()); + assert!(!inf.is_normal()); + assert!(!neg_inf.is_normal()); + assert!(!zero.is_normal()); + assert!(!neg_zero.is_normal()); assert!(1f32.is_normal()); assert!(1e-37f32.is_normal()); assert!(!1e-38f32.is_normal()); @@ -1171,11 +1217,16 @@ mod tests { #[test] fn test_classify() { - assert_eq!(Float::NaN::<f32>().classify(), FPNaN); - assert_eq!(Float::infinity::<f32>().classify(), FPInfinite); - assert_eq!(Float::neg_infinity::<f32>().classify(), FPInfinite); - assert_eq!(Zero::zero::<f32>().classify(), FPZero); - assert_eq!(Float::neg_zero::<f32>().classify(), FPZero); + let nan: f32 = Float::NaN(); + let inf: f32 = Float::infinity(); + let neg_inf: f32 = Float::neg_infinity(); + let zero: f32 = Zero::zero(); + let neg_zero: f32 = Float::neg_zero(); + assert_eq!(nan.classify(), FPNaN); + assert_eq!(inf.classify(), FPInfinite); + assert_eq!(neg_inf.classify(), FPInfinite); + assert_eq!(zero.classify(), FPZero); + assert_eq!(neg_zero.classify(), FPZero); assert_eq!(1f32.classify(), FPNormal); assert_eq!(1e-37f32.classify(), FPNormal); assert_eq!(1e-38f32.classify(), FPSubnormal); @@ -1192,11 +1243,13 @@ mod tests { assert_eq!(Float::ldexp(0f32, -123), 0f32); assert_eq!(Float::ldexp(-0f32, -123), -0f32); - assert_eq!(Float::ldexp(Float::infinity::<f32>(), -123), - Float::infinity::<f32>()); - assert_eq!(Float::ldexp(Float::neg_infinity::<f32>(), -123), - Float::neg_infinity::<f32>()); - assert!(Float::ldexp(Float::NaN::<f32>(), -123).is_NaN()); + + let inf: f32 = Float::infinity(); + let neg_inf: f32 = Float::neg_infinity(); + let nan: f32 = Float::NaN(); + assert_eq!(Float::ldexp(inf, -123), inf); + assert_eq!(Float::ldexp(neg_inf, -123), neg_inf); + assert!(Float::ldexp(nan, -123).is_NaN()); } #[test] @@ -1214,10 +1267,12 @@ mod tests { assert_eq!(0f32.frexp(), (0f32, 0)); assert_eq!((-0f32).frexp(), (-0f32, 0)); - assert_eq!(match Float::infinity::<f32>().frexp() { (x, _) => x }, - Float::infinity::<f32>()) - assert_eq!(match Float::neg_infinity::<f32>().frexp() { (x, _) => x }, - Float::neg_infinity::<f32>()) - assert!(match Float::NaN::<f32>().frexp() { (x, _) => x.is_NaN() }) + + let inf: f32 = Float::infinity(); + let neg_inf: f32 = Float::neg_infinity(); + let nan: f32 = Float::NaN(); + assert_eq!(match inf.frexp() { (x, _) => x }, inf) + assert_eq!(match neg_inf.frexp() { (x, _) => x }, neg_inf) + assert!(match nan.frexp() { (x, _) => x.is_NaN() }) } } diff --git a/src/libstd/num/f64.rs b/src/libstd/num/f64.rs index 52e74d969eb..8f5d6473aea 100644 --- a/src/libstd/num/f64.rs +++ b/src/libstd/num/f64.rs @@ -205,7 +205,7 @@ impl ApproxEq<f64> for f64 { #[inline] fn approx_eq(&self, other: &f64) -> bool { - self.approx_eq_eps(other, &ApproxEq::approx_epsilon::<f64, f64>()) + self.approx_eq_eps(other, &1.0e-6) } #[inline] @@ -578,11 +578,14 @@ impl Real for f64 { /// Converts to degrees, assuming the number is in radians #[inline] - fn to_degrees(&self) -> f64 { *self * (180.0 / Real::pi::<f64>()) } + fn to_degrees(&self) -> f64 { *self * (180.0f64 / Real::pi()) } /// Converts to radians, assuming the number is in degrees #[inline] - fn to_radians(&self) -> f64 { *self * (Real::pi::<f64>() / 180.0) } + fn to_radians(&self) -> f64 { + let value: f64 = Real::pi(); + *self * (value / 180.0) + } } impl RealExt for f64 { @@ -625,10 +628,10 @@ impl Bounded for f64 { impl Primitive for f64 { #[inline] - fn bits() -> uint { 64 } + fn bits(_: Option<f64>) -> uint { 64 } #[inline] - fn bytes() -> uint { Primitive::bits::<f64>() / 8 } + fn bytes(_: Option<f64>) -> uint { Primitive::bits(Some(0f64)) / 8 } } impl Float for f64 { @@ -685,25 +688,25 @@ impl Float for f64 { } #[inline] - fn mantissa_digits() -> uint { 53 } + fn mantissa_digits(_: Option<f64>) -> uint { 53 } #[inline] - fn digits() -> uint { 15 } + fn digits(_: Option<f64>) -> uint { 15 } #[inline] fn epsilon() -> f64 { 2.2204460492503131e-16 } #[inline] - fn min_exp() -> int { -1021 } + fn min_exp(_: Option<f64>) -> int { -1021 } #[inline] - fn max_exp() -> int { 1024 } + fn max_exp(_: Option<f64>) -> int { 1024 } #[inline] - fn min_10_exp() -> int { -307 } + fn min_10_exp(_: Option<f64>) -> int { -307 } #[inline] - fn max_10_exp() -> int { 308 } + fn max_10_exp(_: Option<f64>) -> int { 308 } /// Constructs a floating point number by multiplying `x` by 2 raised to the power of `exp` #[inline] @@ -983,16 +986,20 @@ mod tests { fn test_min() { assert_eq!(1f64.min(&2f64), 1f64); assert_eq!(2f64.min(&1f64), 1f64); - assert!(1f64.min(&Float::NaN::<f64>()).is_NaN()); - assert!(Float::NaN::<f64>().min(&1f64).is_NaN()); + + let nan: f64 = Float::NaN(); + assert!(1f64.min(&nan).is_NaN()); + assert!(nan.min(&1f64).is_NaN()); } #[test] fn test_max() { assert_eq!(1f64.max(&2f64), 2f64); assert_eq!(2f64.max(&1f64), 2f64); - assert!(1f64.max(&Float::NaN::<f64>()).is_NaN()); - assert!(Float::NaN::<f64>().max(&1f64).is_NaN()); + + let nan: f64 = Float::NaN(); + assert!(1f64.max(&nan).is_NaN()); + assert!(nan.max(&1f64).is_NaN()); } #[test] @@ -1000,9 +1007,11 @@ mod tests { assert_eq!(1f64.clamp(&2f64, &4f64), 2f64); assert_eq!(8f64.clamp(&2f64, &4f64), 4f64); assert_eq!(3f64.clamp(&2f64, &4f64), 3f64); - assert!(3f64.clamp(&Float::NaN::<f64>(), &4f64).is_NaN()); - assert!(3f64.clamp(&2f64, &Float::NaN::<f64>()).is_NaN()); - assert!(Float::NaN::<f64>().clamp(&2f64, &4f64).is_NaN()); + + let nan: f64 = Float::NaN(); + assert!(3f64.clamp(&nan, &4f64).is_NaN()); + assert!(3f64.clamp(&2f64, &nan).is_NaN()); + assert!(nan.clamp(&2f64, &4f64).is_NaN()); } #[test] @@ -1079,9 +1088,13 @@ mod tests { fn test_asinh() { assert_eq!(0.0f64.asinh(), 0.0f64); assert_eq!((-0.0f64).asinh(), -0.0f64); - assert_eq!(Float::infinity::<f64>().asinh(), Float::infinity::<f64>()); - assert_eq!(Float::neg_infinity::<f64>().asinh(), Float::neg_infinity::<f64>()); - assert!(Float::NaN::<f64>().asinh().is_NaN()); + + let inf: f64 = Float::infinity(); + let neg_inf: f64 = Float::neg_infinity(); + let nan: f64 = Float::NaN(); + assert_eq!(inf.asinh(), inf); + assert_eq!(neg_inf.asinh(), neg_inf); + assert!(nan.asinh().is_NaN()); assert_approx_eq!(2.0f64.asinh(), 1.443635475178810342493276740273105f64); assert_approx_eq!((-2.0f64).asinh(), -1.443635475178810342493276740273105f64); } @@ -1090,9 +1103,13 @@ mod tests { fn test_acosh() { assert_eq!(1.0f64.acosh(), 0.0f64); assert!(0.999f64.acosh().is_NaN()); - assert_eq!(Float::infinity::<f64>().acosh(), Float::infinity::<f64>()); - assert!(Float::neg_infinity::<f64>().acosh().is_NaN()); - assert!(Float::NaN::<f64>().acosh().is_NaN()); + + let inf: f64 = Float::infinity(); + let neg_inf: f64 = Float::neg_infinity(); + let nan: f64 = Float::NaN(); + assert_eq!(inf.acosh(), inf); + assert!(neg_inf.acosh().is_NaN()); + assert!(nan.acosh().is_NaN()); assert_approx_eq!(2.0f64.acosh(), 1.31695789692481670862504634730796844f64); assert_approx_eq!(3.0f64.acosh(), 1.76274717403908605046521864995958461f64); } @@ -1101,34 +1118,56 @@ mod tests { fn test_atanh() { assert_eq!(0.0f64.atanh(), 0.0f64); assert_eq!((-0.0f64).atanh(), -0.0f64); - assert_eq!(1.0f64.atanh(), Float::infinity::<f64>()); - assert_eq!((-1.0f64).atanh(), Float::neg_infinity::<f64>()); + + let inf: f64 = Float::infinity(); + let neg_inf: f64 = Float::neg_infinity(); + let nan: f64 = Float::NaN(); + assert_eq!(1.0f64.atanh(), inf); + assert_eq!((-1.0f64).atanh(), neg_inf); assert!(2f64.atanh().atanh().is_NaN()); assert!((-2f64).atanh().atanh().is_NaN()); - assert!(Float::infinity::<f64>().atanh().is_NaN()); - assert!(Float::neg_infinity::<f64>().atanh().is_NaN()); - assert!(Float::NaN::<f64>().atanh().is_NaN()); + assert!(inf.atanh().is_NaN()); + assert!(neg_inf.atanh().is_NaN()); + assert!(nan.atanh().is_NaN()); assert_approx_eq!(0.5f64.atanh(), 0.54930614433405484569762261846126285f64); assert_approx_eq!((-0.5f64).atanh(), -0.54930614433405484569762261846126285f64); } #[test] fn test_real_consts() { - assert_approx_eq!(Real::two_pi::<f64>(), 2.0 * Real::pi::<f64>()); - assert_approx_eq!(Real::frac_pi_2::<f64>(), Real::pi::<f64>() / 2f64); - assert_approx_eq!(Real::frac_pi_3::<f64>(), Real::pi::<f64>() / 3f64); - assert_approx_eq!(Real::frac_pi_4::<f64>(), Real::pi::<f64>() / 4f64); - assert_approx_eq!(Real::frac_pi_6::<f64>(), Real::pi::<f64>() / 6f64); - assert_approx_eq!(Real::frac_pi_8::<f64>(), Real::pi::<f64>() / 8f64); - assert_approx_eq!(Real::frac_1_pi::<f64>(), 1f64 / Real::pi::<f64>()); - assert_approx_eq!(Real::frac_2_pi::<f64>(), 2f64 / Real::pi::<f64>()); - assert_approx_eq!(Real::frac_2_sqrtpi::<f64>(), 2f64 / Real::pi::<f64>().sqrt()); - assert_approx_eq!(Real::sqrt2::<f64>(), 2f64.sqrt()); - assert_approx_eq!(Real::frac_1_sqrt2::<f64>(), 1f64 / 2f64.sqrt()); - assert_approx_eq!(Real::log2_e::<f64>(), Real::e::<f64>().log2()); - assert_approx_eq!(Real::log10_e::<f64>(), Real::e::<f64>().log10()); - assert_approx_eq!(Real::ln_2::<f64>(), 2f64.ln()); - assert_approx_eq!(Real::ln_10::<f64>(), 10f64.ln()); + let pi: f64 = Real::pi(); + let two_pi: f64 = Real::two_pi(); + let frac_pi_2: f64 = Real::frac_pi_2(); + let frac_pi_3: f64 = Real::frac_pi_3(); + let frac_pi_4: f64 = Real::frac_pi_4(); + let frac_pi_6: f64 = Real::frac_pi_6(); + let frac_pi_8: f64 = Real::frac_pi_8(); + let frac_1_pi: f64 = Real::frac_1_pi(); + let frac_2_pi: f64 = Real::frac_2_pi(); + let frac_2_sqrtpi: f64 = Real::frac_2_sqrtpi(); + let sqrt2: f64 = Real::sqrt2(); + let frac_1_sqrt2: f64 = Real::frac_1_sqrt2(); + let e: f64 = Real::e(); + let log2_e: f64 = Real::log2_e(); + let log10_e: f64 = Real::log10_e(); + let ln_2: f64 = Real::ln_2(); + let ln_10: f64 = Real::ln_10(); + + assert_approx_eq!(two_pi, 2.0 * pi); + assert_approx_eq!(frac_pi_2, pi / 2f64); + assert_approx_eq!(frac_pi_3, pi / 3f64); + assert_approx_eq!(frac_pi_4, pi / 4f64); + assert_approx_eq!(frac_pi_6, pi / 6f64); + assert_approx_eq!(frac_pi_8, pi / 8f64); + assert_approx_eq!(frac_1_pi, 1f64 / pi); + assert_approx_eq!(frac_2_pi, 2f64 / pi); + assert_approx_eq!(frac_2_sqrtpi, 2f64 / pi.sqrt()); + assert_approx_eq!(sqrt2, 2f64.sqrt()); + assert_approx_eq!(frac_1_sqrt2, 1f64 / 2f64.sqrt()); + assert_approx_eq!(log2_e, e.log2()); + assert_approx_eq!(log10_e, e.log10()); + assert_approx_eq!(ln_2, 2f64.ln()); + assert_approx_eq!(ln_10, 10f64.ln()); } #[test] @@ -1204,17 +1243,23 @@ mod tests { #[test] fn test_primitive() { - assert_eq!(Primitive::bits::<f64>(), sys::size_of::<f64>() * 8); - assert_eq!(Primitive::bytes::<f64>(), sys::size_of::<f64>()); + let none: Option<f64> = None; + assert_eq!(Primitive::bits(none), sys::size_of::<f64>() * 8); + assert_eq!(Primitive::bytes(none), sys::size_of::<f64>()); } #[test] fn test_is_normal() { - assert!(!Float::NaN::<f64>().is_normal()); - assert!(!Float::infinity::<f64>().is_normal()); - assert!(!Float::neg_infinity::<f64>().is_normal()); - assert!(!Zero::zero::<f64>().is_normal()); - assert!(!Float::neg_zero::<f64>().is_normal()); + let nan: f64 = Float::NaN(); + let inf: f64 = Float::infinity(); + let neg_inf: f64 = Float::neg_infinity(); + let zero: f64 = Zero::zero(); + let neg_zero: f64 = Float::neg_zero(); + assert!(!nan.is_normal()); + assert!(!inf.is_normal()); + assert!(!neg_inf.is_normal()); + assert!(!zero.is_normal()); + assert!(!neg_zero.is_normal()); assert!(1f64.is_normal()); assert!(1e-307f64.is_normal()); assert!(!1e-308f64.is_normal()); @@ -1222,11 +1267,16 @@ mod tests { #[test] fn test_classify() { - assert_eq!(Float::NaN::<f64>().classify(), FPNaN); - assert_eq!(Float::infinity::<f64>().classify(), FPInfinite); - assert_eq!(Float::neg_infinity::<f64>().classify(), FPInfinite); - assert_eq!(Zero::zero::<f64>().classify(), FPZero); - assert_eq!(Float::neg_zero::<f64>().classify(), FPZero); + let nan: f64 = Float::NaN(); + let inf: f64 = Float::infinity(); + let neg_inf: f64 = Float::neg_infinity(); + let zero: f64 = Zero::zero(); + let neg_zero: f64 = Float::neg_zero(); + assert_eq!(nan.classify(), FPNaN); + assert_eq!(inf.classify(), FPInfinite); + assert_eq!(neg_inf.classify(), FPInfinite); + assert_eq!(zero.classify(), FPZero); + assert_eq!(neg_zero.classify(), FPZero); assert_eq!(1e-307f64.classify(), FPNormal); assert_eq!(1e-308f64.classify(), FPSubnormal); } @@ -1242,11 +1292,13 @@ mod tests { assert_eq!(Float::ldexp(0f64, -123), 0f64); assert_eq!(Float::ldexp(-0f64, -123), -0f64); - assert_eq!(Float::ldexp(Float::infinity::<f64>(), -123), - Float::infinity::<f64>()); - assert_eq!(Float::ldexp(Float::neg_infinity::<f64>(), -123), - Float::neg_infinity::<f64>()); - assert!(Float::ldexp(Float::NaN::<f64>(), -123).is_NaN()); + + let inf: f64 = Float::infinity(); + let neg_inf: f64 = Float::neg_infinity(); + let nan: f64 = Float::NaN(); + assert_eq!(Float::ldexp(inf, -123), inf); + assert_eq!(Float::ldexp(neg_inf, -123), neg_inf); + assert!(Float::ldexp(nan, -123).is_NaN()); } #[test] @@ -1264,10 +1316,12 @@ mod tests { assert_eq!(0f64.frexp(), (0f64, 0)); assert_eq!((-0f64).frexp(), (-0f64, 0)); - assert_eq!(match Float::infinity::<f64>().frexp() { (x, _) => x }, - Float::infinity::<f64>()) - assert_eq!(match Float::neg_infinity::<f64>().frexp() { (x, _) => x }, - Float::neg_infinity::<f64>()) - assert!(match Float::NaN::<f64>().frexp() { (x, _) => x.is_NaN() }) + + let inf: f64 = Float::infinity(); + let neg_inf: f64 = Float::neg_infinity(); + let nan: f64 = Float::NaN(); + assert_eq!(match inf.frexp() { (x, _) => x }, inf) + assert_eq!(match neg_inf.frexp() { (x, _) => x }, neg_inf) + assert!(match nan.frexp() { (x, _) => x.is_NaN() }) } } diff --git a/src/libstd/num/float.rs b/src/libstd/num/float.rs index 20c7adbd62c..d019de2468b 100644 --- a/src/libstd/num/float.rs +++ b/src/libstd/num/float.rs @@ -342,7 +342,7 @@ impl ApproxEq<float> for float { #[inline] fn approx_eq(&self, other: &float) -> bool { - self.approx_eq_eps(other, &ApproxEq::approx_epsilon::<float, float>()) + self.approx_eq_eps(other, &1.0e-6) } #[inline] @@ -783,32 +783,56 @@ impl Signed for float { impl Bounded for float { #[inline] - fn min_value() -> float { Bounded::min_value::<f64>() as float } + fn min_value() -> float { + let x: f64 = Bounded::min_value(); + x as float + } #[inline] - fn max_value() -> float { Bounded::max_value::<f64>() as float } + fn max_value() -> float { + let x: f64 = Bounded::max_value(); + x as float + } } impl Primitive for float { #[inline] - fn bits() -> uint { Primitive::bits::<f64>() } + fn bits(_: Option<float>) -> uint { + let bits: uint = Primitive::bits(Some(0f64)); + bits + } #[inline] - fn bytes() -> uint { Primitive::bytes::<f64>() } + fn bytes(_: Option<float>) -> uint { + let bytes: uint = Primitive::bytes(Some(0f64)); + bytes + } } impl Float for float { #[inline] - fn NaN() -> float { Float::NaN::<f64>() as float } + fn NaN() -> float { + let value: f64 = Float::NaN(); + value as float + } #[inline] - fn infinity() -> float { Float::infinity::<f64>() as float } + fn infinity() -> float { + let value: f64 = Float::infinity(); + value as float + } #[inline] - fn neg_infinity() -> float { Float::neg_infinity::<f64>() as float } + fn neg_infinity() -> float { + let value: f64 = Float::neg_infinity(); + value as float + } #[inline] - fn neg_zero() -> float { Float::neg_zero::<f64>() as float } + fn neg_zero() -> float { + let value: f64 = Float::neg_zero(); + value as float + } /// Returns `true` if the number is NaN #[inline] @@ -832,30 +856,46 @@ impl Float for float { fn classify(&self) -> FPCategory { (*self as f64).classify() } #[inline] - fn mantissa_digits() -> uint { Float::mantissa_digits::<f64>() } + fn mantissa_digits(_: Option<float>) -> uint { + Float::mantissa_digits(Some(0f64)) + } #[inline] - fn digits() -> uint { Float::digits::<f64>() } + fn digits(_: Option<float>) -> uint { + Float::digits(Some(0f64)) + } #[inline] - fn epsilon() -> float { Float::epsilon::<f64>() as float } + fn epsilon() -> float { + let value: f64 = Float::epsilon(); + value as float + } #[inline] - fn min_exp() -> int { Float::min_exp::<f64>() } + fn min_exp(_: Option<float>) -> int { + Float::min_exp(Some(0f64)) + } #[inline] - fn max_exp() -> int { Float::max_exp::<f64>() } + fn max_exp(_: Option<float>) -> int { + Float::max_exp(Some(0f64)) + } #[inline] - fn min_10_exp() -> int { Float::min_10_exp::<f64>() } + fn min_10_exp(_: Option<float>) -> int { + Float::min_10_exp(Some(0f64)) + } #[inline] - fn max_10_exp() -> int { Float::max_10_exp::<f64>() } + fn max_10_exp(_: Option<float>) -> int { + Float::max_10_exp(Some(0f64)) + } /// Constructs a floating point number by multiplying `x` by 2 raised to the power of `exp` #[inline] fn ldexp(x: float, exp: int) -> float { - Float::ldexp(x as f64, exp) as float + let value: f64 = Float::ldexp(x as f64, exp); + value as float } /// @@ -937,9 +977,10 @@ mod tests { assert_eq!(1f.clamp(&2f, &4f), 2f); assert_eq!(8f.clamp(&2f, &4f), 4f); assert_eq!(3f.clamp(&2f, &4f), 3f); - assert!(3f.clamp(&Float::NaN::<float>(), &4f).is_NaN()); - assert!(3f.clamp(&2f, &Float::NaN::<float>()).is_NaN()); - assert!(Float::NaN::<float>().clamp(&2f, &4f).is_NaN()); + let nan: float = Float::NaN(); + assert!(3f.clamp(&nan, &4f).is_NaN()); + assert!(3f.clamp(&2f, &nan).is_NaN()); + assert!(nan.clamp(&2f, &4f).is_NaN()); } #[test] @@ -1016,9 +1057,13 @@ mod tests { fn test_asinh() { assert_eq!(0.0f.asinh(), 0.0f); assert_eq!((-0.0f).asinh(), -0.0f); - assert_eq!(Float::infinity::<float>().asinh(), Float::infinity::<float>()); - assert_eq!(Float::neg_infinity::<float>().asinh(), Float::neg_infinity::<float>()); - assert!(Float::NaN::<float>().asinh().is_NaN()); + + let inf: float = Float::infinity(); + let neg_inf: float = Float::neg_infinity(); + let nan: float = Float::NaN(); + assert_eq!(inf.asinh(), inf); + assert_eq!(neg_inf.asinh(), neg_inf); + assert!(nan.asinh().is_NaN()); assert_approx_eq!(2.0f.asinh(), 1.443635475178810342493276740273105f); assert_approx_eq!((-2.0f).asinh(), -1.443635475178810342493276740273105f); } @@ -1027,9 +1072,13 @@ mod tests { fn test_acosh() { assert_eq!(1.0f.acosh(), 0.0f); assert!(0.999f.acosh().is_NaN()); - assert_eq!(Float::infinity::<float>().acosh(), Float::infinity::<float>()); - assert!(Float::neg_infinity::<float>().acosh().is_NaN()); - assert!(Float::NaN::<float>().acosh().is_NaN()); + + let inf: float = Float::infinity(); + let neg_inf: float = Float::neg_infinity(); + let nan: float = Float::NaN(); + assert_eq!(inf.acosh(), inf); + assert!(neg_inf.acosh().is_NaN()); + assert!(nan.acosh().is_NaN()); assert_approx_eq!(2.0f.acosh(), 1.31695789692481670862504634730796844f); assert_approx_eq!(3.0f.acosh(), 1.76274717403908605046521864995958461f); } @@ -1038,34 +1087,58 @@ mod tests { fn test_atanh() { assert_eq!(0.0f.atanh(), 0.0f); assert_eq!((-0.0f).atanh(), -0.0f); - assert_eq!(1.0f.atanh(), Float::infinity::<float>()); - assert_eq!((-1.0f).atanh(), Float::neg_infinity::<float>()); + + let inf: float = Float::infinity(); + let neg_inf: float = Float::neg_infinity(); + let inf64: f64 = Float::infinity(); + let neg_inf64: f64 = Float::neg_infinity(); + let nan: float = Float::NaN(); + assert_eq!(1.0f.atanh(), inf); + assert_eq!((-1.0f).atanh(), neg_inf); assert!(2f64.atanh().atanh().is_NaN()); assert!((-2f64).atanh().atanh().is_NaN()); - assert!(Float::infinity::<f64>().atanh().is_NaN()); - assert!(Float::neg_infinity::<f64>().atanh().is_NaN()); - assert!(Float::NaN::<float>().atanh().is_NaN()); + assert!(inf64.atanh().is_NaN()); + assert!(neg_inf64.atanh().is_NaN()); + assert!(nan.atanh().is_NaN()); assert_approx_eq!(0.5f.atanh(), 0.54930614433405484569762261846126285f); assert_approx_eq!((-0.5f).atanh(), -0.54930614433405484569762261846126285f); } #[test] fn test_real_consts() { - assert_approx_eq!(Real::two_pi::<float>(), 2f * Real::pi::<float>()); - assert_approx_eq!(Real::frac_pi_2::<float>(), Real::pi::<float>() / 2f); - assert_approx_eq!(Real::frac_pi_3::<float>(), Real::pi::<float>() / 3f); - assert_approx_eq!(Real::frac_pi_4::<float>(), Real::pi::<float>() / 4f); - assert_approx_eq!(Real::frac_pi_6::<float>(), Real::pi::<float>() / 6f); - assert_approx_eq!(Real::frac_pi_8::<float>(), Real::pi::<float>() / 8f); - assert_approx_eq!(Real::frac_1_pi::<float>(), 1f / Real::pi::<float>()); - assert_approx_eq!(Real::frac_2_pi::<float>(), 2f / Real::pi::<float>()); - assert_approx_eq!(Real::frac_2_sqrtpi::<float>(), 2f / Real::pi::<float>().sqrt()); - assert_approx_eq!(Real::sqrt2::<float>(), 2f.sqrt()); - assert_approx_eq!(Real::frac_1_sqrt2::<float>(), 1f / 2f.sqrt()); - assert_approx_eq!(Real::log2_e::<float>(), Real::e::<float>().log2()); - assert_approx_eq!(Real::log10_e::<float>(), Real::e::<float>().log10()); - assert_approx_eq!(Real::ln_2::<float>(), 2f.ln()); - assert_approx_eq!(Real::ln_10::<float>(), 10f.ln()); + let pi: float = Real::pi(); + let two_pi: float = Real::two_pi(); + let frac_pi_2: float = Real::frac_pi_2(); + let frac_pi_3: float = Real::frac_pi_3(); + let frac_pi_4: float = Real::frac_pi_4(); + let frac_pi_6: float = Real::frac_pi_6(); + let frac_pi_8: float = Real::frac_pi_8(); + let frac_1_pi: float = Real::frac_1_pi(); + let frac_2_pi: float = Real::frac_2_pi(); + let frac_2_sqrtpi: float = Real::frac_2_sqrtpi(); + let sqrt2: float = Real::sqrt2(); + let frac_1_sqrt2: float = Real::frac_1_sqrt2(); + let e: float = Real::e(); + let log2_e: float = Real::log2_e(); + let log10_e: float = Real::log10_e(); + let ln_2: float = Real::ln_2(); + let ln_10: float = Real::ln_10(); + + assert_approx_eq!(two_pi, 2f * pi); + assert_approx_eq!(frac_pi_2, pi / 2f); + assert_approx_eq!(frac_pi_3, pi / 3f); + assert_approx_eq!(frac_pi_4, pi / 4f); + assert_approx_eq!(frac_pi_6, pi / 6f); + assert_approx_eq!(frac_pi_8, pi / 8f); + assert_approx_eq!(frac_1_pi, 1f / pi); + assert_approx_eq!(frac_2_pi, 2f / pi); + assert_approx_eq!(frac_2_sqrtpi, 2f / pi.sqrt()); + assert_approx_eq!(sqrt2, 2f.sqrt()); + assert_approx_eq!(frac_1_sqrt2, 1f / 2f.sqrt()); + assert_approx_eq!(log2_e, e.log2()); + assert_approx_eq!(log10_e, e.log10()); + assert_approx_eq!(ln_2, 2f.ln()); + assert_approx_eq!(ln_10, 10f.ln()); } #[test] @@ -1141,17 +1214,23 @@ mod tests { #[test] fn test_primitive() { - assert_eq!(Primitive::bits::<float>(), sys::size_of::<float>() * 8); - assert_eq!(Primitive::bytes::<float>(), sys::size_of::<float>()); + let none: Option<float> = None; + assert_eq!(Primitive::bits(none), sys::size_of::<float>() * 8); + assert_eq!(Primitive::bytes(none), sys::size_of::<float>()); } #[test] fn test_is_normal() { - assert!(!Float::NaN::<float>().is_normal()); - assert!(!Float::infinity::<float>().is_normal()); - assert!(!Float::neg_infinity::<float>().is_normal()); - assert!(!Zero::zero::<float>().is_normal()); - assert!(!Float::neg_zero::<float>().is_normal()); + let nan: float = Float::NaN(); + let inf: float = Float::infinity(); + let neg_inf: float = Float::neg_infinity(); + let zero: float = Zero::zero(); + let neg_zero: float = Float::neg_zero(); + assert!(!nan.is_normal()); + assert!(!inf.is_normal()); + assert!(!neg_inf.is_normal()); + assert!(!zero.is_normal()); + assert!(!neg_zero.is_normal()); assert!(1f.is_normal()); assert!(1e-307f.is_normal()); assert!(!1e-308f.is_normal()); @@ -1159,11 +1238,16 @@ mod tests { #[test] fn test_classify() { - assert_eq!(Float::NaN::<float>().classify(), FPNaN); - assert_eq!(Float::infinity::<float>().classify(), FPInfinite); - assert_eq!(Float::neg_infinity::<float>().classify(), FPInfinite); - assert_eq!(Zero::zero::<float>().classify(), FPZero); - assert_eq!(Float::neg_zero::<float>().classify(), FPZero); + let nan: float = Float::NaN(); + let inf: float = Float::infinity(); + let neg_inf: float = Float::neg_infinity(); + let zero: float = Zero::zero(); + let neg_zero: float = Float::neg_zero(); + assert_eq!(nan.classify(), FPNaN); + assert_eq!(inf.classify(), FPInfinite); + assert_eq!(neg_inf.classify(), FPInfinite); + assert_eq!(zero.classify(), FPZero); + assert_eq!(neg_zero.classify(), FPZero); assert_eq!(1f.classify(), FPNormal); assert_eq!(1e-307f.classify(), FPNormal); assert_eq!(1e-308f.classify(), FPSubnormal); @@ -1180,11 +1264,13 @@ mod tests { assert_eq!(Float::ldexp(0f, -123), 0f); assert_eq!(Float::ldexp(-0f, -123), -0f); - assert_eq!(Float::ldexp(Float::infinity::<float>(), -123), - Float::infinity::<float>()); - assert_eq!(Float::ldexp(Float::neg_infinity::<float>(), -123), - Float::neg_infinity::<float>()); - assert!(Float::ldexp(Float::NaN::<float>(), -123).is_NaN()); + + let inf: float = Float::infinity(); + let neg_inf: float = Float::neg_infinity(); + let nan: float = Float::NaN(); + assert_eq!(Float::ldexp(inf, -123), inf); + assert_eq!(Float::ldexp(neg_inf, -123), neg_inf); + assert!(Float::ldexp(nan, -123).is_NaN()); } #[test] @@ -1202,11 +1288,13 @@ mod tests { assert_eq!(0f.frexp(), (0f, 0)); assert_eq!((-0f).frexp(), (-0f, 0)); - assert_eq!(match Float::infinity::<float>().frexp() { (x, _) => x }, - Float::infinity::<float>()) - assert_eq!(match Float::neg_infinity::<float>().frexp() { (x, _) => x }, - Float::neg_infinity::<float>()) - assert!(match Float::NaN::<float>().frexp() { (x, _) => x.is_NaN() }) + + let inf: float = Float::infinity(); + let neg_inf: float = Float::neg_infinity(); + let nan: float = Float::NaN(); + assert_eq!(match inf.frexp() { (x, _) => x }, inf); + assert_eq!(match neg_inf.frexp() { (x, _) => x }, neg_inf); + assert!(match nan.frexp() { (x, _) => x.is_NaN() }) } #[test] diff --git a/src/libstd/num/int_macros.rs b/src/libstd/num/int_macros.rs index e2218ce2736..6054d557fa5 100644 --- a/src/libstd/num/int_macros.rs +++ b/src/libstd/num/int_macros.rs @@ -466,10 +466,10 @@ impl Int for $T {} impl Primitive for $T { #[inline] - fn bits() -> uint { bits } + fn bits(_: Option<$T>) -> uint { bits } #[inline] - fn bytes() -> uint { bits / 8 } + fn bytes(_: Option<$T>) -> uint { bits / 8 } } // String conversion functions and impl str -> num @@ -754,8 +754,9 @@ mod tests { #[test] fn test_primitive() { - assert_eq!(Primitive::bits::<$T>(), sys::size_of::<$T>() * 8); - assert_eq!(Primitive::bytes::<$T>(), sys::size_of::<$T>()); + let none: Option<$T> = None; + assert_eq!(Primitive::bits(none), sys::size_of::<$T>() * 8); + assert_eq!(Primitive::bytes(none), sys::size_of::<$T>()); } #[test] diff --git a/src/libstd/num/num.rs b/src/libstd/num/num.rs index fbb8913fbfa..80ab0caac67 100644 --- a/src/libstd/num/num.rs +++ b/src/libstd/num/num.rs @@ -272,8 +272,8 @@ pub trait Primitive: Num + Div<Self,Self> + Rem<Self,Self> { // FIXME (#5527): These should be associated constants - fn bits() -> uint; - fn bytes() -> uint; + fn bits(unused_self: Option<Self>) -> uint; + fn bytes(unused_self: Option<Self>) -> uint; } /// A collection of traits relevant to primitive signed and unsigned integers @@ -314,13 +314,13 @@ pub trait Float: Real fn is_normal(&self) -> bool; fn classify(&self) -> FPCategory; - fn mantissa_digits() -> uint; - fn digits() -> uint; + fn mantissa_digits(unused_self: Option<Self>) -> uint; + fn digits(unused_self: Option<Self>) -> uint; fn epsilon() -> Self; - fn min_exp() -> int; - fn max_exp() -> int; - fn min_10_exp() -> int; - fn max_10_exp() -> int; + fn min_exp(unused_self: Option<Self>) -> int; + fn max_exp(unused_self: Option<Self>) -> int; + fn min_10_exp(unused_self: Option<Self>) -> int; + fn max_10_exp(unused_self: Option<Self>) -> int; fn ldexp(x: Self, exp: int) -> Self; fn frexp(&self) -> (Self, int); @@ -484,9 +484,9 @@ impl<T: CheckedAdd+CheckedSub+Zero+Ord+Bounded> Saturating for T { match self.checked_add(&v) { Some(x) => x, None => if v >= Zero::zero() { - Bounded::max_value::<T>() + Bounded::max_value() } else { - Bounded::min_value::<T>() + Bounded::min_value() } } } @@ -496,9 +496,9 @@ impl<T: CheckedAdd+CheckedSub+Zero+Ord+Bounded> Saturating for T { match self.checked_sub(&v) { Some(x) => x, None => if v >= Zero::zero() { - Bounded::min_value::<T>() + Bounded::min_value() } else { - Bounded::max_value::<T>() + Bounded::max_value() } } } diff --git a/src/libstd/num/uint_macros.rs b/src/libstd/num/uint_macros.rs index d81a2756ad8..8ffaed22d01 100644 --- a/src/libstd/num/uint_macros.rs +++ b/src/libstd/num/uint_macros.rs @@ -404,10 +404,10 @@ impl ToStrRadix for $T { impl Primitive for $T { #[inline] - fn bits() -> uint { bits } + fn bits(_: Option<$T>) -> uint { bits } #[inline] - fn bytes() -> uint { bits / 8 } + fn bytes(_: Option<$T>) -> uint { bits / 8 } } impl BitCount for $T { @@ -532,8 +532,9 @@ mod tests { #[test] fn test_primitive() { - assert_eq!(Primitive::bits::<$T>(), sys::size_of::<$T>() * 8); - assert_eq!(Primitive::bytes::<$T>(), sys::size_of::<$T>()); + let none: Option<$T> = None; + assert_eq!(Primitive::bits(none), sys::size_of::<$T>() * 8); + assert_eq!(Primitive::bytes(none), sys::size_of::<$T>()); } #[test] diff --git a/src/libstd/rt/borrowck.rs b/src/libstd/rt/borrowck.rs index 01269d0d386..e03a61226ad 100644 --- a/src/libstd/rt/borrowck.rs +++ b/src/libstd/rt/borrowck.rs @@ -13,7 +13,7 @@ use c_str::ToCStr; use cast::transmute; use io::{Writer, WriterUtil}; use io; -use libc::{c_char, c_void, size_t, STDERR_FILENO}; +use libc::{c_char, size_t, STDERR_FILENO}; use option::{Option, None, Some}; use ptr::RawPtr; use rt::env; diff --git a/src/libstd/rt/comm.rs b/src/libstd/rt/comm.rs index b547d3c9c30..4b1881409f4 100644 --- a/src/libstd/rt/comm.rs +++ b/src/libstd/rt/comm.rs @@ -159,7 +159,7 @@ impl<T> ChanOne<T> { }; } else { let recvr = Cell::new(recvr); - do Local::borrow::<Scheduler, ()> |sched| { + do Local::borrow |sched: &mut Scheduler| { sched.enqueue_blocked_task(recvr.take()); } } @@ -199,7 +199,7 @@ impl<T> PortOne<T> { if !this.optimistic_check() { // No data available yet. // Switch to the scheduler to put the ~Task into the Packet state. - let sched = Local::take::<Scheduler>(); + let sched: ~Scheduler = Local::take(); do sched.deschedule_running_task_and_then |sched, task| { this.block_on(sched, task); } @@ -221,7 +221,7 @@ impl<T> SelectInner for PortOne<T> { // The optimistic check is never necessary for correctness. For testing // purposes, making it randomly return false simulates a racing sender. use rand::{Rand}; - let actually_check = do Local::borrow::<Scheduler, bool> |sched| { + let actually_check = do Local::borrow |sched: &mut Scheduler| { Rand::rand(&mut sched.rng) }; if actually_check { diff --git a/src/libstd/rt/io/net/ip.rs b/src/libstd/rt/io/net/ip.rs index 3b3ea80eafa..d1d6b16e2eb 100644 --- a/src/libstd/rt/io/net/ip.rs +++ b/src/libstd/rt/io/net/ip.rs @@ -359,7 +359,7 @@ impl FromStr for SocketAddr { mod test { use super::*; use from_str::FromStr; - use option::{Some, None}; + use option::{Option, Some, None}; #[test] fn test_from_str_ipv4() { @@ -368,13 +368,17 @@ mod test { assert_eq!(Some(Ipv4Addr(0, 0, 0, 0)), FromStr::from_str("0.0.0.0")); // out of range - assert_eq!(None, FromStr::from_str::<IpAddr>("256.0.0.1")); + let none: Option<IpAddr> = FromStr::from_str("256.0.0.1"); + assert_eq!(None, none); // too short - assert_eq!(None, FromStr::from_str::<IpAddr>("255.0.0")); + let none: Option<IpAddr> = FromStr::from_str("255.0.0"); + assert_eq!(None, none); // too long - assert_eq!(None, FromStr::from_str::<IpAddr>("255.0.0.1.2")); + let none: Option<IpAddr> = FromStr::from_str("255.0.0.1.2"); + assert_eq!(None, none); // no number between dots - assert_eq!(None, FromStr::from_str::<IpAddr>("255.0..1")); + let none: Option<IpAddr> = FromStr::from_str("255.0..1"); + assert_eq!(None, none); } #[test] @@ -389,15 +393,20 @@ mod test { FromStr::from_str("2a02:6b8::11:11")); // too long group - assert_eq!(None, FromStr::from_str::<IpAddr>("::00000")); + let none: Option<IpAddr> = FromStr::from_str("::00000"); + assert_eq!(None, none); // too short - assert_eq!(None, FromStr::from_str::<IpAddr>("1:2:3:4:5:6:7")); + let none: Option<IpAddr> = FromStr::from_str("1:2:3:4:5:6:7"); + assert_eq!(None, none); // too long - assert_eq!(None, FromStr::from_str::<IpAddr>("1:2:3:4:5:6:7:8:9")); + let none: Option<IpAddr> = FromStr::from_str("1:2:3:4:5:6:7:8:9"); + assert_eq!(None, none); // triple colon - assert_eq!(None, FromStr::from_str::<IpAddr>("1:2:::6:7:8")); + let none: Option<IpAddr> = FromStr::from_str("1:2:::6:7:8"); + assert_eq!(None, none); // two double colons - assert_eq!(None, FromStr::from_str::<IpAddr>("1:2::6::8")); + let none: Option<IpAddr> = FromStr::from_str("1:2::6::8"); + assert_eq!(None, none); } #[test] @@ -412,11 +421,15 @@ mod test { FromStr::from_str("2001:db8:122:c000:2:2100:192.0.2.33")); // colon after v4 - assert_eq!(None, FromStr::from_str::<IpAddr>("::127.0.0.1:")); + let none: Option<IpAddr> = FromStr::from_str("::127.0.0.1:"); + assert_eq!(None, none); // not enought groups - assert_eq!(None, FromStr::from_str::<IpAddr>("1.2.3.4.5:127.0.0.1")); + let none: Option<IpAddr> = FromStr::from_str("1.2.3.4.5:127.0.0.1"); + assert_eq!(None, none); // too many groups - assert_eq!(None, FromStr::from_str::<IpAddr>("1.2.3.4.5:6:7:127.0.0.1")); + let none: Option<IpAddr> = + FromStr::from_str("1.2.3.4.5:6:7:127.0.0.1"); + assert_eq!(None, none); } #[test] @@ -429,13 +442,17 @@ mod test { FromStr::from_str("[::127.0.0.1]:22")); // without port - assert_eq!(None, FromStr::from_str::<SocketAddr>("127.0.0.1")); + let none: Option<SocketAddr> = FromStr::from_str("127.0.0.1"); + assert_eq!(None, none); // without port - assert_eq!(None, FromStr::from_str::<SocketAddr>("127.0.0.1:")); + let none: Option<SocketAddr> = FromStr::from_str("127.0.0.1:"); + assert_eq!(None, none); // wrong brackets around v4 - assert_eq!(None, FromStr::from_str::<SocketAddr>("[127.0.0.1]:22")); + let none: Option<SocketAddr> = FromStr::from_str("[127.0.0.1]:22"); + assert_eq!(None, none); // port out of range - assert_eq!(None, FromStr::from_str::<SocketAddr>("127.0.0.1:123456")); + let none: Option<SocketAddr> = FromStr::from_str("127.0.0.1:123456"); + assert_eq!(None, none); } #[test] diff --git a/src/libstd/rt/io/net/tcp.rs b/src/libstd/rt/io/net/tcp.rs index 746fa5668a5..9be5540de48 100644 --- a/src/libstd/rt/io/net/tcp.rs +++ b/src/libstd/rt/io/net/tcp.rs @@ -29,7 +29,7 @@ impl TcpStream { pub fn connect(addr: SocketAddr) -> Option<TcpStream> { let stream = unsafe { rtdebug!("borrowing io to connect"); - let io = Local::unsafe_borrow::<IoFactoryObject>(); + let io: *mut IoFactoryObject = Local::unsafe_borrow(); rtdebug!("about to connect"); (*io).tcp_connect(addr) }; @@ -100,7 +100,7 @@ pub struct TcpListener(~RtioTcpListenerObject); impl TcpListener { pub fn bind(addr: SocketAddr) -> Option<TcpListener> { let listener = unsafe { - let io = Local::unsafe_borrow::<IoFactoryObject>(); + let io: *mut IoFactoryObject = Local::unsafe_borrow(); (*io).tcp_bind(addr) }; match listener { diff --git a/src/libstd/rt/io/net/udp.rs b/src/libstd/rt/io/net/udp.rs index 644abcbe145..132ca064515 100644 --- a/src/libstd/rt/io/net/udp.rs +++ b/src/libstd/rt/io/net/udp.rs @@ -20,7 +20,10 @@ pub struct UdpSocket(~RtioUdpSocketObject); impl UdpSocket { pub fn bind(addr: SocketAddr) -> Option<UdpSocket> { - let socket = unsafe { (*Local::unsafe_borrow::<IoFactoryObject>()).udp_bind(addr) }; + let socket = unsafe { + let factory: *mut IoFactoryObject = Local::unsafe_borrow(); + (*factory).udp_bind(addr) + }; match socket { Ok(s) => Some(UdpSocket(s)), Err(ioerr) => { diff --git a/src/libstd/rt/io/timer.rs b/src/libstd/rt/io/timer.rs index b0ec747800d..7f2d88f994d 100644 --- a/src/libstd/rt/io/timer.rs +++ b/src/libstd/rt/io/timer.rs @@ -22,7 +22,7 @@ impl Timer { pub fn new() -> Option<Timer> { let timer = unsafe { rtdebug!("Timer::init: borrowing io to init timer"); - let io = Local::unsafe_borrow::<IoFactoryObject>(); + let io: *mut IoFactoryObject = Local::unsafe_borrow(); rtdebug!("about to init timer"); (*io).timer_init() }; diff --git a/src/libstd/rt/local.rs b/src/libstd/rt/local.rs index 18b7394700f..072fb4edf05 100644 --- a/src/libstd/rt/local.rs +++ b/src/libstd/rt/local.rs @@ -19,7 +19,7 @@ use cell::Cell; pub trait Local { fn put(value: ~Self); fn take() -> ~Self; - fn exists() -> bool; + fn exists(unused_value: Option<Self>) -> bool; fn borrow<T>(f: &fn(&mut Self) -> T) -> T; unsafe fn unsafe_take() -> ~Self; unsafe fn unsafe_borrow() -> *mut Self; @@ -31,7 +31,7 @@ impl Local for Task { fn put(value: ~Task) { unsafe { local_ptr::put(value) } } #[inline] fn take() -> ~Task { unsafe { local_ptr::take() } } - fn exists() -> bool { local_ptr::exists() } + fn exists(_: Option<Task>) -> bool { local_ptr::exists() } fn borrow<T>(f: &fn(&mut Task) -> T) -> T { let mut res: Option<T> = None; let res_ptr: *mut Option<T> = &mut res; @@ -59,7 +59,7 @@ impl Local for Task { impl Local for Scheduler { fn put(value: ~Scheduler) { let value = Cell::new(value); - do Local::borrow::<Task,()> |task| { + do Local::borrow |task: &mut Task| { let task = task; task.sched = Some(value.take()); }; @@ -68,12 +68,12 @@ impl Local for Scheduler { fn take() -> ~Scheduler { unsafe { // XXX: Unsafe for speed - let task = Local::unsafe_borrow::<Task>(); + let task: *mut Task = Local::unsafe_borrow(); (*task).sched.take_unwrap() } } - fn exists() -> bool { - do Local::borrow::<Task,bool> |task| { + fn exists(_: Option<Scheduler>) -> bool { + do Local::borrow |task: &mut Task| { match task.sched { Some(ref _task) => true, None => false @@ -81,7 +81,7 @@ impl Local for Scheduler { } } fn borrow<T>(f: &fn(&mut Scheduler) -> T) -> T { - do Local::borrow::<Task, T> |task| { + do Local::borrow |task: &mut Task| { match task.sched { Some(~ref mut task) => { f(task) @@ -94,7 +94,8 @@ impl Local for Scheduler { } unsafe fn unsafe_take() -> ~Scheduler { rtabort!("unimpl") } unsafe fn unsafe_borrow() -> *mut Scheduler { - match (*Local::unsafe_borrow::<Task>()).sched { + let task: *mut Task = Local::unsafe_borrow(); + match (*task).sched { Some(~ref mut sched) => { let s: *mut Scheduler = &mut *sched; return s; @@ -105,6 +106,7 @@ impl Local for Scheduler { } } unsafe fn try_unsafe_borrow() -> Option<*mut Scheduler> { + let task_opt: Option<*mut Task> = Local::try_unsafe_borrow(); match Local::try_unsafe_borrow::<Task>() { Some(task) => { match (*task).sched { @@ -124,15 +126,17 @@ impl Local for Scheduler { impl Local for IoFactoryObject { fn put(_value: ~IoFactoryObject) { rtabort!("unimpl") } fn take() -> ~IoFactoryObject { rtabort!("unimpl") } - fn exists() -> bool { rtabort!("unimpl") } + fn exists(_: Option<IoFactoryObject>) -> bool { rtabort!("unimpl") } fn borrow<T>(_f: &fn(&mut IoFactoryObject) -> T) -> T { rtabort!("unimpl") } unsafe fn unsafe_take() -> ~IoFactoryObject { rtabort!("unimpl") } unsafe fn unsafe_borrow() -> *mut IoFactoryObject { - let sched = Local::unsafe_borrow::<Scheduler>(); + let sched: *mut Scheduler = Local::unsafe_borrow(); let io: *mut IoFactoryObject = (*sched).event_loop.io().unwrap(); return io; } - unsafe fn try_unsafe_borrow() -> Option<*mut IoFactoryObject> { rtabort!("unimpl") } + unsafe fn try_unsafe_borrow() -> Option<*mut IoFactoryObject> { + rtabort!("unimpl") + } } @@ -198,7 +202,7 @@ mod test { let task = ~Task::new_root(&mut sched.stack_pool, None, || {}); Local::put(task); - let res = do Local::borrow::<Task,bool> |_task| { + let res = do Local::borrow |_task: &mut Task| { true }; assert!(res) diff --git a/src/libstd/rt/local_heap.rs b/src/libstd/rt/local_heap.rs index aa8c5dd4674..12ec19a1ecc 100644 --- a/src/libstd/rt/local_heap.rs +++ b/src/libstd/rt/local_heap.rs @@ -13,7 +13,7 @@ use libc; use libc::{c_void, uintptr_t, size_t}; use ops::Drop; -use option::{Some, None}; +use option::{Option, None, Some}; use rt::local::Local; use rt::task::Task; use unstable::raw; @@ -89,7 +89,8 @@ impl Drop for LocalHeap { // A little compatibility function pub unsafe fn local_free(ptr: *libc::c_char) { // XXX: Unsafe borrow for speed. Lame. - match Local::try_unsafe_borrow::<Task>() { + let task_ptr: Option<*mut Task> = Local::try_unsafe_borrow(); + match task_ptr { Some(task) => { (*task).heap.free(ptr as *libc::c_void); } @@ -98,7 +99,7 @@ pub unsafe fn local_free(ptr: *libc::c_char) { } pub fn live_allocs() -> *raw::Box<()> { - let region = do Local::borrow::<Task, *BoxedRegion> |task| { + let region = do Local::borrow |task: &mut Task| { task.heap.boxed_region }; diff --git a/src/libstd/rt/mod.rs b/src/libstd/rt/mod.rs index 7436efb5bf5..6dbeb8c0ea9 100644 --- a/src/libstd/rt/mod.rs +++ b/src/libstd/rt/mod.rs @@ -64,7 +64,7 @@ use cell::Cell; use clone::Clone; use container::Container; use iterator::{Iterator, range}; -use option::{Some, None}; +use option::{Option, None, Some}; use ptr::RawPtr; use rt::local::Local; use rt::sched::{Scheduler, Shutdown}; @@ -408,7 +408,8 @@ fn run_(main: ~fn(), use_main_sched: bool) -> int { pub fn in_sched_context() -> bool { unsafe { - match Local::try_unsafe_borrow::<Task>() { + let task_ptr: Option<*mut Task> = Local::try_unsafe_borrow(); + match task_ptr { Some(task) => { match (*task).task_type { SchedTask => true, @@ -422,7 +423,8 @@ pub fn in_sched_context() -> bool { pub fn in_green_task_context() -> bool { unsafe { - match Local::try_unsafe_borrow::<Task>() { + let task: Option<*mut Task> = Local::try_unsafe_borrow(); + match task { Some(task) => { match (*task).task_type { GreenTask(_) => true, diff --git a/src/libstd/rt/sched.rs b/src/libstd/rt/sched.rs index 26a3b95abbe..b1319321c19 100644 --- a/src/libstd/rt/sched.rs +++ b/src/libstd/rt/sched.rs @@ -169,7 +169,7 @@ impl Scheduler { // successfully run the input task. Start by running the // scheduler. Grab it out of TLS - performing the scheduler // action will have given it away. - let sched = Local::take::<Scheduler>(); + let sched: ~Scheduler = Local::take(); rtdebug!("starting scheduler %u", sched.sched_id()); sched.run(); @@ -185,7 +185,7 @@ impl Scheduler { // cleaning up the memory it uses. As we didn't actually call // task.run() on the scheduler task we never get through all // the cleanup code it runs. - let mut stask = Local::take::<Task>(); + let mut stask: ~Task = Local::take(); rtdebug!("stopping scheduler %u", stask.sched.get_ref().sched_id()); @@ -212,7 +212,7 @@ impl Scheduler { // Our scheduler must be in the task before the event loop // is started. let self_sched = Cell::new(self_sched); - do Local::borrow::<Task,()> |stask| { + do Local::borrow |stask: &mut Task| { stask.sched = Some(self_sched.take()); }; @@ -234,7 +234,7 @@ impl Scheduler { // already have a scheduler stored in our local task, so we // start off by taking it. This is the only path through the // scheduler where we get the scheduler this way. - let mut sched = Local::take::<Scheduler>(); + let mut sched: ~Scheduler = Local::take(); // Assume that we need to continue idling unless we reach the // end of this function without performing an action. @@ -522,7 +522,7 @@ impl Scheduler { // The current task is grabbed from TLS, not taken as an input. // Doing an unsafe_take to avoid writing back a null pointer - // We're going to call `put` later to do that. - let current_task: ~Task = unsafe { Local::unsafe_take::<Task>() }; + let current_task: ~Task = unsafe { Local::unsafe_take() }; // Check that the task is not in an atomically() section (e.g., // holding a pthread mutex, which could deadlock the scheduler). @@ -581,7 +581,7 @@ impl Scheduler { // run the cleanup job, as expected by the previously called // swap_contexts function. unsafe { - let task = Local::unsafe_borrow::<Task>(); + let task: *mut Task = Local::unsafe_borrow::<Task>(); (*task).sched.get_mut_ref().run_cleanup_job(); // Must happen after running the cleanup job (of course). @@ -692,7 +692,7 @@ impl Scheduler { pub fn run_task_later(next_task: ~Task) { let next_task = Cell::new(next_task); - do Local::borrow::<Scheduler,()> |sched| { + do Local::borrow |sched: &mut Scheduler| { sched.enqueue_task(next_task.take()); }; } @@ -1024,12 +1024,12 @@ mod test { // exit before emptying the work queue do run_in_newsched_task { do spawntask { - let sched = Local::take::<Scheduler>(); + let sched: ~Scheduler = Local::take(); do sched.deschedule_running_task_and_then |sched, task| { let task = Cell::new(task); do sched.event_loop.callback_ms(10) { rtdebug!("in callback"); - let mut sched = Local::take::<Scheduler>(); + let mut sched: ~Scheduler = Local::take(); sched.enqueue_blocked_task(task.take()); Local::put(sched); } diff --git a/src/libstd/rt/select.rs b/src/libstd/rt/select.rs index 19a4948af3c..6cde0a1f216 100644 --- a/src/libstd/rt/select.rs +++ b/src/libstd/rt/select.rs @@ -26,3 +26,4 @@ pub trait SelectInner { pub trait SelectPortInner<T> { fn recv_ready(self) -> Option<T>; } + diff --git a/src/libstd/rt/task.rs b/src/libstd/rt/task.rs index 9c2a6e646d2..b1ab7a6cd5d 100644 --- a/src/libstd/rt/task.rs +++ b/src/libstd/rt/task.rs @@ -93,7 +93,7 @@ impl Task { pub fn build_homed_child(stack_size: Option<uint>, f: ~fn(), home: SchedHome) -> ~Task { let f = Cell::new(f); let home = Cell::new(home); - do Local::borrow::<Task, ~Task> |running_task| { + do Local::borrow |running_task: &mut Task| { let mut sched = running_task.sched.take_unwrap(); let new_task = ~running_task.new_child_homed(&mut sched.stack_pool, stack_size, @@ -111,7 +111,7 @@ impl Task { pub fn build_homed_root(stack_size: Option<uint>, f: ~fn(), home: SchedHome) -> ~Task { let f = Cell::new(f); let home = Cell::new(home); - do Local::borrow::<Task, ~Task> |running_task| { + do Local::borrow |running_task: &mut Task| { let mut sched = running_task.sched.take_unwrap(); let new_task = ~Task::new_root_homed(&mut sched.stack_pool, stack_size, @@ -305,7 +305,7 @@ impl Task { // Grab both the scheduler and the task from TLS and check if the // task is executing on an appropriate scheduler. pub fn on_appropriate_sched() -> bool { - do Local::borrow::<Task,bool> |task| { + do Local::borrow |task: &mut Task| { let sched_id = task.sched.get_ref().sched_id(); let sched_run_anything = task.sched.get_ref().run_anything; match task.task_type { @@ -369,7 +369,7 @@ impl Coroutine { unsafe { // Again - might work while safe, or it might not. - do Local::borrow::<Scheduler,()> |sched| { + do Local::borrow |sched: &mut Scheduler| { sched.run_cleanup_job(); } @@ -378,7 +378,7 @@ impl Coroutine { // simply unsafe_borrow it to get this reference. We // need to still have the task in TLS though, so we // need to unsafe_borrow. - let task = Local::unsafe_borrow::<Task>(); + let task: *mut Task = Local::unsafe_borrow(); do (*task).run { // N.B. Removing `start` from the start wrapper @@ -397,7 +397,7 @@ impl Coroutine { } // We remove the sched from the Task in TLS right now. - let sched = Local::take::<Scheduler>(); + let sched: ~Scheduler = Local::take(); // ... allowing us to give it away when performing a // scheduling operation. sched.terminate_current_task() diff --git a/src/libstd/rt/tube.rs b/src/libstd/rt/tube.rs index 247893f75de..b8e535e4c7d 100644 --- a/src/libstd/rt/tube.rs +++ b/src/libstd/rt/tube.rs @@ -51,7 +51,7 @@ impl<T> Tube<T> { // There's a waiting task. Wake it up rtdebug!("waking blocked tube"); let task = (*state).blocked_task.take_unwrap(); - let sched = Local::take::<Scheduler>(); + let sched: ~Scheduler = Local::take(); sched.resume_blocked_task_immediately(task); } } @@ -67,7 +67,7 @@ impl<T> Tube<T> { rtdebug!("blocking on tube recv"); assert!(self.p.refcount() > 1); // There better be somebody to wake us up assert!((*state).blocked_task.is_none()); - let sched = Local::take::<Scheduler>(); + let sched: ~Scheduler = Local::take(); do sched.deschedule_running_task_and_then |_, task| { (*state).blocked_task = Some(task); } @@ -102,7 +102,7 @@ mod test { let mut tube: Tube<int> = Tube::new(); let tube_clone = tube.clone(); let tube_clone_cell = Cell::new(tube_clone); - let sched = Local::take::<Scheduler>(); + let sched: ~Scheduler = Local::take(); do sched.deschedule_running_task_and_then |sched, task| { let mut tube_clone = tube_clone_cell.take(); tube_clone.send(1); @@ -119,7 +119,7 @@ mod test { let mut tube: Tube<int> = Tube::new(); let tube_clone = tube.clone(); let tube_clone = Cell::new(tube_clone); - let sched = Local::take::<Scheduler>(); + let sched: ~Scheduler = Local::take(); do sched.deschedule_running_task_and_then |sched, task| { let tube_clone = Cell::new(tube_clone.take()); do sched.event_loop.callback { @@ -143,7 +143,7 @@ mod test { let mut tube: Tube<int> = Tube::new(); let tube_clone = tube.clone(); let tube_clone = Cell::new(tube_clone); - let sched = Local::take::<Scheduler>(); + let sched: ~Scheduler = Local::take(); do sched.deschedule_running_task_and_then |sched, task| { callback_send(tube_clone.take(), 0); @@ -151,7 +151,7 @@ mod test { if i == 100 { return; } let tube = Cell::new(Cell::new(tube)); - do Local::borrow::<Scheduler, ()> |sched| { + do Local::borrow |sched: &mut Scheduler| { let tube = tube.take(); do sched.event_loop.callback { let mut tube = tube.take(); diff --git a/src/libstd/rt/uv/uvio.rs b/src/libstd/rt/uv/uvio.rs index 6e79a78e061..fac3de2be65 100644 --- a/src/libstd/rt/uv/uvio.rs +++ b/src/libstd/rt/uv/uvio.rs @@ -375,7 +375,7 @@ mod test_remote { let mut tube = Tube::new(); let tube_clone = tube.clone(); let remote_cell = Cell::new_empty(); - do Local::borrow::<Scheduler, ()>() |sched| { + do Local::borrow |sched: &mut Scheduler| { let tube_clone = tube_clone.clone(); let tube_clone_cell = Cell::new(tube_clone); let remote = do sched.event_loop.remote_callback { @@ -416,7 +416,7 @@ impl IoFactory for UvIoFactory { // Block this task and take ownership, switch to scheduler context do task::unkillable { // FIXME(#8674) - let scheduler = Local::take::<Scheduler>(); + let scheduler: ~Scheduler = Local::take(); do scheduler.deschedule_running_task_and_then |_, task| { let mut tcp = TcpWatcher::new(self.uv_loop()); @@ -434,7 +434,7 @@ impl IoFactory for UvIoFactory { unsafe { (*result_cell_ptr).put_back(res); } // Context switch - let scheduler = Local::take::<Scheduler>(); + let scheduler: ~Scheduler = Local::take(); scheduler.resume_blocked_task_immediately(task_cell.take()); } Some(_) => { @@ -464,11 +464,11 @@ impl IoFactory for UvIoFactory { } Err(uverr) => { do task::unkillable { // FIXME(#8674) - let scheduler = Local::take::<Scheduler>(); + let scheduler: ~Scheduler = Local::take(); do scheduler.deschedule_running_task_and_then |_, task| { let task_cell = Cell::new(task); do watcher.as_stream().close { - let scheduler = Local::take::<Scheduler>(); + let scheduler: ~Scheduler = Local::take(); scheduler.resume_blocked_task_immediately(task_cell.take()); } } @@ -487,11 +487,11 @@ impl IoFactory for UvIoFactory { } Err(uverr) => { do task::unkillable { // FIXME(#8674) - let scheduler = Local::take::<Scheduler>(); + let scheduler: ~Scheduler = Local::take(); do scheduler.deschedule_running_task_and_then |_, task| { let task_cell = Cell::new(task); do watcher.close { - let scheduler = Local::take::<Scheduler>(); + let scheduler: ~Scheduler = Local::take(); scheduler.resume_blocked_task_immediately(task_cell.take()); } } @@ -625,7 +625,7 @@ impl Drop for UvTcpListener { do scheduler.deschedule_running_task_and_then |_, task| { let task_cell = Cell::new(task); do self_.watcher().as_stream().close { - let scheduler = Local::take::<Scheduler>(); + let scheduler: ~Scheduler = Local::take(); scheduler.resume_blocked_task_immediately(task_cell.take()); } } @@ -717,7 +717,7 @@ impl Drop for UvTcpStream { do scheduler.deschedule_running_task_and_then |_, task| { let task_cell = Cell::new(task); do self_.watcher.as_stream().close { - let scheduler = Local::take::<Scheduler>(); + let scheduler: ~Scheduler = Local::take(); scheduler.resume_blocked_task_immediately(task_cell.take()); } } @@ -765,7 +765,7 @@ impl RtioTcpStream for UvTcpStream { unsafe { (*result_cell_ptr).put_back(result); } - let scheduler = Local::take::<Scheduler>(); + let scheduler: ~Scheduler = Local::take::<Scheduler>(); scheduler.resume_blocked_task_immediately(task_cell.take()); } } @@ -793,7 +793,7 @@ impl RtioTcpStream for UvTcpStream { unsafe { (*result_cell_ptr).put_back(result); } - let scheduler = Local::take::<Scheduler>(); + let scheduler: ~Scheduler = Local::take(); scheduler.resume_blocked_task_immediately(task_cell.take()); } } @@ -876,7 +876,7 @@ impl Drop for UvUdpSocket { do scheduler.deschedule_running_task_and_then |_, task| { let task_cell = Cell::new(task); do self_.watcher.close { - let scheduler = Local::take::<Scheduler>(); + let scheduler: ~Scheduler = Local::take(); scheduler.resume_blocked_task_immediately(task_cell.take()); } } @@ -917,7 +917,7 @@ impl RtioUdpSocket for UvUdpSocket { unsafe { (*result_cell_ptr).put_back(result); } - let scheduler = Local::take::<Scheduler>(); + let scheduler: ~Scheduler = Local::take(); scheduler.resume_blocked_task_immediately(task_cell.take()); } } @@ -944,7 +944,7 @@ impl RtioUdpSocket for UvUdpSocket { unsafe { (*result_cell_ptr).put_back(result); } - let scheduler = Local::take::<Scheduler>(); + let scheduler: ~Scheduler = Local::take(); scheduler.resume_blocked_task_immediately(task_cell.take()); } } @@ -1094,7 +1094,7 @@ impl Drop for UvTimer { do scheduler.deschedule_running_task_and_then |_, task| { let task_cell = Cell::new(task); do self_.watcher.close { - let scheduler = Local::take::<Scheduler>(); + let scheduler: ~Scheduler = Local::take(); scheduler.resume_blocked_task_immediately(task_cell.take()); } } @@ -1110,7 +1110,7 @@ impl RtioTimer for UvTimer { let task_cell = Cell::new(task); do self_.watcher.start(msecs, 0) |_, status| { assert!(status.is_none()); - let scheduler = Local::take::<Scheduler>(); + let scheduler: ~Scheduler = Local::take(); scheduler.resume_blocked_task_immediately(task_cell.take()); } } @@ -1254,7 +1254,7 @@ impl RtioFileStream for UvFileStream { fn test_simple_io_no_connect() { do run_in_newsched_task { unsafe { - let io = Local::unsafe_borrow::<IoFactoryObject>(); + let io: *mut IoFactoryObject = Local::unsafe_borrow(); let addr = next_test_ip4(); let maybe_chan = (*io).tcp_connect(addr); assert!(maybe_chan.is_err()); @@ -1266,7 +1266,7 @@ fn test_simple_io_no_connect() { fn test_simple_udp_io_bind_only() { do run_in_newsched_task { unsafe { - let io = Local::unsafe_borrow::<IoFactoryObject>(); + let io: *mut IoFactoryObject = Local::unsafe_borrow(); let addr = next_test_ip4(); let maybe_socket = (*io).udp_bind(addr); assert!(maybe_socket.is_ok()); @@ -1430,7 +1430,7 @@ fn test_simple_tcp_server_and_client() { // Start the server first so it's listening when we connect do spawntask { unsafe { - let io = Local::unsafe_borrow::<IoFactoryObject>(); + let io: *mut IoFactoryObject = Local::unsafe_borrow(); let mut listener = (*io).tcp_bind(addr).unwrap(); let mut stream = listener.accept().unwrap(); let mut buf = [0, .. 2048]; @@ -1445,7 +1445,7 @@ fn test_simple_tcp_server_and_client() { do spawntask { unsafe { - let io = Local::unsafe_borrow::<IoFactoryObject>(); + let io: *mut IoFactoryObject = Local::unsafe_borrow(); let mut stream = (*io).tcp_connect(addr).unwrap(); stream.write([0, 1, 2, 3, 4, 5, 6, 7]); } @@ -1540,7 +1540,7 @@ fn test_simple_udp_server_and_client() { do spawntask { unsafe { - let io = Local::unsafe_borrow::<IoFactoryObject>(); + let io: *mut IoFactoryObject = Local::unsafe_borrow(); let mut server_socket = (*io).udp_bind(server_addr).unwrap(); let mut buf = [0, .. 2048]; let (nread,src) = server_socket.recvfrom(buf).unwrap(); @@ -1555,7 +1555,7 @@ fn test_simple_udp_server_and_client() { do spawntask { unsafe { - let io = Local::unsafe_borrow::<IoFactoryObject>(); + let io: *mut IoFactoryObject = Local::unsafe_borrow(); let mut client_socket = (*io).udp_bind(client_addr).unwrap(); client_socket.sendto([0, 1, 2, 3, 4, 5, 6, 7], server_addr); } @@ -1569,7 +1569,7 @@ fn test_read_and_block() { let addr = next_test_ip4(); do spawntask { - let io = unsafe { Local::unsafe_borrow::<IoFactoryObject>() }; + let io: *mut IoFactoryObject = unsafe { Local::unsafe_borrow() }; let mut listener = unsafe { (*io).tcp_bind(addr).unwrap() }; let mut stream = listener.accept().unwrap(); let mut buf = [0, .. 2048]; @@ -1588,7 +1588,7 @@ fn test_read_and_block() { reads += 1; do task::unkillable { // FIXME(#8674) - let scheduler = Local::take::<Scheduler>(); + let scheduler: ~Scheduler = Local::take(); // Yield to the other task in hopes that it // will trigger a read callback while we are // not ready for it @@ -1605,7 +1605,7 @@ fn test_read_and_block() { do spawntask { unsafe { - let io = Local::unsafe_borrow::<IoFactoryObject>(); + let io: *mut IoFactoryObject = Local::unsafe_borrow(); let mut stream = (*io).tcp_connect(addr).unwrap(); stream.write([0, 1, 2, 3, 4, 5, 6, 7]); stream.write([0, 1, 2, 3, 4, 5, 6, 7]); @@ -1625,7 +1625,7 @@ fn test_read_read_read() { do spawntask { unsafe { - let io = Local::unsafe_borrow::<IoFactoryObject>(); + let io: *mut IoFactoryObject = Local::unsafe_borrow(); let mut listener = (*io).tcp_bind(addr).unwrap(); let mut stream = listener.accept().unwrap(); let buf = [1, .. 2048]; @@ -1639,7 +1639,7 @@ fn test_read_read_read() { do spawntask { unsafe { - let io = Local::unsafe_borrow::<IoFactoryObject>(); + let io: *mut IoFactoryObject = Local::unsafe_borrow(); let mut stream = (*io).tcp_connect(addr).unwrap(); let mut buf = [0, .. 2048]; let mut total_bytes_read = 0; @@ -1665,7 +1665,7 @@ fn test_udp_twice() { do spawntask { unsafe { - let io = Local::unsafe_borrow::<IoFactoryObject>(); + let io: *mut IoFactoryObject = Local::unsafe_borrow(); let mut client = (*io).udp_bind(client_addr).unwrap(); assert!(client.sendto([1], server_addr).is_ok()); assert!(client.sendto([2], server_addr).is_ok()); @@ -1674,7 +1674,7 @@ fn test_udp_twice() { do spawntask { unsafe { - let io = Local::unsafe_borrow::<IoFactoryObject>(); + let io: *mut IoFactoryObject = Local::unsafe_borrow(); let mut server = (*io).udp_bind(server_addr).unwrap(); let mut buf1 = [0]; let mut buf2 = [0]; @@ -1702,7 +1702,7 @@ fn test_udp_many_read() { do spawntask { unsafe { - let io = Local::unsafe_borrow::<IoFactoryObject>(); + let io: *mut IoFactoryObject = Local::unsafe_borrow(); let mut server_out = (*io).udp_bind(server_out_addr).unwrap(); let mut server_in = (*io).udp_bind(server_in_addr).unwrap(); let msg = [1, .. 2048]; @@ -1725,7 +1725,7 @@ fn test_udp_many_read() { do spawntask { unsafe { - let io = Local::unsafe_borrow::<IoFactoryObject>(); + let io: *mut IoFactoryObject = Local::unsafe_borrow(); let mut client_out = (*io).udp_bind(client_out_addr).unwrap(); let mut client_in = (*io).udp_bind(client_in_addr).unwrap(); let mut total_bytes_recv = 0; @@ -1754,7 +1754,7 @@ fn test_udp_many_read() { fn test_timer_sleep_simple() { do run_in_newsched_task { unsafe { - let io = Local::unsafe_borrow::<IoFactoryObject>(); + let io: *mut IoFactoryObject = Local::unsafe_borrow(); let timer = (*io).timer_init(); do timer.map_move |mut t| { t.sleep(1) }; } diff --git a/src/libstd/select.rs b/src/libstd/select.rs index 531d55f6043..f121158d4c5 100644 --- a/src/libstd/select.rs +++ b/src/libstd/select.rs @@ -60,7 +60,7 @@ pub fn select<A: Select>(ports: &mut [A]) -> uint { do (|| { let c = Cell::new(c.take()); - let sched = Local::take::<Scheduler>(); + let sched: ~Scheduler = Local::take(); do sched.deschedule_running_task_and_then |sched, task| { let task_handles = task.make_selectable(ports.len()); diff --git a/src/libstd/sys.rs b/src/libstd/sys.rs index bfb9bee7802..cb0753fb2e5 100644 --- a/src/libstd/sys.rs +++ b/src/libstd/sys.rs @@ -143,7 +143,7 @@ pub fn begin_unwind_(msg: *c_char, file: *c_char, line: size_t) -> ! { if in_green_task_context() { // XXX: Logging doesn't work here - the check to call the log // function never passes - so calling the log function directly. - do Local::borrow::<Task, ()> |task| { + do Local::borrow |task: &mut Task| { let msg = match task.name { Some(ref name) => fmt!("task '%s' failed at '%s', %s:%i", @@ -160,7 +160,7 @@ pub fn begin_unwind_(msg: *c_char, file: *c_char, line: size_t) -> ! { msg, file, line as int); } - let task = Local::unsafe_borrow::<Task>(); + let task: *mut Task = Local::unsafe_borrow(); if (*task).unwinder.unwinding { rtabort!("unwinding again"); } diff --git a/src/libstd/task/local_data_priv.rs b/src/libstd/task/local_data_priv.rs index 8132bfe5377..2c2dfd8f689 100644 --- a/src/libstd/task/local_data_priv.rs +++ b/src/libstd/task/local_data_priv.rs @@ -28,7 +28,7 @@ impl Handle { pub fn new() -> Handle { use rt::local::Local; unsafe { - let task = Local::unsafe_borrow::<Task>(); + let task: *mut Task = Local::unsafe_borrow(); NewHandle(&mut (*task).storage) } } diff --git a/src/libstd/task/mod.rs b/src/libstd/task/mod.rs index f872c2614b9..c0b331c52ee 100644 --- a/src/libstd/task/mod.rs +++ b/src/libstd/task/mod.rs @@ -526,7 +526,7 @@ pub fn with_task_name<U>(blk: &fn(Option<&str>) -> U) -> U { use rt::task::Task; if in_green_task_context() { - do Local::borrow::<Task, U> |task| { + do Local::borrow |task: &mut Task| { match task.name { Some(ref name) => blk(Some(name.as_slice())), None => blk(None) @@ -545,7 +545,7 @@ pub fn deschedule() { // FIXME #6842: What does yield really mean in newsched? // FIXME(#7544): Optimize this, since we know we won't block. - let sched = Local::take::<Scheduler>(); + let sched: ~Scheduler = Local::take(); do sched.deschedule_running_task_and_then |sched, task| { sched.enqueue_blocked_task(task); } @@ -556,7 +556,7 @@ pub fn failing() -> bool { use rt::task::Task; - do Local::borrow::<Task, bool> |local| { + do Local::borrow |local: &mut Task| { local.unwinder.unwinding } } @@ -582,7 +582,7 @@ pub fn unkillable<U>(f: &fn() -> U) -> U { unsafe { if in_green_task_context() { // The inhibits/allows might fail and need to borrow the task. - let t = Local::unsafe_borrow::<Task>(); + let t: *mut Task = Local::unsafe_borrow(); do (|| { (*t).death.inhibit_kill((*t).unwinder.unwinding); f() @@ -616,7 +616,7 @@ pub fn rekillable<U>(f: &fn() -> U) -> U { unsafe { if in_green_task_context() { - let t = Local::unsafe_borrow::<Task>(); + let t: *mut Task = Local::unsafe_borrow(); do (|| { (*t).death.allow_kill((*t).unwinder.unwinding); f() @@ -1032,7 +1032,7 @@ fn test_try_fail() { #[cfg(test)] fn get_sched_id() -> int { - do Local::borrow::<::rt::sched::Scheduler, int> |sched| { + do Local::borrow |sched: &mut ::rt::sched::Scheduler| { sched.sched_id() as int } } diff --git a/src/libstd/task/spawn.rs b/src/libstd/task/spawn.rs index 980141d29c3..c3a3dc56ce2 100644 --- a/src/libstd/task/spawn.rs +++ b/src/libstd/task/spawn.rs @@ -449,7 +449,7 @@ impl RuntimeGlue { fn kill_task(mut handle: KillHandle) { do handle.kill().map_move |killed_task| { let killed_task = Cell::new(killed_task); - do Local::borrow::<Scheduler, ()> |sched| { + do Local::borrow |sched: &mut Scheduler| { sched.enqueue_task(killed_task.take()); } }; @@ -460,7 +460,7 @@ impl RuntimeGlue { unsafe { // Can't use safe borrow, because the taskgroup destructor needs to // access the scheduler again to send kill signals to other tasks. - let me = Local::unsafe_borrow::<Task>(); + let me: *mut Task = Local::unsafe_borrow(); blk((*me).death.kill_handle.get_ref(), (*me).unwinder.unwinding) } } @@ -470,7 +470,7 @@ impl RuntimeGlue { unsafe { // Can't use safe borrow, because creating new hashmaps for the // tasksets requires an rng, which needs to borrow the sched. - let me = Local::unsafe_borrow::<Task>(); + let me: *mut Task = Local::unsafe_borrow(); blk(match (*me).taskgroup { None => { // First task in its (unlinked/unsupervised) taskgroup. @@ -574,7 +574,7 @@ pub fn spawn_raw(mut opts: TaskOpts, f: ~fn()) { // If child data is 'None', the enlist is vacuously successful. let enlist_success = do child_data.take().map_move_default(true) |child_data| { let child_data = Cell::new(child_data); // :( - do Local::borrow::<Task, bool> |me| { + do Local::borrow |me: &mut Task| { let (child_tg, ancestors) = child_data.take(); let mut ancestors = ancestors; let handle = me.death.kill_handle.get_ref(); @@ -608,7 +608,7 @@ pub fn spawn_raw(mut opts: TaskOpts, f: ~fn()) { } else { unsafe { // Creating a 1:1 task:thread ... - let sched = Local::unsafe_borrow::<Scheduler>(); + let sched: *mut Scheduler = Local::unsafe_borrow(); let sched_handle = (*sched).make_handle(); // Since this is a 1:1 scheduler we create a queue not in diff --git a/src/libstd/tuple.rs b/src/libstd/tuple.rs index 12073a1f4f0..5d9ca6202e2 100644 --- a/src/libstd/tuple.rs +++ b/src/libstd/tuple.rs @@ -176,7 +176,7 @@ macro_rules! tuple_impls { impl<$($T:Zero),+> Zero for ($($T,)+) { #[inline] fn zero() -> ($($T,)+) { - ($(Zero::zero::<$T>(),)+) + ($({ let x: $T = Zero::zero(); x},)+) } #[inline] fn is_zero(&self) -> bool { diff --git a/src/libstd/unstable/atomics.rs b/src/libstd/unstable/atomics.rs index f286235ca0e..f9380e7ad12 100644 --- a/src/libstd/unstable/atomics.rs +++ b/src/libstd/unstable/atomics.rs @@ -538,7 +538,8 @@ mod test { #[test] fn option_empty() { - assert!(AtomicOption::empty::<()>().is_empty(SeqCst)); + let mut option: AtomicOption<()> = AtomicOption::empty(); + assert!(option.is_empty(SeqCst)); } #[test] diff --git a/src/libstd/unstable/lang.rs b/src/libstd/unstable/lang.rs index e47a3c49f96..1d839b55195 100644 --- a/src/libstd/unstable/lang.rs +++ b/src/libstd/unstable/lang.rs @@ -13,7 +13,7 @@ use c_str::ToCStr; use cast::transmute; use libc::{c_char, c_void, size_t, uintptr_t}; -use option::{Some, None}; +use option::{Option, None, Some}; use sys; use rt::task::Task; use rt::local::Local; @@ -37,7 +37,8 @@ pub fn fail_bounds_check(file: *c_char, line: size_t, #[lang="malloc"] pub unsafe fn local_malloc(td: *c_char, size: uintptr_t) -> *c_char { // XXX: Unsafe borrow for speed. Lame. - match Local::try_unsafe_borrow::<Task>() { + let task: Option<*mut Task> = Local::try_unsafe_borrow(); + match task { Some(task) => { (*task).heap.alloc(td as *c_void, size as uint) as *c_char } diff --git a/src/libstd/unstable/sync.rs b/src/libstd/unstable/sync.rs index cf8ec968e92..8d1545ea2b4 100644 --- a/src/libstd/unstable/sync.rs +++ b/src/libstd/unstable/sync.rs @@ -279,7 +279,8 @@ pub unsafe fn atomically<U>(f: &fn() -> U) -> U { use rt::task::{Task, GreenTask, SchedTask}; use rt::local::Local; - match Local::try_unsafe_borrow::<Task>() { + let task_opt: Option<*mut Task> = Local::try_unsafe_borrow(); + match task_opt { Some(t) => { match (*t).task_type { GreenTask(_) => { diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs index 0a13f1a8a5e..44015a8b443 100644 --- a/src/libsyntax/ast.rs +++ b/src/libsyntax/ast.rs @@ -175,11 +175,15 @@ impl Generics { } #[deriving(Clone, Eq, Encodable, Decodable, IterBytes)] +pub enum MethodProvenance { + FromTrait(def_id), + FromImpl(def_id), +} + +#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)] pub enum def { def_fn(def_id, purity), - def_static_method(/* method */ def_id, - /* trait */ Option<def_id>, - purity), + def_static_method(/* method */ def_id, MethodProvenance, purity), def_self(NodeId), def_self_ty(/* trait id */ NodeId), def_mod(def_id), @@ -716,7 +720,7 @@ impl ToStr for float_ty { } // NB Eq method appears below. -#[deriving(Clone, Eq, Encodable, Decodable,IterBytes)] +#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)] pub struct Ty { id: NodeId, node: ty_, diff --git a/src/libsyntax/ext/build.rs b/src/libsyntax/ext/build.rs index a62a1d121e2..21d67493cbf 100644 --- a/src/libsyntax/ext/build.rs +++ b/src/libsyntax/ext/build.rs @@ -74,6 +74,13 @@ pub trait AstBuilder { // statements fn stmt_expr(&self, expr: @ast::expr) -> @ast::stmt; fn stmt_let(&self, sp: span, mutbl: bool, ident: ast::ident, ex: @ast::expr) -> @ast::stmt; + fn stmt_let_typed(&self, + sp: span, + mutbl: bool, + ident: ast::ident, + typ: ast::Ty, + ex: @ast::expr) + -> @ast::stmt; // blocks fn block(&self, span: span, stmts: ~[@ast::stmt], expr: Option<@ast::expr>) -> ast::Block; @@ -241,8 +248,8 @@ impl AstBuilder for @ExtCtxt { types: ~[ast::Ty]) -> ast::Path { let last_identifier = idents.pop(); - let mut segments: ~[ast::PathSegment] = idents.consume_iter() - .transform(|ident| { + let mut segments: ~[ast::PathSegment] = idents.move_iter() + .map(|ident| { ast::PathSegment { identifier: ident, lifetime: None, @@ -400,6 +407,26 @@ impl AstBuilder for @ExtCtxt { @respan(sp, ast::stmt_decl(@decl, self.next_id())) } + fn stmt_let_typed(&self, + sp: span, + mutbl: bool, + ident: ast::ident, + typ: ast::Ty, + ex: @ast::expr) + -> @ast::stmt { + let pat = self.pat_ident(sp, ident); + let local = @ast::Local { + is_mutbl: mutbl, + ty: typ, + pat: pat, + init: Some(ex), + id: self.next_id(), + span: sp, + }; + let decl = respan(sp, ast::decl_local(local)); + @respan(sp, ast::stmt_decl(@decl, self.next_id())) + } + fn block(&self, span: span, stmts: ~[@ast::stmt], expr: Option<@expr>) -> ast::Block { self.block_all(span, ~[], stmts, expr) } diff --git a/src/libsyntax/ext/deriving/rand.rs b/src/libsyntax/ext/deriving/rand.rs index e55a96f77ff..9f86fe7d7f2 100644 --- a/src/libsyntax/ext/deriving/rand.rs +++ b/src/libsyntax/ext/deriving/rand.rs @@ -76,24 +76,34 @@ fn rand_substructure(cx: @ExtCtxt, span: span, substr: &Substructure) -> @expr { let variant_count = cx.expr_uint(span, variants.len()); - // need to specify the uint-ness of the random number - let uint_ty = cx.ty_ident(span, cx.ident_of("uint")); let r_ty = cx.ty_ident(span, cx.ident_of("R")); let rand_name = cx.path_all(span, true, rand_ident.clone(), None, - ~[ uint_ty, r_ty ]); + ~[]); let rand_name = cx.expr_path(rand_name); - // ::std::rand::Rand::rand::<uint>(rng) + // ::std::rand::Rand::rand(rng) let rv_call = cx.expr_call(span, rand_name, ~[ rng[0].duplicate(cx) ]); + // need to specify the uint-ness of the random number + let uint_ty = cx.ty_ident(span, cx.ident_of("uint")); + let value_ident = cx.ident_of("__value"); + let let_statement = cx.stmt_let_typed(span, + false, + value_ident, + uint_ty, + rv_call); + // rand() % variants.len() - let rand_variant = cx.expr_binary(span, ast::rem, - rv_call, variant_count); + let value_ref = cx.expr_ident(span, value_ident); + let rand_variant = cx.expr_binary(span, + ast::rem, + value_ref, + variant_count); let mut arms = do variants.iter().enumerate().map |(i, id_sum)| { let i_expr = cx.expr_uint(span, i); @@ -111,7 +121,10 @@ fn rand_substructure(cx: @ExtCtxt, span: span, substr: &Substructure) -> @expr { // _ => {} at the end. Should never occur arms.push(cx.arm_unreachable(span)); - cx.expr_match(span, rand_variant, arms) + let match_expr = cx.expr_match(span, rand_variant, arms); + + let block = cx.block(span, ~[ let_statement ], Some(match_expr)); + cx.expr_block(block) } _ => cx.bug("Non-static method in `deriving(Rand)`") }; diff --git a/src/libsyntax/parse/mod.rs b/src/libsyntax/parse/mod.rs index 73e17f551c9..1a7fc558dcd 100644 --- a/src/libsyntax/parse/mod.rs +++ b/src/libsyntax/parse/mod.rs @@ -399,8 +399,8 @@ mod test { types: ~[], } ] - }, - span: sp(0, 6)) + }), + span: sp(0, 6) }) } diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs index 0882a5e3143..8ca858b7935 100644 --- a/src/libsyntax/parse/parser.rs +++ b/src/libsyntax/parse/parser.rs @@ -1374,7 +1374,7 @@ impl Parser { _ => None, }; match found { - Some(INTERPOLATED(token::nt_path(path))) => { + Some(INTERPOLATED(token::nt_path(~path))) => { return PathAndBounds { path: path, bounds: None, @@ -1483,7 +1483,7 @@ impl Parser { let mut path_segments = ~[]; let mut bounds = None; let last_segment_index = segments.len() - 1; - for (i, segment_and_bounds) in segments.consume_iter().enumerate() { + for (i, segment_and_bounds) in segments.move_iter().enumerate() { let PathSegmentAndBoundSet { segment: segment, bound_set: bound_set @@ -4840,7 +4840,7 @@ impl Parser { let path = ast::Path { span: mk_sp(lo, self.span.hi), global: false, - segments: path.consume_iter().transform(|identifier| { + segments: path.move_iter().map(|identifier| { ast::PathSegment { identifier: identifier, lifetime: None, @@ -4876,7 +4876,7 @@ impl Parser { let path = ast::Path { span: mk_sp(lo, self.span.hi), global: false, - segments: path.consume_iter().transform(|identifier| { + segments: path.move_iter().map(|identifier| { ast::PathSegment { identifier: identifier, lifetime: None, @@ -4894,7 +4894,7 @@ impl Parser { let path = ast::Path { span: mk_sp(lo, self.span.hi), global: false, - segments: path.consume_iter().transform(|identifier| { + segments: path.move_iter().map(|identifier| { ast::PathSegment { identifier: identifier, lifetime: None, @@ -4916,7 +4916,7 @@ impl Parser { let path = ast::Path { span: mk_sp(lo, self.span.hi), global: false, - segments: path.consume_iter().transform(|identifier| { + segments: path.move_iter().map(|identifier| { ast::PathSegment { identifier: identifier, lifetime: None, diff --git a/src/libsyntax/visit.rs b/src/libsyntax/visit.rs index ef44a368ab5..e5b7823ae44 100644 --- a/src/libsyntax/visit.rs +++ b/src/libsyntax/visit.rs @@ -320,7 +320,7 @@ pub fn walk_ty<E:Clone, V:Visitor<E>>(visitor: &mut V, typ: &Ty, env: E) { pub fn walk_path<E:Clone, V:Visitor<E>>(visitor: &mut V, path: &Path, env: E) { for segment in path.segments.iter() { - for typ in path.types.iter() { + for typ in segment.types.iter() { visitor.visit_ty(typ, env.clone()) } } diff --git a/src/test/compile-fail/bad-mid-path-type-params.rs b/src/test/compile-fail/bad-mid-path-type-params.rs new file mode 100644 index 00000000000..e4833345d31 --- /dev/null +++ b/src/test/compile-fail/bad-mid-path-type-params.rs @@ -0,0 +1,37 @@ +#[no_std]; + +struct S<T> { + contents: T, +} + +impl<T> S<T> { + fn new<U>(x: T, _: U) -> S<T> { + S { + contents: x, + } + } +} + +trait Trait<T> { + fn new<U>(x: T, y: U) -> Self; +} + +struct S2 { + contents: int, +} + +impl Trait<int> for S2 { + fn new<U>(x: int, _: U) -> S2 { + S2 { + contents: x, + } + } +} + +fn main() { + let _ = S::new::<int,float>(1, 1.0); //~ ERROR the impl referenced by this path has 1 type parameter, but 0 type parameters were supplied + let _ = S::<'self,int>::new::<float>(1, 1.0); //~ ERROR this impl has no lifetime parameter + let _: S2 = Trait::new::<int,float>(1, 1.0); //~ ERROR the trait referenced by this path has 1 type parameter, but 0 type parameters were supplied + let _: S2 = Trait::<'self,int>::new::<float>(1, 1.0); //~ ERROR this trait has no lifetime parameter +} + diff --git a/src/test/compile-fail/issue-4096.rs b/src/test/compile-fail/issue-4096.rs deleted file mode 100644 index 3f1172b6de8..00000000000 --- a/src/test/compile-fail/issue-4096.rs +++ /dev/null @@ -1,22 +0,0 @@ -// Copyright 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. - -pub trait Nummy { - fn from_inty<T>() -> Self; -} - -impl Nummy for float { - fn from_inty<T>() -> float { 0.0 } -} - -fn main() { - let _1:float = Nummy::from_inty::<int>(); //~ ERROR not enough type - //~^ NOTE Static methods have an extra implicit type parameter -} diff --git a/src/test/compile-fail/prim-with-args.rs b/src/test/compile-fail/prim-with-args.rs index 40d5a441241..e60fbf4fc49 100644 --- a/src/test/compile-fail/prim-with-args.rs +++ b/src/test/compile-fail/prim-with-args.rs @@ -23,17 +23,17 @@ let x: u64<int>; //~ ERROR type parameters are not allowed on this type let x: float<int>; //~ ERROR type parameters are not allowed on this type let x: char<int>; //~ ERROR type parameters are not allowed on this type -let x: int<'static>; //~ ERROR region parameters are not allowed on this type -let x: i8<'static>; //~ ERROR region parameters are not allowed on this type -let x: i16<'static>; //~ ERROR region parameters are not allowed on this type -let x: i32<'static>; //~ ERROR region parameters are not allowed on this type -let x: i64<'static>; //~ ERROR region parameters are not allowed on this type -let x: uint<'static>; //~ ERROR region parameters are not allowed on this type -let x: u8<'static>; //~ ERROR region parameters are not allowed on this type -let x: u16<'static>; //~ ERROR region parameters are not allowed on this type -let x: u32<'static>; //~ ERROR region parameters are not allowed on this type -let x: u64<'static>; //~ ERROR region parameters are not allowed on this type -let x: float<'static>; //~ ERROR region parameters are not allowed on this type -let x: char<'static>; //~ ERROR region parameters are not allowed on this type +let x: int<'static>; //~ ERROR lifetime parameters are not allowed on this type +let x: i8<'static>; //~ ERROR lifetime parameters are not allowed on this type +let x: i16<'static>; //~ ERROR lifetime parameters are not allowed on this type +let x: i32<'static>; //~ ERROR lifetime parameters are not allowed on this type +let x: i64<'static>; //~ ERROR lifetime parameters are not allowed on this type +let x: uint<'static>; //~ ERROR lifetime parameters are not allowed on this type +let x: u8<'static>; //~ ERROR lifetime parameters are not allowed on this type +let x: u16<'static>; //~ ERROR lifetime parameters are not allowed on this type +let x: u32<'static>; //~ ERROR lifetime parameters are not allowed on this type +let x: u64<'static>; //~ ERROR lifetime parameters are not allowed on this type +let x: float<'static>; //~ ERROR lifetime parameters are not allowed on this type +let x: char<'static>; //~ ERROR lifetime parameters are not allowed on this type } diff --git a/src/test/compile-fail/regions-bounds.rs b/src/test/compile-fail/regions-bounds.rs index ab2ac6cc0e5..ab365c1bf6f 100644 --- a/src/test/compile-fail/regions-bounds.rs +++ b/src/test/compile-fail/regions-bounds.rs @@ -25,8 +25,4 @@ fn a_fn3<'a,'b>(e: a_class<'a>) -> a_class<'b> { //~^ ERROR cannot infer an appropriate lifetime } -fn a_fn4<'a,'b>() { - let _: int<'a> = 1; //~ ERROR region parameters are not allowed on this type -} - fn main() { } diff --git a/src/test/compile-fail/static-method-privacy.rs b/src/test/compile-fail/static-method-privacy.rs index 0fd82b5ace3..b637037f60e 100644 --- a/src/test/compile-fail/static-method-privacy.rs +++ b/src/test/compile-fail/static-method-privacy.rs @@ -6,5 +6,5 @@ mod a { } fn main() { - let _ = a::S::new(); //~ ERROR function `new` is private + let _ = a::S::new(); //~ ERROR method `new` is private } diff --git a/src/test/run-pass/borrowck-pat-enum.rs b/src/test/run-pass/borrowck-pat-enum.rs index 6c00bea28b6..f320de39c8c 100644 --- a/src/test/run-pass/borrowck-pat-enum.rs +++ b/src/test/run-pass/borrowck-pat-enum.rs @@ -1,3 +1,5 @@ +// xfail-pretty + // Copyright 2012 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. diff --git a/src/test/run-pass/deriving-zero.rs b/src/test/run-pass/deriving-zero.rs index 21956ac24ee..aba23e53282 100644 --- a/src/test/run-pass/deriving-zero.rs +++ b/src/test/run-pass/deriving-zero.rs @@ -36,5 +36,6 @@ struct Lots { } fn main() { - assert!(Zero::zero::<Lots>().is_zero()); + let lots: Lots = Zero::zero(); + assert!(lots.is_zero()); } diff --git a/src/test/run-pass/float-nan.rs b/src/test/run-pass/float-nan.rs index 29a180db185..d59b8c77d00 100644 --- a/src/test/run-pass/float-nan.rs +++ b/src/test/run-pass/float-nan.rs @@ -13,11 +13,12 @@ extern mod extra; use std::num::Float; pub fn main() { - let nan = Float::NaN::<float>(); + let nan: float = Float::NaN(); assert!((nan).is_NaN()); - let inf = Float::infinity::<float>(); - assert_eq!(-inf, Float::neg_infinity::<float>()); + let inf: float = Float::infinity(); + let neg_inf: float = Float::neg_infinity(); + assert_eq!(-inf, neg_inf); assert!( nan != nan); assert!( nan != -nan); diff --git a/src/test/run-pass/mid-path-type-params.rs b/src/test/run-pass/mid-path-type-params.rs index 8f01bd5e5ea..1bc37a035e0 100644 --- a/src/test/run-pass/mid-path-type-params.rs +++ b/src/test/run-pass/mid-path-type-params.rs @@ -10,7 +10,24 @@ impl<T> S<T> { } } +trait Trait<T> { + fn new<U>(x: T, y: U) -> Self; +} + +struct S2 { + contents: int, +} + +impl Trait<int> for S2 { + fn new<U>(x: int, _: U) -> S2 { + S2 { + contents: x, + } + } +} + fn main() { let _ = S::<int>::new::<float>(1, 1.0); + let _: S2 = Trait::<int>::new::<float>(1, 1.0); } diff --git a/src/test/run-pass/trait-default-method-xc.rs b/src/test/run-pass/trait-default-method-xc.rs index 0c334909b25..baf4cf45b3c 100644 --- a/src/test/run-pass/trait-default-method-xc.rs +++ b/src/test/run-pass/trait-default-method-xc.rs @@ -59,7 +59,7 @@ fn main () { assert_eq!(0i.thing(3.14, 1), (3.14, 1)); assert_eq!(B::staticthing(&0i, 3.14, 1), (3.14, 1)); - assert_eq!(B::staticthing::<float, int, int>(&0i, 3.14, 1), (3.14, 1)); + assert_eq!(B::<float>::staticthing::<int>(&0i, 3.14, 1), (3.14, 1)); assert_eq!(g(0i, 3.14, 1), (3.14, 1)); assert_eq!(g(false, 3.14, 1), (3.14, 1)); diff --git a/src/test/run-pass/trait-static-method-overwriting.rs b/src/test/run-pass/trait-static-method-overwriting.rs index e95b80447e4..5ac26e65d88 100644 --- a/src/test/run-pass/trait-static-method-overwriting.rs +++ b/src/test/run-pass/trait-static-method-overwriting.rs @@ -14,7 +14,7 @@ mod base { use std::io; pub trait HasNew<T> { - fn new() -> T; + fn new() -> Self; } pub struct Foo { @@ -41,6 +41,6 @@ mod base { } pub fn main() { - let _f: base::Foo = base::HasNew::new::<base::Foo, base::Foo>(); - let _b: base::Bar = base::HasNew::new::<base::Bar, base::Bar>(); + let _f: base::Foo = base::HasNew::<base::Foo>::new(); + let _b: base::Bar = base::HasNew::<base::Bar>::new(); } |