From 5dd001b2fc06526222c89a8563b25e4850646c15 Mon Sep 17 00:00:00 2001 From: Vadim Chugunov Date: Mon, 23 Feb 2015 22:47:56 -0800 Subject: Fix overflow in precise_time_ns() on Windows, which starts happening after ~2 hours of machine uptime. --- src/libstd/sys/windows/time.rs | 27 +++++++++++++++++++++++++-- 1 file changed, 25 insertions(+), 2 deletions(-) (limited to 'src/libstd') diff --git a/src/libstd/sys/windows/time.rs b/src/libstd/sys/windows/time.rs index 20ceff0aa69..209460df10b 100644 --- a/src/libstd/sys/windows/time.rs +++ b/src/libstd/sys/windows/time.rs @@ -12,6 +12,8 @@ use ops::Sub; use time::Duration; use sync::{Once, ONCE_INIT}; +const NANOS_PER_SEC: i64 = 1_000_000_000; + pub struct SteadyTime { t: libc::LARGE_INTEGER, } @@ -24,7 +26,7 @@ impl SteadyTime { } pub fn ns(&self) -> u64 { - self.t as u64 * 1_000_000_000 / frequency() as u64 + mul_div_i64(self.t as i64, NANOS_PER_SEC, frequency() as i64) as u64 } } @@ -45,6 +47,27 @@ impl<'a> Sub for &'a SteadyTime { fn sub(self, other: &SteadyTime) -> Duration { let diff = self.t as i64 - other.t as i64; - Duration::microseconds(diff * 1_000_000 / frequency() as i64) + Duration::nanoseconds(mul_div_i64(diff, NANOS_PER_SEC, frequency() as i64)) } } + +// Computes (value*numer)/denom without overflow, as long as both +// (numer*denom) and the overall result fit into i64 (which is the case +// for our time conversions). +fn mul_div_i64(value: i64, numer: i64, denom: i64) -> i64 { + let q = value / denom; + let r = value % denom; + // Decompose value as (value/denom*denom + value%denom), + // substitute into (value*numer)/denom and simplify. + // r < denom, so (denom*numer) is the upper bound of (r*numer) + q * numer + r * numer / denom +} + +#[test] +fn test_muldiv() { + assert_eq!(mul_div_i64( 1_000_000_000_001, 1_000_000_000, 1_000_000), 1_000_000_000_001_000); + assert_eq!(mul_div_i64(-1_000_000_000_001, 1_000_000_000, 1_000_000), -1_000_000_000_001_000); + assert_eq!(mul_div_i64(-1_000_000_000_001,-1_000_000_000, 1_000_000), 1_000_000_000_001_000); + assert_eq!(mul_div_i64( 1_000_000_000_001, 1_000_000_000,-1_000_000), -1_000_000_000_001_000); + assert_eq!(mul_div_i64( 1_000_000_000_001,-1_000_000_000,-1_000_000), 1_000_000_000_001_000); +} -- cgit 1.4.1-3-g733a5 From 8b2ff472cf0d1e348cc369e2e2927dc552582b32 Mon Sep 17 00:00:00 2001 From: Tshepang Lekhonkhobe Date: Wed, 25 Feb 2015 08:20:34 +0200 Subject: remove some compiler warnings --- src/libcollections/slice.rs | 4 ++-- src/libcollections/vec.rs | 4 ++-- src/libcoretest/slice.rs | 6 +++--- src/librustc/middle/astconv_util.rs | 3 +-- src/librustc_resolve/lib.rs | 2 +- src/libserialize/json.rs | 2 -- src/libstd/io/cursor.rs | 12 ++++++------ src/libsyntax/ast_util.rs | 8 ++++---- src/rustbook/book.rs | 8 ++++---- 9 files changed, 23 insertions(+), 26 deletions(-) (limited to 'src/libstd') diff --git a/src/libcollections/slice.rs b/src/libcollections/slice.rs index d4c53739686..a2924f8fe53 100644 --- a/src/libcollections/slice.rs +++ b/src/libcollections/slice.rs @@ -2663,7 +2663,7 @@ mod tests { let (left, right) = values.split_at_mut(2); { let left: &[_] = left; - assert!(left[..left.len()] == [1, 2][]); + assert!(left[..left.len()] == [1, 2]); } for p in left { *p += 1; @@ -2671,7 +2671,7 @@ mod tests { { let right: &[_] = right; - assert!(right[..right.len()] == [3, 4, 5][]); + assert!(right[..right.len()] == [3, 4, 5]); } for p in right { *p += 2; diff --git a/src/libcollections/vec.rs b/src/libcollections/vec.rs index 6d4541b5bde..c43c6c739d9 100644 --- a/src/libcollections/vec.rs +++ b/src/libcollections/vec.rs @@ -2090,7 +2090,7 @@ mod tests { let (left, right) = values.split_at_mut(2); { let left: &[_] = left; - assert!(&left[..left.len()] == &[1, 2][]); + assert!(&left[..left.len()] == &[1, 2]); } for p in left { *p += 1; @@ -2098,7 +2098,7 @@ mod tests { { let right: &[_] = right; - assert!(&right[..right.len()] == &[3, 4, 5][]); + assert!(&right[..right.len()] == &[3, 4, 5]); } for p in right { *p += 2; diff --git a/src/libcoretest/slice.rs b/src/libcoretest/slice.rs index 46c7730cc64..fe73b3b4407 100644 --- a/src/libcoretest/slice.rs +++ b/src/libcoretest/slice.rs @@ -59,16 +59,16 @@ fn iterator_to_slice() { let mut iter = data.iter_mut(); assert_eq!(&iter[..], &other_data[..]); // mutability: - assert!(&mut iter[] == other_data); + assert!(&mut iter[..] == other_data); iter.next(); assert_eq!(&iter[..], &other_data[1..]); - assert!(&mut iter[] == &mut other_data[1..]); + assert!(&mut iter[..] == &mut other_data[1..]); iter.next_back(); assert_eq!(&iter[..], &other_data[1..2]); - assert!(&mut iter[] == &mut other_data[1..2]); + assert!(&mut iter[..] == &mut other_data[1..2]); let s = iter.into_slice(); assert!(s == &mut other_data[1..2]); diff --git a/src/librustc/middle/astconv_util.rs b/src/librustc/middle/astconv_util.rs index 17fd80ceaea..0f98b3c33fb 100644 --- a/src/librustc/middle/astconv_util.rs +++ b/src/librustc/middle/astconv_util.rs @@ -68,7 +68,7 @@ pub fn ast_ty_to_prim_ty<'tcx>(tcx: &ty::ctxt<'tcx>, ast_ty: &ast::Ty) Some(d) => d.full_def() }; if let def::DefPrimTy(nty) = def { - Some(prim_ty_to_ty(tcx, &path.segments[], nty)) + Some(prim_ty_to_ty(tcx, &path.segments, nty)) } else { None } @@ -76,4 +76,3 @@ pub fn ast_ty_to_prim_ty<'tcx>(tcx: &ty::ctxt<'tcx>, ast_ty: &ast::Ty) None } } - diff --git a/src/librustc_resolve/lib.rs b/src/librustc_resolve/lib.rs index 95523be68c3..78ce9abe07d 100644 --- a/src/librustc_resolve/lib.rs +++ b/src/librustc_resolve/lib.rs @@ -2985,7 +2985,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { } else { let msg = format!("use of undeclared trait name `{}`", self.path_names_to_string(trait_path, path_depth)); - self.resolve_error(trait_path.span, &msg[]); + self.resolve_error(trait_path.span, &msg); Err(()) } } diff --git a/src/libserialize/json.rs b/src/libserialize/json.rs index 05d4e0f59fe..14930f91c91 100644 --- a/src/libserialize/json.rs +++ b/src/libserialize/json.rs @@ -3945,9 +3945,7 @@ mod tests { #[test] fn test_encode_hashmap_with_arbitrary_key() { - use std::old_io::Writer; use std::collections::HashMap; - use std::fmt; #[derive(PartialEq, Eq, Hash, RustcEncodable)] struct ArbitraryType(uint); let mut hm: HashMap = HashMap::new(); diff --git a/src/libstd/io/cursor.rs b/src/libstd/io/cursor.rs index f6cb4a8c9f3..b1779587528 100644 --- a/src/libstd/io/cursor.rs +++ b/src/libstd/io/cursor.rs @@ -173,7 +173,7 @@ mod tests { assert_eq!(writer.write(&[1, 2, 3]), Ok(3)); assert_eq!(writer.write(&[4, 5, 6, 7]), Ok(4)); let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7]; - assert_eq!(&writer.get_ref()[], b); + assert_eq!(&writer.get_ref()[..], b); } #[test] @@ -369,28 +369,28 @@ mod tests { assert_eq!(writer.write(&[4, 5, 6, 7]), Ok(4)); assert_eq!(writer.position(), 8); let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7]; - assert_eq!(&writer.get_ref()[], b); + assert_eq!(&writer.get_ref()[..], b); assert_eq!(writer.seek(SeekFrom::Start(0)), Ok(0)); assert_eq!(writer.position(), 0); assert_eq!(writer.write(&[3, 4]), Ok(2)); let b: &[_] = &[3, 4, 2, 3, 4, 5, 6, 7]; - assert_eq!(&writer.get_ref()[], b); + assert_eq!(&writer.get_ref()[..], b); assert_eq!(writer.seek(SeekFrom::Current(1)), Ok(3)); assert_eq!(writer.write(&[0, 1]), Ok(2)); let b: &[_] = &[3, 4, 2, 0, 1, 5, 6, 7]; - assert_eq!(&writer.get_ref()[], b); + assert_eq!(&writer.get_ref()[..], b); assert_eq!(writer.seek(SeekFrom::End(-1)), Ok(7)); assert_eq!(writer.write(&[1, 2]), Ok(2)); let b: &[_] = &[3, 4, 2, 0, 1, 5, 6, 1, 2]; - assert_eq!(&writer.get_ref()[], b); + assert_eq!(&writer.get_ref()[..], b); assert_eq!(writer.seek(SeekFrom::End(1)), Ok(10)); assert_eq!(writer.write(&[1]), Ok(1)); let b: &[_] = &[3, 4, 2, 0, 1, 5, 6, 1, 2, 0, 1]; - assert_eq!(&writer.get_ref()[], b); + assert_eq!(&writer.get_ref()[..], b); } #[test] diff --git a/src/libsyntax/ast_util.rs b/src/libsyntax/ast_util.rs index 79f0433761d..264e05f5c8d 100644 --- a/src/libsyntax/ast_util.rs +++ b/src/libsyntax/ast_util.rs @@ -760,13 +760,13 @@ mod test { #[test] fn idents_name_eq_test() { assert!(segments_name_eq( &[Ident{name:Name(3),ctxt:4}, Ident{name:Name(78),ctxt:82}] - .iter().map(ident_to_segment).collect::>()[], + .iter().map(ident_to_segment).collect::>(), &[Ident{name:Name(3),ctxt:104}, Ident{name:Name(78),ctxt:182}] - .iter().map(ident_to_segment).collect::>()[])); + .iter().map(ident_to_segment).collect::>())); assert!(!segments_name_eq( &[Ident{name:Name(3),ctxt:4}, Ident{name:Name(78),ctxt:82}] - .iter().map(ident_to_segment).collect::>()[], + .iter().map(ident_to_segment).collect::>(), &[Ident{name:Name(3),ctxt:104}, Ident{name:Name(77),ctxt:182}] - .iter().map(ident_to_segment).collect::>()[])); + .iter().map(ident_to_segment).collect::>())); } } diff --git a/src/rustbook/book.rs b/src/rustbook/book.rs index 3c116aa860b..8900b60d191 100644 --- a/src/rustbook/book.rs +++ b/src/rustbook/book.rs @@ -114,12 +114,12 @@ pub fn parse_summary(input: R, src: &Path) -> Result i, None => continue }; + let star_idx = match line.find("*") { Some(i) => i, None => continue }; - let start_bracket = star_idx + line[star_idx..].find_str("[").unwrap(); - let end_bracket = start_bracket + line[start_bracket..].find_str("](").unwrap(); + let start_bracket = star_idx + line[star_idx..].find("[").unwrap(); + let end_bracket = start_bracket + line[start_bracket..].find("](").unwrap(); let start_paren = end_bracket + 1; - let end_paren = start_paren + line[start_paren..].find_str(")").unwrap(); + let end_paren = start_paren + line[start_paren..].find(")").unwrap(); let given_path = &line[start_paren + 1 .. end_paren]; let title = line[start_bracket + 1..end_bracket].to_string(); -- cgit 1.4.1-3-g733a5 From 19cb8f32d894719ece5b2308dabab45be1b94fcf Mon Sep 17 00:00:00 2001 From: Huon Wilson Date: Wed, 25 Feb 2015 22:34:21 +1100 Subject: Check stability of struct fields. We were recording stability attributes applied to fields in the compiler, and even annotating it in the libs, but the compiler didn't actually do the checks to give errors/warnings in user crates. --- src/librustc/lint/builtin.rs | 5 + src/librustc/middle/stability.rs | 121 +++++++++ src/librustc/middle/ty.rs | 3 + src/libstd/old_io/mem.rs | 1 + src/test/auxiliary/lint_stability.rs | 24 +- src/test/auxiliary/lint_stability_fields.rs | 60 +++++ src/test/compile-fail/lint-stability-fields.rs | 346 +++++++++++++++++++++++++ src/test/compile-fail/lint-stability.rs | 12 +- 8 files changed, 561 insertions(+), 11 deletions(-) create mode 100644 src/test/auxiliary/lint_stability_fields.rs create mode 100644 src/test/compile-fail/lint-stability-fields.rs (limited to 'src/libstd') diff --git a/src/librustc/lint/builtin.rs b/src/librustc/lint/builtin.rs index a4f69e651df..0bd7f83b959 100644 --- a/src/librustc/lint/builtin.rs +++ b/src/librustc/lint/builtin.rs @@ -1771,6 +1771,11 @@ impl LintPass for Stability { stability::check_path(cx.tcx, path, id, &mut |id, sp, stab| self.lint(cx, id, sp, stab)); } + + fn check_pat(&mut self, cx: &Context, pat: &ast::Pat) { + stability::check_pat(cx.tcx, pat, + &mut |id, sp, stab| self.lint(cx, id, sp, stab)) + } } declare_lint! { diff --git a/src/librustc/middle/stability.rs b/src/librustc/middle/stability.rs index f67e470ee54..ddac6cc7514 100644 --- a/src/librustc/middle/stability.rs +++ b/src/librustc/middle/stability.rs @@ -58,8 +58,10 @@ impl<'a> Annotator<'a> { attrs: &Vec, item_sp: Span, f: F, required: bool) where F: FnOnce(&mut Annotator), { + debug!("annotate(id = {:?}, attrs = {:?})", id, attrs); match attr::find_stability(self.sess.diagnostic(), attrs, item_sp) { Some(stab) => { + debug!("annotate: found {:?}", stab); self.index.local.insert(id, stab.clone()); // Don't inherit #[stable(feature = "rust1", since = "1.0.0")] @@ -72,6 +74,8 @@ impl<'a> Annotator<'a> { } } None => { + debug!("annotate: not found, use_parent = {:?}, parent = {:?}", + use_parent, self.parent); if use_parent { if let Some(stab) = self.parent.clone() { self.index.local.insert(id, stab); @@ -299,6 +303,12 @@ impl<'a, 'v, 'tcx> Visitor<'v> for Checker<'a, 'tcx> { &mut |id, sp, stab| self.check(id, sp, stab)); visit::walk_path(self, path) } + + fn visit_pat(&mut self, pat: &ast::Pat) { + check_pat(self.tcx, pat, + &mut |id, sp, stab| self.check(id, sp, stab)); + visit::walk_pat(self, pat) + } } /// Helper for discovering nodes to check for stability @@ -385,6 +395,76 @@ pub fn check_expr(tcx: &ty::ctxt, e: &ast::Expr, None => return } } + ast::ExprField(ref base_e, ref field) => { + span = field.span; + match ty::expr_ty_adjusted(tcx, base_e).sty { + ty::ty_struct(did, _) => { + ty::lookup_struct_fields(tcx, did) + .iter() + .find(|f| f.name == field.node.name) + .unwrap_or_else(|| { + tcx.sess.span_bug(field.span, + "stability::check_expr: unknown named field access") + }) + .id + } + _ => tcx.sess.span_bug(e.span, + "stability::check_expr: named field access on non-struct") + } + } + ast::ExprTupField(ref base_e, ref field) => { + span = field.span; + match ty::expr_ty_adjusted(tcx, base_e).sty { + ty::ty_struct(did, _) => { + ty::lookup_struct_fields(tcx, did) + .get(field.node) + .unwrap_or_else(|| { + tcx.sess.span_bug(field.span, + "stability::check_expr: unknown unnamed field access") + }) + .id + } + ty::ty_tup(..) => return, + _ => tcx.sess.span_bug(e.span, + "stability::check_expr: unnamed field access on \ + something other than a tuple or struct") + } + } + ast::ExprStruct(_, ref expr_fields, _) => { + let type_ = ty::expr_ty(tcx, e); + match type_.sty { + ty::ty_struct(did, _) => { + let struct_fields = ty::lookup_struct_fields(tcx, did); + // check the stability of each field that appears + // in the construction expression. + for field in expr_fields { + let did = struct_fields + .iter() + .find(|f| f.name == field.ident.node.name) + .unwrap_or_else(|| { + tcx.sess.span_bug(field.span, + "stability::check_expr: unknown named \ + field access") + }) + .id; + maybe_do_stability_check(tcx, did, field.span, cb); + } + + // we're done. + return + } + // we don't look at stability attributes on + // struct-like enums (yet...), but it's definitely not + // a bug to have construct one. + ty::ty_enum(..) => return, + _ => { + tcx.sess.span_bug(e.span, + &format!("stability::check_expr: struct construction \ + of non-struct, type {:?}", + type_.repr(tcx))); + } + } + } _ => return }; @@ -403,6 +483,47 @@ pub fn check_path(tcx: &ty::ctxt, path: &ast::Path, id: ast::NodeId, } +pub fn check_pat(tcx: &ty::ctxt, pat: &ast::Pat, + cb: &mut FnMut(ast::DefId, Span, &Option)) { + debug!("check_pat(pat = {:?})", pat); + if is_internal(tcx, pat.span) { return; } + + let did = match ty::pat_ty_opt(tcx, pat) { + Some(&ty::TyS { sty: ty::ty_struct(did, _), .. }) => did, + Some(_) | None => return, + }; + let struct_fields = ty::lookup_struct_fields(tcx, did); + match pat.node { + // Foo(a, b, c) + ast::PatEnum(_, Some(ref pat_fields)) => { + for (field, struct_field) in pat_fields.iter().zip(struct_fields.iter()) { + // a .. pattern is fine, but anything positional is + // not. + if let ast::PatWild(ast::PatWildMulti) = field.node { + continue + } + maybe_do_stability_check(tcx, struct_field.id, field.span, cb) + } + } + // Foo { a, b, c } + ast::PatStruct(_, ref pat_fields, _) => { + for field in pat_fields { + let did = struct_fields + .iter() + .find(|f| f.name == field.node.ident.name) + .unwrap_or_else(|| { + tcx.sess.span_bug(field.span, + "stability::check_pat: unknown named field access") + }) + .id; + maybe_do_stability_check(tcx, did, field.span, cb); + } + } + // everything else is fine. + _ => {} + } +} + fn maybe_do_stability_check(tcx: &ty::ctxt, id: ast::DefId, span: Span, cb: &mut FnMut(ast::DefId, Span, &Option)) { if !is_staged_api(tcx, id) { return } diff --git a/src/librustc/middle/ty.rs b/src/librustc/middle/ty.rs index 78b8d4f7b1e..17ac7605741 100644 --- a/src/librustc/middle/ty.rs +++ b/src/librustc/middle/ty.rs @@ -4298,6 +4298,9 @@ pub fn free_region_from_def(outlives_extent: region::DestructionScopeData, pub fn pat_ty<'tcx>(cx: &ctxt<'tcx>, pat: &ast::Pat) -> Ty<'tcx> { return node_id_to_type(cx, pat.id); } +pub fn pat_ty_opt<'tcx>(cx: &ctxt<'tcx>, pat: &ast::Pat) -> Option> { + return node_id_to_type_opt(cx, pat.id); +} // Returns the type of an expression as a monotype. diff --git a/src/libstd/old_io/mem.rs b/src/libstd/old_io/mem.rs index c08a2c1f477..e6a8b90ea33 100644 --- a/src/libstd/old_io/mem.rs +++ b/src/libstd/old_io/mem.rs @@ -102,6 +102,7 @@ impl MemWriter { impl Writer for MemWriter { #[inline] + #[allow(deprecated)] fn write_all(&mut self, buf: &[u8]) -> IoResult<()> { self.buf.push_all(buf); Ok(()) diff --git a/src/test/auxiliary/lint_stability.rs b/src/test/auxiliary/lint_stability.rs index fb535eb8336..d47575403e1 100644 --- a/src/test/auxiliary/lint_stability.rs +++ b/src/test/auxiliary/lint_stability.rs @@ -100,14 +100,22 @@ pub trait UnstableTrait { fn dummy(&self) { } } #[stable(feature = "test_feature", since = "1.0.0")] #[deprecated(since = "1.0.0")] -pub struct DeprecatedStruct { pub i: int } +pub struct DeprecatedStruct { + #[stable(feature = "test_feature", since = "1.0.0")] pub i: int +} #[unstable(feature = "test_feature")] #[deprecated(since = "1.0.0")] -pub struct DeprecatedUnstableStruct { pub i: int } +pub struct DeprecatedUnstableStruct { + #[stable(feature = "test_feature", since = "1.0.0")] pub i: int +} #[unstable(feature = "test_feature")] -pub struct UnstableStruct { pub i: int } +pub struct UnstableStruct { + #[stable(feature = "test_feature", since = "1.0.0")] pub i: int +} #[stable(feature = "rust1", since = "1.0.0")] -pub struct StableStruct { pub i: int } +pub struct StableStruct { + #[stable(feature = "test_feature", since = "1.0.0")] pub i: int +} #[stable(feature = "test_feature", since = "1.0.0")] #[deprecated(since = "1.0.0")] @@ -137,14 +145,14 @@ pub enum Enum { #[stable(feature = "test_feature", since = "1.0.0")] #[deprecated(since = "1.0.0")] -pub struct DeprecatedTupleStruct(pub int); +pub struct DeprecatedTupleStruct(#[stable(feature = "rust1", since = "1.0.0")] pub int); #[unstable(feature = "test_feature")] #[deprecated(since = "1.0.0")] -pub struct DeprecatedUnstableTupleStruct(pub int); +pub struct DeprecatedUnstableTupleStruct(#[stable(feature = "rust1", since = "1.0.0")] pub int); #[unstable(feature = "test_feature")] -pub struct UnstableTupleStruct(pub int); +pub struct UnstableTupleStruct(#[stable(feature = "rust1", since = "1.0.0")] pub int); #[stable(feature = "rust1", since = "1.0.0")] -pub struct StableTupleStruct(pub int); +pub struct StableTupleStruct(#[stable(feature = "rust1", since = "1.0.0")] pub int); #[macro_export] macro_rules! macro_test { diff --git a/src/test/auxiliary/lint_stability_fields.rs b/src/test/auxiliary/lint_stability_fields.rs new file mode 100644 index 00000000000..66940ee0081 --- /dev/null +++ b/src/test/auxiliary/lint_stability_fields.rs @@ -0,0 +1,60 @@ +// Copyright 2015 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +#![feature(staged_api)] +#![staged_api] +#![stable(feature = "rust1", since = "1.0.0")] + +#[stable(feature = "rust1", since = "1.0.0")] +pub struct Stable { + #[stable(feature = "rust1", since = "1.0.0")] + pub inherit: u8, // it's a lie (stable doesn't inherit) + #[unstable(feature = "test_feature")] + pub override1: u8, + #[deprecated(since = "1.0.0")] + #[unstable(feature = "test_feature")] + pub override2: u8, +} + +#[stable(feature = "rust1", since = "1.0.0")] +pub struct Stable2(#[stable(feature = "rust1", since = "1.0.0")] pub u8, + #[unstable(feature = "test_feature")] pub u8, + #[unstable(feature = "test_feature")] #[deprecated(since = "1.0.0")] pub u8); + +#[unstable(feature = "test_feature")] +pub struct Unstable { + pub inherit: u8, + #[stable(feature = "rust1", since = "1.0.0")] + pub override1: u8, + #[deprecated(since = "1.0.0")] + #[unstable(feature = "test_feature")] + pub override2: u8, +} + +#[unstable(feature = "test_feature")] +pub struct Unstable2(pub u8, + #[stable(feature = "rust1", since = "1.0.0")] pub u8, + #[unstable(feature = "test_feature")] #[deprecated(since = "1.0.0")] pub u8); + +#[unstable(feature = "test_feature")] +#[deprecated(feature = "rust1", since = "1.0.0")] +pub struct Deprecated { + pub inherit: u8, + #[stable(feature = "rust1", since = "1.0.0")] + pub override1: u8, + #[unstable(feature = "test_feature")] + pub override2: u8, +} + +#[unstable(feature = "test_feature")] +#[deprecated(feature = "rust1", since = "1.0.0")] +pub struct Deprecated2(pub u8, + #[stable(feature = "rust1", since = "1.0.0")] pub u8, + #[unstable(feature = "test_feature")] pub u8); diff --git a/src/test/compile-fail/lint-stability-fields.rs b/src/test/compile-fail/lint-stability-fields.rs new file mode 100644 index 00000000000..c43ff198925 --- /dev/null +++ b/src/test/compile-fail/lint-stability-fields.rs @@ -0,0 +1,346 @@ +// Copyright 2015 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +// aux-build:lint_stability_fields.rs +#![deny(deprecated)] +#![allow(dead_code)] +#![feature(staged_api)] +#![staged_api] + +mod cross_crate { + extern crate lint_stability_fields; + + use self::lint_stability_fields::*; + + pub fn foo() { + let x = Stable { + inherit: 1, + override1: 2, //~ WARN use of unstable + override2: 3, + //~^ ERROR use of deprecated item + //~^^ WARN use of unstable + }; + + let _ = x.inherit; + let _ = x.override1; //~ WARN use of unstable + let _ = x.override2; + //~^ ERROR use of deprecated item + //~^^ WARN use of unstable + + let Stable { + inherit: _, + override1: _, //~ WARN use of unstable + override2: _ + //~^ ERROR use of deprecated item + //~^^ WARN use of unstable + } = x; + // all fine + let Stable { .. } = x; + + let x = Stable2(1, 2, 3); + + let _ = x.0; + let _ = x.1; //~ WARN use of unstable + let _ = x.2; + //~^ ERROR use of deprecated item + //~^^ WARN use of unstable + + let Stable2(_, + _, //~ WARN use of unstable + _) + //~^ ERROR use of deprecated item + //~^^ WARN use of unstable + = x; + // all fine + let Stable2(..) = x; + + + let x = Unstable { //~ WARN use of unstable + inherit: 1, //~ WARN use of unstable + override1: 2, + override2: 3, + //~^ ERROR use of deprecated item + //~^^ WARN use of unstable + }; + + let _ = x.inherit; //~ WARN use of unstable + let _ = x.override1; + let _ = x.override2; + //~^ ERROR use of deprecated item + //~^^ WARN use of unstable + + let Unstable { //~ WARN use of unstable + inherit: _, //~ WARN use of unstable + override1: _, + override2: _ + //~^ ERROR use of deprecated item + //~^^ WARN use of unstable + } = x; + + let Unstable //~ WARN use of unstable + // the patterns are all fine: + { .. } = x; + + + let x = Unstable2(1, 2, 3); //~ WARN use of unstable + + let _ = x.0; //~ WARN use of unstable + let _ = x.1; + let _ = x.2; + //~^ ERROR use of deprecated item + //~^^ WARN use of unstable + + let Unstable2 //~ WARN use of unstable + (_, //~ WARN use of unstable + _, + _) + //~^ ERROR use of deprecated item + //~^^ WARN use of unstable + = x; + let Unstable2 //~ WARN use of unstable + // the patterns are all fine: + (..) = x; + + + let x = Deprecated { + //~^ ERROR use of deprecated item + //~^^ WARN use of unstable + inherit: 1, + //~^ ERROR use of deprecated item + //~^^ WARN use of unstable + override1: 2, + override2: 3, //~ WARN use of unstable + }; + + let _ = x.inherit; + //~^ ERROR use of deprecated item + //~^^ WARN use of unstable + let _ = x.override1; + let _ = x.override2; //~ WARN use of unstable + + let Deprecated { + //~^ ERROR use of deprecated item + //~^^ WARN use of unstable + inherit: _, + //~^ ERROR use of deprecated item + //~^^ WARN use of unstable + override1: _, + override2: _ //~ WARN use of unstable + } = x; + + let Deprecated + //~^ ERROR use of deprecated item + //~^^ WARN use of unstable + // the patterns are all fine: + { .. } = x; + + let x = Deprecated2(1, 2, 3); + //~^ ERROR use of deprecated item + //~^^ WARN use of unstable + + let _ = x.0; + //~^ ERROR use of deprecated item + //~^^ WARN use of unstable + let _ = x.1; + let _ = x.2; //~ WARN use of unstable + + let Deprecated2 + //~^ ERROR use of deprecated item + //~^^ WARN use of unstable + (_, + //~^ ERROR use of deprecated item + //~^^ WARN use of unstable + _, + _) //~ WARN use of unstable + = x; + let Deprecated2 + //~^ ERROR use of deprecated item + //~^^ WARN use of unstable + // the patterns are all fine: + (..) = x; + } +} + +mod this_crate { + #[stable(feature = "rust1", since = "1.0.0")] + struct Stable { + inherit: u8, + #[unstable(feature = "test_feature")] + override1: u8, + #[deprecated(since = "1.0.0")] + #[unstable(feature = "test_feature")] + override2: u8, + } + + #[stable(feature = "rust1", since = "1.0.0")] + struct Stable2(u8, + #[stable(feature = "rust1", since = "1.0.0")] u8, + #[unstable(feature = "test_feature")] #[deprecated(since = "1.0.0")] u8); + + #[unstable(feature = "test_feature")] + struct Unstable { + inherit: u8, + #[stable(feature = "rust1", since = "1.0.0")] + override1: u8, + #[deprecated(since = "1.0.0")] + #[unstable(feature = "test_feature")] + override2: u8, + } + + #[unstable(feature = "test_feature")] + struct Unstable2(u8, + #[stable(feature = "rust1", since = "1.0.0")] u8, + #[unstable(feature = "test_feature")] #[deprecated(since = "1.0.0")] u8); + + #[unstable(feature = "test_feature")] + #[deprecated(feature = "rust1", since = "1.0.0")] + struct Deprecated { + inherit: u8, + #[stable(feature = "rust1", since = "1.0.0")] + override1: u8, + #[unstable(feature = "test_feature")] + override2: u8, + } + + #[unstable(feature = "test_feature")] + #[deprecated(feature = "rust1", since = "1.0.0")] + struct Deprecated2(u8, + #[stable(feature = "rust1", since = "1.0.0")] u8, + #[unstable(feature = "test_feature")] u8); + + pub fn foo() { + let x = Stable { + inherit: 1, + override1: 2, + override2: 3, + //~^ ERROR use of deprecated item + }; + + let _ = x.inherit; + let _ = x.override1; + let _ = x.override2; + //~^ ERROR use of deprecated item + + let Stable { + inherit: _, + override1: _, + override2: _ + //~^ ERROR use of deprecated item + } = x; + // all fine + let Stable { .. } = x; + + let x = Stable2(1, 2, 3); + + let _ = x.0; + let _ = x.1; + let _ = x.2; + //~^ ERROR use of deprecated item + + let Stable2(_, + _, + _) + //~^ ERROR use of deprecated item + = x; + // all fine + let Stable2(..) = x; + + + let x = Unstable { + inherit: 1, + override1: 2, + override2: 3, + //~^ ERROR use of deprecated item + }; + + let _ = x.inherit; + let _ = x.override1; + let _ = x.override2; + //~^ ERROR use of deprecated item + + let Unstable { + inherit: _, + override1: _, + override2: _ + //~^ ERROR use of deprecated item + } = x; + + let Unstable + // the patterns are all fine: + { .. } = x; + + + let x = Unstable2(1, 2, 3); + + let _ = x.0; + let _ = x.1; + let _ = x.2; + //~^ ERROR use of deprecated item + + let Unstable2 + (_, + _, + _) + //~^ ERROR use of deprecated item + = x; + let Unstable2 + // the patterns are all fine: + (..) = x; + + + let x = Deprecated { + //~^ ERROR use of deprecated item + inherit: 1, + //~^ ERROR use of deprecated item + override1: 2, + override2: 3, + }; + + let _ = x.inherit; + //~^ ERROR use of deprecated item + let _ = x.override1; + let _ = x.override2; + + let Deprecated { + //~^ ERROR use of deprecated item + inherit: _, + //~^ ERROR use of deprecated item + override1: _, + override2: _ + } = x; + + let Deprecated + //~^ ERROR use of deprecated item + // the patterns are all fine: + { .. } = x; + + let x = Deprecated2(1, 2, 3); + //~^ ERROR use of deprecated item + + let _ = x.0; + //~^ ERROR use of deprecated item + let _ = x.1; + let _ = x.2; + + let Deprecated2 + //~^ ERROR use of deprecated item + (_, + //~^ ERROR use of deprecated item + _, + _) + = x; + let Deprecated2 + //~^ ERROR use of deprecated item + // the patterns are all fine: + (..) = x; + } +} + +fn main() {} diff --git a/src/test/compile-fail/lint-stability.rs b/src/test/compile-fail/lint-stability.rs index 90792848855..12548c45396 100644 --- a/src/test/compile-fail/lint-stability.rs +++ b/src/test/compile-fail/lint-stability.rs @@ -317,11 +317,17 @@ mod this_crate { #[unstable(feature = "test_feature")] #[deprecated(since = "1.0.0")] - pub struct DeprecatedStruct { i: isize } + pub struct DeprecatedStruct { + #[stable(feature = "test_feature", since = "1.0.0")] i: isize + } #[unstable(feature = "test_feature")] - pub struct UnstableStruct { i: isize } + pub struct UnstableStruct { + #[stable(feature = "test_feature", since = "1.0.0")] i: isize + } #[stable(feature = "rust1", since = "1.0.0")] - pub struct StableStruct { i: isize } + pub struct StableStruct { + #[stable(feature = "test_feature", since = "1.0.0")] i: isize + } #[unstable(feature = "test_feature")] #[deprecated(since = "1.0.0")] -- cgit 1.4.1-3-g733a5 From 804c071d8b9cfe4d40df9565558db8a9d87d7775 Mon Sep 17 00:00:00 2001 From: Dave Huseby Date: Thu, 26 Feb 2015 13:03:06 -0800 Subject: fixing a few bitrig build breakers --- src/libstd/sys/unix/fs.rs | 15 --------------- src/libstd/sys/unix/process2.rs | 1 + 2 files changed, 1 insertion(+), 15 deletions(-) (limited to 'src/libstd') diff --git a/src/libstd/sys/unix/fs.rs b/src/libstd/sys/unix/fs.rs index 1c28d629d40..71b6214460f 100644 --- a/src/libstd/sys/unix/fs.rs +++ b/src/libstd/sys/unix/fs.rs @@ -291,29 +291,14 @@ fn mkstat(stat: &libc::stat) -> FileStat { // FileStat times are in milliseconds fn mktime(secs: u64, nsecs: u64) -> u64 { secs * 1000 + nsecs / 1000000 } - #[cfg(target_os = "bitrig")] - fn ctime(stat: &libc::stat) -> u64 { - mktime(stat.st_ctim.tv_sec as u64, stat.st_ctim.tv_nsec as u64) - } - #[cfg(not(target_os = "bitrig"))] fn ctime(stat: &libc::stat) -> u64 { mktime(stat.st_ctime as u64, stat.st_ctime_nsec as u64) } - #[cfg(target_os = "bitrig")] - fn atime(stat: &libc::stat) -> u64 { - mktime(stat.st_atim.tv_sec as u64, stat.st_atim.tv_nsec as u64) - } - #[cfg(not(target_os = "bitrig"))] fn atime(stat: &libc::stat) -> u64 { mktime(stat.st_atime as u64, stat.st_atime_nsec as u64) } - #[cfg(target_os = "bitrig")] - fn mtime(stat: &libc::stat) -> u64 { - mktime(stat.st_mtim.tv_sec as u64, stat.st_mtim.tv_nsec as u64) - } - #[cfg(not(target_os = "bitrig"))] fn mtime(stat: &libc::stat) -> u64 { mktime(stat.st_mtime as u64, stat.st_mtime_nsec as u64) } diff --git a/src/libstd/sys/unix/process2.rs b/src/libstd/sys/unix/process2.rs index b7a1b002f55..a7d0a864a08 100644 --- a/src/libstd/sys/unix/process2.rs +++ b/src/libstd/sys/unix/process2.rs @@ -439,6 +439,7 @@ fn translate_status(status: c_int) -> ExitStatus { target_os = "ios", target_os = "freebsd", target_os = "dragonfly", + target_os = "bitrig", target_os = "openbsd"))] mod imp { pub fn WIFEXITED(status: i32) -> bool { (status & 0x7f) == 0 } -- cgit 1.4.1-3-g733a5 From 060661d2b4a323c83a1bf043234eae8a344ff6aa Mon Sep 17 00:00:00 2001 From: Huon Wilson Date: Wed, 25 Feb 2015 23:12:22 +1100 Subject: Add some missing stability attributes on struct fields. --- src/libcore/str/mod.rs | 1 + src/libstd/sync/mpsc/mod.rs | 2 +- src/libstd/thread_local/mod.rs | 2 ++ 3 files changed, 4 insertions(+), 1 deletion(-) (limited to 'src/libstd') diff --git a/src/libcore/str/mod.rs b/src/libcore/str/mod.rs index 7e51f8e8503..b354116993c 100644 --- a/src/libcore/str/mod.rs +++ b/src/libcore/str/mod.rs @@ -939,6 +939,7 @@ impl<'a, P: Pattern<'a>> Iterator for SplitStr<'a, P> { type Item = &'a str; #[inline] + #[allow(deprecated)] fn next(&mut self) -> Option<&'a str> { Iterator::next(&mut self.0) } diff --git a/src/libstd/sync/mpsc/mod.rs b/src/libstd/sync/mpsc/mod.rs index 7bd1f3542eb..1310d476f8e 100644 --- a/src/libstd/sync/mpsc/mod.rs +++ b/src/libstd/sync/mpsc/mod.rs @@ -384,7 +384,7 @@ impl !Sync for SyncSender {} /// contains the data being sent as a payload so it can be recovered. #[stable(feature = "rust1", since = "1.0.0")] #[derive(PartialEq, Eq, Clone, Copy)] -pub struct SendError(pub T); +pub struct SendError(#[stable(feature = "rust1", since = "1.0.0")] pub T); /// An error returned from the `recv` function on a `Receiver`. /// diff --git a/src/libstd/thread_local/mod.rs b/src/libstd/thread_local/mod.rs index d65156dae96..764c7d730cb 100644 --- a/src/libstd/thread_local/mod.rs +++ b/src/libstd/thread_local/mod.rs @@ -105,10 +105,12 @@ pub struct Key { // This is trivially devirtualizable by LLVM because we never store anything // to this field and rustc can declare the `static` as constant as well. #[doc(hidden)] + #[unstable(feature = "thread_local_internals")] pub inner: fn() -> &'static __impl::KeyInner>>, // initialization routine to invoke to create a value #[doc(hidden)] + #[unstable(feature = "thread_local_internals")] pub init: fn() -> T, } -- cgit 1.4.1-3-g733a5