From 56dbf3d1223bca9e02a201e43fb48895a1d5cbd1 Mon Sep 17 00:00:00 2001 From: Eduard Burtescu Date: Sat, 1 Nov 2014 19:51:16 +0200 Subject: [PATCH] Register snapshots. --- src/libcore/fmt/mod.rs | 153 -------------------------- src/libcore/intrinsics.rs | 1 - src/libcore/ops.rs | 12 +- src/libcore/panicking.rs | 47 -------- src/librustc/middle/typeck/collect.rs | 18 +-- src/librustrt/unwind.rs | 8 -- src/libstd/fmt.rs | 16 --- src/libsyntax/ast.rs | 3 - src/libsyntax/parse/lexer/mod.rs | 6 - src/libsyntax/parse/parser.rs | 11 -- src/libsyntax/parse/token.rs | 77 ------------- src/snapshots.txt | 9 ++ src/test/run-pass/issue-16739.rs | 9 +- 13 files changed, 18 insertions(+), 352 deletions(-) diff --git a/src/libcore/fmt/mod.rs b/src/libcore/fmt/mod.rs index ddfbfa78502..013ed999b03 100644 --- a/src/libcore/fmt/mod.rs +++ b/src/libcore/fmt/mod.rs @@ -250,37 +250,6 @@ pub trait UpperExp for Sized? { fn fmt(&self, &mut Formatter) -> Result; } -// NOTE(stage0): Remove macro after next snapshot -#[cfg(stage0)] -macro_rules! uniform_fn_call_workaround { - ($( $name: ident, $trait_: ident; )*) => { - $( - #[doc(hidden)] - pub fn $name(x: &T, fmt: &mut Formatter) -> Result { - x.fmt(fmt) - } - )* - } -} -// NOTE(stage0): Remove macro after next snapshot -#[cfg(stage0)] -uniform_fn_call_workaround! { - secret_show, Show; - secret_bool, Bool; - secret_char, Char; - secret_signed, Signed; - secret_unsigned, Unsigned; - secret_octal, Octal; - secret_binary, Binary; - secret_lower_hex, LowerHex; - secret_upper_hex, UpperHex; - secret_string, String; - secret_pointer, Pointer; - secret_float, Float; - secret_lower_exp, LowerExp; - secret_upper_exp, UpperExp; -} - static DEFAULT_ARGUMENT: rt::Argument<'static> = rt::Argument { position: rt::ArgumentNext, format: rt::FormatSpec { @@ -570,16 +539,6 @@ pub fn argument<'a, T>(f: extern "Rust" fn(&T, &mut Formatter) -> Result, /// When the compiler determines that the type of an argument *must* be a string /// (such as for select), then it invokes this method. -// NOTE(stage0): remove function after a snapshot -#[cfg(stage0)] -#[doc(hidden)] #[inline] -pub fn argumentstr<'a>(s: &'a &str) -> Argument<'a> { - argument(secret_string, s) -} - -/// When the compiler determines that the type of an argument *must* be a string -/// (such as for select), then it invokes this method. -#[cfg(not(stage0))] // NOTE(stage0): remove cfg after a snapshot #[doc(hidden)] #[inline] pub fn argumentstr<'a>(s: &'a &str) -> Argument<'a> { argument(String::fmt, s) @@ -587,16 +546,6 @@ pub fn argumentstr<'a>(s: &'a &str) -> Argument<'a> { /// When the compiler determines that the type of an argument *must* be a uint /// (such as for plural), then it invokes this method. -// NOTE(stage0): remove function after a snapshot -#[cfg(stage0)] -#[doc(hidden)] #[inline] -pub fn argumentuint<'a>(s: &'a uint) -> Argument<'a> { - argument(secret_unsigned, s) -} - -/// When the compiler determines that the type of an argument *must* be a uint -/// (such as for plural), then it invokes this method. -#[cfg(not(stage0))] // NOTE(stage0): remove cfg after a snapshot #[doc(hidden)] #[inline] pub fn argumentuint<'a>(s: &'a uint) -> Argument<'a> { argument(Unsigned::fmt, s) @@ -614,15 +563,6 @@ impl<'a> Show for &'a Show+'a { fn fmt(&self, f: &mut Formatter) -> Result { (*self).fmt(f) } } -// NOTE(stage0): remove impl after a snapshot -#[cfg(stage0)] -impl Bool for bool { - fn fmt(&self, f: &mut Formatter) -> Result { - secret_string(&(if *self {"true"} else {"false"}), f) - } -} - -#[cfg(not(stage0))] // NOTE(stage0): remove cfg after a snapshot impl Bool for bool { fn fmt(&self, f: &mut Formatter) -> Result { String::fmt(if *self { "true" } else { "false" }, f) @@ -641,20 +581,6 @@ fn fmt(&self, f: &mut Formatter) -> Result { } } -// NOTE(stage0): remove impl after a snapshot -#[cfg(stage0)] -impl Char for char { - fn fmt(&self, f: &mut Formatter) -> Result { - use char::Char; - - let mut utf8 = [0u8, ..4]; - let amt = self.encode_utf8(utf8).unwrap_or(0); - let s: &str = unsafe { mem::transmute(utf8[..amt]) }; - secret_string(&s, f) - } -} - -#[cfg(not(stage0))] // NOTE(stage0): remove cfg after a snapshot impl Char for char { fn fmt(&self, f: &mut Formatter) -> Result { use char::Char; @@ -666,16 +592,6 @@ fn fmt(&self, f: &mut Formatter) -> Result { } } -// NOTE(stage0): remove impl after a snapshot -#[cfg(stage0)] -impl Pointer for *const T { - fn fmt(&self, f: &mut Formatter) -> Result { - f.flags |= 1 << (rt::FlagAlternate as uint); - secret_lower_hex::(&(*self as uint), f) - } -} - -#[cfg(not(stage0))] // NOTE(stage0): remove cfg after a snapshot impl Pointer for *const T { fn fmt(&self, f: &mut Formatter) -> Result { f.flags |= 1 << (rt::FlagAlternate as uint); @@ -683,45 +599,18 @@ fn fmt(&self, f: &mut Formatter) -> Result { } } -// NOTE(stage0): remove impl after a snapshot -#[cfg(stage0)] -impl Pointer for *mut T { - fn fmt(&self, f: &mut Formatter) -> Result { - secret_pointer::<*const T>(&(*self as *const T), f) - } -} - -#[cfg(not(stage0))] // NOTE(stage0): remove cfg after a snapshot impl Pointer for *mut T { fn fmt(&self, f: &mut Formatter) -> Result { Pointer::fmt(&(*self as *const T), f) } } -// NOTE(stage0): remove impl after a snapshot -#[cfg(stage0)] -impl<'a, T> Pointer for &'a T { - fn fmt(&self, f: &mut Formatter) -> Result { - secret_pointer::<*const T>(&(&**self as *const T), f) - } -} - -#[cfg(not(stage0))] // NOTE(stage0): remove cfg after a snapshot impl<'a, T> Pointer for &'a T { fn fmt(&self, f: &mut Formatter) -> Result { Pointer::fmt(&(*self as *const T), f) } } -// NOTE(stage0): remove impl after a snapshot -#[cfg(stage0)] -impl<'a, T> Pointer for &'a mut T { - fn fmt(&self, f: &mut Formatter) -> Result { - secret_pointer::<*const T>(&(&**self as *const T), f) - } -} - -#[cfg(not(stage0))] // NOTE(stage0): remove cfg after a snapshot impl<'a, T> Pointer for &'a mut T { fn fmt(&self, f: &mut Formatter) -> Result { Pointer::fmt(&(&**self as *const T), f) @@ -797,29 +686,6 @@ fn fmt(&self, fmt: &mut Formatter) -> Result { // Implementation of Show for various core types -// NOTE(stage0): remove macro after a snapshot -#[cfg(stage0)] -macro_rules! delegate(($ty:ty to $other:ident) => { - impl Show for $ty { - fn fmt(&self, f: &mut Formatter) -> Result { - (concat_idents!(secret_, $other)(self, f)) - } - } -}) - -// NOTE(stage0): remove these macros after a snapshot -#[cfg(stage0)] -delegate!(str to string) -#[cfg(stage0)] -delegate!(bool to bool) -#[cfg(stage0)] -delegate!(char to char) -#[cfg(stage0)] -delegate!(f32 to float) -#[cfg(stage0)] -delegate!(f64 to float) - -#[cfg(not(stage0))] // NOTE(stage0): remove cfg after a snapshot macro_rules! delegate(($ty:ty to $other:ident) => { impl Show for $ty { fn fmt(&self, f: &mut Formatter) -> Result { @@ -827,35 +693,16 @@ fn fmt(&self, f: &mut Formatter) -> Result { } } }) -#[cfg(not(stage0))] // NOTE(stage0): remove cfg after a snapshot delegate!(str to String) -#[cfg(not(stage0))] // NOTE(stage0): remove cfg after a snapshot delegate!(bool to Bool) -#[cfg(not(stage0))] // NOTE(stage0): remove cfg after a snapshot delegate!(char to Char) -#[cfg(not(stage0))] // NOTE(stage0): remove cfg after a snapshot delegate!(f32 to Float) -#[cfg(not(stage0))] // NOTE(stage0): remove cfg after a snapshot delegate!(f64 to Float) -// NOTE(stage0): remove impl after a snapshot -#[cfg(stage0)] -impl Show for *const T { - fn fmt(&self, f: &mut Formatter) -> Result { secret_pointer(self, f) } -} - -#[cfg(not(stage0))] // NOTE(stage0): remove cfg after a snapshot impl Show for *const T { fn fmt(&self, f: &mut Formatter) -> Result { Pointer::fmt(self, f) } } -// NOTE(stage0): remove impl after a snapshot -#[cfg(stage0)] -impl Show for *mut T { - fn fmt(&self, f: &mut Formatter) -> Result { secret_pointer(self, f) } -} - -#[cfg(not(stage0))] // NOTE(stage0): remove cfg after a snapshot impl Show for *mut T { fn fmt(&self, f: &mut Formatter) -> Result { Pointer::fmt(self, f) } } diff --git a/src/libcore/intrinsics.rs b/src/libcore/intrinsics.rs index 9d5c2113cb2..91f95ef203c 100644 --- a/src/libcore/intrinsics.rs +++ b/src/libcore/intrinsics.rs @@ -171,7 +171,6 @@ pub struct TyDesc { /// with optimization of surrounding code and reduce performance. It should /// not be used if the invariant can be discovered by the optimizer on its /// own, or if it does not enable any significant optimizations. - #[cfg(not(stage0))] pub fn assume(b: bool); /// Execute a breakpoint trap, for inspection by a debugger. diff --git a/src/libcore/ops.rs b/src/libcore/ops.rs index f6e3e7f61cf..8d072fffb60 100644 --- a/src/libcore/ops.rs +++ b/src/libcore/ops.rs @@ -849,24 +849,21 @@ pub trait DerefMut: Deref { #[lang="fn"] pub trait Fn { /// This is called when the call operator is used. - #[rust_call_abi_hack] - fn call(&self, args: Args) -> Result; + extern "rust-call" fn call(&self, args: Args) -> Result; } /// A version of the call operator that takes a mutable receiver. #[lang="fn_mut"] pub trait FnMut { /// This is called when the call operator is used. - #[rust_call_abi_hack] - fn call_mut(&mut self, args: Args) -> Result; + extern "rust-call" fn call_mut(&mut self, args: Args) -> Result; } /// A version of the call operator that takes a by-value receiver. #[lang="fn_once"] pub trait FnOnce { /// This is called when the call operator is used. - #[rust_call_abi_hack] - fn call_once(self, args: Args) -> Result; + extern "rust-call" fn call_once(self, args: Args) -> Result; } macro_rules! def_fn_mut( @@ -874,9 +871,8 @@ pub trait FnOnce { impl FnMut<($($args,)*),Result> for extern "Rust" fn($($args: $args,)*) -> Result { - #[rust_call_abi_hack] #[allow(non_snake_case)] - fn call_mut(&mut self, args: ($($args,)*)) -> Result { + extern "rust-call" fn call_mut(&mut self, args: ($($args,)*)) -> Result { let ($($args,)*) = args; (*self)($($args,)*) } diff --git a/src/libcore/panicking.rs b/src/libcore/panicking.rs index 39de04c27ce..fd0526db411 100644 --- a/src/libcore/panicking.rs +++ b/src/libcore/panicking.rs @@ -33,49 +33,6 @@ use fmt; use intrinsics; -// NOTE(stage0): remove after a snapshot -#[cfg(stage0)] -#[cold] #[inline(never)] // this is the slow path, always -#[lang="fail"] -pub fn panic(expr_file_line: &(&'static str, &'static str, uint)) -> ! { - let (expr, file, line) = *expr_file_line; - let ref file_line = (file, line); - format_args!(|args| -> () { - panic_fmt(args, file_line); - }, "{}", expr); - - unsafe { intrinsics::abort() } -} - -// NOTE(stage0): remove after a snapshot -#[cfg(stage0)] -#[cold] #[inline(never)] -#[lang="fail_bounds_check"] -fn panic_bounds_check(file_line: &(&'static str, uint), - index: uint, len: uint) -> ! { - format_args!(|args| -> () { - panic_fmt(args, file_line); - }, "index out of bounds: the len is {} but the index is {}", len, index); - unsafe { intrinsics::abort() } -} - -// NOTE(stage0): remove after a snapshot -#[cfg(stage0)] -#[cold] #[inline(never)] -pub fn panic_fmt(fmt: &fmt::Arguments, file_line: &(&'static str, uint)) -> ! { - #[allow(improper_ctypes)] - extern { - #[lang = "fail_fmt"] - fn panic_impl(fmt: &fmt::Arguments, file: &'static str, - line: uint) -> !; - - } - let (file, line) = *file_line; - unsafe { panic_impl(fmt, file, line) } -} - -// NOTE(stage0): remove cfg after a snapshot -#[cfg(not(stage0))] #[cold] #[inline(never)] // this is the slow path, always #[lang="panic"] pub fn panic(expr_file_line: &(&'static str, &'static str, uint)) -> ! { @@ -88,8 +45,6 @@ pub fn panic(expr_file_line: &(&'static str, &'static str, uint)) -> ! { unsafe { intrinsics::abort() } } -// NOTE(stage0): remove cfg after a snapshot -#[cfg(not(stage0))] #[cold] #[inline(never)] #[lang="panic_bounds_check"] fn panic_bounds_check(file_line: &(&'static str, uint), @@ -100,8 +55,6 @@ fn panic_bounds_check(file_line: &(&'static str, uint), unsafe { intrinsics::abort() } } -// NOTE(stage0): remove cfg after a snapshot -#[cfg(not(stage0))] #[cold] #[inline(never)] pub fn panic_fmt(fmt: &fmt::Arguments, file_line: &(&'static str, uint)) -> ! { #[allow(improper_ctypes)] diff --git a/src/librustc/middle/typeck/collect.rs b/src/librustc/middle/typeck/collect.rs index 863f09736ab..0374a64261f 100644 --- a/src/librustc/middle/typeck/collect.rs +++ b/src/librustc/middle/typeck/collect.rs @@ -574,20 +574,6 @@ fn ty_of_method(ccx: &CrateCtxt, rcvr_ty_generics: &ty::Generics, rcvr_visibility: ast::Visibility) -> ty::Method { - // FIXME(pcwalton): Hack until we have syntax in stage0 for snapshots. - let real_abi = match container { - ty::TraitContainer(trait_id) => { - if ccx.tcx.lang_items.fn_trait() == Some(trait_id) || - ccx.tcx.lang_items.fn_mut_trait() == Some(trait_id) || - ccx.tcx.lang_items.fn_once_trait() == Some(trait_id) { - abi::RustCall - } else { - m.pe_abi() - } - } - _ => m.pe_abi(), - }; - let m_ty_generics = ty_generics_for_fn_or_method( ccx, @@ -607,7 +593,7 @@ fn ty_of_method(ccx: &CrateCtxt, untransformed_rcvr_ty, m.pe_explicit_self(), &*m.pe_fn_decl(), - real_abi) + m.pe_abi()) } TraitConvertMethodContext(trait_id, trait_items) => { let tmcx = TraitMethodCtxt { @@ -622,7 +608,7 @@ fn ty_of_method(ccx: &CrateCtxt, untransformed_rcvr_ty, m.pe_explicit_self(), &*m.pe_fn_decl(), - real_abi) + m.pe_abi()) } }; diff --git a/src/librustrt/unwind.rs b/src/librustrt/unwind.rs index c5fc0084ed9..356273964af 100644 --- a/src/librustrt/unwind.rs +++ b/src/librustrt/unwind.rs @@ -497,14 +497,6 @@ extern "C" fn inner( begin_unwind_fmt(msg, &(file, line)) } -// NOTE(stage0): remove after a snapshot -#[cfg(not(test))] -#[lang = "fail_fmt"] -pub extern fn rust_fail_begin_unwind(msg: &fmt::Arguments, - file: &'static str, line: uint) -> ! { - rust_begin_unwind(msg, file, line) -} - /// The entry point for unwinding with a formatted message. /// /// This is designed to reduce the amount of code required at the call diff --git a/src/libstd/fmt.rs b/src/libstd/fmt.rs index cb151dd9c0a..782ef098d81 100644 --- a/src/libstd/fmt.rs +++ b/src/libstd/fmt.rs @@ -424,22 +424,6 @@ fn my_fmt_fn(args: &fmt::Arguments) { #[doc(hidden)] pub use core::fmt::{argument, argumentstr, argumentuint}; -// NOTE(stage0): remove these imports after a snapshot -#[cfg(stage0)] -#[doc(hidden)] -pub use core::fmt::{secret_show, secret_string, secret_unsigned}; -#[cfg(stage0)] -#[doc(hidden)] -pub use core::fmt::{secret_signed, secret_lower_hex, secret_upper_hex}; -#[cfg(stage0)] -#[doc(hidden)] -pub use core::fmt::{secret_bool, secret_char, secret_octal, secret_binary}; -#[cfg(stage0)] -#[doc(hidden)] -pub use core::fmt::{secret_float, secret_upper_exp, secret_lower_exp}; -#[cfg(stage0)] -#[doc(hidden)] -pub use core::fmt::{secret_pointer}; /// The format function takes a precompiled format string and a list of /// arguments, to return the resulting formatted string. diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs index 18fc970c218..078e393eb28 100644 --- a/src/libsyntax/ast.rs +++ b/src/libsyntax/ast.rs @@ -24,9 +24,6 @@ use std::rc::Rc; use serialize::{Encodable, Decodable, Encoder, Decoder}; -#[cfg(stage0)] -pub use self::TtToken as TTTok; - // FIXME #6993: in librustc, uses of "ident" should be replaced // by just "Name". diff --git a/src/libsyntax/parse/lexer/mod.rs b/src/libsyntax/parse/lexer/mod.rs index de5004fe2f8..35d56440b50 100644 --- a/src/libsyntax/parse/lexer/mod.rs +++ b/src/libsyntax/parse/lexer/mod.rs @@ -1491,13 +1491,7 @@ fn check_tokenization (mut string_reader: StringReader, expected: Vec token::Token { - token::Ident(str_to_ident(id), is_mod_name) - } - // make the identifier by looking up the string in the interner - #[cfg(not(stage0))] fn mk_ident(id: &str, style: token::IdentStyle) -> token::Token { token::Ident(str_to_ident(id), style) } diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs index 8ad5bdac7e2..10bb9ef3625 100644 --- a/src/libsyntax/parse/parser.rs +++ b/src/libsyntax/parse/parser.rs @@ -63,7 +63,6 @@ use ast; use ast_util::{as_prec, ident_to_path, operator_prec}; use ast_util; -use attr; use codemap::{Span, BytePos, Spanned, spanned, mk_sp}; use codemap; use parse; @@ -1262,11 +1261,6 @@ pub fn parse_trait_items(&mut self) -> Vec { let vis = p.parse_visibility(); let abi = if p.eat_keyword(keywords::Extern) { p.parse_opt_abi().unwrap_or(abi::C) - } else if attr::contains_name(attrs.as_slice(), - "rust_call_abi_hack") { - // FIXME(stage0, pcwalton): Remove this awful hack after a - // snapshot, and change to `extern "rust-call" fn`. - abi::RustCall } else { abi::Rust }; @@ -4446,11 +4440,6 @@ pub fn parse_method(&mut self, } else { let abi = if self.eat_keyword(keywords::Extern) { self.parse_opt_abi().unwrap_or(abi::C) - } else if attr::contains_name(attrs.as_slice(), - "rust_call_abi_hack") { - // FIXME(stage0, pcwalton): Remove this awful hack after a - // snapshot, and change to `extern "rust-call" fn`. - abi::RustCall } else { abi::Rust }; diff --git a/src/libsyntax/parse/token.rs b/src/libsyntax/parse/token.rs index 615cd34ca14..29a2f38959e 100644 --- a/src/libsyntax/parse/token.rs +++ b/src/libsyntax/parse/token.rs @@ -20,69 +20,6 @@ use std::path::BytesContainer; use std::rc::Rc; -// NOTE(stage0): remove these re-exports after the next snapshot -// (needed to allow quotations to pass stage0) -#[cfg(stage0)] pub use self::Plus as PLUS; -#[cfg(stage0)] pub use self::Minus as MINUS; -#[cfg(stage0)] pub use self::Star as STAR; -#[cfg(stage0)] pub use self::Slash as SLASH; -#[cfg(stage0)] pub use self::Percent as PERCENT; -#[cfg(stage0)] pub use self::Caret as CARET; -#[cfg(stage0)] pub use self::And as AND; -#[cfg(stage0)] pub use self::Or as OR; -#[cfg(stage0)] pub use self::Shl as SHL; -#[cfg(stage0)] pub use self::Shr as SHR; -#[cfg(stage0)] pub use self::Eq as EQ; -#[cfg(stage0)] pub use self::Lt as LT; -#[cfg(stage0)] pub use self::Le as LE; -#[cfg(stage0)] pub use self::EqEq as EQEQ; -#[cfg(stage0)] pub use self::Ne as NE; -#[cfg(stage0)] pub use self::Ge as GE; -#[cfg(stage0)] pub use self::Gt as GT; -#[cfg(stage0)] pub use self::AndAnd as ANDAND; -#[cfg(stage0)] pub use self::OrOr as OROR; -#[cfg(stage0)] pub use self::Not as NOT; -#[cfg(stage0)] pub use self::Tilde as TILDE; -#[cfg(stage0)] pub use self::BinOp as BINOP; -#[cfg(stage0)] pub use self::BinOpEq as BINOPEQ; -#[cfg(stage0)] pub use self::At as AT; -#[cfg(stage0)] pub use self::Dot as DOT; -#[cfg(stage0)] pub use self::DotDot as DOTDOT; -#[cfg(stage0)] pub use self::DotDotDot as DOTDOTDOT; -#[cfg(stage0)] pub use self::Comma as COMMA; -#[cfg(stage0)] pub use self::Semi as SEMI; -#[cfg(stage0)] pub use self::Colon as COLON; -#[cfg(stage0)] pub use self::ModSep as MOD_SEP; -#[cfg(stage0)] pub use self::RArrow as RARROW; -#[cfg(stage0)] pub use self::LArrow as LARROW; -#[cfg(stage0)] pub use self::FatArrow as FAT_ARROW; -#[cfg(stage0)] pub use self::Pound as POUND; -#[cfg(stage0)] pub use self::Dollar as DOLLAR; -#[cfg(stage0)] pub use self::Question as QUESTION; -#[cfg(stage0)] pub use self::LitByte as LIT_BYTE; -#[cfg(stage0)] pub use self::LitChar as LIT_CHAR; -#[cfg(stage0)] pub use self::LitInteger as LIT_INTEGER; -#[cfg(stage0)] pub use self::LitFloat as LIT_FLOAT; -#[cfg(stage0)] pub use self::LitStr as LIT_STR; -#[cfg(stage0)] pub use self::LitStrRaw as LIT_STR_RAW; -#[cfg(stage0)] pub use self::LitBinary as LIT_BINARY; -#[cfg(stage0)] pub use self::LitBinaryRaw as LIT_BINARY_RAW; -#[cfg(stage0)] pub use self::Ident as IDENT; -#[cfg(stage0)] pub use self::Underscore as UNDERSCORE; -#[cfg(stage0)] pub use self::Lifetime as LIFETIME; -#[cfg(stage0)] pub use self::Interpolated as INTERPOLATED; -#[cfg(stage0)] pub use self::DocComment as DOC_COMMENT; -#[cfg(stage0)] pub use self::Whitespace as WS; -#[cfg(stage0)] pub use self::Comment as COMMENT; -#[cfg(stage0)] pub use self::Shebang as SHEBANG; -#[cfg(stage0)] pub use self::Eof as EOF; -#[cfg(stage0)] pub const LPAREN: Token = OpenDelim(Paren); -#[cfg(stage0)] pub const RPAREN: Token = CloseDelim(Paren); -#[cfg(stage0)] pub const LBRACKET: Token = OpenDelim(Bracket); -#[cfg(stage0)] pub const RBRACKET: Token = CloseDelim(Bracket); -#[cfg(stage0)] pub const LBRACE: Token = OpenDelim(Brace); -#[cfg(stage0)] pub const RBRACE: Token = CloseDelim(Brace); - #[allow(non_camel_case_types)] #[deriving(Clone, Encodable, Decodable, PartialEq, Eq, Hash, Show)] pub enum BinOpToken { @@ -109,15 +46,7 @@ pub enum DelimToken { Brace, } -#[cfg(stage0)] -#[allow(non_upper_case_globals)] -pub const ModName: bool = true; -#[cfg(stage0)] -#[allow(non_upper_case_globals)] -pub const Plain: bool = false; - #[deriving(Clone, Encodable, Decodable, PartialEq, Eq, Hash, Show)] -#[cfg(not(stage0))] pub enum IdentStyle { /// `::` follows the identifier with no whitespace in-between. ModName, @@ -173,9 +102,6 @@ pub enum Token { LitBinaryRaw(ast::Name, uint), /* raw binary str delimited by n hash symbols */ /* Name components */ - #[cfg(stage0)] - Ident(ast::Ident, bool), - #[cfg(not(stage0))] Ident(ast::Ident, IdentStyle), Underscore, Lifetime(ast::Ident), @@ -398,9 +324,6 @@ pub enum Nonterminal { NtPat(P), NtExpr(P), NtTy(P), - #[cfg(stage0)] - NtIdent(Box, bool), - #[cfg(not(stage0))] NtIdent(Box, IdentStyle), /// Stuff inside brackets for attributes NtMeta(P), diff --git a/src/snapshots.txt b/src/snapshots.txt index f6eea15d8cf..2c32e0e1643 100644 --- a/src/snapshots.txt +++ b/src/snapshots.txt @@ -1,3 +1,12 @@ +S 2014-11-04 1b2ad78 + freebsd-x86_64 f8c41a522d6a3c9691a0865dab170dcb988e9141 + linux-i386 d827fbbd778b854923971873cf03bdb79c2e8575 + linux-x86_64 1ddca522a8ba4a4f662dc17ca16b0f50f2c15f87 + macos-i386 597cd42301e1569df8ad090574cd535d19283387 + macos-x86_64 4bfb2aff1c3e3c57653b32adc34b399c5aeb759b + winnt-i386 11390f5607bf638b515931dd2f85a7245bf91581 + winnt-x86_64 905c34b5eeaa502fe4ad7446b3d9afb4a8d167c9 + S 2014-10-22 d44ea72 freebsd-x86_64 8bf5ee7c1ca8ab880800cf3a535e16bb7ffbf9e8 linux-i386 1fc8302b405406a3fc183b23c8397bef5a56c52a diff --git a/src/test/run-pass/issue-16739.rs b/src/test/run-pass/issue-16739.rs index 80a7ae72e18..6dcdc1d1086 100644 --- a/src/test/run-pass/issue-16739.rs +++ b/src/test/run-pass/issue-16739.rs @@ -16,18 +16,15 @@ struct Foo { foo: uint } impl FnOnce<(), uint> for Foo { - #[rust_call_abi_hack] - fn call_once(self, _: ()) -> uint { self.foo } + extern "rust-call" fn call_once(self, _: ()) -> uint { self.foo } } impl FnOnce<(uint,), uint> for Foo { - #[rust_call_abi_hack] - fn call_once(self, (x,): (uint,)) -> uint { self.foo + x } + extern "rust-call" fn call_once(self, (x,): (uint,)) -> uint { self.foo + x } } impl FnOnce<(uint, uint), uint> for Foo { - #[rust_call_abi_hack] - fn call_once(self, (x, y): (uint, uint)) -> uint { self.foo + x + y } + extern "rust-call" fn call_once(self, (x, y): (uint, uint)) -> uint { self.foo + x + y } } fn main() { -- GitLab