diff options
Diffstat (limited to 'src/libcore')
35 files changed, 454 insertions, 621 deletions
diff --git a/src/libcore/at_vec.rs b/src/libcore/at_vec.rs index 7d410c0337a..ce3dec89e41 100644 --- a/src/libcore/at_vec.rs +++ b/src/libcore/at_vec.rs @@ -1,7 +1,7 @@ //! Managed vectors // NB: transitionary, de-mode-ing. -// tjc: re-forbid deprecated modes after snapshot +#[forbid(deprecated_mode)]; #[forbid(deprecated_pattern)]; use cast::transmute; @@ -21,7 +21,7 @@ extern mod rustrt { #[abi = "rust-intrinsic"] extern mod rusti { #[legacy_exports]; - fn move_val_init<T>(&dst: T, -src: T); + fn move_val_init<T>(dst: &mut T, -src: T); } /// Returns the number of elements the vector can hold without reallocating @@ -176,7 +176,7 @@ pub mod raw { push_slow(v, move initval); } } - // This doesn't bother to make sure we have space. + #[inline(always)] // really pretty please pub unsafe fn push_fast<T>(v: &mut @[const T], initval: T) { let repr: **VecRepr = ::cast::reinterpret_cast(&v); @@ -184,7 +184,7 @@ pub mod raw { (**repr).unboxed.fill += sys::size_of::<T>(); let p = addr_of(&((**repr).unboxed.data)); let p = ptr::offset(p, fill) as *mut T; - rusti::move_val_init(*p, move initval); + rusti::move_val_init(&mut(*p), move initval); } pub unsafe fn push_slow<T>(v: &mut @[const T], initval: T) { diff --git a/src/libcore/cast.rs b/src/libcore/cast.rs index f4f0d7b6104..030f05c6eea 100644 --- a/src/libcore/cast.rs +++ b/src/libcore/cast.rs @@ -1,4 +1,5 @@ //! Unsafe operations +#[forbid(deprecated_mode)] #[abi = "rust-intrinsic"] extern mod rusti { @@ -18,7 +19,7 @@ pub unsafe fn reinterpret_cast<T, U>(src: &T) -> U { * The forget function will take ownership of the provided value but neglect * to run any required cleanup or memory-management operations on it. This * can be used for various acts of magick, particularly when using - * reinterpret_cast on managed pointer types. + * reinterpret_cast on pointer types. */ #[inline(always)] pub unsafe fn forget<T>(thing: T) { rusti::forget(move thing); } diff --git a/src/libcore/cmath.rs b/src/libcore/cmath.rs index 9a9a7cb3112..b0aeb78afaa 100644 --- a/src/libcore/cmath.rs +++ b/src/libcore/cmath.rs @@ -40,15 +40,15 @@ pub extern mod c_double { #[link_name="fmax"] pure fn fmax(a: c_double, b: c_double) -> c_double; #[link_name="fmin"] pure fn fmin(a: c_double, b: c_double) -> c_double; pure fn nextafter(x: c_double, y: c_double) -> c_double; - pure fn frexp(n: c_double, &value: c_int) -> c_double; + pure fn frexp(n: c_double, value: &mut c_int) -> c_double; pure fn hypot(x: c_double, y: c_double) -> c_double; pure fn ldexp(x: c_double, n: c_int) -> c_double; #[cfg(unix)] #[link_name="lgamma_r"] pure fn lgamma(n: c_double, - &sign: c_int) -> c_double; + sign: &mut c_int) -> c_double; #[cfg(windows)] #[link_name="__lgamma_r"] pure fn lgamma(n: c_double, - &sign: c_int) -> c_double; + sign: &mut c_int) -> c_double; // renamed: log is a reserved keyword; ln seems more natural, too #[link_name="log"] pure fn ln(n: c_double) -> c_double; // renamed: "logb" /often/ is confused for log2 by beginners @@ -58,7 +58,7 @@ pub extern mod c_double { pure fn log10(n: c_double) -> c_double; pure fn log2(n: c_double) -> c_double; #[link_name="ilogb"] pure fn ilog_radix(n: c_double) -> c_int; - pure fn modf(n: c_double, &iptr: c_double) -> c_double; + pure fn modf(n: c_double, iptr: &mut c_double) -> c_double; pure fn pow(n: c_double, e: c_double) -> c_double; // FIXME (#1379): enable when rounding modes become available // pure fn rint(n: c_double) -> c_double; @@ -110,7 +110,7 @@ pub extern mod c_float { #[link_name="fdimf"] pure fn abs_sub(a: c_float, b: c_float) -> c_float; #[link_name="floorf"] pure fn floor(n: c_float) -> c_float; #[link_name="frexpf"] pure fn frexp(n: c_float, - &value: c_int) -> c_float; + value: &mut c_int) -> c_float; #[link_name="fmaf"] pure fn mul_add(a: c_float, b: c_float, c: c_float) -> c_float; #[link_name="fmaxf"] pure fn fmax(a: c_float, b: c_float) -> c_float; @@ -122,11 +122,11 @@ pub extern mod c_float { #[cfg(unix)] #[link_name="lgammaf_r"] pure fn lgamma(n: c_float, - &sign: c_int) -> c_float; + sign: &mut c_int) -> c_float; #[cfg(windows)] #[link_name="__lgammaf_r"] pure fn lgamma(n: c_float, - &sign: c_int) -> c_float; + sign: &mut c_int) -> c_float; #[link_name="logf"] pure fn ln(n: c_float) -> c_float; #[link_name="logbf"] pure fn log_radix(n: c_float) -> c_float; @@ -135,7 +135,7 @@ pub extern mod c_float { #[link_name="log10f"] pure fn log10(n: c_float) -> c_float; #[link_name="ilogbf"] pure fn ilog_radix(n: c_float) -> c_int; #[link_name="modff"] pure fn modf(n: c_float, - &iptr: c_float) -> c_float; + iptr: &mut c_float) -> c_float; #[link_name="powf"] pure fn pow(n: c_float, e: c_float) -> c_float; // FIXME (#1379): enable when rounding modes become available // #[link_name="rintf"] pure fn rint(n: c_float) -> c_float; diff --git a/src/libcore/comm.rs b/src/libcore/comm.rs index 64c38d13e49..c9cd1a21b45 100644 --- a/src/libcore/comm.rs +++ b/src/libcore/comm.rs @@ -32,8 +32,8 @@ will once again be the preferred module for intertask communication. */ -// NB: transitionary, de-mode-ing -// tjc: re-forbid deprecated modes after snapshot +// NB: transitionary, de-mode-ing. +#[forbid(deprecated_mode)]; #[forbid(deprecated_pattern)]; use either::Either; @@ -74,7 +74,7 @@ pub fn Port<T: Send>() -> Port<T> { impl<T: Send> Port<T> { - fn chan() -> Chan<T> { Chan(self) } + fn chan() -> Chan<T> { Chan(&self) } fn send(v: T) { self.chan().send(move v) } fn recv() -> T { recv(self) } fn peek() -> bool { peek(self) } @@ -166,7 +166,7 @@ fn as_raw_port<T: Send, U>(ch: comm::Chan<T>, f: fn(*rust_port) -> U) -> U { * Constructs a channel. The channel is bound to the port used to * construct it. */ -pub fn Chan<T: Send>(&&p: Port<T>) -> Chan<T> { +pub fn Chan<T: Send>(p: &Port<T>) -> Chan<T> { Chan_(rustrt::get_port_id((**p).po)) } @@ -304,19 +304,19 @@ extern mod rusti { #[test] -fn create_port_and_chan() { let p = Port::<int>(); Chan(p); } +fn create_port_and_chan() { let p = Port::<int>(); Chan(&p); } #[test] fn send_int() { let p = Port::<int>(); - let c = Chan(p); + let c = Chan(&p); send(c, 22); } #[test] fn send_recv_fn() { let p = Port::<int>(); - let c = Chan::<int>(p); + let c = Chan::<int>(&p); send(c, 42); assert (recv(p) == 42); } @@ -324,7 +324,7 @@ fn send_recv_fn() { #[test] fn send_recv_fn_infer() { let p = Port(); - let c = Chan(p); + let c = Chan(&p); send(c, 42); assert (recv(p) == 42); } @@ -332,23 +332,23 @@ fn send_recv_fn_infer() { #[test] fn chan_chan_infer() { let p = Port(), p2 = Port::<int>(); - let c = Chan(p); - send(c, Chan(p2)); + let c = Chan(&p); + send(c, Chan(&p2)); recv(p); } #[test] fn chan_chan() { let p = Port::<Chan<int>>(), p2 = Port::<int>(); - let c = Chan(p); - send(c, Chan(p2)); + let c = Chan(&p); + send(c, Chan(&p2)); recv(p); } #[test] fn test_peek() { let po = Port(); - let ch = Chan(po); + let ch = Chan(&po); assert !peek(po); send(ch, ()); assert peek(po); @@ -360,8 +360,8 @@ fn test_peek() { fn test_select2_available() { let po_a = Port(); let po_b = Port(); - let ch_a = Chan(po_a); - let ch_b = Chan(po_b); + let ch_a = Chan(&po_a); + let ch_b = Chan(&po_b); send(ch_a, ~"a"); @@ -376,8 +376,8 @@ fn test_select2_available() { fn test_select2_rendezvous() { let po_a = Port(); let po_b = Port(); - let ch_a = Chan(po_a); - let ch_b = Chan(po_b); + let ch_a = Chan(&po_a); + let ch_b = Chan(&po_b); for iter::repeat(10) { do task::spawn { @@ -400,8 +400,8 @@ fn test_select2_rendezvous() { fn test_select2_stress() { let po_a = Port(); let po_b = Port(); - let ch_a = Chan(po_a); - let ch_b = Chan(po_b); + let ch_a = Chan(&po_a); + let ch_b = Chan(&po_b); let msgs = 100; let times = 4u; @@ -436,7 +436,7 @@ fn test_select2_stress() { #[test] fn test_recv_chan() { let po = Port(); - let ch = Chan(po); + let ch = Chan(&po); send(ch, ~"flower"); assert recv_chan(ch) == ~"flower"; } @@ -445,7 +445,7 @@ fn test_recv_chan() { #[should_fail] #[ignore(cfg(windows))] fn test_recv_chan_dead() { - let ch = Chan(Port()); + let ch = Chan(&Port()); send(ch, ~"flower"); recv_chan(ch); } @@ -454,7 +454,7 @@ fn test_recv_chan_dead() { #[ignore(cfg(windows))] fn test_recv_chan_wrong_task() { let po = Port(); - let ch = Chan(po); + let ch = Chan(&po); send(ch, ~"flower"); assert result::is_err(&task::try(|| recv_chan(ch) diff --git a/src/libcore/core.rc b/src/libcore/core.rc index 818e1e890ec..94e6decc4ca 100644 --- a/src/libcore/core.rc +++ b/src/libcore/core.rc @@ -36,227 +36,185 @@ Implicitly, all crates behave as if they included the following prologue: // Don't link to core. We are core. #[no_core]; -#[legacy_exports]; - #[warn(deprecated_mode)]; #[warn(deprecated_pattern)]; #[warn(vecs_implicitly_copyable)]; #[deny(non_camel_case_types)]; -export int, i8, i16, i32, i64; -export uint, u8, u16, u32, u64; -export float, f32, f64; -export box, char, str, ptr, vec, at_vec, bool; -export either, option, result, iter; -export gc, io, libc, os, run, rand, sys, cast, logging; -export comm, task, future, pipes; -export extfmt; -// The test harness links against core, so don't include runtime in tests. -// FIXME (#2861): Uncomment this after snapshot gets updated. -//#[cfg(notest)] -export rt; -export tuple; -export to_str, to_bytes; -export from_str; -export util; -export dvec, dvec_iter; -export dlist, dlist_iter; -export send_map; -export hash; -export cmp; -export num; -export path; -export mutable; -export flate; -export unit; -export uniq; -export repr; -export cleanup; -export reflect; - -// NDM seems to be necessary for resolve to work -export option_iter; - -// This creates some APIs that I do not want to commit to, but it must be -// exported from core in order for uv to remain in std (see #2648). -export private; - - // Built-in-type support modules /// Operations and constants for `int` #[path = "int-template"] -mod int { +pub mod int { pub use inst::{ pow }; #[path = "int.rs"] - mod inst; + pub mod inst; } /// Operations and constants for `i8` #[path = "int-template"] -mod i8 { +pub mod i8 { #[path = "i8.rs"] - mod inst; + pub mod inst; } /// Operations and constants for `i16` #[path = "int-template"] -mod i16 { +pub mod i16 { #[path = "i16.rs"] - mod inst; + pub mod inst; } /// Operations and constants for `i32` #[path = "int-template"] -mod i32 { +pub mod i32 { #[path = "i32.rs"] - mod inst; + pub mod inst; } /// Operations and constants for `i64` #[path = "int-template"] -mod i64 { +pub mod i64 { #[path = "i64.rs"] - mod inst; + pub mod inst; } /// Operations and constants for `uint` #[path = "uint-template"] -mod uint { +pub mod uint { pub use inst::{ div_ceil, div_round, div_floor, iterate, next_power_of_two }; #[path = "uint.rs"] - mod inst; + pub mod inst; } /// Operations and constants for `u8` #[path = "uint-template"] -mod u8 { +pub mod u8 { pub use inst::is_ascii; #[path = "u8.rs"] - mod inst; + pub mod inst; } /// Operations and constants for `u16` #[path = "uint-template"] -mod u16 { +pub mod u16 { #[path = "u16.rs"] - mod inst; + pub mod inst; } /// Operations and constants for `u32` #[path = "uint-template"] -mod u32 { +pub mod u32 { #[path = "u32.rs"] - mod inst; + pub mod inst; } /// Operations and constants for `u64` #[path = "uint-template"] -mod u64 { +pub mod u64 { #[path = "u64.rs"] - mod inst; + pub mod inst; } -mod box; -mod char; -mod float; -mod f32; -mod f64; -mod str; -mod ptr; -mod vec; -mod at_vec; -mod bool; -mod tuple; -mod unit; -mod uniq; +pub mod box; +pub mod char; +pub mod float; +pub mod f32; +pub mod f64; +pub mod str; +pub mod ptr; +pub mod vec; +pub mod at_vec; +pub mod bool; +pub mod tuple; +pub mod unit; +pub mod uniq; // Ubiquitous-utility-type modules #[cfg(notest)] -mod ops; -mod cmp; -mod num; -mod hash; -mod either; -mod iter; -mod logging; -mod option; +pub mod ops; +pub mod cmp; +pub mod num; +pub mod hash; +pub mod either; +pub mod iter; +pub mod logging; +pub mod option; #[path="iter-trait"] -mod option_iter { +pub mod option_iter { #[path = "option.rs"] - mod inst; + pub mod inst; } -mod result; -mod to_str; -mod to_bytes; -mod from_str; -mod util; +pub mod result; +pub mod to_str; +pub mod to_bytes; +pub mod from_str; +pub mod util; // Data structure modules -mod dvec; +pub mod dvec; #[path="iter-trait"] -mod dvec_iter { +pub mod dvec_iter { #[path = "dvec.rs"] - mod inst; + pub mod inst; } -mod dlist; +pub mod dlist; #[path="iter-trait"] -mod dlist_iter { +pub mod dlist_iter { #[path ="dlist.rs"] - mod inst; + pub mod inst; } -mod send_map; +pub mod send_map; // Concurrency -mod comm; -mod task { +pub mod comm; +pub mod task { pub mod local_data; mod local_data_priv; pub mod spawn; pub mod rt; } -mod future; -mod pipes; +pub mod future; +pub mod pipes; // Runtime and language-primitive support -mod gc; -mod io; -mod libc; -mod os; -mod path; -mod rand; -mod run; -mod sys; -mod cast; -mod mutable; -mod flate; -mod repr; -mod cleanup; -mod reflect; +pub mod gc; +pub mod io; +pub mod libc; +pub mod os; +pub mod path; +pub mod rand; +pub mod run; +pub mod sys; +pub mod cast; +pub mod mutable; +pub mod flate; +pub mod repr; +pub mod cleanup; +pub mod reflect; // Modules supporting compiler-generated code // Exported but not part of the public interface -#[legacy_exports] -mod extfmt; +pub mod extfmt; // The test harness links against core, so don't include runtime in tests. #[cfg(notest)] #[legacy_exports] -mod rt; - +pub mod rt; -// For internal use, not exported +// Ideally not exported, but currently is. +pub mod private; +// For internal use, not exported. mod unicode; -mod private; mod cmath; mod stackwalk; diff --git a/src/libcore/core.rs b/src/libcore/core.rs index c7261aa8c29..a14b67b40f1 100644 --- a/src/libcore/core.rs +++ b/src/libcore/core.rs @@ -2,101 +2,76 @@ // Export various ubiquitous types, constructors, methods. -use option::{Some, None}; -use Option = option::Option; -use result::{Result, Ok, Err}; +pub use option::{Some, None}; +pub use Option = option::Option; +pub use result::{Result, Ok, Err}; -use Path = path::Path; -use GenericPath = path::GenericPath; -use WindowsPath = path::WindowsPath; -use PosixPath = path::PosixPath; +pub use Path = path::Path; +pub use GenericPath = path::GenericPath; +pub use WindowsPath = path::WindowsPath; +pub use PosixPath = path::PosixPath; -use tuple::{TupleOps, ExtendedTupleOps}; -use str::{StrSlice, UniqueStr}; -use vec::{ConstVector, CopyableVector, ImmutableVector}; -use vec::{ImmutableEqVector, ImmutableCopyableVector}; -use vec::{MutableVector, MutableCopyableVector}; -use iter::{BaseIter, ExtendedIter, EqIter, CopyableIter}; -use iter::{CopyableOrderedIter, Times, TimesIx}; -use num::Num; -use ptr::Ptr; -use to_str::ToStr; - -export Path, WindowsPath, PosixPath, GenericPath; -export Option, Some, None; -export Result, Ok, Err; -export extensions; -// The following exports are the extension impls for numeric types -export Num, Times, TimesIx; -// The following exports are the common traits -export StrSlice, UniqueStr; -export ConstVector, CopyableVector, ImmutableVector; -export ImmutableEqVector, ImmutableCopyableVector, IterTraitExtensions; -export MutableVector, MutableCopyableVector; -export BaseIter, CopyableIter, CopyableOrderedIter, ExtendedIter, EqIter; -export TupleOps, ExtendedTupleOps; -export Ptr; -export ToStr; +pub use tuple::{TupleOps, ExtendedTupleOps}; +pub use str::{StrSlice, UniqueStr}; +pub use vec::{ConstVector, CopyableVector, ImmutableVector}; +pub use vec::{ImmutableEqVector, ImmutableCopyableVector}; +pub use vec::{MutableVector, MutableCopyableVector}; +pub use iter::{BaseIter, ExtendedIter, EqIter, CopyableIter}; +pub use iter::{CopyableOrderedIter, Times, TimesIx}; +pub use num::Num; +pub use ptr::Ptr; +pub use to_str::ToStr; // The following exports are the core operators and kinds // The compiler has special knowlege of these so we must not duplicate them // when compiling for testing #[cfg(notest)] -use ops::{Const, Copy, Send, Owned}; +pub use ops::{Const, Copy, Send, Owned}; #[cfg(notest)] -use ops::{Add, Sub, Mul, Div, Modulo, Neg, BitAnd, BitOr, BitXor}; +pub use ops::{Add, Sub, Mul, Div, Modulo, Neg, BitAnd, BitOr, BitXor}; #[cfg(notest)] -use ops::{Shl, Shr, Index}; - -#[cfg(notest)] -export Const, Copy, Send, Owned; -#[cfg(notest)] -export Add, Sub, Mul, Div, Modulo, Neg, BitAnd, BitOr, BitXor; -#[cfg(notest)] -export Shl, Shr, Index; +pub use ops::{Shl, Shr, Index}; #[cfg(test)] extern mod coreops(name = "core", vers = "0.4"); #[cfg(test)] -use coreops::ops::{Const, Copy, Send, Owned}; +pub use coreops::ops::{Const, Copy, Send, Owned}; +#[cfg(test)] +pub use coreops::ops::{Add, Sub, Mul, Div, Modulo, Neg, BitAnd, BitOr}; #[cfg(test)] -use coreops::ops::{Add, Sub, Mul, Div, Modulo, Neg, BitAnd, BitOr, BitXor}; +pub use coreops::ops::{BitXor}; #[cfg(test)] -use coreops::ops::{Shl, Shr, Index}; +pub use coreops::ops::{Shl, Shr, Index}; // Export the log levels as global constants. Higher levels mean // more-verbosity. Error is the bottom level, default logging level is // warn-and-below. -export error, warn, info, debug; - /// The error log level -const error : u32 = 0_u32; +pub const error : u32 = 0_u32; /// The warning log level -const warn : u32 = 1_u32; +pub const warn : u32 = 1_u32; /// The info log level -const info : u32 = 2_u32; +pub const info : u32 = 2_u32; /// The debug log level -const debug : u32 = 3_u32; +pub const debug : u32 = 3_u32; // A curious inner-module that's not exported that contains the binding // 'core' so that macro-expanded references to core::error and such // can be resolved within libcore. #[doc(hidden)] // FIXME #3538 mod core { - #[legacy_exports]; - const error : u32 = 0_u32; - const warn : u32 = 1_u32; - const info : u32 = 2_u32; - const debug : u32 = 3_u32; + pub const error : u32 = 0_u32; + pub const warn : u32 = 1_u32; + pub const info : u32 = 2_u32; + pub const debug : u32 = 3_u32; } // Similar to above. Some magic to make core testable. #[cfg(test)] mod std { - #[legacy_exports]; extern mod std(vers = "0.4"); - use std::test; + pub use std::test; } diff --git a/src/libcore/dlist.rs b/src/libcore/dlist.rs index 17ddd6ea73b..3bcf486ef7e 100644 --- a/src/libcore/dlist.rs +++ b/src/libcore/dlist.rs @@ -9,7 +9,7 @@ Do not use ==, !=, <, etc on doubly-linked lists -- it may not terminate. */ // NB: transitionary, de-mode-ing. -// tjc: re-forbid deprecated modes after snapshot +#[forbid(deprecated_mode)]; #[forbid(deprecated_pattern)]; type DListLink<T> = Option<DListNode<T>>; diff --git a/src/libcore/dvec.rs b/src/libcore/dvec.rs index a2a70908797..1540eb30fe5 100644 --- a/src/libcore/dvec.rs +++ b/src/libcore/dvec.rs @@ -10,7 +10,7 @@ Note that recursive use is not permitted. */ // NB: transitionary, de-mode-ing. -// tjc: re-forbid deprecated modes after snapshot +#[forbid(deprecated_mode)]; #[forbid(deprecated_pattern)]; use cast::reinterpret_cast; diff --git a/src/libcore/either.rs b/src/libcore/either.rs index c64cd25e481..7500ff409a4 100644 --- a/src/libcore/either.rs +++ b/src/libcore/either.rs @@ -1,5 +1,5 @@ // NB: transitionary, de-mode-ing. -// tjc: re-forbid deprecated modes after snapshot +#[forbid(deprecated_mode)]; #[forbid(deprecated_pattern)]; //! A type that represents one of two alternatives diff --git a/src/libcore/extfmt.rs b/src/libcore/extfmt.rs index e10ff4bac71..de2e91b2e32 100644 --- a/src/libcore/extfmt.rs +++ b/src/libcore/extfmt.rs @@ -1,4 +1,7 @@ #[doc(hidden)]; +// NB: transitionary, de-mode-ing. +#[forbid(deprecated_mode)]; +#[forbid(deprecated_pattern)]; /* Syntax Extension: fmt @@ -41,11 +44,10 @@ use option::{Some, None}; */ // Functions used by the fmt extension at compile time -mod ct { - #[legacy_exports]; - enum Signedness { Signed, Unsigned, } - enum Caseness { CaseUpper, CaseLower, } - enum Ty { +pub mod ct { + pub enum Signedness { Signed, Unsigned, } + pub enum Caseness { CaseUpper, CaseLower, } + pub enum Ty { TyBool, TyStr, TyChar, @@ -56,14 +58,14 @@ mod ct { TyFloat, TyPoly, } - enum Flag { + pub enum Flag { FlagLeftJustify, FlagLeftZeroPad, FlagSpaceForSign, FlagSignAlways, FlagAlternate, } - enum Count { + pub enum Count { CountIs(int), CountIsParam(int), CountIsNextParam, @@ -71,7 +73,7 @@ mod ct { } // A formatted conversion from an expression to a string - type Conv = + pub type Conv = {param: Option<int>, flags: ~[Flag], width: Count, @@ -80,10 +82,10 @@ mod ct { // A fragment of the output sequence - enum Piece { PieceString(~str), PieceConv(Conv), } - type ErrorFn = fn@(&str) -> ! ; + pub enum Piece { PieceString(~str), PieceConv(Conv), } + pub type ErrorFn = fn@(&str) -> ! ; - fn parse_fmt_string(s: &str, error: ErrorFn) -> ~[Piece] { + pub fn parse_fmt_string(s: &str, error: ErrorFn) -> ~[Piece] { let mut pieces: ~[Piece] = ~[]; let lim = str::len(s); let mut buf = ~""; @@ -118,7 +120,7 @@ mod ct { flush_buf(move buf, &mut pieces); move pieces } - fn peek_num(s: &str, i: uint, lim: uint) -> + pub fn peek_num(s: &str, i: uint, lim: uint) -> Option<{num: uint, next: uint}> { let mut j = i; let mut accum = 0u; @@ -140,7 +142,8 @@ mod ct { None } } - fn parse_conversion(s: &str, i: uint, lim: uint, error: ErrorFn) -> + pub fn parse_conversion(s: &str, i: uint, lim: uint, + error: ErrorFn) -> {piece: Piece, next: uint} { let parm = parse_parameter(s, i, lim); let flags = parse_flags(s, parm.next, lim); @@ -155,7 +158,7 @@ mod ct { ty: ty.ty}), next: ty.next}; } - fn parse_parameter(s: &str, i: uint, lim: uint) -> + pub fn parse_parameter(s: &str, i: uint, lim: uint) -> {param: Option<int>, next: uint} { if i >= lim { return {param: None, next: i}; } let num = peek_num(s, i, lim); @@ -170,7 +173,7 @@ mod ct { } }; } - fn parse_flags(s: &str, i: uint, lim: uint) -> + pub fn parse_flags(s: &str, i: uint, lim: uint) -> {flags: ~[Flag], next: uint} { let noflags: ~[Flag] = ~[]; if i >= lim { return {flags: move noflags, next: i}; } @@ -198,7 +201,7 @@ mod ct { more(FlagAlternate, s, i, lim) } else { {flags: move noflags, next: i} }; } - fn parse_count(s: &str, i: uint, lim: uint) + pub fn parse_count(s: &str, i: uint, lim: uint) -> {count: Count, next: uint} { return if i >= lim { {count: CountImplied, next: i} @@ -220,7 +223,7 @@ mod ct { } }; } - fn parse_precision(s: &str, i: uint, lim: uint) -> + pub fn parse_precision(s: &str, i: uint, lim: uint) -> {count: Count, next: uint} { return if i >= lim { {count: CountImplied, next: i} @@ -236,7 +239,7 @@ mod ct { } } else { {count: CountImplied, next: i} }; } - fn parse_type(s: &str, i: uint, lim: uint, error: ErrorFn) -> + pub fn parse_type(s: &str, i: uint, lim: uint, error: ErrorFn) -> {ty: Ty, next: uint} { if i >= lim { error(~"missing type in conversion"); } let tstr = str::slice(s, i, i+1u); @@ -274,21 +277,20 @@ mod ct { // decisions made a runtime. If it proves worthwhile then some of these // conditions can be evaluated at compile-time. For now though it's cleaner to // implement it 0this way, I think. -mod rt { - #[legacy_exports]; - const flag_none : u32 = 0u32; - const flag_left_justify : u32 = 0b00000000000000000000000000000001u32; - const flag_left_zero_pad : u32 = 0b00000000000000000000000000000010u32; - const flag_space_for_sign : u32 = 0b00000000000000000000000000000100u32; - const flag_sign_always : u32 = 0b00000000000000000000000000001000u32; - const flag_alternate : u32 = 0b00000000000000000000000000010000u32; +pub mod rt { + pub const flag_none : u32 = 0u32; + pub const flag_left_justify : u32 = 0b00000000000001u32; + pub const flag_left_zero_pad : u32 = 0b00000000000010u32; + pub const flag_space_for_sign : u32 = 0b00000000000100u32; + pub const flag_sign_always : u32 = 0b00000000001000u32; + pub const flag_alternate : u32 = 0b00000000010000u32; - enum Count { CountIs(int), CountImplied, } - enum Ty { TyDefault, TyBits, TyHexUpper, TyHexLower, TyOctal, } + pub enum Count { CountIs(int), CountImplied, } + pub enum Ty { TyDefault, TyBits, TyHexUpper, TyHexLower, TyOctal, } - type Conv = {flags: u32, width: Count, precision: Count, ty: Ty}; + pub type Conv = {flags: u32, width: Count, precision: Count, ty: Ty}; - pure fn conv_int(cv: Conv, i: int) -> ~str { + pub pure fn conv_int(cv: Conv, i: int) -> ~str { let radix = 10; let prec = get_int_precision(cv); let mut s : ~str = int_to_str_prec(i, radix, prec); @@ -301,7 +303,7 @@ mod rt { } return unsafe { pad(cv, s, PadSigned) }; } - pure fn conv_uint(cv: Conv, u: uint) -> ~str { + pub pure fn conv_uint(cv: Conv, u: uint) -> ~str { let prec = get_int_precision(cv); let mut rs = match cv.ty { @@ -313,17 +315,17 @@ mod rt { }; return unsafe { pad(cv, rs, PadUnsigned) }; } - pure fn conv_bool(cv: Conv, b: bool) -> ~str { + pub pure fn conv_bool(cv: Conv, b: bool) -> ~str { let s = if b { ~"true" } else { ~"false" }; // run the boolean conversion through the string conversion logic, // giving it the same rules for precision, etc. return conv_str(cv, s); } - pure fn conv_char(cv: Conv, c: char) -> ~str { + pub pure fn conv_char(cv: Conv, c: char) -> ~str { let mut s = str::from_char(c); return unsafe { pad(cv, s, PadNozero) }; } - pure fn conv_str(cv: Conv, s: &str) -> ~str { + pub pure fn conv_str(cv: Conv, s: &str) -> ~str { // For strings, precision is the maximum characters // displayed let mut unpadded = match cv.precision { @@ -336,7 +338,7 @@ mod rt { }; return unsafe { pad(cv, unpadded, PadNozero) }; } - pure fn conv_float(cv: Conv, f: float) -> ~str { + pub pure fn conv_float(cv: Conv, f: float) -> ~str { let (to_str, digits) = match cv.precision { CountIs(c) => (float::to_str_exact, c as uint), CountImplied => (float::to_str, 6u) @@ -351,14 +353,14 @@ mod rt { } return unsafe { pad(cv, s, PadFloat) }; } - pure fn conv_poly<T>(cv: Conv, v: &T) -> ~str { + pub pure fn conv_poly<T>(cv: Conv, v: &T) -> ~str { let s = sys::log_str(v); return conv_str(cv, s); } // Convert an int to string with minimum number of digits. If precision is // 0 and num is 0 then the result is the empty string. - pure fn int_to_str_prec(num: int, radix: uint, prec: uint) -> ~str { + pub pure fn int_to_str_prec(num: int, radix: uint, prec: uint) -> ~str { return if num < 0 { ~"-" + uint_to_str_prec(-num as uint, radix, prec) } else { uint_to_str_prec(num as uint, radix, prec) }; @@ -367,7 +369,8 @@ mod rt { // Convert a uint to string with a minimum number of digits. If precision // is 0 and num is 0 then the result is the empty string. Could move this // to uint: but it doesn't seem all that useful. - pure fn uint_to_str_prec(num: uint, radix: uint, prec: uint) -> ~str { + pub pure fn uint_to_str_prec(num: uint, radix: uint, + prec: uint) -> ~str { return if prec == 0u && num == 0u { ~"" } else { @@ -380,16 +383,16 @@ mod rt { } else { move s } }; } - pure fn get_int_precision(cv: Conv) -> uint { + pub pure fn get_int_precision(cv: Conv) -> uint { return match cv.precision { CountIs(c) => c as uint, CountImplied => 1u }; } - enum PadMode { PadSigned, PadUnsigned, PadNozero, PadFloat } + pub enum PadMode { PadSigned, PadUnsigned, PadNozero, PadFloat } - impl PadMode : Eq { + pub impl PadMode : Eq { pure fn eq(other: &PadMode) -> bool { match (self, (*other)) { (PadSigned, PadSigned) => true, @@ -405,7 +408,7 @@ mod rt { pure fn ne(other: &PadMode) -> bool { !self.eq(other) } } - fn pad(cv: Conv, s: ~str, mode: PadMode) -> ~str { + pub fn pad(cv: Conv, s: ~str, mode: PadMode) -> ~str { let mut s = move s; // sadtimes let uwidth : uint = match cv.width { CountImplied => return s, @@ -458,209 +461,13 @@ mod rt { } return padstr + s; } - pure fn have_flag(flags: u32, f: u32) -> bool { - flags & f != 0 - } -} - -// Remove after snapshot - -// Functions used by the fmt extension at runtime. For now there are a lot of -// decisions made a runtime. If it proves worthwhile then some of these -// conditions can be evaluated at compile-time. For now though it's cleaner to -// implement it 0this way, I think. -mod rt2 { - #[legacy_exports]; - const flag_none : u32 = 0u32; - const flag_left_justify : u32 = 0b00000000000000000000000000000001u32; - const flag_left_zero_pad : u32 = 0b00000000000000000000000000000010u32; - const flag_space_for_sign : u32 = 0b00000000000000000000000000000100u32; - const flag_sign_always : u32 = 0b00000000000000000000000000001000u32; - const flag_alternate : u32 = 0b00000000000000000000000000010000u32; - - enum Count { CountIs(int), CountImplied, } - enum Ty { TyDefault, TyBits, TyHexUpper, TyHexLower, TyOctal, } - - type Conv = {flags: u32, width: Count, precision: Count, ty: Ty}; - - pure fn conv_int(cv: Conv, i: int) -> ~str { - let radix = 10; - let prec = get_int_precision(cv); - let mut s : ~str = int_to_str_prec(i, radix, prec); - if 0 <= i { - if have_flag(cv.flags, flag_sign_always) { - unsafe { str::unshift_char(&mut s, '+') }; - } else if have_flag(cv.flags, flag_space_for_sign) { - unsafe { str::unshift_char(&mut s, ' ') }; - } - } - return unsafe { pad(cv, s, PadSigned) }; - } - pure fn conv_uint(cv: Conv, u: uint) -> ~str { - let prec = get_int_precision(cv); - let mut rs = - match cv.ty { - TyDefault => uint_to_str_prec(u, 10u, prec), - TyHexLower => uint_to_str_prec(u, 16u, prec), - TyHexUpper => str::to_upper(uint_to_str_prec(u, 16u, prec)), - TyBits => uint_to_str_prec(u, 2u, prec), - TyOctal => uint_to_str_prec(u, 8u, prec) - }; - return unsafe { pad(cv, rs, PadUnsigned) }; - } - pure fn conv_bool(cv: Conv, b: bool) -> ~str { - let s = if b { ~"true" } else { ~"false" }; - // run the boolean conversion through the string conversion logic, - // giving it the same rules for precision, etc. - return conv_str(cv, s); - } - pure fn conv_char(cv: Conv, c: char) -> ~str { - let mut s = str::from_char(c); - return unsafe { pad(cv, s, PadNozero) }; - } - pure fn conv_str(cv: Conv, s: &str) -> ~str { - // For strings, precision is the maximum characters - // displayed - let mut unpadded = match cv.precision { - CountImplied => s.to_unique(), - CountIs(max) => if max as uint < str::char_len(s) { - str::substr(s, 0u, max as uint) - } else { - s.to_unique() - } - }; - return unsafe { pad(cv, unpadded, PadNozero) }; - } - pure fn conv_float(cv: Conv, f: float) -> ~str { - let (to_str, digits) = match cv.precision { - CountIs(c) => (float::to_str_exact, c as uint), - CountImplied => (float::to_str, 6u) - }; - let mut s = unsafe { to_str(f, digits) }; - if 0.0 <= f { - if have_flag(cv.flags, flag_sign_always) { - s = ~"+" + s; - } else if have_flag(cv.flags, flag_space_for_sign) { - s = ~" " + s; - } - } - return unsafe { pad(cv, s, PadFloat) }; - } - pure fn conv_poly<T>(cv: Conv, v: &T) -> ~str { - let s = sys::log_str(v); - return conv_str(cv, s); - } - - // Convert an int to string with minimum number of digits. If precision is - // 0 and num is 0 then the result is the empty string. - pure fn int_to_str_prec(num: int, radix: uint, prec: uint) -> ~str { - return if num < 0 { - ~"-" + uint_to_str_prec(-num as uint, radix, prec) - } else { uint_to_str_prec(num as uint, radix, prec) }; - } - - // Convert a uint to string with a minimum number of digits. If precision - // is 0 and num is 0 then the result is the empty string. Could move this - // to uint: but it doesn't seem all that useful. - pure fn uint_to_str_prec(num: uint, radix: uint, prec: uint) -> ~str { - return if prec == 0u && num == 0u { - ~"" - } else { - let s = uint::to_str(num, radix); - let len = str::char_len(s); - if len < prec { - let diff = prec - len; - let pad = str::from_chars(vec::from_elem(diff, '0')); - pad + s - } else { move s } - }; - } - pure fn get_int_precision(cv: Conv) -> uint { - return match cv.precision { - CountIs(c) => c as uint, - CountImplied => 1u - }; - } - - enum PadMode { PadSigned, PadUnsigned, PadNozero, PadFloat } - - impl PadMode : Eq { - pure fn eq(other: &PadMode) -> bool { - match (self, (*other)) { - (PadSigned, PadSigned) => true, - (PadUnsigned, PadUnsigned) => true, - (PadNozero, PadNozero) => true, - (PadFloat, PadFloat) => true, - (PadSigned, _) => false, - (PadUnsigned, _) => false, - (PadNozero, _) => false, - (PadFloat, _) => false - } - } - pure fn ne(other: &PadMode) -> bool { !self.eq(other) } - } - - fn pad(cv: Conv, s: ~str, mode: PadMode) -> ~str { - let mut s = move s; // sadtimes - let uwidth : uint = match cv.width { - CountImplied => return s, - CountIs(width) => { - // FIXME: width should probably be uint (see Issue #1996) - width as uint - } - }; - let strlen = str::char_len(s); - if uwidth <= strlen { return s; } - let mut padchar = ' '; - let diff = uwidth - strlen; - if have_flag(cv.flags, flag_left_justify) { - let padstr = str::from_chars(vec::from_elem(diff, padchar)); - return s + padstr; - } - let {might_zero_pad, signed} = match mode { - PadNozero => {might_zero_pad:false, signed:false}, - PadSigned => {might_zero_pad:true, signed:true }, - PadFloat => {might_zero_pad:true, signed:true}, - PadUnsigned => {might_zero_pad:true, signed:false} - }; - pure fn have_precision(cv: Conv) -> bool { - return match cv.precision { CountImplied => false, _ => true }; - } - let zero_padding = { - if might_zero_pad && have_flag(cv.flags, flag_left_zero_pad) && - (!have_precision(cv) || mode == PadFloat) { - padchar = '0'; - true - } else { - false - } - }; - let padstr = str::from_chars(vec::from_elem(diff, padchar)); - // This is completely heinous. If we have a signed value then - // potentially rip apart the intermediate result and insert some - // zeros. It may make sense to convert zero padding to a precision - // instead. - - if signed && zero_padding && s.len() > 0 { - let head = str::shift_char(&mut s); - if head == '+' || head == '-' || head == ' ' { - let headstr = str::from_chars(vec::from_elem(1u, head)); - return headstr + padstr + s; - } - else { - str::unshift_char(&mut s, head); - } - } - return padstr + s; - } - pure fn have_flag(flags: u32, f: u32) -> bool { + pub pure fn have_flag(flags: u32, f: u32) -> bool { flags & f != 0 } } #[cfg(test)] mod test { - #[legacy_exports]; #[test] fn fmt_slice() { let s = "abc"; diff --git a/src/libcore/future.rs b/src/libcore/future.rs index 11b6a2c0135..efd5ff65aa5 100644 --- a/src/libcore/future.rs +++ b/src/libcore/future.rs @@ -1,5 +1,6 @@ // NB: transitionary, de-mode-ing. -// tjc: re-forbid deprecated modes after snapshot +// tjc: allowing deprecated modes due to function issue. +// can re-forbid them after snapshot #[forbid(deprecated_pattern)]; /*! @@ -86,7 +87,7 @@ pub fn from_port<A:Send>(port: future_pipe::client::waiting<A>) -> } } -pub fn from_fn<A>(+f: ~fn() -> A) -> Future<A> { +pub fn from_fn<A>(f: ~fn() -> A) -> Future<A> { /*! * Create a future from a function. * @@ -98,7 +99,7 @@ pub fn from_fn<A>(+f: ~fn() -> A) -> Future<A> { Future {state: Pending(move f)} } -pub fn spawn<A:Send>(+blk: fn~() -> A) -> Future<A> { +pub fn spawn<A:Send>(blk: fn~() -> A) -> Future<A> { /*! * Create a future from a unique closure. * diff --git a/src/libcore/int-template.rs b/src/libcore/int-template.rs index 6942d38d5d3..8cb689fd286 100644 --- a/src/libcore/int-template.rs +++ b/src/libcore/int-template.rs @@ -1,5 +1,5 @@ // NB: transitionary, de-mode-ing. -// tjc: re-forbid deprecated modes after snapshot +#[forbid(deprecated_mode)]; #[forbid(deprecated_pattern)]; use T = inst::T; diff --git a/src/libcore/io.rs b/src/libcore/io.rs index 2efc96933da..865b8013fb0 100644 --- a/src/libcore/io.rs +++ b/src/libcore/io.rs @@ -4,6 +4,9 @@ Basic input/output */ +#[forbid(deprecated_mode)]; +#[forbid(deprecated_pattern)]; + use result::Result; use cmp::Eq; diff --git a/src/libcore/iter-trait.rs b/src/libcore/iter-trait.rs index 09bfe2eff36..6de6633f5f8 100644 --- a/src/libcore/iter-trait.rs +++ b/src/libcore/iter-trait.rs @@ -2,7 +2,8 @@ // workaround our lack of traits and lack of macros. See core.{rc,rs} for // how this file is used. -#[warn(deprecated_mode)]; +#[forbid(deprecated_mode)]; +#[forbid(deprecated_pattern)]; use cmp::{Eq, Ord}; use inst::{IMPL_T, EACH, SIZE_HINT}; diff --git a/src/libcore/iter.rs b/src/libcore/iter.rs index bf3e91f7071..322012db135 100644 --- a/src/libcore/iter.rs +++ b/src/libcore/iter.rs @@ -4,6 +4,9 @@ The iteration traits and common implementation */ +#[forbid(deprecated_mode)]; +#[forbid(deprecated_pattern)]; + use cmp::{Eq, Ord}; /// A function used to initialize the elements of a sequence diff --git a/src/libcore/mutable.rs b/src/libcore/mutable.rs index 5948c630cd8..b314ad61ee2 100644 --- a/src/libcore/mutable.rs +++ b/src/libcore/mutable.rs @@ -8,7 +8,7 @@ dynamic checks: your program will fail if you attempt to perform mutation when the data structure should be immutable. */ -// tjc: re-forbid deprecated modes after snapshot +#[forbid(deprecated_mode)]; #[forbid(deprecated_pattern)]; use util::with; diff --git a/src/libcore/ops.rs b/src/libcore/ops.rs index 038c117b8be..7c6bcf5bd51 100644 --- a/src/libcore/ops.rs +++ b/src/libcore/ops.rs @@ -1,5 +1,8 @@ // Core operators and kinds. +#[forbid(deprecated_mode)]; +#[forbid(deprecated_pattern)]; + #[lang="const"] pub trait Const { // Empty. diff --git a/src/libcore/option.rs b/src/libcore/option.rs index 6bd326186cb..c60b7b401cc 100644 --- a/src/libcore/option.rs +++ b/src/libcore/option.rs @@ -1,15 +1,37 @@ /*! - * Operations on the ubiquitous `option` type. - * - * Type `option` represents an optional value. - * - * Every `Option<T>` value can either be `Some(T)` or `none`. Where in other - * languages you might use a nullable type, in Rust you would use an option - * type. - */ - -// NB: transitionary, de-mode-ing. -#[warn(deprecated_mode)]; + +Operations on the ubiquitous `Option` type. + +Type `Option` represents an optional value. + +Every `Option<T>` value can either be `Some(T)` or `None`. Where in other +languages you might use a nullable type, in Rust you would use an option +type. + +Options are most commonly used with pattern matching to query the presence +of a value and take action, always accounting for the `None` case. + +# Example + +~~~ +let msg = Some(~"howdy"); + +// Take a reference to the contained string +match msg { + Some(ref m) => io::println(m), + None => () +} + +// Remove the contained string, destroying the Option +let unwrapped_msg = match move msg { + Some(move m) => m, + None => ~"default message" +}; +~~~ + +*/ + +#[forbid(deprecated_mode)]; #[forbid(deprecated_pattern)]; use cmp::Eq; @@ -22,12 +44,19 @@ pub enum Option<T> { pub pure fn get<T: Copy>(opt: &Option<T>) -> T { /*! - * Gets the value out of an option - * - * # Failure - * - * Fails if the value equals `none` - */ + Gets the value out of an option + + # Failure + + Fails if the value equals `None` + + # Safety note + + In general, because this function may fail, its use is discouraged + (calling `get` on `None` is akin to dereferencing a null pointer). + Instead, prefer to use pattern matching and handle the `None` + case explicitly. + */ match *opt { Some(copy x) => return x, @@ -37,11 +66,18 @@ pub pure fn get<T: Copy>(opt: &Option<T>) -> T { pub pure fn get_ref<T>(opt: &r/Option<T>) -> &r/T { /*! - * Gets an immutable reference to the value inside an option. - * - * # Failure - * - * Fails if the value equals `none` + Gets an immutable reference to the value inside an option. + + # Failure + + Fails if the value equals `None` + + # Safety note + + In general, because this function may fail, its use is discouraged + (calling `get` on `None` is akin to dereferencing a null pointer). + Instead, prefer to use pattern matching and handle the `None` + case explicitly. */ match *opt { Some(ref x) => x, @@ -154,10 +190,20 @@ pub pure fn iter<T>(opt: &Option<T>, f: fn(x: &T)) { #[inline(always)] pub pure fn unwrap<T>(opt: Option<T>) -> T { /*! - * Moves a value out of an option type and returns it. - * - * Useful primarily for getting strings, vectors and unique pointers out - * of option types without copying them. + Moves a value out of an option type and returns it. + + Useful primarily for getting strings, vectors and unique pointers out + of option types without copying them. + + # Failure + + Fails if the value equals `None`. + + # Safety note + + In general, because this function may fail, its use is discouraged. + Instead, prefer to use pattern matching and handle the `None` + case explicitly. */ match move opt { Some(move x) => move x, @@ -165,9 +211,16 @@ pub pure fn unwrap<T>(opt: Option<T>) -> T { } } -/// The ubiquitous option dance. #[inline(always)] pub fn swap_unwrap<T>(opt: &mut Option<T>) -> T { + /*! + The option dance. Moves a value out of an option type and returns it, + replacing the original with `None`. + + # Failure + + Fails if the value equals `None`. + */ if opt.is_none() { fail ~"option::swap_unwrap none" } unwrap(util::replace(opt, None)) } @@ -201,18 +254,38 @@ impl<T> &Option<T> { pure fn iter(f: fn(x: &T)) { iter(self, f) } /// Maps a `some` value from one type to another by reference pure fn map<U>(f: fn(x: &T) -> U) -> Option<U> { map(self, f) } - /// Gets an immutable reference to the value inside a `some`. + /** + Gets an immutable reference to the value inside an option. + + # Failure + + Fails if the value equals `None` + + # Safety note + + In general, because this function may fail, its use is discouraged + (calling `get` on `None` is akin to dereferencing a null pointer). + Instead, prefer to use pattern matching and handle the `None` + case explicitly. + */ pure fn get_ref() -> &self/T { get_ref(self) } } impl<T: Copy> Option<T> { /** - * Gets the value out of an option - * - * # Failure - * - * Fails if the value equals `none` - */ + Gets the value out of an option + + # Failure + + Fails if the value equals `None` + + # Safety note + + In general, because this function may fail, its use is discouraged + (calling `get` on `None` is akin to dereferencing a null pointer). + Instead, prefer to use pattern matching and handle the `None` + case explicitly. + */ pure fn get() -> T { get(&self) } pure fn get_default(def: T) -> T { get_default(&self, def) } /** @@ -252,10 +325,10 @@ impl<T: Eq> Option<T> : Eq { #[test] fn test_unwrap_ptr() { let x = ~0; - let addr_x = ptr::p2::addr_of(&(*x)); + let addr_x = ptr::addr_of(&(*x)); let opt = Some(x); let y = unwrap(opt); - let addr_y = ptr::p2::addr_of(&(*y)); + let addr_y = ptr::addr_of(&(*y)); assert addr_x == addr_y; } diff --git a/src/libcore/os.rs b/src/libcore/os.rs index 68571da3a1e..3fd98e7f298 100644 --- a/src/libcore/os.rs +++ b/src/libcore/os.rs @@ -1,5 +1,5 @@ // NB: transitionary, de-mode-ing. -// tjc: re-forbid +#[forbid(deprecated_mode)]; #[forbid(deprecated_pattern)]; /*! @@ -132,7 +132,7 @@ mod global_env { let env_ch = get_global_env_chan(); let po = comm::Port(); comm::send(env_ch, MsgGetEnv(str::from_slice(n), - comm::Chan(po))); + comm::Chan(&po))); comm::recv(po) } @@ -141,14 +141,14 @@ mod global_env { let po = comm::Port(); comm::send(env_ch, MsgSetEnv(str::from_slice(n), str::from_slice(v), - comm::Chan(po))); + comm::Chan(&po))); comm::recv(po) } pub fn env() -> ~[(~str,~str)] { let env_ch = get_global_env_chan(); let po = comm::Port(); - comm::send(env_ch, MsgEnv(comm::Chan(po))); + comm::send(env_ch, MsgEnv(comm::Chan(&po))); comm::recv(po) } diff --git a/src/libcore/pipes.rs b/src/libcore/pipes.rs index e34c0db35e9..791c6bccde8 100644 --- a/src/libcore/pipes.rs +++ b/src/libcore/pipes.rs @@ -73,7 +73,8 @@ bounded and unbounded protocols allows for less code duplication. */ // NB: transitionary, de-mode-ing. -// tjc: re-forbid deprecated modes after snapshot +// tjc: allowing deprecated modes due to function issue, +// re-forbid after snapshot #[forbid(deprecated_pattern)]; use cmp::Eq; @@ -859,7 +860,7 @@ endpoint is passed to the new task. pub fn spawn_service<T: Send, Tb: Send>( init: extern fn() -> (SendPacketBuffered<T, Tb>, RecvPacketBuffered<T, Tb>), - +service: fn~(v: RecvPacketBuffered<T, Tb>)) + service: fn~(v: RecvPacketBuffered<T, Tb>)) -> SendPacketBuffered<T, Tb> { let (client, server) = init(); @@ -883,7 +884,7 @@ receive state. pub fn spawn_service_recv<T: Send, Tb: Send>( init: extern fn() -> (RecvPacketBuffered<T, Tb>, SendPacketBuffered<T, Tb>), - +service: fn~(v: SendPacketBuffered<T, Tb>)) + service: fn~(v: SendPacketBuffered<T, Tb>)) -> RecvPacketBuffered<T, Tb> { let (client, server) = init(); diff --git a/src/libcore/private.rs b/src/libcore/private.rs index c1b2b32edaf..c4ef136a592 100644 --- a/src/libcore/private.rs +++ b/src/libcore/private.rs @@ -1,5 +1,6 @@ // NB: transitionary, de-mode-ing. -// tjc: re-forbid deprecated modes after snapshot +// tjc: Re-forbid deprecated modes once a snapshot fixes the +// function problem #[forbid(deprecated_pattern)]; #[doc(hidden)]; @@ -45,7 +46,7 @@ type GlobalPtr = *libc::uintptr_t; pub unsafe fn chan_from_global_ptr<T: Send>( global: GlobalPtr, task_fn: fn() -> task::TaskBuilder, - +f: fn~(comm::Port<T>) + f: fn~(comm::Port<T>) ) -> comm::Chan<T> { enum Msg { @@ -63,7 +64,7 @@ pub unsafe fn chan_from_global_ptr<T: Send>( let (setup_po, setup_ch) = do task_fn().spawn_conversation |move f, setup_po, setup_ch| { let po = comm::Port::<T>(); - let ch = comm::Chan(po); + let ch = comm::Chan(&po); comm::send(setup_ch, ch); // Wait to hear if we are the official instance of @@ -109,7 +110,7 @@ pub fn test_from_global_chan1() { // The global channel let globchan = 0; - let globchanp = ptr::p2::addr_of(&globchan); + let globchanp = ptr::addr_of(&globchan); // Create the global channel, attached to a new task let ch = unsafe { @@ -122,7 +123,7 @@ pub fn test_from_global_chan1() { }; // Talk to it let po = comm::Port(); - comm::send(ch, comm::Chan(po)); + comm::send(ch, comm::Chan(&po)); assert comm::recv(po) == true; // This one just reuses the previous channel @@ -135,7 +136,7 @@ pub fn test_from_global_chan1() { // Talk to the original global task let po = comm::Port(); - comm::send(ch, comm::Chan(po)); + comm::send(ch, comm::Chan(&po)); assert comm::recv(po) == true; } @@ -145,10 +146,10 @@ pub fn test_from_global_chan2() { for iter::repeat(100) { // The global channel let globchan = 0; - let globchanp = ptr::p2::addr_of(&globchan); + let globchanp = ptr::addr_of(&globchan); let resultpo = comm::Port(); - let resultch = comm::Chan(resultpo); + let resultch = comm::Chan(&resultpo); // Spawn a bunch of tasks that all want to compete to // create the global channel @@ -165,7 +166,7 @@ pub fn test_from_global_chan2() { } }; let po = comm::Port(); - comm::send(ch, comm::Chan(po)); + comm::send(ch, comm::Chan(&po)); // We are The winner if our version of the // task was installed let winner = comm::recv(po); @@ -203,7 +204,7 @@ pub fn test_from_global_chan2() { */ pub unsafe fn weaken_task(f: fn(comm::Port<()>)) { let po = comm::Port(); - let ch = comm::Chan(po); + let ch = comm::Chan(&po); unsafe { rustrt::rust_task_weaken(cast::reinterpret_cast(&ch)); } diff --git a/src/libcore/ptr.rs b/src/libcore/ptr.rs index fad7eddd2d8..ffa11dcfc75 100644 --- a/src/libcore/ptr.rs +++ b/src/libcore/ptr.rs @@ -1,5 +1,8 @@ //! Unsafe pointer utility functions +#[forbid(deprecated_mode)]; +#[forbid(deprecated_pattern)]; + use cmp::{Eq, Ord}; use libc::{c_void, size_t}; @@ -28,12 +31,6 @@ extern mod rusti { #[inline(always)] pub pure fn addr_of<T>(val: &T) -> *T { unsafe { rusti::addr_of(*val) } } -pub mod p2 { - /// Get an unsafe pointer to a value - #[inline(always)] - pub pure fn addr_of<T>(val: &T) -> *T { unsafe { rusti::addr_of(*val) } } -} - /// Get an unsafe mut pointer to a value #[inline(always)] pub pure fn mut_addr_of<T>(val: &T) -> *mut T { diff --git a/src/libcore/rand.rs b/src/libcore/rand.rs index 32f77a533a6..786fed88de9 100644 --- a/src/libcore/rand.rs +++ b/src/libcore/rand.rs @@ -1,7 +1,7 @@ //! Random number generation // NB: transitional, de-mode-ing. -#[warn(deprecated_mode)]; +#[forbid(deprecated_mode)]; #[forbid(deprecated_pattern)]; #[allow(non_camel_case_types)] // runtime type @@ -310,7 +310,7 @@ pub fn seeded_xorshift(x: u32, y: u32, z: u32, w: u32) -> Rng { // used to make space in TLS for a random number generator -fn tls_rng_state(+_v: @RandRes) {} +fn tls_rng_state(_v: @RandRes) {} /** * Gives back a lazily initialized task-local random number generator, diff --git a/src/libcore/reflect.rs b/src/libcore/reflect.rs index 41006e1dfb5..505804b3da8 100644 --- a/src/libcore/reflect.rs +++ b/src/libcore/reflect.rs @@ -4,6 +4,9 @@ Runtime type reflection */ +#[forbid(deprecated_mode)]; +#[forbid(deprecated_pattern)]; + use intrinsic::{TyDesc, get_tydesc, visit_tydesc, TyVisitor}; use libc::c_void; diff --git a/src/libcore/repr.rs b/src/libcore/repr.rs index ff82ed3fb41..0501b032d2d 100644 --- a/src/libcore/repr.rs +++ b/src/libcore/repr.rs @@ -4,6 +4,9 @@ More runtime type reflection */ +#[forbid(deprecated_mode)]; +#[forbid(deprecated_pattern)]; + use dvec::DVec; use io::{Writer, WriterUtil}; use libc::c_void; diff --git a/src/libcore/result.rs b/src/libcore/result.rs index e61690d5b2c..39fae8905f9 100644 --- a/src/libcore/result.rs +++ b/src/libcore/result.rs @@ -1,7 +1,8 @@ //! A type representing either success or failure // NB: transitionary, de-mode-ing. -// tjc: re-forbid deprecated modes after snapshot + +#[forbid(deprecated_mode)]; #[forbid(deprecated_pattern)]; use cmp::Eq; diff --git a/src/libcore/run.rs b/src/libcore/run.rs index f3e98f6ba82..0ff91749209 100644 --- a/src/libcore/run.rs +++ b/src/libcore/run.rs @@ -1,5 +1,5 @@ // NB: transitionary, de-mode-ing. -// tjc: re-forbid deprecated modes after snapshot +#[forbid(deprecated_mode)]; #[forbid(deprecated_pattern)]; //! Process spawning @@ -296,7 +296,7 @@ pub fn program_output(prog: &str, args: &[~str]) -> // or the other. FIXME (#2625): Surely there's a much more // clever way to do this. let p = comm::Port(); - let ch = comm::Chan(p); + let ch = comm::Chan(&p); do task::spawn_sched(task::SingleThreaded) { let errput = readclose(pipe_err.in); comm::send(ch, (2, move errput)); diff --git a/src/libcore/stackwalk.rs b/src/libcore/stackwalk.rs index 09973148c8c..a88a44701ce 100644 --- a/src/libcore/stackwalk.rs +++ b/src/libcore/stackwalk.rs @@ -3,8 +3,8 @@ #[legacy_modes]; // tjc: remove after snapshot // NB: transitionary, de-mode-ing. -// XXX: Can't do this because frame_address needs a deprecated mode. -//#[forbid(deprecated_mode)]; +// XXX: Can't forbid this because frame_address needs a deprecated mode. +#[allow(deprecated_mode)]; #[forbid(deprecated_pattern)]; use cast::reinterpret_cast; diff --git a/src/libcore/str.rs b/src/libcore/str.rs index cf996a8b254..285b6114957 100644 --- a/src/libcore/str.rs +++ b/src/libcore/str.rs @@ -7,8 +7,8 @@ * some heavy-duty uses, try std::rope. */ -#[warn(deprecated_mode)]; -#[warn(deprecated_pattern)]; +#[forbid(deprecated_mode)]; +#[forbid(deprecated_pattern)]; use cmp::{Eq, Ord}; use libc::size_t; diff --git a/src/libcore/task.rs b/src/libcore/task.rs index 5ca35a7f562..8d7791d18d9 100644 --- a/src/libcore/task.rs +++ b/src/libcore/task.rs @@ -1,5 +1,6 @@ // NB: transitionary, de-mode-ing. -// tjc: re-forbid deprecated modes after snapshot +// tjc: Deprecated modes allowed because of function arg issue +// in task::spawn. Re-forbid after snapshot. #[forbid(deprecated_pattern)]; /*! @@ -219,7 +220,7 @@ pub type TaskOpts = { // FIXME (#2585): Replace the 'consumed' bit with move mode on self pub enum TaskBuilder = { opts: TaskOpts, - gen_body: fn@(+v: fn~()) -> fn~(), + gen_body: fn@(v: fn~()) -> fn~(), can_not_copy: Option<util::NonCopyable>, mut consumed: bool, }; @@ -232,7 +233,7 @@ pub enum TaskBuilder = { pub fn task() -> TaskBuilder { TaskBuilder({ opts: default_task_opts(), - gen_body: |+body| move body, // Identity function + gen_body: |body| move body, // Identity function can_not_copy: None, mut consumed: false, }) @@ -409,7 +410,7 @@ impl TaskBuilder { * generator by applying the task body which results from the * existing body generator to the new body generator. */ - fn add_wrapper(wrapper: fn@(+v: fn~()) -> fn~()) -> TaskBuilder { + fn add_wrapper(wrapper: fn@(v: fn~()) -> fn~()) -> TaskBuilder { let prev_gen_body = self.gen_body; let notify_chan = if self.opts.notify_chan.is_none() { None @@ -441,7 +442,7 @@ impl TaskBuilder { * When spawning into a new scheduler, the number of threads requested * must be greater than zero. */ - fn spawn(+f: fn~()) { + fn spawn(f: fn~()) { let notify_chan = if self.opts.notify_chan.is_none() { None } else { @@ -459,7 +460,7 @@ impl TaskBuilder { spawn::spawn_raw(move opts, x.gen_body(move f)); } /// Runs a task, while transfering ownership of one argument to the child. - fn spawn_with<A: Send>(arg: A, +f: fn~(+v: A)) { + fn spawn_with<A: Send>(arg: A, f: fn~(v: A)) { let arg = ~mut Some(move arg); do self.spawn |move arg, move f| { f(option::swap_unwrap(arg)) @@ -477,12 +478,12 @@ impl TaskBuilder { * otherwise be required to establish communication from the parent * to the child. */ - fn spawn_listener<A: Send>(+f: fn~(comm::Port<A>)) -> comm::Chan<A> { + fn spawn_listener<A: Send>(f: fn~(comm::Port<A>)) -> comm::Chan<A> { let setup_po = comm::Port(); - let setup_ch = comm::Chan(setup_po); + let setup_ch = comm::Chan(&setup_po); do self.spawn |move f| { let po = comm::Port(); - let ch = comm::Chan(po); + let ch = comm::Chan(&po); comm::send(setup_ch, ch); f(move po); } @@ -493,10 +494,10 @@ impl TaskBuilder { * Runs a new task, setting up communication in both directions */ fn spawn_conversation<A: Send, B: Send> - (+f: fn~(comm::Port<A>, comm::Chan<B>)) + (f: fn~(comm::Port<A>, comm::Chan<B>)) -> (comm::Port<B>, comm::Chan<A>) { let from_child = comm::Port(); - let to_parent = comm::Chan(from_child); + let to_parent = comm::Chan(&from_child); let to_child = do self.spawn_listener |move f, from_parent| { f(from_parent, to_parent) }; @@ -516,9 +517,9 @@ impl TaskBuilder { * # Failure * Fails if a future_result was already set for this task. */ - fn try<T: Send>(+f: fn~() -> T) -> Result<T,()> { + fn try<T: Send>(f: fn~() -> T) -> Result<T,()> { let po = comm::Port(); - let ch = comm::Chan(po); + let ch = comm::Chan(&po); let mut result = None; let fr_task_builder = self.future_result(|+r| { @@ -555,7 +556,7 @@ pub fn default_task_opts() -> TaskOpts { /* Spawn convenience functions */ -pub fn spawn(+f: fn~()) { +pub fn spawn(f: fn~()) { /*! * Creates and executes a new child task * @@ -568,7 +569,7 @@ pub fn spawn(+f: fn~()) { task().spawn(move f) } -pub fn spawn_unlinked(+f: fn~()) { +pub fn spawn_unlinked(f: fn~()) { /*! * Creates a child task unlinked from the current one. If either this * task or the child task fails, the other will not be killed. @@ -577,7 +578,7 @@ pub fn spawn_unlinked(+f: fn~()) { task().unlinked().spawn(move f) } -pub fn spawn_supervised(+f: fn~()) { +pub fn spawn_supervised(f: fn~()) { /*! * Creates a child task unlinked from the current one. If either this * task or the child task fails, the other will not be killed. @@ -586,7 +587,7 @@ pub fn spawn_supervised(+f: fn~()) { task().supervised().spawn(move f) } -pub fn spawn_with<A:Send>(+arg: A, +f: fn~(+v: A)) { +pub fn spawn_with<A:Send>(arg: A, f: fn~(v: A)) { /*! * Runs a task, while transfering ownership of one argument to the * child. @@ -600,7 +601,7 @@ pub fn spawn_with<A:Send>(+arg: A, +f: fn~(+v: A)) { task().spawn_with(move arg, move f) } -pub fn spawn_listener<A:Send>(+f: fn~(comm::Port<A>)) -> comm::Chan<A> { +pub fn spawn_listener<A:Send>(f: fn~(comm::Port<A>)) -> comm::Chan<A> { /*! * Runs a new task while providing a channel from the parent to the child * @@ -611,7 +612,7 @@ pub fn spawn_listener<A:Send>(+f: fn~(comm::Port<A>)) -> comm::Chan<A> { } pub fn spawn_conversation<A: Send, B: Send> - (+f: fn~(comm::Port<A>, comm::Chan<B>)) + (f: fn~(comm::Port<A>, comm::Chan<B>)) -> (comm::Port<B>, comm::Chan<A>) { /*! * Runs a new task, setting up communication in both directions @@ -622,7 +623,7 @@ pub fn spawn_conversation<A: Send, B: Send> task().spawn_conversation(move f) } -pub fn spawn_sched(mode: SchedMode, +f: fn~()) { +pub fn spawn_sched(mode: SchedMode, f: fn~()) { /*! * Creates a new scheduler and executes a task on it * @@ -639,7 +640,7 @@ pub fn spawn_sched(mode: SchedMode, +f: fn~()) { task().sched_mode(mode).spawn(move f) } -pub fn try<T:Send>(+f: fn~() -> T) -> Result<T,()> { +pub fn try<T:Send>(f: fn~() -> T) -> Result<T,()> { /*! * Execute a function in another task and return either the return value * of the function or result::err. @@ -772,7 +773,7 @@ fn test_cant_dup_task_builder() { #[test] #[ignore(cfg(windows))] fn test_spawn_unlinked_unsup_no_fail_down() { // grandchild sends on a port let po = comm::Port(); - let ch = comm::Chan(po); + let ch = comm::Chan(&po); do spawn_unlinked { do spawn_unlinked { // Give middle task a chance to fail-but-not-kill-us. @@ -802,7 +803,7 @@ fn test_spawn_unlinked_sup_fail_down() { #[test] #[should_fail] #[ignore(cfg(windows))] fn test_spawn_linked_sup_fail_up() { // child fails; parent fails let po = comm::Port::<()>(); - let _ch = comm::Chan(po); + let _ch = comm::Chan(&po); // Unidirectional "parenting" shouldn't override bidirectional linked. // We have to cheat with opts - the interface doesn't support them because // they don't make sense (redundant with task().supervised()). @@ -845,7 +846,7 @@ fn test_spawn_linked_sup_fail_down() { // parent fails; child fails #[test] #[should_fail] #[ignore(cfg(windows))] fn test_spawn_linked_unsup_fail_up() { // child fails; parent fails let po = comm::Port::<()>(); - let _ch = comm::Chan(po); + let _ch = comm::Chan(&po); // Default options are to spawn linked & unsupervised. do spawn { fail; } comm::recv(po); // We should get punted awake @@ -917,7 +918,7 @@ fn test_spawn_linked_sup_propagate_sibling() { #[test] fn test_run_basic() { let po = comm::Port(); - let ch = comm::Chan(po); + let ch = comm::Chan(&po); do task().spawn { comm::send(ch, ()); } @@ -927,7 +928,7 @@ fn test_run_basic() { #[test] fn test_add_wrapper() { let po = comm::Port(); - let ch = comm::Chan(po); + let ch = comm::Chan(&po); let b0 = task(); let b1 = do b0.add_wrapper |body| { fn~() { @@ -961,7 +962,7 @@ fn test_back_to_the_future_result() { #[test] fn test_spawn_listiner_bidi() { let po = comm::Port(); - let ch = comm::Chan(po); + let ch = comm::Chan(&po); let ch = do spawn_listener |po| { // Now the child has a port called 'po' to read from and // an environment-captured channel called 'ch'. @@ -1017,7 +1018,7 @@ fn test_spawn_sched_no_threads() { #[test] fn test_spawn_sched() { let po = comm::Port(); - let ch = comm::Chan(po); + let ch = comm::Chan(&po); fn f(i: int, ch: comm::Chan<()>) { let parent_sched_id = rt::rust_get_sched_id(); @@ -1041,7 +1042,7 @@ fn test_spawn_sched() { #[test] fn test_spawn_sched_childs_on_same_sched() { let po = comm::Port(); - let ch = comm::Chan(po); + let ch = comm::Chan(&po); do spawn_sched(SingleThreaded) { let parent_sched_id = rt::rust_get_sched_id(); @@ -1075,9 +1076,9 @@ fn test_spawn_sched_blocking() { for iter::repeat(20u) { let start_po = comm::Port(); - let start_ch = comm::Chan(start_po); + let start_ch = comm::Chan(&start_po); let fin_po = comm::Port(); - let fin_ch = comm::Chan(fin_po); + let fin_ch = comm::Chan(&fin_po); let lock = testrt::rust_dbg_lock_create(); @@ -1105,12 +1106,12 @@ fn test_spawn_sched_blocking() { } let setup_po = comm::Port(); - let setup_ch = comm::Chan(setup_po); + let setup_ch = comm::Chan(&setup_po); let parent_po = comm::Port(); - let parent_ch = comm::Chan(parent_po); + let parent_ch = comm::Chan(&parent_po); do spawn { let child_po = comm::Port(); - comm::send(setup_ch, comm::Chan(child_po)); + comm::send(setup_ch, comm::Chan(&child_po)); pingpong(child_po, parent_ch); }; @@ -1126,15 +1127,15 @@ fn test_spawn_sched_blocking() { } #[cfg(test)] -fn avoid_copying_the_body(spawnfn: fn(+v: fn~())) { +fn avoid_copying_the_body(spawnfn: fn(v: fn~())) { let p = comm::Port::<uint>(); - let ch = comm::Chan(p); + let ch = comm::Chan(&p); let x = ~1; - let x_in_parent = ptr::p2::addr_of(&(*x)) as uint; + let x_in_parent = ptr::addr_of(&(*x)) as uint; do spawnfn { - let x_in_child = ptr::p2::addr_of(&(*x)) as uint; + let x_in_child = ptr::addr_of(&(*x)) as uint; comm::send(ch, x_in_child); } @@ -1149,7 +1150,7 @@ fn test_avoid_copying_the_body_spawn() { #[test] fn test_avoid_copying_the_body_spawn_listener() { - do avoid_copying_the_body |+f| { + do avoid_copying_the_body |f| { spawn_listener(fn~(move f, _po: comm::Port<int>) { f(); }); @@ -1167,7 +1168,7 @@ fn test_avoid_copying_the_body_task_spawn() { #[test] fn test_avoid_copying_the_body_spawn_listener_1() { - do avoid_copying_the_body |+f| { + do avoid_copying_the_body |f| { task().spawn_listener(fn~(move f, _po: comm::Port<int>) { f(); }); @@ -1195,7 +1196,7 @@ fn test_avoid_copying_the_body_unlinked() { #[test] fn test_platform_thread() { let po = comm::Port(); - let ch = comm::Chan(po); + let ch = comm::Chan(&po); do task().sched_mode(PlatformThread).spawn { comm::send(ch, ()); } diff --git a/src/libcore/task/local_data.rs b/src/libcore/task/local_data.rs index 2130354229a..99101189315 100644 --- a/src/libcore/task/local_data.rs +++ b/src/libcore/task/local_data.rs @@ -78,7 +78,7 @@ pub unsafe fn local_data_modify<T: Owned>( } #[test] -pub fn test_tls_multitask() unsafe { +fn test_tls_multitask() unsafe { fn my_key(_x: @~str) { } local_data_set(my_key, @~"parent data"); do task::spawn unsafe { @@ -94,7 +94,7 @@ pub fn test_tls_multitask() unsafe { } #[test] -pub fn test_tls_overwrite() unsafe { +fn test_tls_overwrite() unsafe { fn my_key(_x: @~str) { } local_data_set(my_key, @~"first data"); local_data_set(my_key, @~"next data"); // Shouldn't leak. @@ -102,7 +102,7 @@ pub fn test_tls_overwrite() unsafe { } #[test] -pub fn test_tls_pop() unsafe { +fn test_tls_pop() unsafe { fn my_key(_x: @~str) { } local_data_set(my_key, @~"weasel"); assert *(local_data_pop(my_key).get()) == ~"weasel"; @@ -111,7 +111,7 @@ pub fn test_tls_pop() unsafe { } #[test] -pub fn test_tls_modify() unsafe { +fn test_tls_modify() unsafe { fn my_key(_x: @~str) { } local_data_modify(my_key, |data| { match data { @@ -130,7 +130,7 @@ pub fn test_tls_modify() unsafe { } #[test] -pub fn test_tls_crust_automorestack_memorial_bug() unsafe { +fn test_tls_crust_automorestack_memorial_bug() unsafe { // This might result in a stack-canary clobber if the runtime fails to set // sp_limit to 0 when calling the cleanup extern - it might automatically // jump over to the rust stack, which causes next_c_sp to get recorded as @@ -143,7 +143,7 @@ pub fn test_tls_crust_automorestack_memorial_bug() unsafe { } #[test] -pub fn test_tls_multiple_types() unsafe { +fn test_tls_multiple_types() unsafe { fn str_key(_x: @~str) { } fn box_key(_x: @@()) { } fn int_key(_x: @int) { } @@ -155,7 +155,7 @@ pub fn test_tls_multiple_types() unsafe { } #[test] -pub fn test_tls_overwrite_multiple_types() { +fn test_tls_overwrite_multiple_types() { fn str_key(_x: @~str) { } fn box_key(_x: @@()) { } fn int_key(_x: @int) { } @@ -171,7 +171,7 @@ pub fn test_tls_overwrite_multiple_types() { #[test] #[should_fail] #[ignore(cfg(windows))] -pub fn test_tls_cleanup_on_failure() unsafe { +fn test_tls_cleanup_on_failure() unsafe { fn str_key(_x: @~str) { } fn box_key(_x: @@()) { } fn int_key(_x: @int) { } diff --git a/src/libcore/task/local_data_priv.rs b/src/libcore/task/local_data_priv.rs index 9849ce7b68c..e84e4dad164 100644 --- a/src/libcore/task/local_data_priv.rs +++ b/src/libcore/task/local_data_priv.rs @@ -17,11 +17,11 @@ impl LocalData: Eq { // We use dvec because it's the best data structure in core. If TLS is used // heavily in future, this could be made more efficient with a proper map. -pub type TaskLocalElement = (*libc::c_void, *libc::c_void, LocalData); +type TaskLocalElement = (*libc::c_void, *libc::c_void, LocalData); // Has to be a pointer at outermost layer; the foreign call returns void *. -pub type TaskLocalMap = @dvec::DVec<Option<TaskLocalElement>>; +type TaskLocalMap = @dvec::DVec<Option<TaskLocalElement>>; -pub extern fn cleanup_task_local_map(map_ptr: *libc::c_void) unsafe { +extern fn cleanup_task_local_map(map_ptr: *libc::c_void) unsafe { assert !map_ptr.is_null(); // Get and keep the single reference that was created at the beginning. let _map: TaskLocalMap = cast::reinterpret_cast(&map_ptr); @@ -29,7 +29,7 @@ pub extern fn cleanup_task_local_map(map_ptr: *libc::c_void) unsafe { } // Gets the map from the runtime. Lazily initialises if not done so already. -pub unsafe fn get_task_local_map(task: *rust_task) -> TaskLocalMap { +unsafe fn get_task_local_map(task: *rust_task) -> TaskLocalMap { // Relies on the runtime initialising the pointer to null. // NOTE: The map's box lives in TLS invisibly referenced once. Each time @@ -52,7 +52,7 @@ pub unsafe fn get_task_local_map(task: *rust_task) -> TaskLocalMap { } } -pub unsafe fn key_to_key_value<T: Owned>( +unsafe fn key_to_key_value<T: Owned>( key: LocalDataKey<T>) -> *libc::c_void { // Keys are closures, which are (fnptr,envptr) pairs. Use fnptr. @@ -62,7 +62,7 @@ pub unsafe fn key_to_key_value<T: Owned>( } // If returning Some(..), returns with @T with the map's reference. Careful! -pub unsafe fn local_data_lookup<T: Owned>( +unsafe fn local_data_lookup<T: Owned>( map: TaskLocalMap, key: LocalDataKey<T>) -> Option<(uint, *libc::c_void)> { @@ -80,7 +80,7 @@ pub unsafe fn local_data_lookup<T: Owned>( } } -pub unsafe fn local_get_helper<T: Owned>( +unsafe fn local_get_helper<T: Owned>( task: *rust_task, key: LocalDataKey<T>, do_pop: bool) -> Option<@T> { diff --git a/src/libcore/task/spawn.rs b/src/libcore/task/spawn.rs index 0e1284da3bc..6eaace1fa1a 100644 --- a/src/libcore/task/spawn.rs +++ b/src/libcore/task/spawn.rs @@ -61,6 +61,7 @@ ****************************************************************************/ #[doc(hidden)]; // FIXME #3538 +#[warn(deprecated_mode)]; use rt::rust_task; use rt::rust_closure; @@ -69,16 +70,16 @@ macro_rules! move_it ( { $x:expr } => { unsafe { let y <- *ptr::addr_of(&($x)); move y } } ) -pub type TaskSet = send_map::linear::LinearMap<*rust_task,()>; +type TaskSet = send_map::linear::LinearMap<*rust_task,()>; -pub fn new_taskset() -> TaskSet { +fn new_taskset() -> TaskSet { send_map::linear::LinearMap() } -pub fn taskset_insert(tasks: &mut TaskSet, task: *rust_task) { +fn taskset_insert(tasks: &mut TaskSet, task: *rust_task) { let didnt_overwrite = tasks.insert(task, ()); assert didnt_overwrite; } -pub fn taskset_remove(tasks: &mut TaskSet, task: *rust_task) { +fn taskset_remove(tasks: &mut TaskSet, task: *rust_task) { let was_present = tasks.remove(&task); assert was_present; } @@ -87,7 +88,7 @@ pub fn taskset_each(tasks: &TaskSet, blk: fn(v: *rust_task) -> bool) { } // One of these per group of linked-failure tasks. -pub type TaskGroupData = { +type TaskGroupData = { // All tasks which might kill this group. When this is empty, the group // can be "GC"ed (i.e., its link in the ancestor list can be removed). mut members: TaskSet, @@ -95,12 +96,12 @@ pub type TaskGroupData = { // tasks in this group. mut descendants: TaskSet, }; -pub type TaskGroupArc = private::Exclusive<Option<TaskGroupData>>; +type TaskGroupArc = private::Exclusive<Option<TaskGroupData>>; -pub type TaskGroupInner = &mut Option<TaskGroupData>; +type TaskGroupInner = &mut Option<TaskGroupData>; // A taskgroup is 'dead' when nothing can cause it to fail; only members can. -pub pure fn taskgroup_is_dead(tg: &TaskGroupData) -> bool { +pure fn taskgroup_is_dead(tg: &TaskGroupData) -> bool { (&tg.members).is_empty() } @@ -111,7 +112,7 @@ pub pure fn taskgroup_is_dead(tg: &TaskGroupData) -> bool { // taskgroup which was spawned-unlinked. Tasks from intermediate generations // have references to the middle of the list; when intermediate generations // die, their node in the list will be collected at a descendant's spawn-time. -pub type AncestorNode = { +type AncestorNode = { // Since the ancestor list is recursive, we end up with references to // exclusives within other exclusives. This is dangerous business (if // circular references arise, deadlock and memory leaks are imminent). @@ -124,16 +125,16 @@ pub type AncestorNode = { // Recursive rest of the list. mut ancestors: AncestorList, }; -pub enum AncestorList = Option<private::Exclusive<AncestorNode>>; +enum AncestorList = Option<private::Exclusive<AncestorNode>>; // Accessors for taskgroup arcs and ancestor arcs that wrap the unsafety. #[inline(always)] -pub fn access_group<U>(x: &TaskGroupArc, blk: fn(TaskGroupInner) -> U) -> U { +fn access_group<U>(x: &TaskGroupArc, blk: fn(TaskGroupInner) -> U) -> U { unsafe { x.with(blk) } } #[inline(always)] -pub fn access_ancestors<U>(x: &private::Exclusive<AncestorNode>, +fn access_ancestors<U>(x: &private::Exclusive<AncestorNode>, blk: fn(x: &mut AncestorNode) -> U) -> U { unsafe { x.with(blk) } } @@ -146,7 +147,7 @@ pub fn access_ancestors<U>(x: &private::Exclusive<AncestorNode>, // (3) As a bonus, coalesces away all 'dead' taskgroup nodes in the list. // FIXME(#2190): Change Option<fn@(...)> to Option<fn&(...)>, to save on // allocations. Once that bug is fixed, changing the sigil should suffice. -pub fn each_ancestor(list: &mut AncestorList, +fn each_ancestor(list: &mut AncestorList, bail_opt: Option<fn@(TaskGroupInner)>, forward_blk: fn(TaskGroupInner) -> bool) -> bool { @@ -271,7 +272,7 @@ pub fn each_ancestor(list: &mut AncestorList, } // One of these per task. -pub struct TCB { +struct TCB { me: *rust_task, // List of tasks with whose fates this one's is intertwined. tasks: TaskGroupArc, // 'none' means the group has failed. @@ -303,7 +304,7 @@ pub struct TCB { } } -pub fn TCB(me: *rust_task, tasks: TaskGroupArc, ancestors: AncestorList, +fn TCB(me: *rust_task, tasks: TaskGroupArc, ancestors: AncestorList, is_main: bool, notifier: Option<AutoNotify>) -> TCB { let notifier = move notifier; @@ -318,7 +319,7 @@ pub fn TCB(me: *rust_task, tasks: TaskGroupArc, ancestors: AncestorList, } } -pub struct AutoNotify { +struct AutoNotify { notify_chan: Chan<Notification>, mut failed: bool, drop { @@ -327,14 +328,14 @@ pub struct AutoNotify { } } -pub fn AutoNotify(chan: Chan<Notification>) -> AutoNotify { +fn AutoNotify(chan: Chan<Notification>) -> AutoNotify { AutoNotify { notify_chan: chan, failed: true // Un-set above when taskgroup successfully made. } } -pub fn enlist_in_taskgroup(state: TaskGroupInner, me: *rust_task, +fn enlist_in_taskgroup(state: TaskGroupInner, me: *rust_task, is_member: bool) -> bool { let newstate = util::replace(state, None); // If 'None', the group was failing. Can't enlist. @@ -350,7 +351,7 @@ pub fn enlist_in_taskgroup(state: TaskGroupInner, me: *rust_task, } // NB: Runs in destructor/post-exit context. Can't 'fail'. -pub fn leave_taskgroup(state: TaskGroupInner, me: *rust_task, +fn leave_taskgroup(state: TaskGroupInner, me: *rust_task, is_member: bool) { let newstate = util::replace(state, None); // If 'None', already failing and we've already gotten a kill signal. @@ -363,7 +364,7 @@ pub fn leave_taskgroup(state: TaskGroupInner, me: *rust_task, } // NB: Runs in destructor/post-exit context. Can't 'fail'. -pub fn kill_taskgroup(state: TaskGroupInner, me: *rust_task, is_main: bool) { +fn kill_taskgroup(state: TaskGroupInner, me: *rust_task, is_main: bool) { // NB: We could do the killing iteration outside of the group arc, by // having "let mut newstate" here, swapping inside, and iterating after. // But that would let other exiting tasks fall-through and exit while we @@ -405,7 +406,7 @@ macro_rules! taskgroup_key ( () => (cast::transmute((-2 as uint, 0u))) ) -pub fn gen_child_taskgroup(linked: bool, supervised: bool) +fn gen_child_taskgroup(linked: bool, supervised: bool) -> (TaskGroupArc, AncestorList, bool) { let spawner = rt::rust_get_task(); /*######################################################################* @@ -487,7 +488,7 @@ pub fn gen_child_taskgroup(linked: bool, supervised: bool) } } -pub fn spawn_raw(opts: TaskOpts, +f: fn~()) { +pub fn spawn_raw(opts: TaskOpts, f: fn~()) { let (child_tg, ancestors, is_main) = gen_child_taskgroup(opts.linked, opts.supervised); @@ -532,7 +533,7 @@ pub fn spawn_raw(opts: TaskOpts, +f: fn~()) { fn make_child_wrapper(child: *rust_task, child_arc: TaskGroupArc, ancestors: AncestorList, is_main: bool, notify_chan: Option<Chan<Notification>>, - +f: fn~()) -> fn~() { + f: fn~()) -> fn~() { let child_data = ~mut Some((move child_arc, move ancestors)); return fn~(move notify_chan, move child_data, move f) { // Agh. Get move-mode items into the closure. FIXME (#2829) @@ -636,7 +637,7 @@ pub fn spawn_raw(opts: TaskOpts, +f: fn~()) { #[test] fn test_spawn_raw_simple() { let po = comm::Port(); - let ch = comm::Chan(po); + let ch = comm::Chan(&po); do spawn_raw(default_task_opts()) { comm::send(ch, ()); } diff --git a/src/libcore/util.rs b/src/libcore/util.rs index aa1fe14ba88..6c633f16abf 100644 --- a/src/libcore/util.rs +++ b/src/libcore/util.rs @@ -5,7 +5,7 @@ Miscellaneous helpers for common patterns. */ // NB: transitionary, de-mode-ing. -// tjc: re-forbid deprecated modes after snapshot +#[forbid(deprecated_mode)]; #[forbid(deprecated_pattern)]; use cmp::Eq; diff --git a/src/libcore/vec.rs b/src/libcore/vec.rs index 0c822bd0a03..3a2b73f5b5b 100644 --- a/src/libcore/vec.rs +++ b/src/libcore/vec.rs @@ -1,7 +1,7 @@ //! Vectors -#[warn(deprecated_mode)]; -#[warn(deprecated_pattern)]; +#[forbid(deprecated_mode)]; +#[forbid(deprecated_pattern)]; #[warn(non_camel_case_types)]; use cmp::{Eq, Ord}; @@ -18,9 +18,10 @@ extern mod rustrt { #[abi = "rust-intrinsic"] extern mod rusti { - fn move_val_init<T>(&dst: T, -src: T); + fn move_val_init<T>(dst: &mut T, -src: T); } + /// Returns true if a vector contains no elements pub pure fn is_empty<T>(v: &[const T]) -> bool { as_const_buf(v, |_p, len| len == 0u) @@ -104,7 +105,7 @@ pub pure fn from_fn<T>(n_elts: uint, op: iter::InitOp<T>) -> ~[T] { do as_mut_buf(v) |p, _len| { let mut i: uint = 0u; while i < n_elts { - rusti::move_val_init(*ptr::mut_offset(p, i), op(i)); + rusti::move_val_init(&mut(*ptr::mut_offset(p, i)), op(i)); i += 1u; } } @@ -489,7 +490,7 @@ unsafe fn push_fast<T>(v: &mut ~[T], initval: T) { (**repr).unboxed.fill += sys::size_of::<T>(); let p = addr_of(&((**repr).unboxed.data)); let p = ptr::offset(p, fill) as *mut T; - rusti::move_val_init(*p, move initval); + rusti::move_val_init(&mut(*p), move initval); } #[inline(never)] @@ -1769,7 +1770,7 @@ pub mod raw { do as_mut_buf(v) |p, _len| { let mut box2 = None; box2 <-> box; - rusti::move_val_init(*ptr::mut_offset(p, i), + rusti::move_val_init(&mut(*ptr::mut_offset(p, i)), option::unwrap(move box2)); } } @@ -1918,10 +1919,9 @@ impl<A: Copy> &[A]: iter::CopyableIter<A> { } pure fn to_vec() -> ~[A] { iter::to_vec(&self) } - // FIXME--bug in resolve prevents this from working (#2611) - // fn flat_map_to_vec<B:copy,IB:base_iter<B>>(op: fn(A) -> IB) -> ~[B] { - // iter::flat_map_to_vec(self, op) - // } + pure fn flat_map_to_vec<B:Copy,IB:BaseIter<B>>(op: fn(A) -> IB) -> ~[B] { + iter::flat_map_to_vec(&self, op) + } pub pure fn find(p: fn(a: A) -> bool) -> Option<A> { iter::find(&self, p) |