rustc: De-mode all overloaded operators

4 files changed, 308 insertions, 0 deletions

diff --git a/src/libsyntax/parse/comments.rs b/src/libsyntax/parse/comments.rs
index 7fcf7a032dc..214b9e3fbbd 100644
--- a/src/libsyntax/parse/comments.rs
+++ b/src/libsyntax/parse/comments.rs
@@ -17,6 +17,7 @@ enum cmnt_style {
     blank_line, // Just a manual blank line "\n\n", for layout
 }
 
+#[cfg(stage0)]
 impl cmnt_style : cmp::Eq {
     pure fn eq(&&other: cmnt_style) -> bool {
         (self as uint) == (other as uint)
@@ -25,6 +26,16 @@ impl cmnt_style : cmp::Eq {
         (self as uint) != (other as uint)
     }
 }
+#[cfg(stage1)]
+#[cfg(stage2)]
+impl cmnt_style : cmp::Eq {
+    pure fn eq(other: &cmnt_style) -> bool {
+        (self as uint) == ((*other) as uint)
+    }
+    pure fn ne(other: &cmnt_style) -> bool {
+        (self as uint) != ((*other) as uint)
+    }
+}
 
 type cmnt = {style: cmnt_style, lines: ~[~str], pos: uint};
 
diff --git a/src/libsyntax/parse/obsolete.rs b/src/libsyntax/parse/obsolete.rs
index 5b0fd67ae50..3891e7b6d17 100644
--- a/src/libsyntax/parse/obsolete.rs
+++ b/src/libsyntax/parse/obsolete.rs
@@ -24,6 +24,7 @@ pub enum ObsoleteSyntax {
     ObsoletePrivSection
 }
 
+#[cfg(stage0)]
 impl ObsoleteSyntax : cmp::Eq {
     pure fn eq(&&other: ObsoleteSyntax) -> bool {
         self as uint == other as uint
@@ -32,6 +33,16 @@ impl ObsoleteSyntax : cmp::Eq {
         !self.eq(other)
     }
 }
+#[cfg(stage1)]
+#[cfg(stage2)]
+impl ObsoleteSyntax : cmp::Eq {
+    pure fn eq(other: &ObsoleteSyntax) -> bool {
+        self as uint == (*other) as uint
+    }
+    pure fn ne(other: &ObsoleteSyntax) -> bool {
+        !self.eq(other)
+    }
+}
 
 impl ObsoleteSyntax: to_bytes::IterBytes {
     #[inline(always)]
diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs
index a1c1208d21c..a6ad5b35484 100644
--- a/src/libsyntax/parse/parser.rs
+++ b/src/libsyntax/parse/parser.rs
@@ -3647,12 +3647,21 @@ impl parser {
     }
 }
 
+#[cfg(stage0)]
 impl restriction : cmp::Eq {
     pure fn eq(&&other: restriction) -> bool {
         (self as uint) == (other as uint)
     }
     pure fn ne(&&other: restriction) -> bool { !self.eq(other) }
 }
+#[cfg(stage1)]
+#[cfg(stage2)]
+impl restriction : cmp::Eq {
+    pure fn eq(other: &restriction) -> bool {
+        (self as uint) == ((*other) as uint)
+    }
+    pure fn ne(other: &restriction) -> bool { !self.eq(other) }
+}
 
 //
 // Local Variables:
diff --git a/src/libsyntax/parse/token.rs b/src/libsyntax/parse/token.rs
index 5629907ff14..d04a65fd2db 100644
--- a/src/libsyntax/parse/token.rs
+++ b/src/libsyntax/parse/token.rs
@@ -435,13 +435,23 @@ fn reserved_keyword_table() -> HashMap<~str, ()> {
     words
 }
 
+#[cfg(stage0)]
 impl binop : cmp::Eq {
     pure fn eq(&&other: binop) -> bool {
         (self as uint) == (other as uint)
     }
     pure fn ne(&&other: binop) -> bool { !self.eq(other) }
 }
+#[cfg(stage1)]
+#[cfg(stage2)]
+impl binop : cmp::Eq {
+    pure fn eq(other: &binop) -> bool {
+        (self as uint) == ((*other) as uint)
+    }
+    pure fn ne(other: &binop) -> bool { !self.eq(other) }
+}
 
+#[cfg(stage0)]
 impl token : cmp::Eq {
     pure fn eq(&&other: token) -> bool {
         match self {
@@ -707,6 +717,273 @@ impl token : cmp::Eq {
     }
     pure fn ne(&&other: token) -> bool { !self.eq(other) }
 }
+#[cfg(stage1)]
+#[cfg(stage2)]
+impl token : cmp::Eq {
+    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_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
+                }
+            }
+        }
+    }
+    pure fn ne(other: &token) -> bool { !self.eq(other) }
+}
 
 // Local Variables:
 // fill-column: 78;