mathieu/os-rust
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Register snapshots

Browse source
This commit is contained in:
Brian Anderson 2012-11-28 12:33:00 -08:00
parent be6613e048
commit 8179e268ef
78 changed files with 475 additions and 5514 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

9
src/compiletest/common.rs
View file

@ -1,14 +1,5 @@
enum mode { mode_compile_fail, mode_run_fail, mode_run_pass, mode_pretty, }
#[cfg(stage0)]
impl mode : cmp::Eq {
pure fn eq(other: &mode) -> bool {
(*other) as int == self as int
}
pure fn ne(other: &mode) -> bool { !self.eq(other) }
}
#[cfg(stage1)]
#[cfg(stage2)]
impl mode : cmp::Eq {
pure fn eq(&self, other: &mode) -> bool {
(*other) as int == (*self) as int

41
src/libcargo/cargo.rc
View file

@ -65,25 +65,6 @@ struct Package {
}
impl Package : cmp::Ord {
#[cfg(stage0)]
pure fn lt(other: &Package) -> bool {
if self.name.lt(&(*other).name) { return true; }
if (*other).name.lt(&self.name) { return false; }
if self.uuid.lt(&(*other).uuid) { return true; }
if (*other).uuid.lt(&self.uuid) { return false; }
if self.url.lt(&(*other).url) { return true; }
if (*other).url.lt(&self.url) { return false; }
if self.method.lt(&(*other).method) { return true; }
if (*other).method.lt(&self.method) { return false; }
if self.description.lt(&(*other).description) { return true; }
if (*other).description.lt(&self.description) { return false; }
if self.tags.lt(&(*other).tags) { return true; }
if (*other).tags.lt(&self.tags) { return false; }
if self.versions.lt(&(*other).versions) { return true; }
return false;
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn lt(&self, other: &Package) -> bool {
if (*self).name.lt(&(*other).name) { return true; }
if (*other).name.lt(&(*self).name) { return false; }
@ -100,20 +81,8 @@ impl Package : cmp::Ord {
if (*self).versions.lt(&(*other).versions) { return true; }
return false;
}
#[cfg(stage0)]
pure fn le(other: &Package) -> bool { !(*other).lt(&self) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn le(&self, other: &Package) -> bool { !(*other).lt(&(*self)) }
#[cfg(stage0)]
pure fn ge(other: &Package) -> bool { !self.lt(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ge(&self, other: &Package) -> bool { !(*self).lt(other) }
#[cfg(stage0)]
pure fn gt(other: &Package) -> bool { (*other).lt(&self) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn gt(&self, other: &Package) -> bool { (*other).lt(&(*self)) }
}
@ -160,19 +129,9 @@ struct Options {
enum Mode { SystemMode, UserMode, LocalMode }
impl Mode : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &Mode) -> bool {
(self as uint) == ((*other) as uint)
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &Mode) -> bool {
((*self) as uint) == ((*other) as uint)
}
#[cfg(stage0)]
pure fn ne(other: &Mode) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &Mode) -> bool { !(*self).eq(other) }
}

273
src/libcore/alternate_crate.rc
View file

@ -1,273 +0,0 @@
/*!
The Rust core library.
The Rust core library provides runtime features required by the language,
including the task scheduler and memory allocators, as well as library
support for Rust built-in types, platform abstractions, and other commonly
used features.
`core` includes modules corresponding to each of the integer types, each of
the floating point types, the `bool` type, tuples, characters, strings,
vectors (`vec`), shared boxes (`box`), and unsafe and borrowed pointers
(`ptr`). Additionally, `core` provides task management and creation (`task`),
communication primitives (`comm` and `pipes`), an efficient vector builder
(`dvec`), platform abstractions (`os` and `path`), basic I/O abstractions
(`io`), common traits (`cmp`, `num`, `to_str`), and complete bindings
to the C standard library (`libc`).
`core` is linked to all crates by default and its contents imported.
Implicitly, all crates behave as if they included the following prologue:
extern mod core;
use core::*;
*/
#[link(name = "core",
vers = "0.5",
uuid = "c70c24a7-5551-4f73-8e37-380b11d80be8",
url = "https://github.com/mozilla/rust/tree/master/src/libcore")];
#[comment = "The Rust core library"];
#[license = "MIT"];
#[crate_type = "lib"];
// Don't link to core. We are core.
#[no_core];
#[warn(deprecated_mode)];
#[warn(deprecated_pattern)];
#[warn(vecs_implicitly_copyable)];
#[deny(non_camel_case_types)];
// Built-in-type support modules
/// Operations and constants for `int`
#[path = "int-template.rs"]
#[merge = "int-template/intb.rs"]
pub mod int;
/// Operations and constants for `i8`
#[path = "int-template.rs"]
#[merge = "int-template/i8b.rs"]
pub mod i8;
/// Operations and constants for `i16`
#[path = "int-template.rs"]
#[merge = "int-template/i16b.rs"]
pub mod i16;
/// Operations and constants for `i32`
#[path = "int-template.rs"]
#[merge = "int-template/i32b.rs"]
pub mod i32;
/// Operations and constants for `i64`
#[path = "int-template.rs"]
#[merge = "int-template/i64b.rs"]
pub mod i64;
/// Operations and constants for `uint`
#[path = "uint-template.rs"]
#[merge = "uint-template/uintb.rs"]
pub mod uint;
/// Operations and constants for `u8`
#[path = "uint-template.rs"]
#[merge = "uint-template/u8b.rs"]
pub mod u8;
/// Operations and constants for `u16`
#[path = "uint-template.rs"]
#[merge = "uint-template/u16b.rs"]
pub mod u16;
/// Operations and constants for `u32`
#[path = "uint-template.rs"]
#[merge = "uint-template/u32b.rs"]
pub mod u32;
/// Operations and constants for `u64`
#[path = "uint-template.rs"]
#[merge = "uint-template/u64b.rs"]
pub mod u64;
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 owned;
// Ubiquitous-utility-type modules
#[cfg(notest)]
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.rs"]
#[merge = "iter-trait/optionb.rs"]
pub mod option_iter;
pub mod result;
pub mod to_str;
pub mod to_bytes;
pub mod from_str;
pub mod util;
// Data structure modules
pub mod dvec;
#[path="iter-trait.rs"]
#[merge = "iter-trait/dvecb.rs"]
pub mod dvec_iter;
pub mod dlist;
#[path="iter-trait.rs"]
#[merge = "iter-trait/dlistb.rs"]
pub mod dlist_iter;
pub mod send_map;
// Concurrency
pub mod comm;
#[merge = "task/mod.rs"]
pub mod task;
pub mod pipes;
// Runtime and language-primitive support
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;
pub mod condition;
// Modules supporting compiler-generated code
// Exported but not part of the public interface
pub mod extfmt;
// The test harness links against core, so don't include runtime in tests.
#[cfg(notest)]
#[legacy_exports]
pub mod rt;
// Ideally not exported, but currently is.
pub mod private;
// For internal use, not exported.
mod unicode;
mod cmath;
mod stackwalk;
// Top-level, visible-everywhere definitions.
// Export various ubiquitous types, constructors, methods.
pub use option::{Some, None};
pub use Option = option::Option;
pub use result::{Result, Ok, Err};
pub use Path = path::Path;
pub use GenericPath = path::GenericPath;
pub use WindowsPath = path::WindowsPath;
pub use PosixPath = path::PosixPath;
pub use tuple::{CopyableTuple, ImmutableTuple, ExtendedTupleOps};
pub use str::{StrSlice, Trimmable};
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, CopyableNonstrictIter, Times};
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)]
pub use ops::{Const, Copy, Send, Owned};
#[cfg(notest)]
pub use ops::{Drop};
#[cfg(notest)]
pub use ops::{Add, Sub, Mul, Div, Modulo, Neg, BitAnd, BitOr, BitXor};
#[cfg(notest)]
pub use ops::{Shl, Shr, Index};
#[cfg(test)]
extern mod coreops(name = "core", vers = "0.5");
#[cfg(test)]
pub use coreops::ops::{Const, Copy, Send, Owned};
#[cfg(test)]
pub use coreops::ops::{Drop};
#[cfg(test)]
pub use coreops::ops::{Add, Sub, Mul, Div, Modulo, Neg, BitAnd, BitOr};
#[cfg(test)]
pub use coreops::ops::{BitXor};
#[cfg(test)]
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.
/// The error log level
pub const error : u32 = 1_u32;
/// The warning log level
pub const warn : u32 = 2_u32;
/// The info log level
pub const info : u32 = 3_u32;
/// The debug log level
pub const debug : u32 = 4_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 {
pub const error : u32 = 1_u32;
pub const warn : u32 = 2_u32;
pub const info : u32 = 3_u32;
pub const debug : u32 = 4_u32;
}
// Similar to above. Some magic to make core testable.
#[cfg(test)]
mod std {
extern mod std(vers = "0.5");
pub use std::test;
}
// Local Variables:
// mode: rust;
// fill-column: 78;
// indent-tabs-mode: nil
// c-basic-offset: 4
// buffer-file-coding-system: utf-8-unix
// End:

8
src/libcore/bool.rs
View file

@ -66,15 +66,7 @@ pub fn all_values(blk: fn(v: bool)) {
pub pure fn to_bit(v: bool) -> u8 { if v { 1u8 } else { 0u8 } }
impl bool : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &bool) -> bool { self == (*other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &bool) -> bool { (*self) == (*other) }
#[cfg(stage0)]
pure fn ne(other: &bool) -> bool { self != (*other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &bool) -> bool { (*self) != (*other) }
}

24
src/libcore/box.rs
View file

@ -28,38 +28,14 @@ pub pure fn ptr_eq<T>(a: @T, b: @T) -> bool {
}
impl<T:Eq> @const T : Eq {
#[cfg(stage0)]
pure fn eq(other: &@const T) -> bool { *self == *(*other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &@const T) -> bool { *(*self) == *(*other) }
#[cfg(stage0)]
pure fn ne(other: &@const T) -> bool { *self != *(*other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &@const T) -> bool { *(*self) != *(*other) }
}
impl<T:Ord> @const T : Ord {
#[cfg(stage0)]
pure fn lt(other: &@const T) -> bool { *self < *(*other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn lt(&self, other: &@const T) -> bool { *(*self) < *(*other) }
#[cfg(stage0)]
pure fn le(other: &@const T) -> bool { *self <= *(*other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn le(&self, other: &@const T) -> bool { *(*self) <= *(*other) }
#[cfg(stage0)]
pure fn ge(other: &@const T) -> bool { *self >= *(*other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ge(&self, other: &@const T) -> bool { *(*self) >= *(*other) }
#[cfg(stage0)]
pure fn gt(other: &@const T) -> bool { *self > *(*other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn gt(&self, other: &@const T) -> bool { *(*self) > *(*other) }
}

8
src/libcore/char.rs
View file

@ -181,15 +181,7 @@ pub pure fn cmp(a: char, b: char) -> int {
}
impl char : Eq {
#[cfg(stage0)]
pure fn eq(other: &char) -> bool { self == (*other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &char) -> bool { (*self) == (*other) }
#[cfg(stage0)]
pure fn ne(other: &char) -> bool { self != (*other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &char) -> bool { (*self) != (*other) }
}

38
src/libcore/cmp.rs
View file

@ -30,17 +30,6 @@ mod nounittest {
* default implementations.
*/
#[lang="ord"]
#[cfg(stage0)]
pub trait Ord {
pure fn lt(other: &self) -> bool;
pure fn le(other: &self) -> bool;
pure fn ge(other: &self) -> bool;
pure fn gt(other: &self) -> bool;
}
#[lang="ord"]
#[cfg(stage1)]
#[cfg(stage2)]
pub trait Ord {
pure fn lt(&self, other: &self) -> bool;
pure fn le(&self, other: &self) -> bool;
@ -58,15 +47,6 @@ mod nounittest {
* a default implementation.
*/
#[lang="eq"]
#[cfg(stage0)]
pub trait Eq {
pure fn eq(other: &self) -> bool;
pure fn ne(other: &self) -> bool;
}
#[lang="eq"]
#[cfg(stage1)]
#[cfg(stage2)]
pub trait Eq {
pure fn eq(&self, other: &self) -> bool;
pure fn ne(&self, other: &self) -> bool;
@ -81,16 +61,6 @@ mod nounittest {
mod unittest {
#[legacy_exports];
#[cfg(stage0)]
pub trait Ord {
pure fn lt(other: &self) -> bool;
pure fn le(other: &self) -> bool;
pure fn ge(other: &self) -> bool;
pure fn gt(other: &self) -> bool;
}
#[cfg(stage1)]
#[cfg(stage2)]
pub trait Ord {
pure fn lt(&self, other: &self) -> bool;
pure fn le(&self, other: &self) -> bool;
@ -98,14 +68,6 @@ mod unittest {
pure fn gt(&self, other: &self) -> bool;
}
#[cfg(stage0)]
pub trait Eq {
pure fn eq(other: &self) -> bool;
pure fn ne(other: &self) -> bool;
}
#[cfg(stage1)]
#[cfg(stage2)]
pub trait Eq {
pure fn eq(&self, other: &self) -> bool;
pure fn ne(&self, other: &self) -> bool;

202
src/libcore/core.rc
View file

@ -1,5 +1,3 @@
// DIVERT
/*!
The Rust core library.
@ -47,80 +45,54 @@ Implicitly, all crates behave as if they included the following prologue:
// Built-in-type support modules
/// Operations and constants for `int`
#[path = "int-template"]
pub mod int {
pub use inst::{ pow };
#[path = "int.rs"]
pub mod inst;
}
#[path = "int-template.rs"]
#[merge = "int-template/intb.rs"]
pub mod int;
/// Operations and constants for `i8`
#[path = "int-template"]
pub mod i8 {
#[path = "i8.rs"]
pub mod inst;
}
#[path = "int-template.rs"]
#[merge = "int-template/i8b.rs"]
pub mod i8;
/// Operations and constants for `i16`
#[path = "int-template"]
pub mod i16 {
#[path = "i16.rs"]
pub mod inst;
}
#[path = "int-template.rs"]
#[merge = "int-template/i16b.rs"]
pub mod i16;
/// Operations and constants for `i32`
#[path = "int-template"]
pub mod i32 {
#[path = "i32.rs"]
pub mod inst;
}
#[path = "int-template.rs"]
#[merge = "int-template/i32b.rs"]
pub mod i32;
/// Operations and constants for `i64`
#[path = "int-template"]
pub mod i64 {
#[path = "i64.rs"]
pub mod inst;
}
#[path = "int-template.rs"]
#[merge = "int-template/i64b.rs"]
pub mod i64;
/// Operations and constants for `uint`
#[path = "uint-template"]
pub mod uint {
pub use inst::{
div_ceil, div_round, div_floor, iterate,
next_power_of_two
};
#[path = "uint.rs"]
pub mod inst;
}
#[path = "uint-template.rs"]
#[merge = "uint-template/uintb.rs"]
pub mod uint;
/// Operations and constants for `u8`
#[path = "uint-template"]
pub mod u8 {
pub use inst::is_ascii;
#[path = "u8.rs"]
pub mod inst;
}
#[path = "uint-template.rs"]
#[merge = "uint-template/u8b.rs"]
pub mod u8;
/// Operations and constants for `u16`
#[path = "uint-template"]
pub mod u16 {
#[path = "u16.rs"]
pub mod inst;
}
#[path = "uint-template.rs"]
#[merge = "uint-template/u16b.rs"]
pub mod u16;
/// Operations and constants for `u32`
#[path = "uint-template"]
pub mod u32 {
#[path = "u32.rs"]
pub mod inst;
}
#[path = "uint-template.rs"]
#[merge = "uint-template/u32b.rs"]
pub mod u32;
/// Operations and constants for `u64`
#[path = "uint-template"]
pub mod u64 {
#[path = "u64.rs"]
pub mod inst;
}
#[path = "uint-template.rs"]
#[merge = "uint-template/u64b.rs"]
pub mod u64;
pub mod box;
@ -148,11 +120,9 @@ pub mod either;
pub mod iter;
pub mod logging;
pub mod option;
#[path="iter-trait"]
pub mod option_iter {
#[path = "option.rs"]
pub mod inst;
}
#[path="iter-trait.rs"]
#[merge = "iter-trait/optionb.rs"]
pub mod option_iter;
pub mod result;
pub mod to_str;
pub mod to_bytes;
@ -162,27 +132,19 @@ pub mod util;
// Data structure modules
pub mod dvec;
#[path="iter-trait"]
pub mod dvec_iter {
#[path = "dvec.rs"]
pub mod inst;
}
#[path="iter-trait.rs"]
#[merge = "iter-trait/dvecb.rs"]
pub mod dvec_iter;
pub mod dlist;
#[path="iter-trait"]
pub mod dlist_iter {
#[path ="dlist.rs"]
pub mod inst;
}
#[path="iter-trait.rs"]
#[merge = "iter-trait/dlistb.rs"]
pub mod dlist_iter;
pub mod send_map;
// Concurrency
pub mod comm;
pub mod task {
pub mod local_data;
mod local_data_priv;
pub mod spawn;
pub mod rt;
}
#[merge = "task/mod.rs"]
pub mod task;
pub mod pipes;
// Runtime and language-primitive support
@ -220,6 +182,88 @@ mod unicode;
mod cmath;
mod stackwalk;
// Top-level, visible-everywhere definitions.
// Export various ubiquitous types, constructors, methods.
pub use option::{Some, None};
pub use Option = option::Option;
pub use result::{Result, Ok, Err};
pub use Path = path::Path;
pub use GenericPath = path::GenericPath;
pub use WindowsPath = path::WindowsPath;
pub use PosixPath = path::PosixPath;
pub use tuple::{CopyableTuple, ImmutableTuple, ExtendedTupleOps};
pub use str::{StrSlice, Trimmable};
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, CopyableNonstrictIter, Times};
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)]
pub use ops::{Const, Copy, Send, Owned};
#[cfg(notest)]
pub use ops::{Drop};
#[cfg(notest)]
pub use ops::{Add, Sub, Mul, Div, Modulo, Neg, BitAnd, BitOr, BitXor};
#[cfg(notest)]
pub use ops::{Shl, Shr, Index};
#[cfg(test)]
extern mod coreops(name = "core", vers = "0.5");
#[cfg(test)]
pub use coreops::ops::{Const, Copy, Send, Owned};
#[cfg(test)]
pub use coreops::ops::{Drop};
#[cfg(test)]
pub use coreops::ops::{Add, Sub, Mul, Div, Modulo, Neg, BitAnd, BitOr};
#[cfg(test)]
pub use coreops::ops::{BitXor};
#[cfg(test)]
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.
/// The error log level
pub const error : u32 = 1_u32;
/// The warning log level
pub const warn : u32 = 2_u32;
/// The info log level
pub const info : u32 = 3_u32;
/// The debug log level
pub const debug : u32 = 4_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 {
pub const error : u32 = 1_u32;
pub const warn : u32 = 2_u32;
pub const info : u32 = 3_u32;
pub const debug : u32 = 4_u32;
}
// Similar to above. Some magic to make core testable.
#[cfg(test)]
mod std {
extern mod std(vers = "0.5");
pub use std::test;
}
// Local Variables:
// mode: rust;
// fill-column: 78;

81
src/libcore/core.rs
View file

@ -1,81 +0,0 @@
// Top-level, visible-everywhere definitions.
// Export various ubiquitous types, constructors, methods.
pub use option::{Some, None};
pub use Option = option::Option;
pub use result::{Result, Ok, Err};
pub use Path = path::Path;
pub use GenericPath = path::GenericPath;
pub use WindowsPath = path::WindowsPath;
pub use PosixPath = path::PosixPath;
pub use tuple::{CopyableTuple, ImmutableTuple, ExtendedTupleOps};
pub use str::{StrSlice, Trimmable};
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, CopyableNonstrictIter, Times};
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)]
pub use ops::{Const, Copy, Send, Owned};
#[cfg(notest)]
pub use ops::{Drop};
#[cfg(notest)]
pub use ops::{Add, Sub, Mul, Div, Modulo, Neg, BitAnd, BitOr, BitXor};
#[cfg(notest)]
pub use ops::{Shl, Shr, Index};
#[cfg(test)]
extern mod coreops(name = "core", vers = "0.5");
#[cfg(test)]
pub use coreops::ops::{Const, Copy, Send, Owned};
#[cfg(test)]
pub use coreops::ops::{Drop};
#[cfg(test)]
pub use coreops::ops::{Add, Sub, Mul, Div, Modulo, Neg, BitAnd, BitOr};
#[cfg(test)]
pub use coreops::ops::{BitXor};
#[cfg(test)]
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.
/// The error log level
pub const error : u32 = 1_u32;
/// The warning log level
pub const warn : u32 = 2_u32;
/// The info log level
pub const info : u32 = 3_u32;
/// The debug log level
pub const debug : u32 = 4_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 {
pub const error : u32 = 1_u32;
pub const warn : u32 = 2_u32;
pub const info : u32 = 3_u32;
pub const debug : u32 = 4_u32;
}
// Similar to above. Some magic to make core testable.
#[cfg(test)]
mod std {
extern mod std(vers = "0.5");
pub use std::test;
}

23
src/libcore/either.rs
View file

@ -132,25 +132,6 @@ pub pure fn unwrap_right<T,U>(eith: Either<T,U>) -> U {
}
impl<T:Eq,U:Eq> Either<T,U> : Eq {
#[cfg(stage0)]
pure fn eq(other: &Either<T,U>) -> bool {
match self {
Left(ref a) => {
match (*other) {
Left(ref b) => (*a).eq(b),
Right(_) => false
}
}
Right(ref a) => {
match (*other) {
Left(_) => false,
Right(ref b) => (*a).eq(b)
}
}
}
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &Either<T,U>) -> bool {
match (*self) {
Left(ref a) => {
@ -167,10 +148,6 @@ impl<T:Eq,U:Eq> Either<T,U> : Eq {
}
}
}
#[cfg(stage0)]
pure fn ne(other: &Either<T,U>) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &Either<T,U>) -> bool { !(*self).eq(other) }
}

19
src/libcore/extfmt.rs
View file

@ -438,21 +438,6 @@ pub mod rt {
pub enum PadMode { PadSigned, PadUnsigned, PadNozero, PadFloat }
pub impl PadMode : Eq {
#[cfg(stage0)]
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
}
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &PadMode) -> bool {
match ((*self), (*other)) {
(PadSigned, PadSigned) => true,
@ -465,10 +450,6 @@ pub mod rt {
(PadFloat, _) => false
}
}
#[cfg(stage0)]
pure fn ne(other: &PadMode) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &PadMode) -> bool { !(*self).eq(other) }
}

24
src/libcore/float.rs
View file

@ -400,38 +400,14 @@ pub pure fn cos(x: float) -> float { f64::cos(x as f64) as float }
pub pure fn tan(x: float) -> float { f64::tan(x as f64) as float }
impl float : Eq {
#[cfg(stage0)]
pub pure fn eq(other: &float) -> bool { self == (*other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &float) -> bool { (*self) == (*other) }
#[cfg(stage0)]
pub pure fn ne(other: &float) -> bool { self != (*other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &float) -> bool { (*self) != (*other) }
}
impl float : Ord {
#[cfg(stage0)]
pub pure fn lt(other: &float) -> bool { self < (*other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn lt(&self, other: &float) -> bool { (*self) < (*other) }
#[cfg(stage0)]
pub pure fn le(other: &float) -> bool { self <= (*other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn le(&self, other: &float) -> bool { (*self) <= (*other) }
#[cfg(stage0)]
pub pure fn ge(other: &float) -> bool { self >= (*other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ge(&self, other: &float) -> bool { (*self) >= (*other) }
#[cfg(stage0)]
pub pure fn gt(other: &float) -> bool { self > (*other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn gt(&self, other: &float) -> bool { (*self) > (*other) }
}

24
src/libcore/int-template.rs
View file

@ -55,38 +55,14 @@ pub pure fn abs(i: T) -> T {
}
impl T : Ord {
#[cfg(stage0)]
pure fn lt(other: &T) -> bool { return self < (*other); }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn lt(&self, other: &T) -> bool { return (*self) < (*other); }
#[cfg(stage0)]
pure fn le(other: &T) -> bool { return self <= (*other); }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn le(&self, other: &T) -> bool { return (*self) <= (*other); }
#[cfg(stage0)]
pure fn ge(other: &T) -> bool { return self >= (*other); }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ge(&self, other: &T) -> bool { return (*self) >= (*other); }
#[cfg(stage0)]
pure fn gt(other: &T) -> bool { return self > (*other); }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn gt(&self, other: &T) -> bool { return (*self) > (*other); }
}
impl T : Eq {
#[cfg(stage0)]
pure fn eq(other: &T) -> bool { return self == (*other); }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &T) -> bool { return (*self) == (*other); }
#[cfg(stage0)]
pure fn ne(other: &T) -> bool { return self != (*other); }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &T) -> bool { return (*self) != (*other); }
}

13
src/libcore/io.rs
View file

@ -516,25 +516,12 @@ pub enum FileFlag { Append, Create, Truncate, NoFlag, }
pub enum WriterType { Screen, File }
pub impl WriterType : Eq {
#[cfg(stage0)]
pure fn eq(other: &WriterType) -> bool {
match (self, (*other)) {
(Screen, Screen) | (File, File) => true,
(Screen, _) | (File, _) => false
}
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &WriterType) -> bool {
match ((*self), (*other)) {
(Screen, Screen) | (File, File) => true,
(Screen, _) | (File, _) => false
}
}
#[cfg(stage0)]
pure fn ne(other: &WriterType) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &WriterType) -> bool { !(*self).eq(other) }
}

24
src/libcore/option.rs
View file

@ -301,26 +301,6 @@ impl<T: Copy> Option<T> {
}
impl<T: Eq> Option<T> : Eq {
#[cfg(stage0)]
pure fn eq(other: &Option<T>) -> bool {
match self {
None => {
match (*other) {
None => true,
Some(_) => false
}
}
Some(ref self_contents) => {
match (*other) {
None => false,
Some(ref other_contents) =>
(*self_contents).eq(other_contents)
}
}
}
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &Option<T>) -> bool {
match (*self) {
None => {
@ -338,10 +318,6 @@ impl<T: Eq> Option<T> : Eq {
}
}
}
#[cfg(stage0)]
pure fn ne(other: &Option<T>) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &Option<T>) -> bool { !(*self).eq(other) }
}

24
src/libcore/owned.rs
View file

@ -7,38 +7,14 @@
use cmp::{Eq, Ord};
impl<T:Eq> ~const T : Eq {
#[cfg(stage0)]
pure fn eq(other: &~const T) -> bool { *self == *(*other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &~const T) -> bool { *(*self) == *(*other) }
#[cfg(stage0)]
pure fn ne(other: &~const T) -> bool { *self != *(*other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &~const T) -> bool { *(*self) != *(*other) }
}
impl<T:Ord> ~const T : Ord {
#[cfg(stage0)]
pure fn lt(other: &~const T) -> bool { *self < *(*other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn lt(&self, other: &~const T) -> bool { *(*self) < *(*other) }
#[cfg(stage0)]
pure fn le(other: &~const T) -> bool { *self <= *(*other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn le(&self, other: &~const T) -> bool { *(*self) <= *(*other) }
#[cfg(stage0)]
pure fn ge(other: &~const T) -> bool { *self >= *(*other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ge(&self, other: &~const T) -> bool { *(*self) >= *(*other) }
#[cfg(stage0)]
pure fn gt(other: &~const T) -> bool { *self > *(*other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn gt(&self, other: &~const T) -> bool { *(*self) > *(*other) }
}

24
src/libcore/path.rs
View file

@ -344,44 +344,20 @@ impl PosixPath : ToStr {
}
impl PosixPath : Eq {
#[cfg(stage0)]
pure fn eq(other: &PosixPath) -> bool {
return self.is_absolute == (*other).is_absolute &&
self.components == (*other).components;
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &PosixPath) -> bool {
return (*self).is_absolute == (*other).is_absolute &&
(*self).components == (*other).components;
}
#[cfg(stage0)]
pure fn ne(other: &PosixPath) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &PosixPath) -> bool { !(*self).eq(other) }
}
impl WindowsPath : Eq {
#[cfg(stage0)]
pure fn eq(other: &WindowsPath) -> bool {
return self.host == (*other).host &&
self.device == (*other).device &&
self.is_absolute == (*other).is_absolute &&
self.components == (*other).components;
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &WindowsPath) -> bool {
return (*self).host == (*other).host &&
(*self).device == (*other).device &&
(*self).is_absolute == (*other).is_absolute &&
(*self).components == (*other).components;
}
#[cfg(stage0)]
pure fn ne(other: &WindowsPath) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &WindowsPath) -> bool { !(*self).eq(other) }
}

10
src/libcore/pipes.rs
View file

@ -98,19 +98,9 @@ enum State {
}
impl State : Eq {
#[cfg(stage0)]
pure fn eq(other: &State) -> bool {
(self as uint) == ((*other) as uint)
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &State) -> bool {
((*self) as uint) == ((*other) as uint)
}
#[cfg(stage0)]
pure fn ne(other: &State) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &State) -> bool { !(*self).eq(other) }
}

68
src/libcore/ptr.rs
View file

@ -208,75 +208,31 @@ impl<T> *mut T: Ptr<T> {
// Equality for pointers
impl<T> *const T : Eq {
#[cfg(stage0)]
pure fn eq(other: &*const T) -> bool unsafe {
let a: uint = cast::reinterpret_cast(&self);
let b: uint = cast::reinterpret_cast(&(*other));
return a == b;
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &*const T) -> bool unsafe {
let a: uint = cast::reinterpret_cast(&(*self));
let b: uint = cast::reinterpret_cast(&(*other));
return a == b;
}
#[cfg(stage0)]
pure fn ne(other: &*const T) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &*const T) -> bool { !(*self).eq(other) }
}
// Comparison for pointers
impl<T> *const T : Ord {
#[cfg(stage0)]
pure fn lt(other: &*const T) -> bool unsafe {
let a: uint = cast::reinterpret_cast(&self);
let b: uint = cast::reinterpret_cast(&(*other));
return a < b;
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn lt(&self, other: &*const T) -> bool unsafe {
let a: uint = cast::reinterpret_cast(&(*self));
let b: uint = cast::reinterpret_cast(&(*other));
return a < b;
}
#[cfg(stage0)]
pure fn le(other: &*const T) -> bool unsafe {
let a: uint = cast::reinterpret_cast(&self);
let b: uint = cast::reinterpret_cast(&(*other));
return a <= b;
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn le(&self, other: &*const T) -> bool unsafe {
let a: uint = cast::reinterpret_cast(&(*self));
let b: uint = cast::reinterpret_cast(&(*other));
return a <= b;
}
#[cfg(stage0)]
pure fn ge(other: &*const T) -> bool unsafe {
let a: uint = cast::reinterpret_cast(&self);
let b: uint = cast::reinterpret_cast(&(*other));
return a >= b;
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ge(&self, other: &*const T) -> bool unsafe {
let a: uint = cast::reinterpret_cast(&(*self));
let b: uint = cast::reinterpret_cast(&(*other));
return a >= b;
}
#[cfg(stage0)]
pure fn gt(other: &*const T) -> bool unsafe {
let a: uint = cast::reinterpret_cast(&self);
let b: uint = cast::reinterpret_cast(&(*other));
return a > b;
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn gt(&self, other: &*const T) -> bool unsafe {
let a: uint = cast::reinterpret_cast(&(*self));
let b: uint = cast::reinterpret_cast(&(*other));
@ -286,17 +242,9 @@ impl<T> *const T : Ord {
// Equality for region pointers
impl<T:Eq> &const T : Eq {
#[cfg(stage0)]
pure fn eq(other: & &self/const T) -> bool { return *self == *(*other); }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: & &self/const T) -> bool {
return *(*self) == *(*other);
}
#[cfg(stage0)]
pure fn ne(other: & &self/const T) -> bool { return *self != *(*other); }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: & &self/const T) -> bool {
return *(*self) != *(*other);
}
@ -304,31 +252,15 @@ impl<T:Eq> &const T : Eq {
// Comparison for region pointers
impl<T:Ord> &const T : Ord {
#[cfg(stage0)]
pure fn lt(other: & &self/const T) -> bool { *self < *(*other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn lt(&self, other: & &self/const T) -> bool {
*(*self) < *(*other)
}
#[cfg(stage0)]
pure fn le(other: & &self/const T) -> bool { *self <= *(*other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn le(&self, other: & &self/const T) -> bool {
*(*self) <= *(*other)
}
#[cfg(stage0)]
pure fn ge(other: & &self/const T) -> bool { *self >= *(*other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ge(&self, other: & &self/const T) -> bool {
*(*self) >= *(*other)
}
#[cfg(stage0)]
pure fn gt(other: & &self/const T) -> bool { *self > *(*other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn gt(&self, other: & &self/const T) -> bool {
*(*self) > *(*other)
}

10
src/libcore/repr.rs
View file

@ -516,19 +516,9 @@ enum EnumVisitState {
}
impl EnumVisitState : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &EnumVisitState) -> bool {
(self as uint) == ((*other) as uint)
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &EnumVisitState) -> bool {
((*self) as uint) == ((*other) as uint)
}
#[cfg(stage0)]
pure fn ne(other: &EnumVisitState) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &EnumVisitState) -> bool { !(*self).eq(other) }
}

23
src/libcore/result.rs
View file

@ -365,25 +365,6 @@ pub fn unwrap_err<T, U>(res: Result<T, U>) -> U {
}
impl<T:Eq,U:Eq> Result<T,U> : Eq {
#[cfg(stage0)]
pure fn eq(other: &Result<T,U>) -> bool {
match self {
Ok(ref e0a) => {
match (*other) {
Ok(ref e0b) => *e0a == *e0b,
_ => false
}
}
Err(ref e0a) => {
match (*other) {
Err(ref e0b) => *e0a == *e0b,
_ => false
}
}
}
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &Result<T,U>) -> bool {
match (*self) {
Ok(ref e0a) => {
@ -400,10 +381,6 @@ impl<T:Eq,U:Eq> Result<T,U> : Eq {
}
}
}
#[cfg(stage0)]
pure fn ne(other: &Result<T,U>) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &Result<T,U>) -> bool { !(*self).eq(other) }
}

78
src/libcore/str.rs
View file

@ -737,139 +737,61 @@ pure fn gt(a: &str, b: &str) -> bool {
impl &str : Eq {
#[inline(always)]
#[cfg(stage0)]
pure fn eq(other: & &self/str) -> bool {
eq_slice(self, (*other))
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: & &self/str) -> bool {
eq_slice((*self), (*other))
}
#[inline(always)]
#[cfg(stage0)]
pure fn ne(other: & &self/str) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: & &self/str) -> bool { !(*self).eq(other) }
}
impl ~str : Eq {
#[inline(always)]
#[cfg(stage0)]
pure fn eq(other: &~str) -> bool {
eq_slice(self, (*other))
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &~str) -> bool {
eq_slice((*self), (*other))
}
#[inline(always)]
#[cfg(stage0)]
pure fn ne(other: &~str) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &~str) -> bool { !(*self).eq(other) }
}
impl @str : Eq {
#[inline(always)]
#[cfg(stage0)]
pure fn eq(other: &@str) -> bool {
eq_slice(self, (*other))
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &@str) -> bool {
eq_slice((*self), (*other))
}
#[inline(always)]
#[cfg(stage0)]
pure fn ne(other: &@str) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &@str) -> bool { !(*self).eq(other) }
}
impl ~str : Ord {
#[inline(always)]
#[cfg(stage0)]
pure fn lt(other: &~str) -> bool { lt(self, (*other)) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn lt(&self, other: &~str) -> bool { lt((*self), (*other)) }
#[inline(always)]
#[cfg(stage0)]
pure fn le(other: &~str) -> bool { le(self, (*other)) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn le(&self, other: &~str) -> bool { le((*self), (*other)) }
#[inline(always)]
#[cfg(stage0)]
pure fn ge(other: &~str) -> bool { ge(self, (*other)) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ge(&self, other: &~str) -> bool { ge((*self), (*other)) }
#[inline(always)]
#[cfg(stage0)]
pure fn gt(other: &~str) -> bool { gt(self, (*other)) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn gt(&self, other: &~str) -> bool { gt((*self), (*other)) }
}
impl &str : Ord {
#[inline(always)]
#[cfg(stage0)]
pure fn lt(other: & &self/str) -> bool { lt(self, (*other)) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn lt(&self, other: & &self/str) -> bool { lt((*self), (*other)) }
#[inline(always)]
#[cfg(stage0)]
pure fn le(other: & &self/str) -> bool { le(self, (*other)) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn le(&self, other: & &self/str) -> bool { le((*self), (*other)) }
#[inline(always)]
#[cfg(stage0)]
pure fn ge(other: & &self/str) -> bool { ge(self, (*other)) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ge(&self, other: & &self/str) -> bool { ge((*self), (*other)) }
#[inline(always)]
#[cfg(stage0)]
pure fn gt(other: & &self/str) -> bool { gt(self, (*other)) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn gt(&self, other: & &self/str) -> bool { gt((*self), (*other)) }
}
impl @str : Ord {
#[inline(always)]
#[cfg(stage0)]
pure fn lt(other: &@str) -> bool { lt(self, (*other)) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn lt(&self, other: &@str) -> bool { lt((*self), (*other)) }
#[inline(always)]
#[cfg(stage0)]
pure fn le(other: &@str) -> bool { le(self, (*other)) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn le(&self, other: &@str) -> bool { le((*self), (*other)) }
#[inline(always)]
#[cfg(stage0)]
pure fn ge(other: &@str) -> bool { ge(self, (*other)) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ge(&self, other: &@str) -> bool { ge((*self), (*other)) }
#[inline(always)]
#[cfg(stage0)]
pure fn gt(other: &@str) -> bool { gt(self, (*other)) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn gt(&self, other: &@str) -> bool { gt((*self), (*other)) }
}

64
src/libcore/task.rs
View file

@ -43,15 +43,7 @@ pub enum Task {
}
impl Task : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &Task) -> bool { *self == *(*other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &Task) -> bool { *(*self) == *(*other) }
#[cfg(stage0)]
pure fn ne(other: &Task) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &Task) -> bool { !(*self).eq(other) }
}
@ -72,25 +64,12 @@ pub enum TaskResult {
}
impl TaskResult : Eq {
#[cfg(stage0)]
pure fn eq(other: &TaskResult) -> bool {
match (self, (*other)) {
(Success, Success) | (Failure, Failure) => true,
(Success, _) | (Failure, _) => false
}
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &TaskResult) -> bool {
match ((*self), (*other)) {
(Success, Success) | (Failure, Failure) => true,
(Success, _) | (Failure, _) => false
}
}
#[cfg(stage0)]
pure fn ne(other: &TaskResult) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &TaskResult) -> bool { !(*self).eq(other) }
}
@ -114,43 +93,6 @@ pub enum SchedMode {
}
impl SchedMode : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &SchedMode) -> bool {
match self {
SingleThreaded => {
match (*other) {
SingleThreaded => true,
_ => false
}
}
ThreadPerCore => {
match (*other) {
ThreadPerCore => true,
_ => false
}
}
ThreadPerTask => {
match (*other) {
ThreadPerTask => true,
_ => false
}
}
ManualThreads(e0a) => {
match (*other) {
ManualThreads(e0b) => e0a == e0b,
_ => false
}
}
PlatformThread => {
match (*other) {
PlatformThread => true,
_ => false
}
}
}
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &SchedMode) -> bool {
match (*self) {
SingleThreaded => {
@ -185,12 +127,6 @@ impl SchedMode : cmp::Eq {
}
}
}
#[cfg(stage0)]
pure fn ne(other: &SchedMode) -> bool {
!self.eq(other)
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &SchedMode) -> bool {
!(*self).eq(other)
}

12
src/libcore/task/local_data_priv.rs
View file

@ -7,23 +7,11 @@ pub trait LocalData { }
impl<T: Owned> @T: LocalData { }
impl LocalData: Eq {
#[cfg(stage0)]
pure fn eq(other: &@LocalData) -> bool unsafe {
let ptr_a: (uint, uint) = cast::reinterpret_cast(&self);
let ptr_b: (uint, uint) = cast::reinterpret_cast(other);
return ptr_a == ptr_b;
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &@LocalData) -> bool unsafe {
let ptr_a: (uint, uint) = cast::reinterpret_cast(&(*self));
let ptr_b: (uint, uint) = cast::reinterpret_cast(other);
return ptr_a == ptr_b;
}
#[cfg(stage0)]
pure fn ne(other: &@LocalData) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &@LocalData) -> bool { !(*self).eq(other) }
}

93
src/libcore/tuple.rs
View file

@ -95,18 +95,6 @@ impl<A: Copy, B: Copy> (~[A], ~[B]): ExtendedTupleOps<A,B> {
}
impl<A: Eq, B: Eq> (A, B) : Eq {
#[cfg(stage0)]
pure fn eq(other: &(A, B)) -> bool {
match self {
(ref self_a, ref self_b) => match other {
&(ref other_a, ref other_b) => {
(*self_a).eq(other_a) && (*self_b).eq(other_b)
}
}
}
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &(A, B)) -> bool {
match (*self) {
(ref self_a, ref self_b) => match other {
@ -116,31 +104,10 @@ impl<A: Eq, B: Eq> (A, B) : Eq {
}
}
}
#[cfg(stage0)]
pure fn ne(other: &(A, B)) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &(A, B)) -> bool { !(*self).eq(other) }
}
impl<A: Ord, B: Ord> (A, B) : Ord {
#[cfg(stage0)]
pure fn lt(other: &(A, B)) -> bool {
match self {
(ref self_a, ref self_b) => {
match (*other) {
(ref other_a, ref other_b) => {
if (*self_a).lt(other_a) { return true; }
if (*other_a).lt(self_a) { return false; }
if (*self_b).lt(other_b) { return true; }
return false;
}
}
}
}
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn lt(&self, other: &(A, B)) -> bool {
match (*self) {
(ref self_a, ref self_b) => {
@ -155,37 +122,12 @@ impl<A: Ord, B: Ord> (A, B) : Ord {
}
}
}
#[cfg(stage0)]
pure fn le(other: &(A, B)) -> bool { !(*other).lt(&self) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn le(&self, other: &(A, B)) -> bool { !(*other).lt(&(*self)) }
#[cfg(stage0)]
pure fn ge(other: &(A, B)) -> bool { !self.lt(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ge(&self, other: &(A, B)) -> bool { !(*self).lt(other) }
#[cfg(stage0)]
pure fn gt(other: &(A, B)) -> bool { (*other).lt(&self) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn gt(&self, other: &(A, B)) -> bool { (*other).lt(&(*self)) }
}
impl<A: Eq, B: Eq, C: Eq> (A, B, C) : Eq {
#[cfg(stage0)]
pure fn eq(other: &(A, B, C)) -> bool {
match self {
(ref self_a, ref self_b, ref self_c) => match other {
&(ref other_a, ref other_b, ref other_c) => {
(*self_a).eq(other_a) && (*self_b).eq(other_b)
&& (*self_c).eq(other_c)
}
}
}
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &(A, B, C)) -> bool {
match (*self) {
(ref self_a, ref self_b, ref self_c) => match other {
@ -196,33 +138,10 @@ impl<A: Eq, B: Eq, C: Eq> (A, B, C) : Eq {
}
}
}
#[cfg(stage0)]
pure fn ne(other: &(A, B, C)) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &(A, B, C)) -> bool { !(*self).eq(other) }
}
impl<A: Ord, B: Ord, C: Ord> (A, B, C) : Ord {
#[cfg(stage0)]
pure fn lt(other: &(A, B, C)) -> bool {
match self {
(ref self_a, ref self_b, ref self_c) => {
match (*other) {
(ref other_a, ref other_b, ref other_c) => {
if (*self_a).lt(other_a) { return true; }
if (*other_a).lt(self_a) { return false; }
if (*self_b).lt(other_b) { return true; }
if (*other_b).lt(self_b) { return false; }
if (*self_c).lt(other_c) { return true; }
return false;
}
}
}
}
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn lt(&self, other: &(A, B, C)) -> bool {
match (*self) {
(ref self_a, ref self_b, ref self_c) => {
@ -239,20 +158,8 @@ impl<A: Ord, B: Ord, C: Ord> (A, B, C) : Ord {
}
}
}
#[cfg(stage0)]
pure fn le(other: &(A, B, C)) -> bool { !(*other).lt(&self) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn le(&self, other: &(A, B, C)) -> bool { !(*other).lt(&(*self)) }
#[cfg(stage0)]
pure fn ge(other: &(A, B, C)) -> bool { !self.lt(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ge(&self, other: &(A, B, C)) -> bool { !(*self).lt(other) }
#[cfg(stage0)]
pure fn gt(other: &(A, B, C)) -> bool { (*other).lt(&self) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn gt(&self, other: &(A, B, C)) -> bool { (*other).lt(&(*self)) }
}

24
src/libcore/uint-template.rs
View file

@ -49,38 +49,14 @@ pub pure fn compl(i: T) -> T {
}
impl T : Ord {
#[cfg(stage0)]
pure fn lt(other: &T) -> bool { self < (*other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn lt(&self, other: &T) -> bool { (*self) < (*other) }
#[cfg(stage0)]
pure fn le(other: &T) -> bool { self <= (*other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn le(&self, other: &T) -> bool { (*self) <= (*other) }
#[cfg(stage0)]
pure fn ge(other: &T) -> bool { self >= (*other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ge(&self, other: &T) -> bool { (*self) >= (*other) }
#[cfg(stage0)]
pure fn gt(other: &T) -> bool { self > (*other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn gt(&self, other: &T) -> bool { (*self) > (*other) }
}
impl T : Eq {
#[cfg(stage0)]
pure fn eq(other: &T) -> bool { return self == (*other); }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &T) -> bool { return (*self) == (*other); }
#[cfg(stage0)]
pure fn ne(other: &T) -> bool { return self != (*other); }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &T) -> bool { return (*self) != (*other); }
}

24
src/libcore/unit.rs
View file

@ -11,38 +11,14 @@ Functions for the unit type.
use cmp::{Eq, Ord};
impl () : Eq {
#[cfg(stage0)]
pure fn eq(_other: &()) -> bool { true }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, _other: &()) -> bool { true }
#[cfg(stage0)]
pure fn ne(_other: &()) -> bool { false }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, _other: &()) -> bool { false }
}
impl () : Ord {
#[cfg(stage0)]
pure fn lt(_other: &()) -> bool { false }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn lt(&self, _other: &()) -> bool { false }
#[cfg(stage0)]
pure fn le(_other: &()) -> bool { true }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn le(&self, _other: &()) -> bool { true }
#[cfg(stage0)]
pure fn ge(_other: &()) -> bool { true }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ge(&self, _other: &()) -> bool { true }
#[cfg(stage0)]
pure fn gt(_other: &()) -> bool { false }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn gt(&self, _other: &()) -> bool { false }
}

72
src/libcore/vec.rs
View file

@ -1347,47 +1347,23 @@ pure fn eq<T: Eq>(a: &[T], b: &[T]) -> bool {
impl<T: Eq> &[T] : Eq {
#[inline(always)]
#[cfg(stage0)]
pure fn eq(other: & &self/[T]) -> bool { eq(self, (*other)) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: & &self/[T]) -> bool { eq((*self), (*other)) }
#[inline(always)]
#[cfg(stage0)]
pure fn ne(other: & &self/[T]) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: & &self/[T]) -> bool { !(*self).eq(other) }
}
impl<T: Eq> ~[T] : Eq {
#[inline(always)]
#[cfg(stage0)]
pure fn eq(other: &~[T]) -> bool { eq(self, (*other)) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &~[T]) -> bool { eq((*self), (*other)) }
#[inline(always)]
#[cfg(stage0)]
pure fn ne(other: &~[T]) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &~[T]) -> bool { !(*self).eq(other) }
}
impl<T: Eq> @[T] : Eq {
#[inline(always)]
#[cfg(stage0)]
pure fn eq(other: &@[T]) -> bool { eq(self, (*other)) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &@[T]) -> bool { eq((*self), (*other)) }
#[inline(always)]
#[cfg(stage0)]
pure fn ne(other: &@[T]) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &@[T]) -> bool { !(*self).eq(other) }
}
@ -1414,82 +1390,34 @@ pure fn gt<T: Ord>(a: &[T], b: &[T]) -> bool { lt(b, a) }
impl<T: Ord> &[T] : Ord {
#[inline(always)]
#[cfg(stage0)]
pure fn lt(other: & &self/[T]) -> bool { lt(self, (*other)) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn lt(&self, other: & &self/[T]) -> bool { lt((*self), (*other)) }
#[inline(always)]
#[cfg(stage0)]
pure fn le(other: & &self/[T]) -> bool { le(self, (*other)) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn le(&self, other: & &self/[T]) -> bool { le((*self), (*other)) }
#[inline(always)]
#[cfg(stage0)]
pure fn ge(other: & &self/[T]) -> bool { ge(self, (*other)) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ge(&self, other: & &self/[T]) -> bool { ge((*self), (*other)) }
#[inline(always)]
#[cfg(stage0)]
pure fn gt(other: & &self/[T]) -> bool { gt(self, (*other)) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn gt(&self, other: & &self/[T]) -> bool { gt((*self), (*other)) }
}
impl<T: Ord> ~[T] : Ord {
#[inline(always)]
#[cfg(stage0)]
pure fn lt(other: &~[T]) -> bool { lt(self, (*other)) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn lt(&self, other: &~[T]) -> bool { lt((*self), (*other)) }
#[inline(always)]
#[cfg(stage0)]
pure fn le(other: &~[T]) -> bool { le(self, (*other)) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn le(&self, other: &~[T]) -> bool { le((*self), (*other)) }
#[inline(always)]
#[cfg(stage0)]
pure fn ge(other: &~[T]) -> bool { ge(self, (*other)) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ge(&self, other: &~[T]) -> bool { ge((*self), (*other)) }
#[inline(always)]
#[cfg(stage0)]
pure fn gt(other: &~[T]) -> bool { gt(self, (*other)) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn gt(&self, other: &~[T]) -> bool { gt((*self), (*other)) }
}
impl<T: Ord> @[T] : Ord {
#[inline(always)]
#[cfg(stage0)]
pure fn lt(other: &@[T]) -> bool { lt(self, (*other)) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn lt(&self, other: &@[T]) -> bool { lt((*self), (*other)) }
#[inline(always)]
#[cfg(stage0)]
pure fn le(other: &@[T]) -> bool { le(self, (*other)) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn le(&self, other: &@[T]) -> bool { le((*self), (*other)) }
#[inline(always)]
#[cfg(stage0)]
pure fn ge(other: &@[T]) -> bool { ge(self, (*other)) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ge(&self, other: &@[T]) -> bool { ge((*self), (*other)) }
#[inline(always)]
#[cfg(stage0)]
pure fn gt(other: &@[T]) -> bool { gt(self, (*other)) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn gt(&self, other: &@[T]) -> bool { gt((*self), (*other)) }
}

10
src/libfuzzer/fuzzer.rc
View file

@ -34,16 +34,6 @@ use syntax::diagnostic;
enum test_mode { tm_converge, tm_run, }
type context = { mode: test_mode }; // + rng
#[cfg(stage0)]
impl test_mode : cmp::Eq {
pure fn eq(other: &test_mode) -> bool {
(self as uint) == ((*other) as uint)
}
pure fn ne(other: &test_mode) -> bool { !self.eq(other) }
}
#[cfg(stage1)]
#[cfg(stage2)]
impl test_mode : cmp::Eq {
pure fn eq(&self, other: &test_mode) -> bool {
((*self) as uint) == ((*other) as uint)

501
src/librustc/alternate_crate.rc
View file

@ -1,501 +0,0 @@
// -*- rust -*-
#[link(name = "rustc",
vers = "0.5",
uuid = "0ce89b41-2f92-459e-bbc1-8f5fe32f16cf",
url = "https://github.com/mozilla/rust/tree/master/src/rustc")];
#[comment = "The Rust compiler"];
#[license = "MIT"];
#[crate_type = "lib"];
#[no_core];
#[legacy_modes];
#[legacy_exports];
#[allow(vecs_implicitly_copyable)];
#[allow(non_camel_case_types)];
#[allow(deprecated_mode)];
#[allow(deprecated_pattern)];
extern mod core(vers = "0.5");
extern mod std(vers = "0.5");
extern mod syntax(vers = "0.5");
use core::*;
/*
Alternate names for some modules.
I am using this to help extract metadata into its own crate. In metadata.rs
it redefines all these modules in order to gate access from metadata to the
rest of the compiler, then uses these to access the original implementation.
*/
use util_ = util;
use lib_ = lib;
use driver_ = driver;
use middle_ = middle;
use back_ = back;
mod middle {
#[legacy_exports];
mod trans {
#[legacy_exports];
#[legacy_exports]
#[path = "middle/trans/inline.rs"]
mod inline;
#[legacy_exports]
#[path = "middle/trans/monomorphize.rs"]
mod monomorphize;
#[legacy_exports]
#[path = "middle/trans/controlflow.rs"]
mod controlflow;
#[legacy_exports]
#[path = "middle/trans/glue.rs"]
mod glue;
#[legacy_exports]
#[path = "middle/trans/datum.rs"]
mod datum;
#[legacy_exports]
#[path = "middle/trans/callee.rs"]
mod callee;
#[legacy_exports]
#[path = "middle/trans/expr.rs"]
mod expr;
#[legacy_exports]
#[path = "middle/trans/common.rs"]
mod common;
#[legacy_exports]
#[path = "middle/trans/consts.rs"]
mod consts;
#[legacy_exports]
#[path = "middle/trans/type_of.rs"]
mod type_of;
#[legacy_exports]
#[path = "middle/trans/build.rs"]
mod build;
#[legacy_exports]
#[path = "middle/trans/base.rs"]
mod base;
#[legacy_exports]
#[path = "middle/trans/alt.rs"]
mod alt;
#[legacy_exports]
#[path = "middle/trans/uniq.rs"]
mod uniq;
#[legacy_exports]
#[path = "middle/trans/closure.rs"]
mod closure;
#[legacy_exports]
#[path = "middle/trans/tvec.rs"]
mod tvec;
#[legacy_exports]
#[path = "middle/trans/meth.rs"]
mod meth;
#[legacy_exports]
#[path = "middle/trans/foreign.rs"]
mod foreign;
#[legacy_exports]
#[path = "middle/trans/reflect.rs"]
mod reflect;
#[legacy_exports]
#[path = "middle/trans/shape.rs"]
mod shape;
#[legacy_exports]
#[path = "middle/trans/debuginfo.rs"]
mod debuginfo;
#[legacy_exports]
#[path = "middle/trans/type_use.rs"]
mod type_use;
#[legacy_exports]
#[path = "middle/trans/reachable.rs"]
mod reachable;
#[path = "middle/trans/machine.rs"]
mod machine;
#[path = "middle/trans/deriving.rs"]
mod deriving;
}
#[legacy_exports]
#[path = "middle/ty.rs"]
mod ty;
#[legacy_exports]
#[path = "middle/resolve.rs"]
mod resolve;
#[path = "middle/typeck.rs"]
#[merge = "middle/typeck/mod.rs"]
pub mod typeck;
#[legacy_exports]
#[path = "middle/check_loop.rs"]
mod check_loop;
#[legacy_exports]
#[path = "middle/check_alt.rs"]
mod check_alt;
#[legacy_exports]
#[path = "middle/check_const.rs"]
mod check_const;
#[legacy_exports]
#[path = "middle/lint.rs"]
mod lint;
#[path = "middle/borrowck.rs"]
#[merge = "middle/borrowck/mod.rs"]
mod borrowck;
#[legacy_exports]
#[path = "middle/mem_categorization.rs"]
mod mem_categorization;
#[legacy_exports]
#[path = "middle/liveness.rs"]
mod liveness;
#[legacy_exports]
#[path = "middle/kind.rs"]
mod kind;
#[legacy_exports]
#[path = "middle/freevars.rs"]
mod freevars;
#[legacy_exports]
#[path = "middle/capture.rs"]
mod capture;
#[legacy_exports]
#[path = "middle/pat_util.rs"]
mod pat_util;
#[legacy_exports]
#[path = "middle/region.rs"]
mod region;
#[legacy_exports]
#[path = "middle/const_eval.rs"]
mod const_eval;
#[legacy_exports]
#[path = "middle/astencode.rs"]
mod astencode;
#[legacy_exports]
#[path = "middle/lang_items.rs"]
mod lang_items;
#[legacy_exports]
#[path = "middle/privacy.rs"]
mod privacy;
}
mod front {
#[legacy_exports];
#[legacy_exports]
#[path = "front/config.rs"]
mod config;
#[legacy_exports]
#[path = "front/test.rs"]
mod test;
#[legacy_exports]
#[path = "front/core_inject.rs"]
mod core_inject;
#[legacy_exports]
#[path = "front/intrinsic_inject.rs"]
mod intrinsic_inject;
}
mod back {
#[legacy_exports];
#[legacy_exports]
#[path = "back/link.rs"]
mod link;
#[legacy_exports]
#[path = "back/abi.rs"]
mod abi;
#[legacy_exports]
#[path = "back/upcall.rs"]
mod upcall;
#[legacy_exports]
#[path = "back/x86.rs"]
mod x86;
#[legacy_exports]
#[path = "back/x86_64.rs"]
mod x86_64;
#[legacy_exports]
#[path = "back/rpath.rs"]
mod rpath;
#[legacy_exports]
#[path = "back/target_strs.rs"]
mod target_strs;
}
#[merge = "metadata/mod.rs"]
mod metadata;
#[merge = "driver/mod.rs"]
mod driver;
mod util {
#[legacy_exports];
#[legacy_exports]
#[path = "util/common.rs"]
mod common;
#[legacy_exports]
#[path = "util/ppaux.rs"]
mod ppaux;
}
mod lib {
#[legacy_exports];
#[legacy_exports]
#[path = "lib/llvm.rs"]
mod llvm;
}
use result::{Ok, Err};
use io::ReaderUtil;
use std::getopts;
use std::map::HashMap;
use getopts::{opt_present};
use getopts::groups;
use syntax::codemap;
use syntax::diagnostic;
use driver::driver::{host_triple, optgroups, early_error,
str_input, file_input, build_session_options,
build_session, build_configuration, parse_pretty,
pp_mode, pretty_print_input, list_metadata,
compile_input};
use driver::session;
use middle::lint;
fn version(argv0: &str) {
let mut vers = ~"unknown version";
let env_vers = env!("CFG_VERSION");
if env_vers.len() != 0 { vers = env_vers; }
io::println(fmt!("%s %s", argv0, vers));
io::println(fmt!("host: %s", host_triple()));
}
fn usage(argv0: &str) {
let message = fmt!("Usage: %s [OPTIONS] INPUT", argv0);
io::println(groups::usage(message, optgroups()) +
~"Additional help:
-W help Print 'lint' options and default settings
-Z help Print internal options for debugging rustc
");
}
fn describe_warnings() {
io::println(fmt!("
Available lint options:
-W <foo> Warn about <foo>
-A <foo> Allow <foo>
-D <foo> Deny <foo>
-F <foo> Forbid <foo> (deny, and deny all overrides)
"));
let lint_dict = lint::get_lint_dict();
let mut max_key = 0;
for lint_dict.each_key |k| { max_key = uint::max(k.len(), max_key); }
fn padded(max: uint, s: &str) -> ~str {
str::from_bytes(vec::from_elem(max - s.len(), ' ' as u8)) + s
}
io::println(fmt!("\nAvailable lint checks:\n"));
io::println(fmt!(" %s %7.7s %s",
padded(max_key, ~"name"), ~"default", ~"meaning"));
io::println(fmt!(" %s %7.7s %s\n",
padded(max_key, ~"----"), ~"-------", ~"-------"));
for lint_dict.each |k, v| {
let k = str::replace(k, ~"_", ~"-");
io::println(fmt!(" %s %7.7s %s",
padded(max_key, k),
match v.default {
lint::allow => ~"allow",
lint::warn => ~"warn",
lint::deny => ~"deny",
lint::forbid => ~"forbid"
},
v.desc));
}
io::println(~"");
}
fn describe_debug_flags() {
io::println(fmt!("\nAvailable debug options:\n"));
for session::debugging_opts_map().each |pair| {
let (name, desc, _) = *pair;
io::println(fmt!(" -Z %-20s -- %s", name, desc));
}
}
fn run_compiler(args: &~[~str], demitter: diagnostic::emitter) {
// Don't display log spew by default. Can override with RUST_LOG.
logging::console_off();
let mut args = *args;
let binary = args.shift();
if args.is_empty() { usage(binary); return; }
let matches =
match getopts::groups::getopts(args, optgroups()) {
Ok(m) => m,
Err(f) => {
early_error(demitter, getopts::fail_str(f))
}
};
if opt_present(matches, ~"h") || opt_present(matches, ~"help") {
usage(binary);
return;
}
let lint_flags = vec::append(getopts::opt_strs(matches, ~"W"),
getopts::opt_strs(matches, ~"warn"));
if lint_flags.contains(&~"help") {
describe_warnings();
return;
}
if getopts::opt_strs(matches, ~"Z").contains(&~"help") {
describe_debug_flags();
return;
}
if opt_present(matches, ~"v") || opt_present(matches, ~"version") {
version(binary);
return;
}
let input = match vec::len(matches.free) {
0u => early_error(demitter, ~"no input filename given"),
1u => {
let ifile = matches.free[0];
if ifile == ~"-" {
let src = str::from_bytes(io::stdin().read_whole_stream());
str_input(src)
} else {
file_input(Path(ifile))
}
}
_ => early_error(demitter, ~"multiple input filenames provided")
};
let sopts = build_session_options(binary, matches, demitter);
let sess = build_session(sopts, demitter);
let odir = getopts::opt_maybe_str(matches, ~"out-dir");
let odir = odir.map(|o| Path(*o));
let ofile = getopts::opt_maybe_str(matches, ~"o");
let ofile = ofile.map(|o| Path(*o));
let cfg = build_configuration(sess, binary, input);
let pretty =
option::map(&getopts::opt_default(matches, ~"pretty",
~"normal"),
|a| parse_pretty(sess, *a) );
match pretty {
Some::<pp_mode>(ppm) => {
pretty_print_input(sess, cfg, input, ppm);
return;
}
None::<pp_mode> => {/* continue */ }
}
let ls = opt_present(matches, ~"ls");
if ls {
match input {
file_input(ifile) => {
list_metadata(sess, &ifile, io::stdout());
}
str_input(_) => {
early_error(demitter, ~"can not list metadata for stdin");
}
}
return;
}
compile_input(sess, cfg, input, &odir, &ofile);
}
enum monitor_msg {
fatal,
done,
}
impl monitor_msg : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &monitor_msg) -> bool {
(self as uint) == ((*other) as uint)
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &monitor_msg) -> bool {
((*self) as uint) == ((*other) as uint)
}
#[cfg(stage0)]
pure fn ne(other: &monitor_msg) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &monitor_msg) -> bool { !(*self).eq(other) }
}
/*
This is a sanity check that any failure of the compiler is performed
through the diagnostic module and reported properly - we shouldn't be calling
plain-old-fail on any execution path that might be taken. Since we have
console logging off by default, hitting a plain fail statement would make the
compiler silently exit, which would be terrible.
This method wraps the compiler in a subtask and injects a function into the
diagnostic emitter which records when we hit a fatal error. If the task
fails without recording a fatal error then we've encountered a compiler
bug and need to present an error.
*/
fn monitor(+f: fn~(diagnostic::emitter)) {
let p = comm::Port();
let ch = comm::Chan(&p);
match do task::try |move f| {
// The 'diagnostics emitter'. Every error, warning, etc. should
// go through this function.
let demitter = fn@(cmsp: Option<(@codemap::CodeMap, codemap::span)>,
msg: &str, lvl: diagnostic::level) {
if lvl == diagnostic::fatal {
comm::send(ch, fatal);
}
diagnostic::emit(cmsp, msg, lvl);
};
struct finally {
ch: comm::Chan<monitor_msg>,
drop { comm::send(self.ch, done); }
}
let _finally = finally { ch: ch };
f(demitter)
} {
result::Ok(_) => { /* fallthrough */ }
result::Err(_) => {
// Task failed without emitting a fatal diagnostic
if comm::recv(p) == done {
diagnostic::emit(
None,
diagnostic::ice_msg(~"unexpected failure"),
diagnostic::error);
for [
~"the compiler hit an unexpected failure path. \
this is a bug",
~"try running with RUST_LOG=rustc=1,::rt::backtrace \
to get further details and report the results \
to github.com/mozilla/rust/issues"
].each |note| {
diagnostic::emit(None, *note, diagnostic::note)
}
}
// Fail so the process returns a failure code
fail;
}
}
}
fn main() {
let mut args = os::args();
do monitor |move args, demitter| {
run_compiler(&args, demitter);
}
}
// Local Variables:
// fill-column: 78;
// indent-tabs-mode: nil
// c-basic-offset: 4
// buffer-file-coding-system: utf-8-unix
// End:

10
src/librustc/back/link.rs
View file

@ -27,19 +27,9 @@ enum output_type {
}
impl output_type : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &output_type) -> bool {
(self as uint) == ((*other) as uint)
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &output_type) -> bool {
((*self) as uint) == ((*other) as uint)
}
#[cfg(stage0)]
pure fn ne(other: &output_type) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &output_type) -> bool { !(*self).eq(other) }
}

10
src/librustc/driver/driver.rs
View file

@ -141,19 +141,9 @@ enum compile_upto {
}
impl compile_upto : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &compile_upto) -> bool {
(self as uint) == ((*other) as uint)
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &compile_upto) -> bool {
((*self) as uint) == ((*other) as uint)
}
#[cfg(stage0)]
pure fn ne(other: &compile_upto) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &compile_upto) -> bool { !(*self).eq(other) }
}

30
src/librustc/driver/session.rs
View file

@ -13,38 +13,18 @@ use middle::lint;
enum os { os_win32, os_macos, os_linux, os_freebsd, }
impl os : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &os) -> bool {
(self as uint) == ((*other) as uint)
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &os) -> bool {
((*self) as uint) == ((*other) as uint)
}
#[cfg(stage0)]
pure fn ne(other: &os) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &os) -> bool { !(*self).eq(other) }
}
enum arch { arch_x86, arch_x86_64, arch_arm, }
impl arch : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &arch) -> bool {
(self as uint) == ((*other) as uint)
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &arch) -> bool {
((*self) as uint) == ((*other) as uint)
}
#[cfg(stage0)]
pure fn ne(other: &arch) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &arch) -> bool { !(*self).eq(other) }
}
@ -111,19 +91,9 @@ enum OptLevel {
}
impl OptLevel : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &OptLevel) -> bool {
(self as uint) == ((*other) as uint)
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &OptLevel) -> bool {
((*self) as uint) == ((*other) as uint)
}
#[cfg(stage0)]
pure fn ne(other: &OptLevel) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &OptLevel) -> bool { !(*self).eq(other) }
}

43
src/librustc/lib/llvm.rs
View file

@ -131,45 +131,6 @@ enum TypeKind {
}
impl TypeKind : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &TypeKind) -> bool {
match (self, (*other)) {
(Void, Void) => true,
(Half, Half) => true,
(Float, Float) => true,
(Double, Double) => true,
(X86_FP80, X86_FP80) => true,
(FP128, FP128) => true,
(PPC_FP128, PPC_FP128) => true,
(Label, Label) => true,
(Integer, Integer) => true,
(Function, Function) => true,
(Struct, Struct) => true,
(Array, Array) => true,
(Pointer, Pointer) => true,
(Vector, Vector) => true,
(Metadata, Metadata) => true,
(X86_MMX, X86_MMX) => true,
(Void, _) => false,
(Half, _) => false,
(Float, _) => false,
(Double, _) => false,
(X86_FP80, _) => false,
(FP128, _) => false,
(PPC_FP128, _) => false,
(Label, _) => false,
(Integer, _) => false,
(Function, _) => false,
(Struct, _) => false,
(Array, _) => false,
(Pointer, _) => false,
(Vector, _) => false,
(Metadata, _) => false,
(X86_MMX, _) => false,
}
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &TypeKind) -> bool {
match ((*self), (*other)) {
(Void, Void) => true,
@ -206,10 +167,6 @@ impl TypeKind : cmp::Eq {
(X86_MMX, _) => false,
}
}
#[cfg(stage0)]
pure fn ne(other: &TypeKind) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &TypeKind) -> bool { !(*self).eq(other) }
}

10
src/librustc/metadata/decoder.rs
View file

@ -140,19 +140,9 @@ enum Family {
}
impl Family : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &Family) -> bool {
(self as uint) == ((*other) as uint)
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &Family) -> bool {
((*self) as uint) == ((*other) as uint)
}
#[cfg(stage0)]
pure fn ne(other: &Family) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &Family) -> bool { !(*self).eq(other) }
}

70
src/librustc/middle/borrowck.rs
View file

@ -323,50 +323,6 @@ enum bckerr_code {
}
impl bckerr_code : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &bckerr_code) -> bool {
match self {
err_mut_uniq => {
match (*other) {
err_mut_uniq => true,
_ => false
}
}
err_mut_variant => {
match (*other) {
err_mut_variant => true,
_ => false
}
}
err_root_not_permitted => {
match (*other) {
err_root_not_permitted => true,
_ => false
}
}
err_mutbl(e0a) => {
match (*other) {
err_mutbl(e0b) => e0a == e0b,
_ => false
}
}
err_out_of_root_scope(e0a, e1a) => {
match (*other) {
err_out_of_root_scope(e0b, e1b) =>
e0a == e0b && e1a == e1b,
_ => false
}
}
err_out_of_scope(e0a, e1a) => {
match (*other) {
err_out_of_scope(e0b, e1b) => e0a == e0b && e1a == e1b,
_ => false
}
}
}
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &bckerr_code) -> bool {
match (*self) {
err_mut_uniq => {
@ -408,10 +364,6 @@ impl bckerr_code : cmp::Eq {
}
}
}
#[cfg(stage0)]
pure fn ne(other: &bckerr_code) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &bckerr_code) -> bool { !(*self).eq(other) }
}
@ -420,19 +372,9 @@ impl bckerr_code : cmp::Eq {
type bckerr = {cmt: cmt, code: bckerr_code};
impl bckerr : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &bckerr) -> bool {
self.cmt == (*other).cmt && self.code == (*other).code
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &bckerr) -> bool {
(*self).cmt == (*other).cmt && (*self).code == (*other).code
}
#[cfg(stage0)]
pure fn ne(other: &bckerr) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &bckerr) -> bool { !(*self).eq(other) }
}
@ -463,21 +405,9 @@ fn save_and_restore<T:Copy,U>(save_and_restore_t: &mut T, f: fn() -> U) -> U {
/// Creates and returns a new root_map
impl root_map_key : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &root_map_key) -> bool {
self.id == (*other).id && self.derefs == (*other).derefs
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &root_map_key) -> bool {
(*self).id == (*other).id && (*self).derefs == (*other).derefs
}
#[cfg(stage0)]
pure fn ne(other: &root_map_key) -> bool {
! (self == (*other))
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &root_map_key) -> bool {
! ((*self) == (*other))
}

33
src/librustc/middle/borrowck/check_loans.rs
View file

@ -33,25 +33,6 @@ enum purity_cause {
}
impl purity_cause : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &purity_cause) -> bool {
match self {
pc_pure_fn => {
match (*other) {
pc_pure_fn => true,
_ => false
}
}
pc_cmt(e0a) => {
match (*other) {
pc_cmt(e0b) => e0a == e0b,
_ => false
}
}
}
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &purity_cause) -> bool {
match (*self) {
pc_pure_fn => {
@ -68,10 +49,6 @@ impl purity_cause : cmp::Eq {
}
}
}
#[cfg(stage0)]
pure fn ne(other: &purity_cause) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &purity_cause) -> bool { !(*self).eq(other) }
}
@ -97,19 +74,9 @@ enum assignment_type {
}
impl assignment_type : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &assignment_type) -> bool {
(self as uint) == ((*other) as uint)
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &assignment_type) -> bool {
((*self) as uint) == ((*other) as uint)
}
#[cfg(stage0)]
pure fn ne(other: &assignment_type) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &assignment_type) -> bool { !(*self).eq(other) }
}

20
src/librustc/middle/check_alt.rs
View file

@ -126,22 +126,6 @@ enum ctor {
}
impl ctor : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &ctor) -> bool {
match (self, (*other)) {
(single, single) => true,
(variant(did_self), variant(did_other)) => did_self == did_other,
(val(cv_self), val(cv_other)) => cv_self == cv_other,
(range(cv0_self, cv1_self), range(cv0_other, cv1_other)) => {
cv0_self == cv0_other && cv1_self == cv1_other
}
(single, _) | (variant(_), _) | (val(_), _) | (range(*), _) => {
false
}
}
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &ctor) -> bool {
match ((*self), (*other)) {
(single, single) => true,
@ -155,10 +139,6 @@ impl ctor : cmp::Eq {
}
}
}
#[cfg(stage0)]
pure fn ne(other: &ctor) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &ctor) -> bool { !(*self).eq(other) }
}

18
src/librustc/middle/const_eval.rs
View file

@ -206,20 +206,6 @@ enum const_val {
}
impl const_val : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &const_val) -> bool {
match (self, (*other)) {
(const_float(a), const_float(b)) => a == b,
(const_int(a), const_int(b)) => a == b,
(const_uint(a), const_uint(b)) => a == b,
(const_str(a), const_str(b)) => a == b,
(const_bool(a), const_bool(b)) => a == b,
(const_float(_), _) | (const_int(_), _) | (const_uint(_), _) |
(const_str(_), _) | (const_bool(_), _) => false
}
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &const_val) -> bool {
match ((*self), (*other)) {
(const_float(a), const_float(b)) => a == b,
@ -231,10 +217,6 @@ impl const_val : cmp::Eq {
(const_str(_), _) | (const_bool(_), _) => false
}
}
#[cfg(stage0)]
pure fn ne(other: &const_val) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &const_val) -> bool { !(*self).eq(other) }
}

20
src/librustc/middle/lint.rs
View file

@ -68,19 +68,9 @@ enum lint {
}
impl lint : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &lint) -> bool {
(self as uint) == ((*other) as uint)
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &lint) -> bool {
((*self) as uint) == ((*other) as uint)
}
#[cfg(stage0)]
pure fn ne(other: &lint) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &lint) -> bool { !(*self).eq(other) }
}
@ -98,19 +88,9 @@ enum level {
}
impl level : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &level) -> bool {
(self as uint) == ((*other) as uint)
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &level) -> bool {
((*self) as uint) == ((*other) as uint)
}
#[cfg(stage0)]
pure fn ne(other: &level) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &level) -> bool { !(*self).eq(other) }
}

51
src/librustc/middle/liveness.rs
View file

@ -119,28 +119,12 @@ enum Variable = uint;
enum LiveNode = uint;
impl Variable : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &Variable) -> bool { *self == *(*other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &Variable) -> bool { *(*self) == *(*other) }
#[cfg(stage0)]
pure fn ne(other: &Variable) -> bool { *self != *(*other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &Variable) -> bool { *(*self) != *(*other) }
}
impl LiveNode : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &LiveNode) -> bool { *self == *(*other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &LiveNode) -> bool { *(*self) == *(*other) }
#[cfg(stage0)]
pure fn ne(other: &LiveNode) -> bool { *self != *(*other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &LiveNode) -> bool { *(*self) != *(*other) }
}
@ -152,37 +136,6 @@ enum LiveNodeKind {
}
impl LiveNodeKind : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &LiveNodeKind) -> bool {
match self {
FreeVarNode(e0a) => {
match (*other) {
FreeVarNode(e0b) => e0a == e0b,
_ => false
}
}
ExprNode(e0a) => {
match (*other) {
ExprNode(e0b) => e0a == e0b,
_ => false
}
}
VarDefNode(e0a) => {
match (*other) {
VarDefNode(e0b) => e0a == e0b,
_ => false
}
}
ExitNode => {
match (*other) {
ExitNode => true,
_ => false
}
}
}
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &LiveNodeKind) -> bool {
match (*self) {
FreeVarNode(e0a) => {
@ -211,10 +164,6 @@ impl LiveNodeKind : cmp::Eq {
}
}
}
#[cfg(stage0)]
pure fn ne(other: &LiveNodeKind) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &LiveNodeKind) -> bool { !(*self).eq(other) }
}

202
src/librustc/middle/mem_categorization.rs
View file

@ -56,68 +56,6 @@ enum categorization {
}
impl categorization : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &categorization) -> bool {
match self {
cat_rvalue => {
match (*other) {
cat_rvalue => true,
_ => false
}
}
cat_special(e0a) => {
match (*other) {
cat_special(e0b) => e0a == e0b,
_ => false
}
}
cat_local(e0a) => {
match (*other) {
cat_local(e0b) => e0a == e0b,
_ => false
}
}
cat_binding(e0a) => {
match (*other) {
cat_binding(e0b) => e0a == e0b,
_ => false
}
}
cat_arg(e0a) => {
match (*other) {
cat_arg(e0b) => e0a == e0b,
_ => false
}
}
cat_stack_upvar(e0a) => {
match (*other) {
cat_stack_upvar(e0b) => e0a == e0b,
_ => false
}
}
cat_deref(e0a, e1a, e2a) => {
match (*other) {
cat_deref(e0b, e1b, e2b) =>
e0a == e0b && e1a == e1b && e2a == e2b,
_ => false
}
}
cat_comp(e0a, e1a) => {
match (*other) {
cat_comp(e0b, e1b) => e0a == e0b && e1a == e1b,
_ => false
}
}
cat_discr(e0a, e1a) => {
match (*other) {
cat_discr(e0b, e1b) => e0a == e0b && e1a == e1b,
_ => false
}
}
}
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &categorization) -> bool {
match (*self) {
cat_rvalue => {
@ -177,10 +115,6 @@ impl categorization : cmp::Eq {
}
}
}
#[cfg(stage0)]
pure fn ne(other: &categorization) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &categorization) -> bool { !(*self).eq(other) }
}
@ -193,37 +127,6 @@ enum ptr_kind {
}
impl ptr_kind : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &ptr_kind) -> bool {
match self {
uniq_ptr => {
match (*other) {
uniq_ptr => true,
_ => false
}
}
gc_ptr => {
match (*other) {
gc_ptr => true,
_ => false
}
}
region_ptr(e0a) => {
match (*other) {
region_ptr(e0b) => e0a == e0b,
_ => false
}
}
unsafe_ptr => {
match (*other) {
unsafe_ptr => true,
_ => false
}
}
}
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &ptr_kind) -> bool {
match (*self) {
uniq_ptr => {
@ -252,10 +155,6 @@ impl ptr_kind : cmp::Eq {
}
}
}
#[cfg(stage0)]
pure fn ne(other: &ptr_kind) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &ptr_kind) -> bool { !(*self).eq(other) }
}
@ -273,43 +172,6 @@ enum comp_kind {
}
impl comp_kind : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &comp_kind) -> bool {
match self {
comp_tuple => {
match (*other) {
comp_tuple => true,
_ => false
}
}
comp_anon_field => {
match (*other) {
comp_anon_field => true,
_ => false
}
}
comp_variant(e0a) => {
match (*other) {
comp_variant(e0b) => e0a == e0b,
_ => false
}
}
comp_field(e0a, e1a) => {
match (*other) {
comp_field(e0b, e1b) => e0a == e0b && e1a == e1b,
_ => false
}
}
comp_index(e0a, e1a) => {
match (*other) {
comp_index(e0b, e1b) => e0a == e0b && e1a == e1b,
_ => false
}
}
}
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &comp_kind) -> bool {
match (*self) {
comp_tuple => {
@ -344,10 +206,6 @@ impl comp_kind : cmp::Eq {
}
}
}
#[cfg(stage0)]
pure fn ne(other: &comp_kind) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &comp_kind) -> bool { !(*self).eq(other) }
}
@ -360,19 +218,9 @@ enum special_kind {
}
impl special_kind : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &special_kind) -> bool {
(self as uint) == ((*other) as uint)
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &special_kind) -> bool {
((*self) as uint) == ((*other) as uint)
}
#[cfg(stage0)]
pure fn ne(other: &special_kind) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &special_kind) -> bool { !(*self).eq(other) }
}
@ -389,17 +237,6 @@ type cmt_ = {id: ast::node_id, // id of expr/pat producing this value
type cmt = @cmt_;
impl cmt_ : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &cmt_) -> bool {
self.id == (*other).id &&
self.span == (*other).span &&
self.cat == (*other).cat &&
self.lp == (*other).lp &&
self.mutbl == (*other).mutbl &&
self.ty == (*other).ty
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &cmt_) -> bool {
(*self).id == (*other).id &&
(*self).span == (*other).span &&
@ -408,10 +245,6 @@ impl cmt_ : cmp::Eq {
(*self).mutbl == (*other).mutbl &&
(*self).ty == (*other).ty
}
#[cfg(stage0)]
pure fn ne(other: &cmt_) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &cmt_) -> bool { !(*self).eq(other) }
}
@ -426,37 +259,6 @@ enum loan_path {
}
impl loan_path : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &loan_path) -> bool {
match self {
lp_local(e0a) => {
match (*other) {
lp_local(e0b) => e0a == e0b,
_ => false
}
}
lp_arg(e0a) => {
match (*other) {
lp_arg(e0b) => e0a == e0b,
_ => false
}
}
lp_deref(e0a, e1a) => {
match (*other) {
lp_deref(e0b, e1b) => e0a == e0b && e1a == e1b,
_ => false
}
}
lp_comp(e0a, e1a) => {
match (*other) {
lp_comp(e0b, e1b) => e0a == e0b && e1a == e1b,
_ => false
}
}
}
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &loan_path) -> bool {
match (*self) {
lp_local(e0a) => {
@ -485,10 +287,6 @@ impl loan_path : cmp::Eq {
}
}
}
#[cfg(stage0)]
pure fn ne(other: &loan_path) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &loan_path) -> bool { !(*self).eq(other) }
}

3
src/librustc/middle/privacy.rs
View file

@ -148,6 +148,9 @@ fn check_crate(tcx: ty::ctxt, method_map: &method_map, crate: @ast::crate) {
visit::visit_mod(the_module, span, node_id, method_map, visitor);
// FIXME #4054: n_added gets corrupted without this log statement
debug!("%i", n_added);
for n_added.times {
ignore(privileged_items.pop());
}

11
src/librustc/middle/region.rs
View file

@ -374,21 +374,10 @@ type region_dep = {ambient_variance: region_variance, id: ast::node_id};
type dep_map = HashMap<ast::node_id, @DVec<region_dep>>;
impl region_dep : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &region_dep) -> bool {
self.ambient_variance == (*other).ambient_variance &&
self.id == (*other).id
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &region_dep) -> bool {
(*self).ambient_variance == (*other).ambient_variance &&
(*self).id == (*other).id
}
#[cfg(stage0)]
pure fn ne(other: &region_dep) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &region_dep) -> bool { !(*self).eq(other) }
}

89
src/librustc/middle/resolve.rs
View file

@ -108,31 +108,6 @@ enum PatternBindingMode {
}
impl PatternBindingMode : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &PatternBindingMode) -> bool {
match self {
RefutableMode => {
match *other {
RefutableMode => true,
_ => false
}
}
LocalIrrefutableMode => {
match *other {
LocalIrrefutableMode => true,
_ => false
}
}
ArgumentIrrefutableMode(mode_a) => {
match *other {
ArgumentIrrefutableMode(mode_b) => mode_a == mode_b,
_ => false
}
}
}
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &PatternBindingMode) -> bool {
match (*self) {
RefutableMode => {
@ -155,10 +130,6 @@ impl PatternBindingMode : cmp::Eq {
}
}
}
#[cfg(stage0)]
pure fn ne(other: &PatternBindingMode) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &PatternBindingMode) -> bool {
!(*self).eq(other)
}
@ -198,19 +169,9 @@ enum Mutability {
}
impl Mutability : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &Mutability) -> bool {
(self as uint) == ((*other) as uint)
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &Mutability) -> bool {
((*self) as uint) == ((*other) as uint)
}
#[cfg(stage0)]
pure fn ne(other: &Mutability) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &Mutability) -> bool { !(*self).eq(other) }
}
@ -232,19 +193,9 @@ enum ImportDirectiveNS {
}
impl ImportDirectiveNS : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &ImportDirectiveNS) -> bool {
(self as uint) == ((*other) as uint)
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &ImportDirectiveNS) -> bool {
((*self) as uint) == ((*other) as uint)
}
#[cfg(stage0)]
pure fn ne(other: &ImportDirectiveNS) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &ImportDirectiveNS) -> bool {
!(*self).eq(other)
}
@ -343,19 +294,9 @@ enum XrayFlag {
}
impl XrayFlag : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &XrayFlag) -> bool {
(self as uint) == ((*other) as uint)
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &XrayFlag) -> bool {
((*self) as uint) == ((*other) as uint)
}
#[cfg(stage0)]
pure fn ne(other: &XrayFlag) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &XrayFlag) -> bool { !(*self).eq(other) }
}
@ -365,19 +306,9 @@ enum AllowCapturingSelfFlag {
}
impl AllowCapturingSelfFlag : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &AllowCapturingSelfFlag) -> bool {
(self as uint) == ((*other) as uint)
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &AllowCapturingSelfFlag) -> bool {
((*self) as uint) == ((*other) as uint)
}
#[cfg(stage0)]
pure fn ne(other: &AllowCapturingSelfFlag) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &AllowCapturingSelfFlag) -> bool {
!(*self).eq(other)
}
@ -400,19 +331,9 @@ enum DuplicateCheckingMode {
}
impl DuplicateCheckingMode : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &DuplicateCheckingMode) -> bool {
(self as uint) == (*other as uint)
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &DuplicateCheckingMode) -> bool {
((*self) as uint) == (*other as uint)
}
#[cfg(stage0)]
pure fn ne(other: &DuplicateCheckingMode) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &DuplicateCheckingMode) -> bool {
!(*self).eq(other)
}
@ -619,19 +540,9 @@ enum Privacy {
}
impl Privacy : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &Privacy) -> bool {
(self as uint) == ((*other) as uint)
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &Privacy) -> bool {
((*self) as uint) == ((*other) as uint)
}
#[cfg(stage0)]
pure fn ne(other: &Privacy) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &Privacy) -> bool { !(*self).eq(other) }
}

10
src/librustc/middle/trans/alt.rs
View file

@ -907,19 +907,9 @@ fn pick_col(m: &[@Match]) -> uint {
enum branch_kind { no_branch, single, switch, compare, }
impl branch_kind : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &branch_kind) -> bool {
(self as uint) == ((*other) as uint)
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &branch_kind) -> bool {
((*self) as uint) == ((*other) as uint)
}
#[cfg(stage0)]
pure fn ne(other: &branch_kind) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &branch_kind) -> bool { !(*self).eq(other) }
}

56
src/librustc/middle/trans/common.rs
View file

@ -296,25 +296,6 @@ enum cleanup {
}
impl cleantype : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &cleantype) -> bool {
match self {
normal_exit_only => {
match (*other) {
normal_exit_only => true,
_ => false
}
}
normal_exit_and_unwind => {
match (*other) {
normal_exit_and_unwind => true,
_ => false
}
}
}
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &cleantype) -> bool {
match (*self) {
normal_exit_only => {
@ -331,10 +312,6 @@ impl cleantype : cmp::Eq {
}
}
}
#[cfg(stage0)]
pure fn ne(other: &cleantype) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &cleantype) -> bool { !(*self).eq(other) }
}
@ -1167,25 +1144,6 @@ type mono_id_ = {
type mono_id = @mono_id_;
impl mono_param_id : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &mono_param_id) -> bool {
match (self, (*other)) {
(mono_precise(ty_a, ids_a), mono_precise(ty_b, ids_b)) => {
ty_a == ty_b && ids_a == ids_b
}
(mono_any, mono_any) => true,
(mono_repr(size_a, align_a, is_float_a, mode_a),
mono_repr(size_b, align_b, is_float_b, mode_b)) => {
size_a == size_b && align_a == align_b &&
is_float_a == is_float_b && mode_a == mode_b
}
(mono_precise(*), _) => false,
(mono_any, _) => false,
(mono_repr(*), _) => false
}
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &mono_param_id) -> bool {
match ((*self), (*other)) {
(mono_precise(ty_a, ids_a), mono_precise(ty_b, ids_b)) => {
@ -1202,27 +1160,13 @@ impl mono_param_id : cmp::Eq {
(mono_repr(*), _) => false
}
}
#[cfg(stage0)]
pure fn ne(other: &mono_param_id) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &mono_param_id) -> bool { !(*self).eq(other) }
}
impl mono_id_ : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &mono_id_) -> bool {
self.def == (*other).def && self.params == (*other).params
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &mono_id_) -> bool {
(*self).def == (*other).def && (*self).params == (*other).params
}
#[cfg(stage0)]
pure fn ne(other: &mono_id_) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &mono_id_) -> bool { !(*self).eq(other) }
}

25
src/librustc/middle/trans/datum.rs
View file

@ -139,19 +139,9 @@ impl DatumMode {
}
impl DatumMode: cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &DatumMode) -> bool {
self as uint == (*other as uint)
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &DatumMode) -> bool {
(*self) as uint == (*other as uint)
}
#[cfg(stage0)]
pure fn ne(other: &DatumMode) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &DatumMode) -> bool { !(*self).eq(other) }
}
@ -809,17 +799,6 @@ impl DatumBlock {
}
impl CopyAction : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &CopyAction) -> bool {
match (self, (*other)) {
(INIT, INIT) => true,
(DROP_EXISTING, DROP_EXISTING) => true,
(INIT, _) => false,
(DROP_EXISTING, _) => false,
}
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &CopyAction) -> bool {
match ((*self), (*other)) {
(INIT, INIT) => true,
@ -828,9 +807,5 @@ impl CopyAction : cmp::Eq {
(DROP_EXISTING, _) => false,
}
}
#[cfg(stage0)]
pure fn ne(other: &CopyAction) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &CopyAction) -> bool { !(*self).eq(other) }
}

36
src/librustc/middle/trans/expr.rs
View file

@ -148,17 +148,6 @@ impl Dest {
}
impl Dest : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &Dest) -> bool {
match (self, (*other)) {
(SaveIn(e0a), SaveIn(e0b)) => e0a == e0b,
(Ignore, Ignore) => true,
(SaveIn(*), _) => false,
(Ignore, _) => false,
}
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &Dest) -> bool {
match ((*self), (*other)) {
(SaveIn(e0a), SaveIn(e0b)) => e0a == e0b,
@ -167,10 +156,6 @@ impl Dest : cmp::Eq {
(Ignore, _) => false,
}
}
#[cfg(stage0)]
pure fn ne(other: &Dest) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &Dest) -> bool { !(*self).eq(other) }
}
@ -1444,23 +1429,6 @@ enum cast_kind {
}
impl cast_kind : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &cast_kind) -> bool {
match (self, (*other)) {
(cast_pointer, cast_pointer) => true,
(cast_integral, cast_integral) => true,
(cast_float, cast_float) => true,
(cast_enum, cast_enum) => true,
(cast_other, cast_other) => true,
(cast_pointer, _) => false,
(cast_integral, _) => false,
(cast_float, _) => false,
(cast_enum, _) => false,
(cast_other, _) => false,
}
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &cast_kind) -> bool {
match ((*self), (*other)) {
(cast_pointer, cast_pointer) => true,
@ -1475,10 +1443,6 @@ impl cast_kind : cmp::Eq {
(cast_other, _) => false,
}
}
#[cfg(stage0)]
pure fn ne(other: &cast_kind) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &cast_kind) -> bool { !(*self).eq(other) }
}

10
src/librustc/middle/trans/foreign.rs
View file

@ -41,19 +41,9 @@ enum x86_64_reg_class {
}
impl x86_64_reg_class : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &x86_64_reg_class) -> bool {
(self as uint) == ((*other) as uint)
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &x86_64_reg_class) -> bool {
((*self) as uint) == ((*other) as uint)
}
#[cfg(stage0)]
pure fn ne(other: &x86_64_reg_class) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &x86_64_reg_class) -> bool { !(*self).eq(other) }
}

527
src/librustc/middle/ty.rs
View file

@ -245,25 +245,11 @@ type creader_cache_key = {cnum: int, pos: uint, len: uint};
type creader_cache = HashMap<creader_cache_key, t>;
impl creader_cache_key : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &creader_cache_key) -> bool {
self.cnum == (*other).cnum &&
self.pos == (*other).pos &&
self.len == (*other).len
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &creader_cache_key) -> bool {
(*self).cnum == (*other).cnum &&
(*self).pos == (*other).pos &&
(*self).len == (*other).len
}
#[cfg(stage0)]
pure fn ne(other: &creader_cache_key) -> bool {
!(self == (*other))
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &creader_cache_key) -> bool {
!((*self) == (*other))
}
@ -278,19 +264,9 @@ impl creader_cache_key : to_bytes::IterBytes {
type intern_key = {sty: sty, o_def_id: Option<ast::def_id>};
impl intern_key : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &intern_key) -> bool {
self.sty == (*other).sty && self.o_def_id == (*other).o_def_id
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &intern_key) -> bool {
(*self).sty == (*other).sty && (*self).o_def_id == (*other).o_def_id
}
#[cfg(stage0)]
pure fn ne(other: &intern_key) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &intern_key) -> bool { !(*self).eq(other) }
}
@ -312,19 +288,6 @@ type opt_region_variance = Option<region_variance>;
enum region_variance { rv_covariant, rv_invariant, rv_contravariant }
impl region_variance : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &region_variance) -> bool {
match (self, (*other)) {
(rv_covariant, rv_covariant) => true,
(rv_invariant, rv_invariant) => true,
(rv_contravariant, rv_contravariant) => true,
(rv_covariant, _) => false,
(rv_invariant, _) => false,
(rv_contravariant, _) => false
}
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &region_variance) -> bool {
match ((*self), (*other)) {
(rv_covariant, rv_covariant) => true,
@ -335,10 +298,6 @@ impl region_variance : cmp::Eq {
(rv_contravariant, _) => false
}
}
#[cfg(stage0)]
pure fn ne(other: &region_variance) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &region_variance) -> bool { !(*self).eq(other) }
}
@ -547,19 +506,9 @@ type FnTy = FnTyBase<FnMeta>;
type param_ty = {idx: uint, def_id: def_id};
impl param_ty : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &param_ty) -> bool {
self.idx == (*other).idx && self.def_id == (*other).def_id
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &param_ty) -> bool {
(*self).idx == (*other).idx && (*self).def_id == (*other).def_id
}
#[cfg(stage0)]
pure fn ne(other: &param_ty) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &param_ty) -> bool { !(*self).eq(other) }
}
@ -776,20 +725,6 @@ impl InferRegion : to_bytes::IterBytes {
}
impl InferRegion : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &InferRegion) -> bool {
match (self, *other) {
(ReVar(rva), ReVar(rvb)) => {
rva == rvb
}
(ReSkolemized(rva, _), ReSkolemized(rvb, _)) => {
rva == rvb
}
_ => false
}
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &InferRegion) -> bool {
match ((*self), *other) {
(ReVar(rva), ReVar(rvb)) => {
@ -801,12 +736,6 @@ impl InferRegion : cmp::Eq {
_ => false
}
}
#[cfg(stage0)]
pure fn ne(other: &InferRegion) -> bool {
!(self == (*other))
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &InferRegion) -> bool {
!((*self) == (*other))
}
@ -4278,88 +4207,27 @@ pure fn determine_inherited_purity(parent_purity: ast::purity,
}
impl mt : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &mt) -> bool {
self.ty == (*other).ty && self.mutbl == (*other).mutbl
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &mt) -> bool {
(*self).ty == (*other).ty && (*self).mutbl == (*other).mutbl
}
#[cfg(stage0)]
pure fn ne(other: &mt) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &mt) -> bool { !(*self).eq(other) }
}
impl arg : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &arg) -> bool {
self.mode == (*other).mode && self.ty == (*other).ty
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &arg) -> bool {
(*self).mode == (*other).mode && (*self).ty == (*other).ty
}
#[cfg(stage0)]
pure fn ne(other: &arg) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &arg) -> bool { !(*self).eq(other) }
}
impl field : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &field) -> bool {
self.ident == (*other).ident && self.mt == (*other).mt
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &field) -> bool {
(*self).ident == (*other).ident && (*self).mt == (*other).mt
}
#[cfg(stage0)]
pure fn ne(other: &field) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &field) -> bool { !(*self).eq(other) }
}
impl vstore : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &vstore) -> bool {
match self {
vstore_fixed(e0a) => {
match (*other) {
vstore_fixed(e0b) => e0a == e0b,
_ => false
}
}
vstore_uniq => {
match (*other) {
vstore_uniq => true,
_ => false
}
}
vstore_box => {
match (*other) {
vstore_box => true,
_ => false
}
}
vstore_slice(e0a) => {
match (*other) {
vstore_slice(e0b) => e0a == e0b,
_ => false
}
}
}
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &vstore) -> bool {
match (*self) {
vstore_fixed(e0a) => {
@ -4388,175 +4256,60 @@ impl vstore : cmp::Eq {
}
}
}
#[cfg(stage0)]
pure fn ne(other: &vstore) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &vstore) -> bool { !(*self).eq(other) }
}
impl FnMeta : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &FnMeta) -> bool {
self.purity == (*other).purity &&
self.proto == (*other).proto &&
self.bounds == (*other).bounds &&
self.ret_style == (*other).ret_style
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &FnMeta) -> bool {
(*self).purity == (*other).purity &&
(*self).proto == (*other).proto &&
(*self).bounds == (*other).bounds &&
(*self).ret_style == (*other).ret_style
}
#[cfg(stage0)]
pure fn ne(other: &FnMeta) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &FnMeta) -> bool { !(*self).eq(other) }
}
impl FnSig : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &FnSig) -> bool {
self.inputs == (*other).inputs &&
self.output == (*other).output
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &FnSig) -> bool {
(*self).inputs == (*other).inputs &&
(*self).output == (*other).output
}
#[cfg(stage0)]
pure fn ne(other: &FnSig) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &FnSig) -> bool { !(*self).eq(other) }
}
impl<M: cmp::Eq> FnTyBase<M> : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &FnTyBase<M>) -> bool {
self.meta == (*other).meta && self.sig == (*other).sig
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &FnTyBase<M>) -> bool {
(*self).meta == (*other).meta && (*self).sig == (*other).sig
}
#[cfg(stage0)]
pure fn ne(other: &FnTyBase<M>) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &FnTyBase<M>) -> bool { !(*self).eq(other) }
}
impl TyVid : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &TyVid) -> bool { *self == *(*other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &TyVid) -> bool { *(*self) == *(*other) }
#[cfg(stage0)]
pure fn ne(other: &TyVid) -> bool { *self != *(*other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &TyVid) -> bool { *(*self) != *(*other) }
}
impl IntVid : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &IntVid) -> bool { *self == *(*other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &IntVid) -> bool { *(*self) == *(*other) }
#[cfg(stage0)]
pure fn ne(other: &IntVid) -> bool { *self != *(*other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &IntVid) -> bool { *(*self) != *(*other) }
}
impl FloatVid : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &FloatVid) -> bool { *self == *(*other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &FloatVid) -> bool { *(*self) == *(*other) }
#[cfg(stage0)]
pure fn ne(other: &FloatVid) -> bool { *self != *(*other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &FloatVid) -> bool { *(*self) != *(*other) }
}
impl FnVid : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &FnVid) -> bool { *self == *(*other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &FnVid) -> bool { *(*self) == *(*other) }
#[cfg(stage0)]
pure fn ne(other: &FnVid) -> bool { *self != *(*other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &FnVid) -> bool { *(*self) != *(*other) }
}
impl RegionVid : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &RegionVid) -> bool { *self == *(*other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &RegionVid) -> bool { *(*self) == *(*other) }
#[cfg(stage0)]
pure fn ne(other: &RegionVid) -> bool { *self != *(*other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &RegionVid) -> bool { *(*self) != *(*other) }
}
impl Region : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &Region) -> bool {
match self {
re_bound(e0a) => {
match (*other) {
re_bound(e0b) => e0a == e0b,
_ => false
}
}
re_free(e0a, e1a) => {
match (*other) {
re_free(e0b, e1b) => e0a == e0b && e1a == e1b,
_ => false
}
}
re_scope(e0a) => {
match (*other) {
re_scope(e0b) => e0a == e0b,
_ => false
}
}
re_static => {
match (*other) {
re_static => true,
_ => false
}
}
re_infer(e0a) => {
match (*other) {
re_infer(e0b) => e0a == e0b,
_ => false
}
}
}
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &Region) -> bool {
match (*self) {
re_bound(e0a) => {
@ -4591,45 +4344,10 @@ impl Region : cmp::Eq {
}
}
}
#[cfg(stage0)]
pure fn ne(other: &Region) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &Region) -> bool { !(*self).eq(other) }
}
impl bound_region : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &bound_region) -> bool {
match self {
br_self => {
match (*other) {
br_self => true,
_ => false
}
}
br_anon(e0a) => {
match (*other) {
br_anon(e0b) => e0a == e0b,
_ => false
}
}
br_named(e0a) => {
match (*other) {
br_named(e0b) => e0a == e0b,
_ => false
}
}
br_cap_avoid(e0a, e1a) => {
match (*other) {
br_cap_avoid(e0b, e1b) => e0a == e0b && e1a == e1b,
_ => false
}
}
}
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &bound_region) -> bool {
match (*self) {
br_self => {
@ -4658,216 +4376,26 @@ impl bound_region : cmp::Eq {
}
}
}
#[cfg(stage0)]
pure fn ne(other: &bound_region) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &bound_region) -> bool { !(*self).eq(other) }
}
impl substs : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &substs) -> bool {
self.self_r == (*other).self_r &&
self.self_ty == (*other).self_ty &&
self.tps == (*other).tps
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &substs) -> bool {
(*self).self_r == (*other).self_r &&
(*self).self_ty == (*other).self_ty &&
(*self).tps == (*other).tps
}
#[cfg(stage0)]
pure fn ne(other: &substs) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &substs) -> bool { !(*self).eq(other) }
}
impl InferTy : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &InferTy) -> bool {
self.to_hash() == (*other).to_hash()
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &InferTy) -> bool {
(*self).to_hash() == (*other).to_hash()
}
#[cfg(stage0)]
pure fn ne(other: &InferTy) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &InferTy) -> bool { !(*self).eq(other) }
}
impl sty : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &sty) -> bool {
match self {
ty_nil => {
match (*other) {
ty_nil => true,
_ => false
}
}
ty_bot => {
match (*other) {
ty_bot => true,
_ => false
}
}
ty_bool => {
match (*other) {
ty_bool => true,
_ => false
}
}
ty_int(e0a) => {
match (*other) {
ty_int(e0b) => e0a == e0b,
_ => false
}
}
ty_uint(e0a) => {
match (*other) {
ty_uint(e0b) => e0a == e0b,
_ => false
}
}
ty_float(e0a) => {
match (*other) {
ty_float(e0b) => e0a == e0b,
_ => false
}
}
ty_estr(e0a) => {
match (*other) {
ty_estr(e0b) => e0a == e0b,
_ => false
}
}
ty_enum(e0a, e1a) => {
match (*other) {
ty_enum(e0b, e1b) => e0a == e0b && e1a == e1b,
_ => false
}
}
ty_box(e0a) => {
match (*other) {
ty_box(e0b) => e0a == e0b,
_ => false
}
}
ty_uniq(e0a) => {
match (*other) {
ty_uniq(e0b) => e0a == e0b,
_ => false
}
}
ty_evec(e0a, e1a) => {
match (*other) {
ty_evec(e0b, e1b) => e0a == e0b && e1a == e1b,
_ => false
}
}
ty_ptr(e0a) => {
match (*other) {
ty_ptr(e0b) => e0a == e0b,
_ => false
}
}
ty_rptr(e0a, e1a) => {
match (*other) {
ty_rptr(e0b, e1b) => e0a == e0b && e1a == e1b,
_ => false
}
}
ty_rec(e0a) => {
match (*other) {
ty_rec(e0b) => e0a == e0b,
_ => false
}
}
ty_fn(e0a) => {
match (*other) {
ty_fn(e0b) => e0a == e0b,
_ => false
}
}
ty_trait(e0a, e1a, e2a) => {
match (*other) {
ty_trait(e0b, e1b, e2b) =>
e0a == e0b && e1a == e1b && e2a == e2b,
_ => false
}
}
ty_class(e0a, e1a) => {
match (*other) {
ty_class(e0b, e1b) => e0a == e0b && e1a == e1b,
_ => false
}
}
ty_tup(e0a) => {
match (*other) {
ty_tup(e0b) => e0a == e0b,
_ => false
}
}
ty_infer(e0a) => {
match (*other) {
ty_infer(e0b) => e0a == e0b,
_ => false
}
}
ty_err => {
match (*other) {
ty_err => true,
_ => false
}
}
ty_param(e0a) => {
match (*other) {
ty_param(e0b) => e0a == e0b,
_ => false
}
}
ty_self => {
match (*other) {
ty_self => true,
_ => false
}
}
ty_type => {
match (*other) {
ty_type => true,
_ => false
}
}
ty_opaque_box => {
match (*other) {
ty_opaque_box => true,
_ => false
}
}
ty_opaque_closure_ptr(e0a) => {
match (*other) {
ty_opaque_closure_ptr(e0b) => e0a == e0b,
_ => false
}
}
ty_unboxed_vec(e0a) => {
match (*other) {
ty_unboxed_vec(e0b) => e0a == e0b,
_ => false
}
}
}
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &sty) -> bool {
match (*self) {
ty_nil => {
@ -5029,51 +4557,10 @@ impl sty : cmp::Eq {
}
}
}
#[cfg(stage0)]
pure fn ne(other: &sty) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &sty) -> bool { !(*self).eq(other) }
}
impl param_bound : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &param_bound) -> bool {
match self {
bound_copy => {
match (*other) {
bound_copy => true,
_ => false
}
}
bound_owned => {
match (*other) {
bound_owned => true,
_ => false
}
}
bound_send => {
match (*other) {
bound_send => true,
_ => false
}
}
bound_const => {
match (*other) {
bound_const => true,
_ => false
}
}
bound_trait(e0a) => {
match (*other) {
bound_trait(e0b) => e0a == e0b,
_ => false
}
}
}
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &param_bound) -> bool {
match (*self) {
bound_copy => {
@ -5108,23 +4595,11 @@ impl param_bound : cmp::Eq {
}
}
}
#[cfg(stage0)]
pure fn ne(other: &param_bound) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &param_bound) -> bool { !(*self).eq(other) }
pure fn ne(&self, other: &param_bound) -> bool { !self.eq(other) }
}
impl Kind : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &Kind) -> bool { *self == *(*other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &Kind) -> bool { *(*self) == *(*other) }
#[cfg(stage0)]
pure fn ne(other: &Kind) -> bool { *self != *(*other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &Kind) -> bool { *(*self) != *(*other) }
}

53
src/librustc/middle/typeck/infer/region_inference.rs
View file

@ -469,25 +469,6 @@ enum Constraint {
}
impl Constraint : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &Constraint) -> bool {
match (self, (*other)) {
(ConstrainVarSubVar(v0a, v1a), ConstrainVarSubVar(v0b, v1b)) => {
v0a == v0b && v1a == v1b
}
(ConstrainRegSubVar(ra, va), ConstrainRegSubVar(rb, vb)) => {
ra == rb && va == vb
}
(ConstrainVarSubReg(va, ra), ConstrainVarSubReg(vb, rb)) => {
va == vb && ra == rb
}
(ConstrainVarSubVar(*), _) => false,
(ConstrainRegSubVar(*), _) => false,
(ConstrainVarSubReg(*), _) => false
}
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &Constraint) -> bool {
match ((*self), (*other)) {
(ConstrainVarSubVar(v0a, v1a), ConstrainVarSubVar(v0b, v1b)) => {
@ -504,10 +485,6 @@ impl Constraint : cmp::Eq {
(ConstrainVarSubReg(*), _) => false
}
}
#[cfg(stage0)]
pure fn ne(other: &Constraint) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &Constraint) -> bool { !(*self).eq(other) }
}
@ -532,19 +509,9 @@ struct TwoRegions {
}
impl TwoRegions : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &TwoRegions) -> bool {
self.a == (*other).a && self.b == (*other).b
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &TwoRegions) -> bool {
(*self).a == (*other).a && (*self).b == (*other).b
}
#[cfg(stage0)]
pure fn ne(other: &TwoRegions) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &TwoRegions) -> bool { !(*self).eq(other) }
}
@ -1068,38 +1035,18 @@ priv impl RegionVarBindings {
enum Direction { Incoming = 0, Outgoing = 1 }
impl Direction : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &Direction) -> bool {
(self as uint) == ((*other) as uint)
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &Direction) -> bool {
((*self) as uint) == ((*other) as uint)
}
#[cfg(stage0)]
pure fn ne(other: &Direction) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &Direction) -> bool { !(*self).eq(other) }
}
enum Classification { Expanding, Contracting }
impl Classification : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &Classification) -> bool {
(self as uint) == ((*other) as uint)
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &Classification) -> bool {
((*self) as uint) == ((*other) as uint)
}
#[cfg(stage0)]
pure fn ne(other: &Classification) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &Classification) -> bool { !(*self).eq(other) }
}

422
src/librustc/rustc.rc
View file

@ -1,5 +1,3 @@
// DIVERT
// -*- rust -*-
#[link(name = "rustc",
@ -45,246 +43,446 @@ mod middle {
mod trans {
#[legacy_exports];
#[legacy_exports]
#[path = "middle/trans/inline.rs"]
mod inline;
#[legacy_exports]
#[path = "middle/trans/monomorphize.rs"]
mod monomorphize;
#[legacy_exports]
#[path = "middle/trans/controlflow.rs"]
mod controlflow;
#[legacy_exports]
#[path = "middle/trans/glue.rs"]
mod glue;
#[legacy_exports]
#[path = "middle/trans/datum.rs"]
mod datum;
#[legacy_exports]
#[path = "middle/trans/callee.rs"]
mod callee;
#[legacy_exports]
#[path = "middle/trans/expr.rs"]
mod expr;
#[legacy_exports]
#[path = "middle/trans/common.rs"]
mod common;
#[legacy_exports]
#[path = "middle/trans/consts.rs"]
mod consts;
#[legacy_exports]
#[path = "middle/trans/type_of.rs"]
mod type_of;
#[legacy_exports]
#[path = "middle/trans/build.rs"]
mod build;
#[legacy_exports]
#[path = "middle/trans/base.rs"]
mod base;
#[legacy_exports]
#[path = "middle/trans/alt.rs"]
mod alt;
#[legacy_exports]
#[path = "middle/trans/uniq.rs"]
mod uniq;
#[legacy_exports]
#[path = "middle/trans/closure.rs"]
mod closure;
#[legacy_exports]
#[path = "middle/trans/tvec.rs"]
mod tvec;
#[legacy_exports]
#[path = "middle/trans/meth.rs"]
mod meth;
#[legacy_exports]
#[path = "middle/trans/foreign.rs"]
mod foreign;
#[legacy_exports]
#[path = "middle/trans/reflect.rs"]
mod reflect;
#[legacy_exports]
#[path = "middle/trans/shape.rs"]
mod shape;
#[legacy_exports]
#[path = "middle/trans/debuginfo.rs"]
mod debuginfo;
#[legacy_exports]
#[path = "middle/trans/type_use.rs"]
mod type_use;
#[legacy_exports]
#[path = "middle/trans/reachable.rs"]
mod reachable;
#[path = "middle/trans/machine.rs"]
mod machine;
#[path = "middle/trans/deriving.rs"]
mod deriving;
}
#[legacy_exports]
#[path = "middle/ty.rs"]
mod ty;
#[legacy_exports]
#[path = "middle/resolve.rs"]
mod resolve;
pub mod typeck {
#[legacy_exports];
#[legacy_exports]
pub mod check {
#[legacy_exports]
mod alt;
#[legacy_exports]
mod vtable;
#[legacy_exports]
mod writeback;
#[legacy_exports]
mod regionmanip;
#[legacy_exports]
mod regionck;
#[legacy_exports]
mod demand;
#[legacy_exports]
pub mod method;
}
#[legacy_exports]
mod rscope;
#[legacy_exports]
mod astconv;
mod infer {
#[legacy_exports];
#[legacy_exports]
mod assignment;
#[legacy_exports]
mod combine;
#[legacy_exports]
mod glb;
#[legacy_exports]
mod integral;
mod floating;
#[legacy_exports]
mod lattice;
#[legacy_exports]
mod lub;
#[legacy_exports]
mod region_inference;
#[legacy_exports]
mod resolve;
#[legacy_exports]
mod sub;
#[legacy_exports]
mod to_str;
#[legacy_exports]
mod unify;
#[cfg(test)]
#[legacy_exports]
mod test;
}
#[legacy_exports]
mod collect;
#[legacy_exports]
mod coherence;
mod deriving;
}
#[path = "middle/typeck.rs"]
#[merge = "middle/typeck/mod.rs"]
pub mod typeck;
#[legacy_exports]
#[path = "middle/check_loop.rs"]
mod check_loop;
#[legacy_exports]
#[path = "middle/check_alt.rs"]
mod check_alt;
#[legacy_exports]
#[path = "middle/check_const.rs"]
mod check_const;
#[legacy_exports]
#[path = "middle/lint.rs"]
mod lint;
mod borrowck {
#[legacy_exports];
#[legacy_exports]
mod check_loans;
#[legacy_exports]
mod gather_loans;
#[legacy_exports]
mod loan;
#[legacy_exports]
mod preserve;
}
#[path = "middle/borrowck.rs"]
#[merge = "middle/borrowck/mod.rs"]
mod borrowck;
#[legacy_exports]
#[path = "middle/mem_categorization.rs"]
mod mem_categorization;
#[legacy_exports]
#[path = "middle/liveness.rs"]
mod liveness;
#[legacy_exports]
#[path = "middle/kind.rs"]
mod kind;
#[legacy_exports]
#[path = "middle/freevars.rs"]
mod freevars;
#[legacy_exports]
#[path = "middle/capture.rs"]
mod capture;
#[legacy_exports]
#[path = "middle/pat_util.rs"]
mod pat_util;
#[legacy_exports]
#[path = "middle/region.rs"]
mod region;
#[legacy_exports]
#[path = "middle/const_eval.rs"]
mod const_eval;
#[legacy_exports]
#[path = "middle/astencode.rs"]
mod astencode;
#[legacy_exports]
#[path = "middle/lang_items.rs"]
mod lang_items;
#[legacy_exports]
#[path = "middle/privacy.rs"]
mod privacy;
}
mod front {
#[legacy_exports];
#[legacy_exports]
#[path = "front/config.rs"]
mod config;
#[legacy_exports]
#[path = "front/test.rs"]
mod test;
#[legacy_exports]
#[path = "front/core_inject.rs"]
mod core_inject;
#[legacy_exports]
#[path = "front/intrinsic_inject.rs"]
mod intrinsic_inject;
}
mod back {
#[legacy_exports];
#[legacy_exports]
#[path = "back/link.rs"]
mod link;
#[legacy_exports]
#[path = "back/abi.rs"]
mod abi;
#[legacy_exports]
#[path = "back/upcall.rs"]
mod upcall;
#[legacy_exports]
#[path = "back/x86.rs"]
mod x86;
#[legacy_exports]
#[path = "back/x86_64.rs"]
mod x86_64;
#[legacy_exports]
#[path = "back/rpath.rs"]
mod rpath;
#[legacy_exports]
#[path = "back/target_strs.rs"]
mod target_strs;
}
mod metadata {
#[legacy_exports];
export encoder;
export creader;
export cstore;
export csearch;
export common;
export decoder;
export tyencode;
export tydecode;
export loader;
export filesearch;
#[merge = "metadata/mod.rs"]
mod metadata;
#[legacy_exports]
mod common;
#[legacy_exports]
mod tyencode;
#[legacy_exports]
mod tydecode;
#[legacy_exports]
mod encoder;
#[legacy_exports]
mod decoder;
#[legacy_exports]
mod creader;
#[legacy_exports]
mod cstore;
#[legacy_exports]
mod csearch;
#[legacy_exports]
mod loader;
#[legacy_exports]
mod filesearch;
}
mod driver {
#[legacy_exports];
#[legacy_exports]
mod driver;
#[legacy_exports]
mod session;
}
#[merge = "driver/mod.rs"]
mod driver;
mod util {
#[legacy_exports];
#[legacy_exports]
#[path = "util/common.rs"]
mod common;
#[legacy_exports]
#[path = "util/ppaux.rs"]
mod ppaux;
}
mod lib {
#[legacy_exports];
#[legacy_exports]
#[path = "lib/llvm.rs"]
mod llvm;
}
use result::{Ok, Err};
use io::ReaderUtil;
use std::getopts;
use std::map::HashMap;
use getopts::{opt_present};
use getopts::groups;
use syntax::codemap;
use syntax::diagnostic;
use driver::driver::{host_triple, optgroups, early_error,
str_input, file_input, build_session_options,
build_session, build_configuration, parse_pretty,
pp_mode, pretty_print_input, list_metadata,
compile_input};
use driver::session;
use middle::lint;
fn version(argv0: &str) {
let mut vers = ~"unknown version";
let env_vers = env!("CFG_VERSION");
if env_vers.len() != 0 { vers = env_vers; }
io::println(fmt!("%s %s", argv0, vers));
io::println(fmt!("host: %s", host_triple()));
}
fn usage(argv0: &str) {
let message = fmt!("Usage: %s [OPTIONS] INPUT", argv0);
io::println(groups::usage(message, optgroups()) +
~"Additional help:
-W help Print 'lint' options and default settings
-Z help Print internal options for debugging rustc
");
}
fn describe_warnings() {
io::println(fmt!("
Available lint options:
-W <foo> Warn about <foo>
-A <foo> Allow <foo>
-D <foo> Deny <foo>
-F <foo> Forbid <foo> (deny, and deny all overrides)
"));
let lint_dict = lint::get_lint_dict();
let mut max_key = 0;
for lint_dict.each_key |k| { max_key = uint::max(k.len(), max_key); }
fn padded(max: uint, s: &str) -> ~str {
str::from_bytes(vec::from_elem(max - s.len(), ' ' as u8)) + s
}
io::println(fmt!("\nAvailable lint checks:\n"));
io::println(fmt!(" %s %7.7s %s",
padded(max_key, ~"name"), ~"default", ~"meaning"));
io::println(fmt!(" %s %7.7s %s\n",
padded(max_key, ~"----"), ~"-------", ~"-------"));
for lint_dict.each |k, v| {
let k = str::replace(k, ~"_", ~"-");
io::println(fmt!(" %s %7.7s %s",
padded(max_key, k),
match v.default {
lint::allow => ~"allow",
lint::warn => ~"warn",
lint::deny => ~"deny",
lint::forbid => ~"forbid"
},
v.desc));
}
io::println(~"");
}
fn describe_debug_flags() {
io::println(fmt!("\nAvailable debug options:\n"));
for session::debugging_opts_map().each |pair| {
let (name, desc, _) = *pair;
io::println(fmt!(" -Z %-20s -- %s", name, desc));
}
}
fn run_compiler(args: &~[~str], demitter: diagnostic::emitter) {
// Don't display log spew by default. Can override with RUST_LOG.
logging::console_off();
let mut args = *args;
let binary = args.shift();
if args.is_empty() { usage(binary); return; }
let matches =
match getopts::groups::getopts(args, optgroups()) {
Ok(m) => m,
Err(f) => {
early_error(demitter, getopts::fail_str(f))
}
};
if opt_present(matches, ~"h") || opt_present(matches, ~"help") {
usage(binary);
return;
}
let lint_flags = vec::append(getopts::opt_strs(matches, ~"W"),
getopts::opt_strs(matches, ~"warn"));
if lint_flags.contains(&~"help") {
describe_warnings();
return;
}
if getopts::opt_strs(matches, ~"Z").contains(&~"help") {
describe_debug_flags();
return;
}
if opt_present(matches, ~"v") || opt_present(matches, ~"version") {
version(binary);
return;
}
let input = match vec::len(matches.free) {
0u => early_error(demitter, ~"no input filename given"),
1u => {
let ifile = matches.free[0];
if ifile == ~"-" {
let src = str::from_bytes(io::stdin().read_whole_stream());
str_input(src)
} else {
file_input(Path(ifile))
}
}
_ => early_error(demitter, ~"multiple input filenames provided")
};
let sopts = build_session_options(binary, matches, demitter);
let sess = build_session(sopts, demitter);
let odir = getopts::opt_maybe_str(matches, ~"out-dir");
let odir = odir.map(|o| Path(*o));
let ofile = getopts::opt_maybe_str(matches, ~"o");
let ofile = ofile.map(|o| Path(*o));
let cfg = build_configuration(sess, binary, input);
let pretty =
option::map(&getopts::opt_default(matches, ~"pretty",
~"normal"),
|a| parse_pretty(sess, *a) );
match pretty {
Some::<pp_mode>(ppm) => {
pretty_print_input(sess, cfg, input, ppm);
return;
}
None::<pp_mode> => {/* continue */ }
}
let ls = opt_present(matches, ~"ls");
if ls {
match input {
file_input(ifile) => {
list_metadata(sess, &ifile, io::stdout());
}
str_input(_) => {
early_error(demitter, ~"can not list metadata for stdin");
}
}
return;
}
compile_input(sess, cfg, input, &odir, &ofile);
}
enum monitor_msg {
fatal,
done,
}
impl monitor_msg : cmp::Eq {
pure fn eq(&self, other: &monitor_msg) -> bool {
((*self) as uint) == ((*other) as uint)
}
pure fn ne(&self, other: &monitor_msg) -> bool { !(*self).eq(other) }
}
/*
This is a sanity check that any failure of the compiler is performed
through the diagnostic module and reported properly - we shouldn't be calling
plain-old-fail on any execution path that might be taken. Since we have
console logging off by default, hitting a plain fail statement would make the
compiler silently exit, which would be terrible.
This method wraps the compiler in a subtask and injects a function into the
diagnostic emitter which records when we hit a fatal error. If the task
fails without recording a fatal error then we've encountered a compiler
bug and need to present an error.
*/
fn monitor(+f: fn~(diagnostic::emitter)) {
let p = comm::Port();
let ch = comm::Chan(&p);
match do task::try |move f| {
// The 'diagnostics emitter'. Every error, warning, etc. should
// go through this function.
let demitter = fn@(cmsp: Option<(@codemap::CodeMap, codemap::span)>,
msg: &str, lvl: diagnostic::level) {
if lvl == diagnostic::fatal {
comm::send(ch, fatal);
}
diagnostic::emit(cmsp, msg, lvl);
};
struct finally {
ch: comm::Chan<monitor_msg>,
drop { comm::send(self.ch, done); }
}
let _finally = finally { ch: ch };
f(demitter)
} {
result::Ok(_) => { /* fallthrough */ }
result::Err(_) => {
// Task failed without emitting a fatal diagnostic
if comm::recv(p) == done {
diagnostic::emit(
None,
diagnostic::ice_msg(~"unexpected failure"),
diagnostic::error);
for [
~"the compiler hit an unexpected failure path. \
this is a bug",
~"try running with RUST_LOG=rustc=1,::rt::backtrace \
to get further details and report the results \
to github.com/mozilla/rust/issues"
].each |note| {
diagnostic::emit(None, *note, diagnostic::note)
}
}
// Fail so the process returns a failure code
fail;
}
}
}
fn main() {
let mut args = os::args();
do monitor |move args, demitter| {
run_compiler(&args, demitter);
}
}
// Local Variables:
// fill-column: 78;
// indent-tabs-mode: nil

261
src/librustc/rustc.rs
View file

@ -1,261 +0,0 @@
// -*- rust -*-
use result::{Ok, Err};
use io::ReaderUtil;
use std::getopts;
use std::map::HashMap;
use getopts::{opt_present};
use getopts::groups;
use syntax::codemap;
use syntax::diagnostic;
use driver::driver::{host_triple, optgroups, early_error,
str_input, file_input, build_session_options,
build_session, build_configuration, parse_pretty,
pp_mode, pretty_print_input, list_metadata,
compile_input};
use driver::session;
use middle::lint;
fn version(argv0: &str) {
let mut vers = ~"unknown version";
let env_vers = env!("CFG_VERSION");
if env_vers.len() != 0 { vers = env_vers; }
io::println(fmt!("%s %s", argv0, vers));
io::println(fmt!("host: %s", host_triple()));
}
fn usage(argv0: &str) {
let message = fmt!("Usage: %s [OPTIONS] INPUT", argv0);
io::println(groups::usage(message, optgroups()) +
~"Additional help:
-W help Print 'lint' options and default settings
-Z help Print internal options for debugging rustc
");
}
fn describe_warnings() {
io::println(fmt!("
Available lint options:
-W <foo> Warn about <foo>
-A <foo> Allow <foo>
-D <foo> Deny <foo>
-F <foo> Forbid <foo> (deny, and deny all overrides)
"));
let lint_dict = lint::get_lint_dict();
let mut max_key = 0;
for lint_dict.each_key |k| { max_key = uint::max(k.len(), max_key); }
fn padded(max: uint, s: &str) -> ~str {
str::from_bytes(vec::from_elem(max - s.len(), ' ' as u8)) + s
}
io::println(fmt!("\nAvailable lint checks:\n"));
io::println(fmt!(" %s %7.7s %s",
padded(max_key, ~"name"), ~"default", ~"meaning"));
io::println(fmt!(" %s %7.7s %s\n",
padded(max_key, ~"----"), ~"-------", ~"-------"));
for lint_dict.each |k, v| {
let k = str::replace(k, ~"_", ~"-");
io::println(fmt!(" %s %7.7s %s",
padded(max_key, k),
match v.default {
lint::allow => ~"allow",
lint::warn => ~"warn",
lint::deny => ~"deny",
lint::forbid => ~"forbid"
},
v.desc));
}
io::println(~"");
}
fn describe_debug_flags() {
io::println(fmt!("\nAvailable debug options:\n"));
for session::debugging_opts_map().each |pair| {
let (name, desc, _) = *pair;
io::println(fmt!(" -Z %-20s -- %s", name, desc));
}
}
fn run_compiler(args: &~[~str], demitter: diagnostic::emitter) {
// Don't display log spew by default. Can override with RUST_LOG.
logging::console_off();
let mut args = *args;
let binary = args.shift();
if args.is_empty() { usage(binary); return; }
let matches =
match getopts::groups::getopts(args, optgroups()) {
Ok(m) => m,
Err(f) => {
early_error(demitter, getopts::fail_str(f))
}
};
if opt_present(matches, ~"h") || opt_present(matches, ~"help") {
usage(binary);
return;
}
let lint_flags = vec::append(getopts::opt_strs(matches, ~"W"),
getopts::opt_strs(matches, ~"warn"));
if lint_flags.contains(&~"help") {
describe_warnings();
return;
}
if getopts::opt_strs(matches, ~"Z").contains(&~"help") {
describe_debug_flags();
return;
}
if opt_present(matches, ~"v") || opt_present(matches, ~"version") {
version(binary);
return;
}
let input = match vec::len(matches.free) {
0u => early_error(demitter, ~"no input filename given"),
1u => {
let ifile = matches.free[0];
if ifile == ~"-" {
let src = str::from_bytes(io::stdin().read_whole_stream());
str_input(src)
} else {
file_input(Path(ifile))
}
}
_ => early_error(demitter, ~"multiple input filenames provided")
};
let sopts = build_session_options(binary, matches, demitter);
let sess = build_session(sopts, demitter);
let odir = getopts::opt_maybe_str(matches, ~"out-dir");
let odir = odir.map(|o| Path(*o));
let ofile = getopts::opt_maybe_str(matches, ~"o");
let ofile = ofile.map(|o| Path(*o));
let cfg = build_configuration(sess, binary, input);
let pretty =
option::map(&getopts::opt_default(matches, ~"pretty",
~"normal"),
|a| parse_pretty(sess, *a) );
match pretty {
Some::<pp_mode>(ppm) => {
pretty_print_input(sess, cfg, input, ppm);
return;
}
None::<pp_mode> => {/* continue */ }
}
let ls = opt_present(matches, ~"ls");
if ls {
match input {
file_input(ifile) => {
list_metadata(sess, &ifile, io::stdout());
}
str_input(_) => {
early_error(demitter, ~"can not list metadata for stdin");
}
}
return;
}
compile_input(sess, cfg, input, &odir, &ofile);
}
enum monitor_msg {
fatal,
done,
}
impl monitor_msg : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &monitor_msg) -> bool {
(self as uint) == ((*other) as uint)
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &monitor_msg) -> bool {
((*self) as uint) == ((*other) as uint)
}
#[cfg(stage0)]
pure fn ne(other: &monitor_msg) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &monitor_msg) -> bool { !(*self).eq(other) }
}
/*
This is a sanity check that any failure of the compiler is performed
through the diagnostic module and reported properly - we shouldn't be calling
plain-old-fail on any execution path that might be taken. Since we have
console logging off by default, hitting a plain fail statement would make the
compiler silently exit, which would be terrible.
This method wraps the compiler in a subtask and injects a function into the
diagnostic emitter which records when we hit a fatal error. If the task
fails without recording a fatal error then we've encountered a compiler
bug and need to present an error.
*/
fn monitor(+f: fn~(diagnostic::emitter)) {
let p = comm::Port();
let ch = comm::Chan(&p);
match do task::try |move f| {
// The 'diagnostics emitter'. Every error, warning, etc. should
// go through this function.
let demitter = fn@(cmsp: Option<(@codemap::CodeMap, codemap::span)>,
msg: &str, lvl: diagnostic::level) {
if lvl == diagnostic::fatal {
comm::send(ch, fatal);
}
diagnostic::emit(cmsp, msg, lvl);
};
struct finally {
ch: comm::Chan<monitor_msg>,
drop { comm::send(self.ch, done); }
}
let _finally = finally { ch: ch };
f(demitter)
} {
result::Ok(_) => { /* fallthrough */ }
result::Err(_) => {
// Task failed without emitting a fatal diagnostic
if comm::recv(p) == done {
diagnostic::emit(
None,
diagnostic::ice_msg(~"unexpected failure"),
diagnostic::error);
for [
~"the compiler hit an unexpected failure path. \
this is a bug",
~"try running with RUST_LOG=rustc=1,::rt::backtrace \
to get further details and report the results \
to github.com/mozilla/rust/issues"
].each |note| {
diagnostic::emit(None, *note, diagnostic::note)
}
}
// Fail so the process returns a failure code
fail;
}
}
}
fn main() {
let mut args = os::args();
do monitor |move args, demitter| {
run_compiler(&args, demitter);
}
}
// Local Variables:
// mode: rust
// fill-column: 78;
// indent-tabs-mode: nil
// c-basic-offset: 4
// buffer-file-coding-system: utf-8-unix
// End:

20
src/librustdoc/config.rs
View file

@ -11,19 +11,9 @@ pub enum OutputFormat {
}
impl OutputFormat : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &OutputFormat) -> bool {
(self as uint) == ((*other) as uint)
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &OutputFormat) -> bool {
((*self) as uint) == ((*other) as uint)
}
#[cfg(stage0)]
pure fn ne(other: &OutputFormat) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &OutputFormat) -> bool { !(*self).eq(other) }
}
@ -36,19 +26,9 @@ pub enum OutputStyle {
}
impl OutputStyle : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &OutputStyle) -> bool {
(self as uint) == ((*other) as uint)
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &OutputStyle) -> bool {
((*self) as uint) == ((*other) as uint)
}
#[cfg(stage0)]
pure fn ne(other: &OutputStyle) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &OutputStyle) -> bool { !(*self).eq(other) }
}

289
src/librustdoc/doc.rs
View file

@ -7,19 +7,9 @@ pub type Doc_ = {
};
impl Doc_ : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &Doc_) -> bool {
self.pages == (*other).pages
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &Doc_) -> bool {
(*self).pages == (*other).pages
}
#[cfg(stage0)]
pure fn ne(other: &Doc_) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &Doc_) -> bool { !(*self).eq(other) }
}
@ -28,15 +18,7 @@ pub enum Doc {
}
impl Doc : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &Doc) -> bool { *self == *(*other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &Doc) -> bool { *(*self) == *(*other) }
#[cfg(stage0)]
pure fn ne(other: &Doc) -> bool { *self != *(*other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &Doc) -> bool { *(*self) != *(*other) }
}
@ -46,25 +28,6 @@ pub enum Page {
}
impl Page : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &Page) -> bool {
match self {
CratePage(e0a) => {
match (*other) {
CratePage(e0b) => e0a == e0b,
_ => false
}
}
ItemPage(e0a) => {
match (*other) {
ItemPage(e0b) => e0a == e0b,
_ => false
}
}
}
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &Page) -> bool {
match (*self) {
CratePage(e0a) => {
@ -81,10 +44,6 @@ impl Page : cmp::Eq {
}
}
}
#[cfg(stage0)]
pure fn ne(other: &Page) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &Page) -> bool { !(*self).eq(other) }
}
@ -94,19 +53,9 @@ pub enum Implementation {
}
impl Implementation : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &Implementation) -> bool {
(self as uint) == ((*other) as uint)
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &Implementation) -> bool {
((*self) as uint) == ((*other) as uint)
}
#[cfg(stage0)]
pure fn ne(other: &Implementation) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &Implementation) -> bool { !(*self).eq(other) }
}
@ -121,19 +70,9 @@ pub type Section = {
};
impl Section : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &Section) -> bool {
self.header == (*other).header && self.body == (*other).body
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &Section) -> bool {
(*self).header == (*other).header && (*self).body == (*other).body
}
#[cfg(stage0)]
pure fn ne(other: &Section) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &Section) -> bool { !(*self).eq(other) }
}
@ -145,19 +84,9 @@ pub type CrateDoc = {
};
impl CrateDoc : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &CrateDoc) -> bool {
self.topmod == (*other).topmod
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &CrateDoc) -> bool {
(*self).topmod == (*other).topmod
}
#[cfg(stage0)]
pure fn ne(other: &CrateDoc) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &CrateDoc) -> bool { !(*self).eq(other) }
}
@ -174,67 +103,6 @@ pub enum ItemTag {
}
impl ItemTag : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &ItemTag) -> bool {
match self {
ModTag(e0a) => {
match (*other) {
ModTag(e0b) => e0a == e0b,
_ => false
}
}
NmodTag(e0a) => {
match (*other) {
NmodTag(e0b) => e0a == e0b,
_ => false
}
}
ConstTag(e0a) => {
match (*other) {
ConstTag(e0b) => e0a == e0b,
_ => false
}
}
FnTag(e0a) => {
match (*other) {
FnTag(e0b) => e0a == e0b,
_ => false
}
}
EnumTag(e0a) => {
match (*other) {
EnumTag(e0b) => e0a == e0b,
_ => false
}
}
TraitTag(e0a) => {
match (*other) {
TraitTag(e0b) => e0a == e0b,
_ => false
}
}
ImplTag(e0a) => {
match (*other) {
ImplTag(e0b) => e0a == e0b,
_ => false
}
}
TyTag(e0a) => {
match (*other) {
TyTag(e0b) => e0a == e0b,
_ => false
}
}
StructTag(e0a) => {
match (*other) {
StructTag(e0b) => e0a == e0b,
_ => false
}
}
}
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &ItemTag) -> bool {
match (*self) {
ModTag(e0a) => {
@ -293,10 +161,6 @@ impl ItemTag : cmp::Eq {
}
}
}
#[cfg(stage0)]
pure fn ne(other: &ItemTag) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &ItemTag) -> bool { !(*self).eq(other) }
}
@ -312,18 +176,6 @@ pub type ItemDoc = {
};
impl ItemDoc : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &ItemDoc) -> bool {
self.id == (*other).id &&
self.name == (*other).name &&
self.path == (*other).path &&
self.brief == (*other).brief &&
self.desc == (*other).desc &&
self.sections == (*other).sections &&
self.reexport == (*other).reexport
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &ItemDoc) -> bool {
(*self).id == (*other).id &&
(*self).name == (*other).name &&
@ -333,10 +185,6 @@ impl ItemDoc : cmp::Eq {
(*self).sections == (*other).sections &&
(*self).reexport == (*other).reexport
}
#[cfg(stage0)]
pure fn ne(other: &ItemDoc) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &ItemDoc) -> bool { !(*self).eq(other) }
}
@ -346,19 +194,9 @@ pub type SimpleItemDoc = {
};
impl SimpleItemDoc : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &SimpleItemDoc) -> bool {
self.item == (*other).item && self.sig == (*other).sig
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &SimpleItemDoc) -> bool {
(*self).item == (*other).item && (*self).sig == (*other).sig
}
#[cfg(stage0)]
pure fn ne(other: &SimpleItemDoc) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &SimpleItemDoc) -> bool { !(*self).eq(other) }
}
@ -369,23 +207,11 @@ pub type ModDoc_ = {
};
impl ModDoc_ : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &ModDoc_) -> bool {
self.item == (*other).item &&
self.items == (*other).items &&
self.index == (*other).index
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &ModDoc_) -> bool {
(*self).item == (*other).item &&
(*self).items == (*other).items &&
(*self).index == (*other).index
}
#[cfg(stage0)]
pure fn ne(other: &ModDoc_) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &ModDoc_) -> bool { !(*self).eq(other) }
}
@ -394,15 +220,7 @@ pub enum ModDoc {
}
impl ModDoc : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &ModDoc) -> bool { *self == *(*other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &ModDoc) -> bool { *(*self) == *(*other) }
#[cfg(stage0)]
pure fn ne(other: &ModDoc) -> bool { *self != *(*other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &ModDoc) -> bool { *(*self) != *(*other) }
}
@ -413,23 +231,11 @@ pub type NmodDoc = {
};
impl NmodDoc : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &NmodDoc) -> bool {
self.item == (*other).item &&
self.fns == (*other).fns &&
self.index == (*other).index
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &NmodDoc) -> bool {
(*self).item == (*other).item &&
(*self).fns == (*other).fns &&
(*self).index == (*other).index
}
#[cfg(stage0)]
pure fn ne(other: &NmodDoc) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &NmodDoc) -> bool { !(*self).eq(other) }
}
@ -443,19 +249,9 @@ pub type EnumDoc = {
};
impl EnumDoc : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &EnumDoc) -> bool {
self.item == (*other).item && self.variants == (*other).variants
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &EnumDoc) -> bool {
(*self).item == (*other).item && (*self).variants == (*other).variants
}
#[cfg(stage0)]
pure fn ne(other: &EnumDoc) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &EnumDoc) -> bool { !(*self).eq(other) }
}
@ -466,23 +262,11 @@ pub type VariantDoc = {
};
impl VariantDoc : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &VariantDoc) -> bool {
self.name == (*other).name &&
self.desc == (*other).desc &&
self.sig == (*other).sig
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &VariantDoc) -> bool {
(*self).name == (*other).name &&
(*self).desc == (*other).desc &&
(*self).sig == (*other).sig
}
#[cfg(stage0)]
pure fn ne(other: &VariantDoc) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &VariantDoc) -> bool { !(*self).eq(other) }
}
@ -492,19 +276,9 @@ pub type TraitDoc = {
};
impl TraitDoc : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &TraitDoc) -> bool {
self.item == (*other).item && self.methods == (*other).methods
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &TraitDoc) -> bool {
(*self).item == (*other).item && (*self).methods == (*other).methods
}
#[cfg(stage0)]
pure fn ne(other: &TraitDoc) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &TraitDoc) -> bool { !(*self).eq(other) }
}
@ -518,17 +292,6 @@ pub type MethodDoc = {
};
impl MethodDoc : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &MethodDoc) -> bool {
self.name == (*other).name &&
self.brief == (*other).brief &&
self.desc == (*other).desc &&
self.sections == (*other).sections &&
self.sig == (*other).sig &&
self.implementation == (*other).implementation
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &MethodDoc) -> bool {
(*self).name == (*other).name &&
(*self).brief == (*other).brief &&
@ -537,10 +300,6 @@ impl MethodDoc : cmp::Eq {
(*self).sig == (*other).sig &&
(*self).implementation == (*other).implementation
}
#[cfg(stage0)]
pure fn ne(other: &MethodDoc) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &MethodDoc) -> bool { !(*self).eq(other) }
}
@ -552,25 +311,12 @@ pub type ImplDoc = {
};
impl ImplDoc : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &ImplDoc) -> bool {
self.item == (*other).item &&
self.trait_types == (*other).trait_types &&
self.self_ty == (*other).self_ty &&
self.methods == (*other).methods
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &ImplDoc) -> bool {
(*self).item == (*other).item &&
(*self).trait_types == (*other).trait_types &&
(*self).self_ty == (*other).self_ty &&
(*self).methods == (*other).methods
}
#[cfg(stage0)]
pure fn ne(other: &ImplDoc) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &ImplDoc) -> bool { !(*self).eq(other) }
}
@ -583,23 +329,11 @@ pub type StructDoc = {
};
impl StructDoc : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &StructDoc) -> bool {
return self.item == other.item
&& self.fields == other.fields
&& self.sig == other.sig;
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &StructDoc) -> bool {
return (*self).item == other.item
&& (*self).fields == other.fields
&& (*self).sig == other.sig;
}
#[cfg(stage0)]
pure fn ne(other: &StructDoc) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &StructDoc) -> bool { !(*self).eq(other) }
}
@ -608,19 +342,9 @@ pub type Index = {
};
impl Index : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &Index) -> bool {
self.entries == (*other).entries
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &Index) -> bool {
(*self).entries == (*other).entries
}
#[cfg(stage0)]
pure fn ne(other: &Index) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &Index) -> bool { !(*self).eq(other) }
}
@ -642,25 +366,12 @@ pub type IndexEntry = {
};
impl IndexEntry : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &IndexEntry) -> bool {
self.kind == (*other).kind &&
self.name == (*other).name &&
self.brief == (*other).brief &&
self.link == (*other).link
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &IndexEntry) -> bool {
(*self).kind == (*other).kind &&
(*self).name == (*other).name &&
(*self).brief == (*other).brief &&
(*self).link == (*other).link
}
#[cfg(stage0)]
pure fn ne(other: &IndexEntry) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &IndexEntry) -> bool { !(*self).eq(other) }
}

61
src/libstd/deque.rs
View file

@ -239,25 +239,6 @@ mod tests {
type RecCy = {x: int, y: int, t: Taggy};
impl Taggy : Eq {
#[cfg(stage0)]
pure fn eq(other: &Taggy) -> bool {
match self {
One(a1) => match (*other) {
One(b1) => return a1 == b1,
_ => return false
},
Two(a1, a2) => match (*other) {
Two(b1, b2) => return a1 == b1 && a2 == b2,
_ => return false
},
Three(a1, a2, a3) => match (*other) {
Three(b1, b2, b3) => return a1 == b1 && a2 == b2 && a3 == b3,
_ => return false
}
}
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &Taggy) -> bool {
match (*self) {
One(a1) => match (*other) {
@ -274,36 +255,11 @@ mod tests {
}
}
}
#[cfg(stage0)]
pure fn ne(other: &Taggy) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &Taggy) -> bool { !(*self).eq(other) }
}
impl Taggypar<int> : Eq {
//let eq4: EqFn<Taggypar<int>> = |x,y| taggypareq::<int>(x, y);
#[cfg(stage0)]
pure fn eq(other: &Taggypar<int>) -> bool {
match self {
Onepar::<int>(a1) => match (*other) {
Onepar::<int>(b1) => return a1 == b1,
_ => return false
},
Twopar::<int>(a1, a2) => match (*other) {
Twopar::<int>(b1, b2) => return a1 == b1 && a2 == b2,
_ => return false
},
Threepar::<int>(a1, a2, a3) => match (*other) {
Threepar::<int>(b1, b2, b3) => {
return a1 == b1 && a2 == b2 && a3 == b3
}
_ => return false
}
}
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &Taggypar<int>) -> bool {
match (*self) {
Onepar::<int>(a1) => match (*other) {
@ -322,33 +278,16 @@ mod tests {
}
}
}
#[cfg(stage0)]
pure fn ne(other: &Taggypar<int>) -> bool {
!self.eq(other)
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &Taggypar<int>) -> bool {
!(*self).eq(other)
}
}
impl RecCy : Eq {
#[cfg(stage0)]
pure fn eq(other: &RecCy) -> bool {
return self.x == (*other).x && self.y == (*other).y &&
self.t == (*other).t;
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &RecCy) -> bool {
return (*self).x == (*other).x && (*self).y == (*other).y &&
(*self).t == (*other).t;
}
#[cfg(stage0)]
pure fn ne(other: &RecCy) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &RecCy) -> bool { !(*self).eq(other) }
}

142
src/libstd/getopts.rs
View file

@ -88,25 +88,6 @@ fn mkname(nm: &str) -> Name {
}
impl Name : Eq {
#[cfg(stage0)]
pure fn eq(other: &Name) -> bool {
match self {
Long(ref e0a) => {
match (*other) {
Long(ref e0b) => e0a == e0b,
_ => false
}
}
Short(e0a) => {
match (*other) {
Short(e0b) => e0a == e0b,
_ => false
}
}
}
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &Name) -> bool {
match (*self) {
Long(ref e0a) => {
@ -123,65 +104,29 @@ impl Name : Eq {
}
}
}
#[cfg(stage0)]
pure fn ne(other: &Name) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &Name) -> bool { !(*self).eq(other) }
}
impl Occur : Eq {
#[cfg(stage0)]
pure fn eq(other: &Occur) -> bool {
(self as uint) == ((*other) as uint)
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &Occur) -> bool {
((*self) as uint) == ((*other) as uint)
}
#[cfg(stage0)]
pure fn ne(other: &Occur) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &Occur) -> bool { !(*self).eq(other) }
}
impl HasArg : Eq {
#[cfg(stage0)]
pure fn eq(other: &HasArg) -> bool {
(self as uint) == ((*other) as uint)
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &HasArg) -> bool {
((*self) as uint) == ((*other) as uint)
}
#[cfg(stage0)]
pure fn ne(other: &HasArg) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &HasArg) -> bool { !(*self).eq(other) }
}
impl Opt : Eq {
#[cfg(stage0)]
pure fn eq(other: &Opt) -> bool {
self.name == (*other).name &&
self.hasarg == (*other).hasarg &&
self.occur == (*other).occur
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &Opt) -> bool {
(*self).name == (*other).name &&
(*self).hasarg == (*other).hasarg &&
(*self).occur == (*other).occur
}
#[cfg(stage0)]
pure fn ne(other: &Opt) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &Opt) -> bool { !(*self).eq(other) }
}
@ -227,17 +172,6 @@ enum Optval { Val(~str), Given, }
pub type Matches = {opts: ~[Opt], vals: ~[~[Optval]], free: ~[~str]};
impl Optval : Eq {
#[cfg(stage0)]
pure fn eq(other: &Optval) -> bool {
match self {
Val(ref s) => match *other { Val (ref os) => s == os,
Given => false },
Given => match *other { Val(_) => false,
Given => true }
}
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &Optval) -> bool {
match (*self) {
Val(ref s) => match *other { Val (ref os) => s == os,
@ -246,31 +180,15 @@ impl Optval : Eq {
Given => true }
}
}
#[cfg(stage0)]
pure fn ne(other: &Optval) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &Optval) -> bool { !(*self).eq(other) }
}
impl Matches : Eq {
#[cfg(stage0)]
pure fn eq(other: &Matches) -> bool {
self.opts == (*other).opts &&
self.vals == (*other).vals &&
self.free == (*other).free
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &Matches) -> bool {
(*self).opts == (*other).opts &&
(*self).vals == (*other).vals &&
(*self).free == (*other).free
}
#[cfg(stage0)]
pure fn ne(other: &Matches) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &Matches) -> bool { !(*self).eq(other) }
}
@ -303,33 +221,6 @@ pub enum Fail_ {
impl Fail_ : Eq {
// this whole thing should be easy to infer...
#[cfg(stage0)]
pure fn eq(other: &Fail_) -> bool {
match self {
ArgumentMissing(ref s) => {
match *other { ArgumentMissing(ref so) => s == so,
_ => false }
}
UnrecognizedOption(ref s) => {
match *other { UnrecognizedOption(ref so) => s == so,
_ => false }
}
OptionMissing(ref s) => {
match *other { OptionMissing(ref so) => s == so,
_ => false }
}
OptionDuplicated(ref s) => {
match *other { OptionDuplicated(ref so) => s == so,
_ => false }
}
UnexpectedArgument(ref s) => {
match *other { UnexpectedArgument(ref so) => s == so,
_ => false }
}
}
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &Fail_) -> bool {
match (*self) {
ArgumentMissing(ref s) => {
@ -354,10 +245,6 @@ impl Fail_ : Eq {
}
}
}
#[cfg(stage0)]
pure fn ne(other: &Fail_) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &Fail_) -> bool { !(*self).eq(other) }
}
@ -627,19 +514,9 @@ enum FailType {
}
impl FailType : Eq {
#[cfg(stage0)]
pure fn eq(other: &FailType) -> bool {
(self as uint) == ((*other) as uint)
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &FailType) -> bool {
((*self) as uint) == ((*other) as uint)
}
#[cfg(stage0)]
pure fn ne(other: &FailType) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &FailType) -> bool { !(*self).eq(other) }
}
@ -661,17 +538,6 @@ pub mod groups {
};
impl OptGroup : Eq {
#[cfg(stage0)]
pure fn eq(other: &OptGroup) -> bool {
self.short_name == (*other).short_name &&
self.long_name == (*other).long_name &&
self.hint == (*other).hint &&
self.desc == (*other).desc &&
self.hasarg == (*other).hasarg &&
self.occur == (*other).occur
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &OptGroup) -> bool {
(*self).short_name == (*other).short_name &&
(*self).long_name == (*other).long_name &&
@ -680,11 +546,9 @@ pub mod groups {
(*self).hasarg == (*other).hasarg &&
(*self).occur == (*other).occur
}
#[cfg(stage0)]
pure fn ne(other: &OptGroup) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &OptGroup) -> bool { !(*self).eq(other) }
pure fn ne(&self, other: &OptGroup) -> bool {
!self.eq(other)
}
}
/// Create a long option that is required and takes an argument

139
src/libstd/json.rs
View file

@ -905,44 +905,6 @@ pub impl Deserializer: serialization::Deserializer {
}
impl Json : Eq {
#[cfg(stage0)]
pure fn eq(other: &Json) -> bool {
// XXX: This is ugly because matching on references is broken, and
// we can't match on dereferenced tuples without a copy.
match self {
Number(f0) =>
match *other { Number(f1) => f0 == f1, _ => false },
String(ref s0) =>
match *other { String(ref s1) => s0 == s1, _ => false },
Boolean(b0) =>
match *other { Boolean(b1) => b0 == b1, _ => false },
Null =>
match *other { Null => true, _ => false },
List(v0) =>
match *other { List(v1) => v0 == v1, _ => false },
Object(ref d0) => {
match *other {
Object(ref d1) => {
if d0.len() == d1.len() {
let mut equal = true;
for d0.each |k, v0| {
match d1.find_ref(k) {
Some(v1) if v0 == v1 => { },
_ => { equal = false; break }
}
};
equal
} else {
false
}
}
_ => false
}
}
}
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &Json) -> bool {
// XXX: This is ugly because matching on references is broken, and
// we can't match on dereferenced tuples without a copy.
@ -978,88 +940,11 @@ impl Json : Eq {
}
}
}
#[cfg(stage0)]
pure fn ne(other: &Json) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &Json) -> bool { !(*self).eq(other) }
}
/// Test if two json values are less than one another
impl Json : Ord {
#[cfg(stage0)]
pure fn lt(other: &Json) -> bool {
match self {
Number(f0) => {
match *other {
Number(f1) => f0 < f1,
String(_) | Boolean(_) | List(_) | Object(_) |
Null => true
}
}
String(ref s0) => {
match *other {
Number(_) => false,
String(ref s1) => s0 < s1,
Boolean(_) | List(_) | Object(_) | Null => true
}
}
Boolean(b0) => {
match *other {
Number(_) | String(_) => false,
Boolean(b1) => b0 < b1,
List(_) | Object(_) | Null => true
}
}
List(l0) => {
match *other {
Number(_) | String(_) | Boolean(_) => false,
List(l1) => l0 < l1,
Object(_) | Null => true
}
}
Object(ref d0) => {
match *other {
Number(_) | String(_) | Boolean(_) | List(_) => false,
Object(ref d1) => {
unsafe {
let mut d0_flat = ~[];
let mut d1_flat = ~[];
// XXX: this is horribly inefficient...
for d0.each |k, v| {
d0_flat.push((@copy *k, @copy *v));
}
d0_flat.qsort();
for d1.each |k, v| {
d1_flat.push((@copy *k, @copy *v));
}
d1_flat.qsort();
d0_flat < d1_flat
}
}
Null => true
}
}
Null => {
match *other {
Number(_) | String(_) | Boolean(_) | List(_) |
Object(_) =>
false,
Null => true
}
}
}
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn lt(&self, other: &Json) -> bool {
match (*self) {
Number(f0) => {
@ -1130,41 +1015,17 @@ impl Json : Ord {
}
}
}
#[cfg(stage0)]
pure fn le(other: &Json) -> bool { !(*other).lt(&self) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn le(&self, other: &Json) -> bool { !(*other).lt(&(*self)) }
#[cfg(stage0)]
pure fn ge(other: &Json) -> bool { !self.lt(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ge(&self, other: &Json) -> bool { !(*self).lt(other) }
#[cfg(stage0)]
pure fn gt(other: &Json) -> bool { (*other).lt(&self) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn gt(&self, other: &Json) -> bool { (*other).lt(&(*self)) }
}
impl Error : Eq {
#[cfg(stage0)]
pure fn eq(other: &Error) -> bool {
self.line == other.line &&
self.col == other.col &&
self.msg == other.msg
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &Error) -> bool {
(*self).line == other.line &&
(*self).col == other.col &&
(*self).msg == other.msg
}
#[cfg(stage0)]
pure fn ne(other: &Error) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &Error) -> bool { !(*self).eq(other) }
}

23
src/libstd/list.rs
View file

@ -148,25 +148,6 @@ pub fn each<T>(l: @List<T>, f: fn(&T) -> bool) {
}
impl<T:Eq> List<T> : Eq {
#[cfg(stage0)]
pure fn eq(other: &List<T>) -> bool {
match self {
Cons(ref e0a, e1a) => {
match (*other) {
Cons(ref e0b, e1b) => e0a == e0b && e1a == e1b,
_ => false
}
}
Nil => {
match (*other) {
Nil => true,
_ => false
}
}
}
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &List<T>) -> bool {
match (*self) {
Cons(ref e0a, e1a) => {
@ -183,10 +164,6 @@ impl<T:Eq> List<T> : Eq {
}
}
}
#[cfg(stage0)]
pure fn ne(other: &List<T>) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &List<T>) -> bool { !(*self).eq(other) }
}

45
src/libstd/net_url.rs
View file

@ -315,19 +315,9 @@ pure fn userinfo_to_str(userinfo: UserInfo) -> ~str {
}
impl UserInfo : Eq {
#[cfg(stage0)]
pure fn eq(other: &UserInfo) -> bool {
self.user == (*other).user && self.pass == (*other).pass
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &UserInfo) -> bool {
(*self).user == (*other).user && (*self).pass == (*other).pass
}
#[cfg(stage0)]
pure fn ne(other: &UserInfo) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &UserInfo) -> bool { !(*self).eq(other) }
}
@ -389,19 +379,6 @@ enum Input {
}
impl Input : Eq {
#[cfg(stage0)]
pure fn eq(other: &Input) -> bool {
match (self, (*other)) {
(Digit, Digit) => true,
(Hex, Hex) => true,
(Unreserved, Unreserved) => true,
(Digit, _) => false,
(Hex, _) => false,
(Unreserved, _) => false
}
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &Input) -> bool {
match ((*self), (*other)) {
(Digit, Digit) => true,
@ -412,10 +389,6 @@ impl Input : Eq {
(Unreserved, _) => false
}
}
#[cfg(stage0)]
pure fn ne(other: &Input) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &Input) -> bool { !(*self).eq(other) }
}
@ -749,18 +722,6 @@ impl Url: to_str::ToStr {
}
impl Url : Eq {
#[cfg(stage0)]
pure fn eq(other: &Url) -> bool {
self.scheme == (*other).scheme
&& self.user == (*other).user
&& self.host == (*other).host
&& self.port == (*other).port
&& self.path == (*other).path
&& self.query == (*other).query
&& self.fragment == (*other).fragment
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &Url) -> bool {
(*self).scheme == (*other).scheme
&& (*self).user == (*other).user
@ -771,12 +732,6 @@ impl Url : Eq {
&& (*self).fragment == (*other).fragment
}
#[cfg(stage0)]
pure fn ne(other: &Url) -> bool {
!self.eq(other)
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &Url) -> bool {
!(*self).eq(other)
}

56
src/libstd/sort.rs
View file

@ -871,16 +871,6 @@ mod test_tim_sort {
}
impl CVal: Ord {
#[cfg(stage0)]
pure fn lt(other: &CVal) -> bool {
unsafe {
let rng = rand::Rng();
if rng.gen_float() > 0.995 { fail ~"It's happening!!!"; }
}
self.val < other.val
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn lt(&self, other: &CVal) -> bool {
unsafe {
let rng = rand::Rng();
@ -888,20 +878,8 @@ mod test_tim_sort {
}
(*self).val < other.val
}
#[cfg(stage0)]
pure fn le(other: &CVal) -> bool { self.val <= other.val }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn le(&self, other: &CVal) -> bool { (*self).val <= other.val }
#[cfg(stage0)]
pure fn gt(other: &CVal) -> bool { self.val > other.val }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn gt(&self, other: &CVal) -> bool { (*self).val > other.val }
#[cfg(stage0)]
pure fn ge(other: &CVal) -> bool { self.val >= other.val }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ge(&self, other: &CVal) -> bool { (*self).val >= other.val }
}
@ -957,16 +935,6 @@ mod test_tim_sort {
struct DVal { val: uint }
#[cfg(stage0)]
impl DVal: Ord {
pure fn lt(_x: &DVal) -> bool { true }
pure fn le(_x: &DVal) -> bool { true }
pure fn gt(_x: &DVal) -> bool { true }
pure fn ge(_x: &DVal) -> bool { true }
}
#[cfg(stage1)]
#[cfg(stage2)]
impl DVal: Ord {
pure fn lt(&self, _x: &DVal) -> bool { true }
pure fn le(&self, _x: &DVal) -> bool { true }
@ -1183,39 +1151,15 @@ mod big_tests {
}
impl LVal: Ord {
#[cfg(stage0)]
pure fn lt(other: &a/LVal/&self) -> bool {
self.val < other.val
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn lt(&self, other: &a/LVal/&self) -> bool {
(*self).val < other.val
}
#[cfg(stage0)]
pure fn le(other: &a/LVal/&self) -> bool {
self.val <= other.val
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn le(&self, other: &a/LVal/&self) -> bool {
(*self).val <= other.val
}
#[cfg(stage0)]
pure fn gt(other: &a/LVal/&self) -> bool {
self.val > other.val
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn gt(&self, other: &a/LVal/&self) -> bool {
(*self).val > other.val
}
#[cfg(stage0)]
pure fn ge(other: &a/LVal/&self) -> bool {
self.val >= other.val
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ge(&self, other: &a/LVal/&self) -> bool {
(*self).val >= other.val
}

10
src/libstd/test.rs
View file

@ -85,19 +85,9 @@ fn parse_opts(args: &[~str]) -> OptRes {
pub enum TestResult { TrOk, TrFailed, TrIgnored, }
impl TestResult : Eq {
#[cfg(stage0)]
pure fn eq(other: &TestResult) -> bool {
(self as uint) == ((*other) as uint)
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &TestResult) -> bool {
((*self) as uint) == ((*other) as uint)
}
#[cfg(stage0)]
pure fn ne(other: &TestResult) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &TestResult) -> bool { !(*self).eq(other) }
}

39
src/libstd/time.rs
View file

@ -24,19 +24,9 @@ extern mod rustrt {
pub type Timespec = {sec: i64, nsec: i32};
impl Timespec : Eq {
#[cfg(stage0)]
pure fn eq(other: &Timespec) -> bool {
self.sec == (*other).sec && self.nsec == (*other).nsec
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &Timespec) -> bool {
(*self).sec == (*other).sec && (*self).nsec == (*other).nsec
}
#[cfg(stage0)]
pure fn ne(other: &Timespec) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &Timespec) -> bool { !(*self).eq(other) }
}
@ -91,23 +81,6 @@ type Tm_ = {
};
impl Tm_ : Eq {
#[cfg(stage0)]
pure fn eq(other: &Tm_) -> bool {
self.tm_sec == (*other).tm_sec &&
self.tm_min == (*other).tm_min &&
self.tm_hour == (*other).tm_hour &&
self.tm_mday == (*other).tm_mday &&
self.tm_mon == (*other).tm_mon &&
self.tm_year == (*other).tm_year &&
self.tm_wday == (*other).tm_wday &&
self.tm_yday == (*other).tm_yday &&
self.tm_isdst == (*other).tm_isdst &&
self.tm_gmtoff == (*other).tm_gmtoff &&
self.tm_zone == (*other).tm_zone &&
self.tm_nsec == (*other).tm_nsec
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &Tm_) -> bool {
(*self).tm_sec == (*other).tm_sec &&
(*self).tm_min == (*other).tm_min &&
@ -122,10 +95,6 @@ impl Tm_ : Eq {
(*self).tm_zone == (*other).tm_zone &&
(*self).tm_nsec == (*other).tm_nsec
}
#[cfg(stage0)]
pure fn ne(other: &Tm_) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &Tm_) -> bool { !(*self).eq(other) }
}
@ -134,15 +103,7 @@ pub enum Tm {
}
impl Tm : Eq {
#[cfg(stage0)]
pure fn eq(other: &Tm) -> bool { *self == *(*other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &Tm) -> bool { *(*self) == *(*other) }
#[cfg(stage0)]
pure fn ne(other: &Tm) -> bool { *self != *(*other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &Tm) -> bool { *(*self) != *(*other) }
}

128
src/libsyntax/alternate_crate.rc
View file

@ -1,128 +0,0 @@
#[link(name = "syntax",
vers = "0.5",
uuid = "9311401b-d6ea-4cd9-a1d9-61f89499c645")];
#[crate_type = "lib"];
#[no_core];
#[legacy_modes];
#[legacy_exports];
#[allow(vecs_implicitly_copyable)];
#[allow(non_camel_case_types)];
#[allow(deprecated_mode)];
#[allow(deprecated_pattern)];
extern mod core(vers = "0.5");
extern mod std(vers = "0.5");
use core::*;
#[legacy_exports]
mod attr;
#[legacy_exports]
mod diagnostic;
mod codemap;
#[legacy_exports]
mod ast;
#[legacy_exports]
mod ast_util;
#[legacy_exports]
mod ast_map;
#[legacy_exports]
mod visit;
#[legacy_exports]
mod fold;
#[legacy_exports]
mod util {
#[legacy_exports];
#[legacy_exports]
#[path = "util/interner.rs"]
mod interner;
}
#[merge = "parse/mod.rs"]
mod parse;
mod print {
#[legacy_exports];
#[legacy_exports]
#[path = "print/pp.rs"]
mod pp;
#[legacy_exports]
#[path = "print/pprust.rs"]
mod pprust;
}
mod ext {
#[legacy_exports];
#[legacy_exports]
#[path = "ext/base.rs"]
mod base;
#[legacy_exports]
#[path = "ext/expand.rs"]
mod expand;
#[legacy_exports]
#[path = "ext/qquote.rs"]
mod qquote;
#[path = "ext/quote.rs"]
mod quote;
#[path = "ext/deriving.rs"]
mod deriving;
#[legacy_exports]
#[path = "ext/build.rs"]
mod build;
mod tt {
#[legacy_exports];
#[legacy_exports]
#[path = "ext/tt/transcribe.rs"]
mod transcribe;
#[legacy_exports]
#[path = "ext/tt/macro_parser.rs"]
mod macro_parser;
#[legacy_exports]
#[path = "ext/tt/macro_rules.rs"]
mod macro_rules;
}
#[legacy_exports]
#[path = "ext/simplext.rs"]
mod simplext;
#[legacy_exports]
#[path = "ext/fmt.rs"]
mod fmt;
#[legacy_exports]
#[path = "ext/env.rs"]
mod env;
#[legacy_exports]
#[path = "ext/concat_idents.rs"]
mod concat_idents;
#[legacy_exports]
#[path = "ext/ident_to_str.rs"]
mod ident_to_str;
#[legacy_exports]
#[path = "ext/log_syntax.rs"]
mod log_syntax;
#[legacy_exports]
#[path = "ext/auto_serialize.rs"]
mod auto_serialize;
#[legacy_exports]
#[path = "ext/source_util.rs"]
mod source_util;
#[legacy_exports]
#[path = "ext/pipes.rs"]
#[merge = "ext/pipes/mod.rs"]
mod pipes;
#[legacy_exports]
#[path = "ext/trace_macros.rs"]
mod trace_macros;
}

640
src/libsyntax/ast.rs
View file

@ -50,15 +50,7 @@ impl<D: Deserializer> ident: Deserializable<D> {
}
impl ident: cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &ident) -> bool { self.repr == other.repr }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &ident) -> bool { (*self).repr == other.repr }
#[cfg(stage0)]
pure fn ne(other: &ident) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &ident) -> bool { !(*self).eq(other) }
}
@ -88,19 +80,9 @@ type node_id = int;
type def_id = {crate: crate_num, node: node_id};
impl def_id : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &def_id) -> bool {
self.crate == (*other).crate && self.node == (*other).node
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &def_id) -> bool {
(*self).crate == (*other).crate && (*self).node == (*other).node
}
#[cfg(stage0)]
pure fn ne(other: &def_id) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &def_id) -> bool { !(*self).eq(other) }
}
@ -149,129 +131,6 @@ enum def {
}
impl def : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &def) -> bool {
match self {
def_fn(e0a, e1a) => {
match (*other) {
def_fn(e0b, e1b) => e0a == e0b && e1a == e1b,
_ => false
}
}
def_static_method(e0a, e1a, e2a) => {
match (*other) {
def_static_method(e0b, e1b, e2b) =>
e0a == e0b && e1a == e1b && e2a == e2b,
_ => false
}
}
def_self(e0a) => {
match (*other) {
def_self(e0b) => e0a == e0b,
_ => false
}
}
def_mod(e0a) => {
match (*other) {
def_mod(e0b) => e0a == e0b,
_ => false
}
}
def_foreign_mod(e0a) => {
match (*other) {
def_foreign_mod(e0b) => e0a == e0b,
_ => false
}
}
def_const(e0a) => {
match (*other) {
def_const(e0b) => e0a == e0b,
_ => false
}
}
def_arg(e0a, e1a) => {
match (*other) {
def_arg(e0b, e1b) => e0a == e0b && e1a == e1b,
_ => false
}
}
def_local(e0a, e1a) => {
match (*other) {
def_local(e0b, e1b) => e0a == e0b && e1a == e1b,
_ => false
}
}
def_variant(e0a, e1a) => {
match (*other) {
def_variant(e0b, e1b) => e0a == e0b && e1a == e1b,
_ => false
}
}
def_ty(e0a) => {
match (*other) {
def_ty(e0b) => e0a == e0b,
_ => false
}
}
def_prim_ty(e0a) => {
match (*other) {
def_prim_ty(e0b) => e0a == e0b,
_ => false
}
}
def_ty_param(e0a, e1a) => {
match (*other) {
def_ty_param(e0b, e1b) => e0a == e0b && e1a == e1b,
_ => false
}
}
def_binding(e0a, e1a) => {
match (*other) {
def_binding(e0b, e1b) => e0a == e0b && e1a == e1b,
_ => false
}
}
def_use(e0a) => {
match (*other) {
def_use(e0b) => e0a == e0b,
_ => false
}
}
def_upvar(e0a, e1a, e2a, e3a) => {
match (*other) {
def_upvar(e0b, e1b, e2b, e3b) =>
e0a == e0b && e1a == e1b && e2a == e2b && e3a == e3b,
_ => false
}
}
def_class(e0a) => {
match (*other) {
def_class(e0b) => e0a == e0b,
_ => false
}
}
def_typaram_binder(e0a) => {
match (*other) {
def_typaram_binder(e1a) => e0a == e1a,
_ => false
}
}
def_region(e0a) => {
match (*other) {
def_region(e0b) => e0a == e0b,
_ => false
}
}
def_label(e0a) => {
match (*other) {
def_label(e0b) => e0a == e0b,
_ => false
}
}
}
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &def) -> bool {
match (*self) {
def_fn(e0a, e1a) => {
@ -392,10 +251,6 @@ impl def : cmp::Eq {
}
}
}
#[cfg(stage0)]
pure fn ne(other: &def) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &def) -> bool { !(*self).eq(other) }
}
@ -464,37 +319,6 @@ impl binding_mode : to_bytes::IterBytes {
}
impl binding_mode : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &binding_mode) -> bool {
match self {
bind_by_value => {
match (*other) {
bind_by_value => true,
_ => false
}
}
bind_by_move => {
match (*other) {
bind_by_move => true,
_ => false
}
}
bind_by_ref(e0a) => {
match (*other) {
bind_by_ref(e0b) => e0a == e0b,
_ => false
}
}
bind_by_implicit_ref => {
match (*other) {
bind_by_implicit_ref => true,
_ => false
}
}
}
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &binding_mode) -> bool {
match (*self) {
bind_by_value => {
@ -523,10 +347,6 @@ impl binding_mode : cmp::Eq {
}
}
}
#[cfg(stage0)]
pure fn ne(other: &binding_mode) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &binding_mode) -> bool { !(*self).eq(other) }
}
@ -565,19 +385,9 @@ impl mutability : to_bytes::IterBytes {
}
impl mutability : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &mutability) -> bool {
(self as uint) == ((*other) as uint)
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &mutability) -> bool {
((*self) as uint) == ((*other) as uint)
}
#[cfg(stage0)]
pure fn ne(other: &mutability) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &mutability) -> bool { !(*self).eq(other) }
}
@ -591,19 +401,9 @@ pub enum Proto {
}
impl Proto : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &Proto) -> bool {
(self as uint) == ((*other) as uint)
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &Proto) -> bool {
((*self) as uint) == ((*other) as uint)
}
#[cfg(stage0)]
pure fn ne(other: &Proto) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &Proto) -> bool { !(*self).eq(other) }
}
@ -664,19 +464,9 @@ enum binop {
}
impl binop : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &binop) -> bool {
(self as uint) == ((*other) as uint)
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &binop) -> bool {
((*self) as uint) == ((*other) as uint)
}
#[cfg(stage0)]
pure fn ne(other: &binop) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &binop) -> bool { !(*self).eq(other) }
}
@ -691,43 +481,6 @@ enum unop {
}
impl unop : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &unop) -> bool {
match self {
box(e0a) => {
match (*other) {
box(e0b) => e0a == e0b,
_ => false
}
}
uniq(e0a) => {
match (*other) {
uniq(e0b) => e0a == e0b,
_ => false
}
}
deref => {
match (*other) {
deref => true,
_ => false
}
}
not => {
match (*other) {
not => true,
_ => false
}
}
neg => {
match (*other) {
neg => true,
_ => false
}
}
}
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &unop) -> bool {
match (*self) {
box(e0a) => {
@ -762,12 +515,6 @@ impl unop : cmp::Eq {
}
}
}
#[cfg(stage0)]
pure fn ne(other: &unop) -> bool {
!self.eq(other)
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &unop) -> bool {
!(*self).eq(other)
}
@ -795,25 +542,6 @@ impl<T: to_bytes::IterBytes> inferable<T> : to_bytes::IterBytes {
}
impl<T:cmp::Eq> inferable<T> : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &inferable<T>) -> bool {
match self {
expl(e0a) => {
match (*other) {
expl(e0b) => e0a == e0b,
_ => false
}
}
infer(e0a) => {
match (*other) {
infer(e0b) => e0a == e0b,
_ => false
}
}
}
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &inferable<T>) -> bool {
match (*self) {
expl(e0a) => {
@ -830,10 +558,6 @@ impl<T:cmp::Eq> inferable<T> : cmp::Eq {
}
}
}
#[cfg(stage0)]
pure fn ne(other: &inferable<T>) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &inferable<T>) -> bool { !(*self).eq(other) }
}
@ -850,19 +574,9 @@ impl rmode : to_bytes::IterBytes {
impl rmode : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &rmode) -> bool {
(self as uint) == ((*other) as uint)
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &rmode) -> bool {
((*self) as uint) == ((*other) as uint)
}
#[cfg(stage0)]
pure fn ne(other: &rmode) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &rmode) -> bool { !(*self).eq(other) }
}
@ -913,17 +627,6 @@ type field = spanned<field_>;
enum blk_check_mode { default_blk, unsafe_blk, }
impl blk_check_mode : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &blk_check_mode) -> bool {
match (self, (*other)) {
(default_blk, default_blk) => true,
(unsafe_blk, unsafe_blk) => true,
(default_blk, _) => false,
(unsafe_blk, _) => false,
}
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &blk_check_mode) -> bool {
match ((*self), (*other)) {
(default_blk, default_blk) => true,
@ -932,10 +635,6 @@ impl blk_check_mode : cmp::Eq {
(unsafe_blk, _) => false,
}
}
#[cfg(stage0)]
pure fn ne(other: &blk_check_mode) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &blk_check_mode) -> bool { !(*self).eq(other) }
}
@ -1152,35 +851,6 @@ enum lit_ {
}
impl ast::lit_: cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &ast::lit_) -> bool {
match (self, *other) {
(lit_str(a), lit_str(b)) => a == b,
(lit_int(val_a, ty_a), lit_int(val_b, ty_b)) => {
val_a == val_b && ty_a == ty_b
}
(lit_uint(val_a, ty_a), lit_uint(val_b, ty_b)) => {
val_a == val_b && ty_a == ty_b
}
(lit_int_unsuffixed(a), lit_int_unsuffixed(b)) => a == b,
(lit_float(val_a, ty_a), lit_float(val_b, ty_b)) => {
val_a == val_b && ty_a == ty_b
}
(lit_float_unsuffixed(a), lit_float_unsuffixed(b)) => a == b,
(lit_nil, lit_nil) => true,
(lit_bool(a), lit_bool(b)) => a == b,
(lit_str(_), _) => false,
(lit_int(*), _) => false,
(lit_uint(*), _) => false,
(lit_int_unsuffixed(*), _) => false,
(lit_float(*), _) => false,
(lit_float_unsuffixed(*), _) => false,
(lit_nil, _) => false,
(lit_bool(_), _) => false
}
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &ast::lit_) -> bool {
match ((*self), *other) {
(lit_str(a), lit_str(b)) => a == b,
@ -1207,10 +877,6 @@ impl ast::lit_: cmp::Eq {
(lit_bool(_), _) => false
}
}
#[cfg(stage0)]
pure fn ne(other: &ast::lit_) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &ast::lit_) -> bool { !(*self).eq(other) }
}
@ -1253,25 +919,6 @@ impl int_ty : to_bytes::IterBytes {
}
impl int_ty : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &int_ty) -> bool {
match (self, (*other)) {
(ty_i, ty_i) => true,
(ty_char, ty_char) => true,
(ty_i8, ty_i8) => true,
(ty_i16, ty_i16) => true,
(ty_i32, ty_i32) => true,
(ty_i64, ty_i64) => true,
(ty_i, _) => false,
(ty_char, _) => false,
(ty_i8, _) => false,
(ty_i16, _) => false,
(ty_i32, _) => false,
(ty_i64, _) => false,
}
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &int_ty) -> bool {
match ((*self), (*other)) {
(ty_i, ty_i) => true,
@ -1288,10 +935,6 @@ impl int_ty : cmp::Eq {
(ty_i64, _) => false,
}
}
#[cfg(stage0)]
pure fn ne(other: &int_ty) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &int_ty) -> bool { !(*self).eq(other) }
}
@ -1306,23 +949,6 @@ impl uint_ty : to_bytes::IterBytes {
}
impl uint_ty : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &uint_ty) -> bool {
match (self, (*other)) {
(ty_u, ty_u) => true,
(ty_u8, ty_u8) => true,
(ty_u16, ty_u16) => true,
(ty_u32, ty_u32) => true,
(ty_u64, ty_u64) => true,
(ty_u, _) => false,
(ty_u8, _) => false,
(ty_u16, _) => false,
(ty_u32, _) => false,
(ty_u64, _) => false
}
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &uint_ty) -> bool {
match ((*self), (*other)) {
(ty_u, ty_u) => true,
@ -1337,10 +963,6 @@ impl uint_ty : cmp::Eq {
(ty_u64, _) => false
}
}
#[cfg(stage0)]
pure fn ne(other: &uint_ty) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &uint_ty) -> bool { !(*self).eq(other) }
}
@ -1354,25 +976,12 @@ impl float_ty : to_bytes::IterBytes {
}
}
impl float_ty : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &float_ty) -> bool {
match (self, (*other)) {
(ty_f, ty_f) | (ty_f32, ty_f32) | (ty_f64, ty_f64) => true,
(ty_f, _) | (ty_f32, _) | (ty_f64, _) => false
}
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &float_ty) -> bool {
match ((*self), (*other)) {
(ty_f, ty_f) | (ty_f32, ty_f32) | (ty_f64, ty_f64) => true,
(ty_f, _) | (ty_f32, _) | (ty_f64, _) => false
}
}
#[cfg(stage0)]
pure fn ne(other: &float_ty) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &float_ty) -> bool { !(*self).eq(other) }
}
@ -1392,43 +1001,6 @@ enum prim_ty {
}
impl prim_ty : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &prim_ty) -> bool {
match self {
ty_int(e0a) => {
match (*other) {
ty_int(e0b) => e0a == e0b,
_ => false
}
}
ty_uint(e0a) => {
match (*other) {
ty_uint(e0b) => e0a == e0b,
_ => false
}
}
ty_float(e0a) => {
match (*other) {
ty_float(e0b) => e0a == e0b,
_ => false
}
}
ty_str => {
match (*other) {
ty_str => true,
_ => false
}
}
ty_bool => {
match (*other) {
ty_bool => true,
_ => false
}
}
}
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &prim_ty) -> bool {
match (*self) {
ty_int(e0a) => {
@ -1463,10 +1035,6 @@ impl prim_ty : cmp::Eq {
}
}
}
#[cfg(stage0)]
pure fn ne(other: &prim_ty) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &prim_ty) -> bool { !(*self).eq(other) }
}
@ -1491,27 +1059,12 @@ enum Onceness {
}
impl Onceness : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &Onceness) -> bool {
match (self, *other) {
(Once, Once) | (Many, Many) => true,
_ => false
}
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &Onceness) -> bool {
match ((*self), *other) {
(Once, Once) | (Many, Many) => true,
_ => false
}
}
#[cfg(stage0)]
pure fn ne(other: &Onceness) -> bool {
!self.eq(other)
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &Onceness) -> bool {
!(*self).eq(other)
}
@ -1553,21 +1106,9 @@ enum ty_ {
// Equality and byte-iter (hashing) can be quite approximate for AST types.
// since we only care about this for normalizing them to "real" types.
impl Ty : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &Ty) -> bool {
ptr::addr_of(&self) == ptr::addr_of(&(*other))
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &Ty) -> bool {
ptr::addr_of(&(*self)) == ptr::addr_of(&(*other))
}
#[cfg(stage0)]
pure fn ne(other: &Ty) -> bool {
ptr::addr_of(&self) != ptr::addr_of(&(*other))
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &Ty) -> bool {
ptr::addr_of(&(*self)) != ptr::addr_of(&(*other))
}
@ -1607,19 +1148,9 @@ impl purity : to_bytes::IterBytes {
}
impl purity : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &purity) -> bool {
(self as uint) == ((*other) as uint)
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &purity) -> bool {
((*self) as uint) == ((*other) as uint)
}
#[cfg(stage0)]
pure fn ne(other: &purity) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &purity) -> bool { !(*self).eq(other) }
}
@ -1638,17 +1169,6 @@ impl ret_style : to_bytes::IterBytes {
}
impl ret_style : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &ret_style) -> bool {
match (self, (*other)) {
(noreturn, noreturn) => true,
(return_val, return_val) => true,
(noreturn, _) => false,
(return_val, _) => false,
}
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &ret_style) -> bool {
match ((*self), (*other)) {
(noreturn, noreturn) => true,
@ -1657,10 +1177,6 @@ impl ret_style : cmp::Eq {
(return_val, _) => false,
}
}
#[cfg(stage0)]
pure fn ne(other: &ret_style) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &ret_style) -> bool { !(*self).eq(other) }
}
@ -1676,49 +1192,6 @@ enum self_ty_ {
}
impl self_ty_ : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &self_ty_) -> bool {
match self {
sty_static => {
match (*other) {
sty_static => true,
_ => false
}
}
sty_by_ref => {
match (*other) {
sty_by_ref => true,
_ => false
}
}
sty_value => {
match (*other) {
sty_value => true,
_ => false
}
}
sty_region(e0a) => {
match (*other) {
sty_region(e0b) => e0a == e0b,
_ => false
}
}
sty_box(e0a) => {
match (*other) {
sty_box(e0b) => e0a == e0b,
_ => false
}
}
sty_uniq(e0a) => {
match (*other) {
sty_uniq(e0b) => e0a == e0b,
_ => false
}
}
}
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &self_ty_) -> bool {
match (*self) {
sty_static => {
@ -1759,10 +1232,6 @@ impl self_ty_ : cmp::Eq {
}
}
}
#[cfg(stage0)]
pure fn ne(other: &self_ty_) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &self_ty_) -> bool { !(*self).eq(other) }
}
@ -1794,36 +1263,13 @@ enum foreign_abi {
enum foreign_mod_sort { named, anonymous }
impl foreign_mod_sort : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &foreign_mod_sort) -> bool {
(self as uint) == ((*other) as uint)
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &foreign_mod_sort) -> bool {
((*self) as uint) == ((*other) as uint)
}
#[cfg(stage0)]
pure fn ne(other: &foreign_mod_sort) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &foreign_mod_sort) -> bool { !(*self).eq(other) }
}
impl foreign_abi : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &foreign_abi) -> bool {
match (self, (*other)) {
(foreign_abi_rust_intrinsic, foreign_abi_rust_intrinsic) => true,
(foreign_abi_cdecl, foreign_abi_cdecl) => true,
(foreign_abi_stdcall, foreign_abi_stdcall) => true,
(foreign_abi_rust_intrinsic, _) => false,
(foreign_abi_cdecl, _) => false,
(foreign_abi_stdcall, _) => false,
}
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &foreign_abi) -> bool {
match ((*self), (*other)) {
(foreign_abi_rust_intrinsic, foreign_abi_rust_intrinsic) => true,
@ -1834,10 +1280,6 @@ impl foreign_abi : cmp::Eq {
(foreign_abi_stdcall, _) => false,
}
}
#[cfg(stage0)]
pure fn ne(other: &foreign_abi) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &foreign_abi) -> bool { !(*self).eq(other) }
}
@ -1886,19 +1328,9 @@ type path_list_ident = spanned<path_list_ident_>;
enum namespace { module_ns, type_value_ns }
impl namespace : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &namespace) -> bool {
(self as uint) == ((*other) as uint)
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &namespace) -> bool {
((*self) as uint) == ((*other) as uint)
}
#[cfg(stage0)]
pure fn ne(other: &namespace) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &namespace) -> bool { !(*self).eq(other) }
}
@ -1946,19 +1378,9 @@ type attribute = spanned<attribute_>;
enum attr_style { attr_outer, attr_inner, }
impl attr_style : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &attr_style) -> bool {
(self as uint) == ((*other) as uint)
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &attr_style) -> bool {
((*self) as uint) == ((*other) as uint)
}
#[cfg(stage0)]
pure fn ne(other: &attr_style) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &attr_style) -> bool { !(*self).eq(other) }
}
@ -1985,19 +1407,6 @@ type trait_ref = {path: @path, ref_id: node_id, impl_id: node_id};
enum visibility { public, private, inherited }
impl visibility : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &visibility) -> bool {
match (self, (*other)) {
(public, public) => true,
(private, private) => true,
(inherited, inherited) => true,
(public, _) => false,
(private, _) => false,
(inherited, _) => false,
}
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &visibility) -> bool {
match ((*self), (*other)) {
(public, public) => true,
@ -2008,10 +1417,6 @@ impl visibility : cmp::Eq {
(inherited, _) => false,
}
}
#[cfg(stage0)]
pure fn ne(other: &visibility) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &visibility) -> bool { !(*self).eq(other) }
}
@ -2033,30 +1438,6 @@ enum struct_field_kind {
}
impl struct_field_kind : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &struct_field_kind) -> bool {
match self {
named_field(ident_a, class_mutability_a, visibility_a) => {
match *other {
named_field(ident_b, class_mutability_b, visibility_b)
=> {
ident_a == ident_b &&
class_mutability_a == class_mutability_b &&
visibility_a == visibility_b
}
unnamed_field => false
}
}
unnamed_field => {
match *other {
named_field(*) => false,
unnamed_field => true
}
}
}
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &struct_field_kind) -> bool {
match (*self) {
named_field(ident_a, class_mutability_a, visibility_a) => {
@ -2078,12 +1459,6 @@ impl struct_field_kind : cmp::Eq {
}
}
}
#[cfg(stage0)]
pure fn ne(other: &struct_field_kind) -> bool {
!self.eq(other)
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &struct_field_kind) -> bool {
!(*self).eq(other)
}
@ -2142,17 +1517,6 @@ impl class_mutability : to_bytes::IterBytes {
}
impl class_mutability : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &class_mutability) -> bool {
match (self, (*other)) {
(class_mutable, class_mutable) => true,
(class_immutable, class_immutable) => true,
(class_mutable, _) => false,
(class_immutable, _) => false,
}
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &class_mutability) -> bool {
match ((*self), (*other)) {
(class_mutable, class_mutable) => true,
@ -2161,10 +1525,6 @@ impl class_mutability : cmp::Eq {
(class_immutable, _) => false,
}
}
#[cfg(stage0)]
pure fn ne(other: &class_mutability) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &class_mutability) -> bool { !(*self).eq(other) }
}

23
src/libsyntax/ast_map.rs
View file

@ -12,25 +12,6 @@ enum path_elt {
}
impl path_elt : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &path_elt) -> bool {
match self {
path_mod(e0a) => {
match (*other) {
path_mod(e0b) => e0a == e0b,
_ => false
}
}
path_name(e0a) => {
match (*other) {
path_name(e0b) => e0a == e0b,
_ => false
}
}
}
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &path_elt) -> bool {
match (*self) {
path_mod(e0a) => {
@ -47,10 +28,6 @@ impl path_elt : cmp::Eq {
}
}
}
#[cfg(stage0)]
pure fn ne(other: &path_elt) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &path_elt) -> bool { !(*self).eq(other) }
}

10
src/libsyntax/attr.rs
View file

@ -338,19 +338,9 @@ enum inline_attr {
}
impl inline_attr : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &inline_attr) -> bool {
(self as uint) == ((*other) as uint)
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &inline_attr) -> bool {
((*self) as uint) == ((*other) as uint)
}
#[cfg(stage0)]
pure fn ne(other: &inline_attr) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &inline_attr) -> bool { !(*self).eq(other) }
}

46
src/libsyntax/codemap.rs
View file

@ -37,29 +37,11 @@ impl BytePos: Pos {
pure fn to_uint(&self) -> uint { **self }
}
#[cfg(stage0)]
impl BytePos: cmp::Eq {
pure fn eq(other: &BytePos) -> bool { *self == **other }
pure fn ne(other: &BytePos) -> bool { !self.eq(other) }
}
#[cfg(stage1)]
#[cfg(stage2)]
impl BytePos: cmp::Eq {
pure fn eq(&self, other: &BytePos) -> bool { **self == **other }
pure fn ne(&self, other: &BytePos) -> bool { !(*self).eq(other) }
}
#[cfg(stage0)]
impl BytePos: cmp::Ord {
pure fn lt(other: &BytePos) -> bool { *self < **other }
pure fn le(other: &BytePos) -> bool { *self <= **other }
pure fn ge(other: &BytePos) -> bool { *self >= **other }
pure fn gt(other: &BytePos) -> bool { *self > **other }
}
#[cfg(stage1)]
#[cfg(stage2)]
impl BytePos: cmp::Ord {
pure fn lt(&self, other: &BytePos) -> bool { **self < **other }
pure fn le(&self, other: &BytePos) -> bool { **self <= **other }
@ -101,29 +83,11 @@ impl CharPos: Pos {
pure fn to_uint(&self) -> uint { **self }
}
#[cfg(stage0)]
impl CharPos: cmp::Eq {
pure fn eq(other: &CharPos) -> bool { *self == **other }
pure fn ne(other: &CharPos) -> bool { !self.eq(other) }
}
#[cfg(stage1)]
#[cfg(stage2)]
impl CharPos: cmp::Eq {
pure fn eq(&self, other: &CharPos) -> bool { **self == **other }
pure fn ne(&self, other: &CharPos) -> bool { !(*self).eq(other) }
}
#[cfg(stage0)]
impl CharPos: cmp::Ord {
pure fn lt(other: &CharPos) -> bool { *self < **other }
pure fn le(other: &CharPos) -> bool { *self <= **other }
pure fn ge(other: &CharPos) -> bool { *self >= **other }
pure fn gt(other: &CharPos) -> bool { *self > **other }
}
#[cfg(stage1)]
#[cfg(stage2)]
impl CharPos: cmp::Ord {
pure fn lt(&self, other: &CharPos) -> bool { **self < **other }
pure fn le(&self, other: &CharPos) -> bool { **self <= **other }
@ -173,19 +137,9 @@ pub struct span {
}
impl span : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &span) -> bool {
return self.lo == (*other).lo && self.hi == (*other).hi;
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &span) -> bool {
return (*self).lo == (*other).lo && (*self).hi == (*other).hi;
}
#[cfg(stage0)]
pure fn ne(other: &span) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &span) -> bool { !(*self).eq(other) }
}

10
src/libsyntax/diagnostic.rs
View file

@ -149,19 +149,9 @@ enum level {
}
impl level : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &level) -> bool {
(self as uint) == ((*other) as uint)
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &level) -> bool {
((*self) as uint) == ((*other) as uint)
}
#[cfg(stage0)]
pure fn ne(other: &level) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &level) -> bool { !(*self).eq(other) }
}

15
src/libsyntax/ext/pipes/proto.rs
View file

@ -6,17 +6,6 @@ use ast_builder::{path, append_types};
enum direction { send, recv }
impl direction : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &direction) -> bool {
match (self, (*other)) {
(send, send) => true,
(recv, recv) => true,
(send, _) => false,
(recv, _) => false,
}
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &direction) -> bool {
match ((*self), (*other)) {
(send, send) => true,
@ -25,10 +14,6 @@ impl direction : cmp::Eq {
(recv, _) => false,
}
}
#[cfg(stage0)]
pure fn ne(other: &direction) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &direction) -> bool { !(*self).eq(other) }
}

12
src/libsyntax/parse/comments.rs
View file

@ -20,21 +20,9 @@ enum cmnt_style {
}
impl cmnt_style : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &cmnt_style) -> bool {
(self as uint) == ((*other) as uint)
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &cmnt_style) -> bool {
((*self) as uint) == ((*other) as uint)
}
#[cfg(stage0)]
pure fn ne(other: &cmnt_style) -> bool {
(self as uint) != ((*other) as uint)
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &cmnt_style) -> bool {
((*self) as uint) != ((*other) as uint)
}

12
src/libsyntax/parse/obsolete.rs
View file

@ -29,21 +29,9 @@ pub enum ObsoleteSyntax {
}
impl ObsoleteSyntax : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &ObsoleteSyntax) -> bool {
self as uint == (*other) as uint
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &ObsoleteSyntax) -> bool {
(*self) as uint == (*other) as uint
}
#[cfg(stage0)]
pure fn ne(other: &ObsoleteSyntax) -> bool {
!self.eq(other)
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &ObsoleteSyntax) -> bool {
!(*self).eq(other)
}

10
src/libsyntax/parse/parser.rs
View file

@ -3747,19 +3747,9 @@ impl Parser {
}
impl restriction : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &restriction) -> bool {
(self as uint) == ((*other) as uint)
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &restriction) -> bool {
((*self) as uint) == ((*other) as uint)
}
#[cfg(stage0)]
pure fn ne(other: &restriction) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &restriction) -> bool { !(*self).eq(other) }
}

285
src/libsyntax/parse/token.rs
View file

@ -463,294 +463,13 @@ fn reserved_keyword_table() -> HashMap<~str, ()> {
}
impl binop : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &binop) -> bool {
(self as uint) == ((*other) as uint)
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &binop) -> bool {
((*self) as uint) == ((*other) as uint)
}
#[cfg(stage0)]
pure fn ne(other: &binop) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &binop) -> bool { !(*self).eq(other) }
}
impl Token : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &Token) -> bool {
match self {
EQ => {
match (*other) {
EQ => true,
_ => false
}
}
LT => {
match (*other) {
LT => true,
_ => false
}
}
LE => {
match (*other) {
LE => true,
_ => false
}
}
EQEQ => {
match (*other) {
EQEQ => true,
_ => false
}
}
NE => {
match (*other) {
NE => true,
_ => false
}
}
GE => {
match (*other) {
GE => true,
_ => false
}
}
GT => {
match (*other) {
GT => true,
_ => false
}
}
ANDAND => {
match (*other) {
ANDAND => true,
_ => false
}
}
OROR => {
match (*other) {
OROR => true,
_ => false
}
}
NOT => {
match (*other) {
NOT => true,
_ => false
}
}
TILDE => {
match (*other) {
TILDE => true,
_ => false
}
}
BINOP(e0a) => {
match (*other) {
BINOP(e0b) => e0a == e0b,
_ => false
}
}
BINOPEQ(e0a) => {
match (*other) {
BINOPEQ(e0b) => e0a == e0b,
_ => false
}
}
AT => {
match (*other) {
AT => true,
_ => false
}
}
DOT => {
match (*other) {
DOT => true,
_ => false
}
}
DOTDOT => {
match (*other) {
DOTDOT => true,
_ => false
}
}
ELLIPSIS => {
match (*other) {
ELLIPSIS => true,
_ => false
}
}
COMMA => {
match (*other) {
COMMA => true,
_ => false
}
}
SEMI => {
match (*other) {
SEMI => true,
_ => false
}
}
COLON => {
match (*other) {
COLON => true,
_ => false
}
}
MOD_SEP => {
match (*other) {
MOD_SEP => true,
_ => false
}
}
RARROW => {
match (*other) {
RARROW => true,
_ => false
}
}
LARROW => {
match (*other) {
LARROW => true,
_ => false
}
}
DARROW => {
match (*other) {
DARROW => true,
_ => false
}
}
FAT_ARROW => {
match (*other) {
FAT_ARROW => true,
_ => false
}
}
LPAREN => {
match (*other) {
LPAREN => true,
_ => false
}
}
RPAREN => {
match (*other) {
RPAREN => true,
_ => false
}
}
LBRACKET => {
match (*other) {
LBRACKET => true,
_ => false
}
}
RBRACKET => {
match (*other) {
RBRACKET => true,
_ => false
}
}
LBRACE => {
match (*other) {
LBRACE => true,
_ => false
}
}
RBRACE => {
match (*other) {
RBRACE => true,
_ => false
}
}
POUND => {
match (*other) {
POUND => true,
_ => false
}
}
DOLLAR => {
match (*other) {
DOLLAR => true,
_ => false
}
}
LIT_INT(e0a, e1a) => {
match (*other) {
LIT_INT(e0b, e1b) => e0a == e0b && e1a == e1b,
_ => false
}
}
LIT_UINT(e0a, e1a) => {
match (*other) {
LIT_UINT(e0b, e1b) => e0a == e0b && e1a == e1b,
_ => false
}
}
LIT_INT_UNSUFFIXED(e0a) => {
match (*other) {
LIT_INT_UNSUFFIXED(e0b) => e0a == e0b,
_ => false
}
}
LIT_FLOAT(e0a, e1a) => {
match (*other) {
LIT_FLOAT(e0b, e1b) => e0a == e0b && e1a == e1b,
_ => false
}
}
LIT_FLOAT_UNSUFFIXED(e0a) => {
match (*other) {
LIT_FLOAT_UNSUFFIXED(e0b) => e0a == e0b,
_ => false
}
}
LIT_STR(e0a) => {
match (*other) {
LIT_STR(e0b) => e0a == e0b,
_ => false
}
}
IDENT(e0a, e1a) => {
match (*other) {
IDENT(e0b, e1b) => e0a == e0b && e1a == e1b,
_ => false
}
}
UNDERSCORE => {
match (*other) {
UNDERSCORE => true,
_ => false
}
}
INTERPOLATED(_) => {
match (*other) {
INTERPOLATED(_) => true,
_ => false
}
}
DOC_COMMENT(e0a) => {
match (*other) {
DOC_COMMENT(e0b) => e0a == e0b,
_ => false
}
}
EOF => {
match (*other) {
EOF => true,
_ => false
}
}
}
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &Token) -> bool {
match (*self) {
EQ => {
@ -1019,10 +738,6 @@ impl Token : cmp::Eq {
}
}
}
#[cfg(stage0)]
pure fn ne(other: &Token) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &Token) -> bool { !(*self).eq(other) }
}

15
src/libsyntax/print/pp.rs
View file

@ -56,17 +56,6 @@ use dvec::DVec;
enum breaks { consistent, inconsistent, }
impl breaks : cmp::Eq {
#[cfg(stage0)]
pure fn eq(other: &breaks) -> bool {
match (self, (*other)) {
(consistent, consistent) => true,
(inconsistent, inconsistent) => true,
(consistent, _) => false,
(inconsistent, _) => false,
}
}
#[cfg(stage1)]
#[cfg(stage2)]
pure fn eq(&self, other: &breaks) -> bool {
match ((*self), (*other)) {
(consistent, consistent) => true,
@ -75,10 +64,6 @@ impl breaks : cmp::Eq {
(inconsistent, _) => false,
}
}
#[cfg(stage0)]
pure fn ne(other: &breaks) -> bool { !self.eq(other) }
#[cfg(stage1)]
#[cfg(stage2)]
pure fn ne(&self, other: &breaks) -> bool { !(*self).eq(other) }
}

83
src/libsyntax/syntax.rc
View file

@ -1,5 +1,3 @@
// DIVERT
#[link(name = "syntax",
vers = "0.5",
uuid = "9311401b-d6ea-4cd9-a1d9-61f89499c645")];
@ -42,116 +40,89 @@ mod fold;
mod util {
#[legacy_exports];
#[legacy_exports]
#[path = "util/interner.rs"]
mod interner;
}
mod parse {
#[legacy_exports];
export parser;
export common;
export lexer;
export token;
export comments;
export prec;
export classify;
export attr;
#[legacy_exports]
mod lexer;
#[legacy_exports]
mod parser;
#[legacy_exports]
mod token;
#[legacy_exports]
mod comments;
#[legacy_exports]
mod attr;
#[legacy_exports]
/// Common routines shared by parser mods
#[legacy_exports]
mod common;
/// Functions dealing with operator precedence
#[legacy_exports]
mod prec;
/// Routines the parser uses to classify AST nodes
#[legacy_exports]
mod classify;
/// Reporting obsolete syntax
#[legacy_exports]
mod obsolete;
}
#[merge = "parse/mod.rs"]
mod parse;
mod print {
#[legacy_exports];
#[legacy_exports]
#[path = "print/pp.rs"]
mod pp;
#[legacy_exports]
#[path = "print/pprust.rs"]
mod pprust;
}
mod ext {
#[legacy_exports];
#[legacy_exports]
#[path = "ext/base.rs"]
mod base;
#[legacy_exports]
#[path = "ext/expand.rs"]
mod expand;
#[legacy_exports]
#[path = "ext/qquote.rs"]
mod qquote;
#[path = "ext/quote.rs"]
mod quote;
#[path = "ext/deriving.rs"]
mod deriving;
#[legacy_exports]
#[path = "ext/build.rs"]
mod build;
mod tt {
#[legacy_exports];
#[legacy_exports]
#[path = "ext/tt/transcribe.rs"]
mod transcribe;
#[legacy_exports]
#[path = "ext/tt/macro_parser.rs"]
mod macro_parser;
#[legacy_exports]
#[path = "ext/tt/macro_rules.rs"]
mod macro_rules;
}
#[legacy_exports]
#[path = "ext/simplext.rs"]
mod simplext;
#[legacy_exports]
#[path = "ext/fmt.rs"]
mod fmt;
#[legacy_exports]
#[path = "ext/env.rs"]
mod env;
#[legacy_exports]
#[path = "ext/concat_idents.rs"]
mod concat_idents;
#[legacy_exports]
#[path = "ext/ident_to_str.rs"]
mod ident_to_str;
#[legacy_exports]
#[path = "ext/log_syntax.rs"]
mod log_syntax;
#[legacy_exports]
#[path = "ext/auto_serialize.rs"]
mod auto_serialize;
#[legacy_exports]
#[path = "ext/source_util.rs"]
mod source_util;
mod pipes {
#[legacy_exports];
#[legacy_exports]
mod ast_builder;
#[legacy_exports]
mod parse_proto;
#[legacy_exports]
mod pipec;
#[legacy_exports]
mod proto;
#[legacy_exports]
mod check;
#[legacy_exports]
mod liveness;
}
#[legacy_exports]
#[path = "ext/pipes.rs"]
#[merge = "ext/pipes/mod.rs"]
mod pipes;
#[legacy_exports]
#[path = "ext/trace_macros.rs"]
mod trace_macros;
}

8
src/snapshots.txt
View file

@ -1,3 +1,11 @@
S 2012-11-26 be6613e
winnt-i386 f800925ce98d23f842a03be65f01aae0dfa1e897
freebsd-x86_64 23462b234b8ff3c0b6d6f94e5952178dbcef3488
linux-i386 e5fc408495952b61c3c103265cf1f54e2ab51e05
linux-x86_64 beb6454c57267c9fb198e4f0f8d4773e28f5bdf4
macos-i386 46b83a3fec0731198e010827c6842f2854cc79df
macos-x86_64 d06b16853e2a81fa5edb7fb2de73e6665c1ccd28
S 2012-11-18 68c73dc
freebsd-x86_64 976e75614c455557e3763e270cbf7b5fce1c5c67
linux-i386 d44088ce7183622921626038becf9c5e2d76cb66