auto merge of #8162 : thestinger/rust/no-copy, r=brson

3 files changed, 71 insertions, 102 deletions

diff --git a/src/libsyntax/parse/obsolete.rs b/src/libsyntax/parse/obsolete.rs
index 7e0081bdb68..3472b9f1d67 100644
--- a/src/libsyntax/parse/obsolete.rs
+++ b/src/libsyntax/parse/obsolete.rs
@@ -30,7 +30,6 @@ use std::to_bytes;
 /// The specific types of unsupported syntax
 #[deriving(Eq)]
 pub enum ObsoleteSyntax {
-    ObsoleteLowerCaseKindBounds,
     ObsoleteLet,
     ObsoleteFieldTerminator,
     ObsoleteStructCtor,
@@ -96,12 +95,6 @@ impl ParserObsoleteMethods for Parser {
     /// Reports an obsolete syntax non-fatal error.
     pub fn obsolete(&self, sp: span, kind: ObsoleteSyntax) {
         let (kind_str, desc) = match kind {
-            ObsoleteLowerCaseKindBounds => (
-                "lower-case kind bounds",
-                "the `send`, `copy`, `const`, and `owned` \
-                 kinds are represented as traits now, and \
-                 should be camel cased"
-            ),
             ObsoleteLet => (
                 "`let` in field declaration",
                 "declare fields as `field: Type`"
diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs
index 6ff4b91ec97..9444c463686 100644
--- a/src/libsyntax/parse/parser.rs
+++ b/src/libsyntax/parse/parser.rs
@@ -71,7 +71,7 @@ use parse::lexer::TokenAndSpan;
 use parse::obsolete::{ObsoleteClassTraits};
 use parse::obsolete::{ObsoleteLet, ObsoleteFieldTerminator};
 use parse::obsolete::{ObsoleteMoveInit, ObsoleteBinaryMove, ObsoleteSwap};
-use parse::obsolete::{ObsoleteSyntax, ObsoleteLowerCaseKindBounds};
+use parse::obsolete::ObsoleteSyntax;
 use parse::obsolete::{ObsoleteUnsafeBlock, ObsoleteImplSyntax};
 use parse::obsolete::{ObsoleteMutOwnedPointer};
 use parse::obsolete::{ObsoleteMutVector, ObsoleteImplVisibility};
@@ -3309,30 +3309,8 @@ impl Parser {
                     self.bump();
                 }
                 token::MOD_SEP | token::IDENT(*) => {
-                    let obsolete_bound = match *self.token {
-                        token::MOD_SEP => false,
-                        token::IDENT(sid, _) => {
-                            match self.id_to_str(sid).as_slice() {
-                                "send" |
-                                "copy" |
-                                "const" |
-                                "owned" => {
-                                    self.obsolete(
-                                        *self.span,
-                                        ObsoleteLowerCaseKindBounds);
-                                    self.bump();
-                                    true
-                                }
-                                _ => false
-                            }
-                        }
-                        _ => fail!()
-                    };
-
-                    if !obsolete_bound {
-                        let tref = self.parse_trait_ref();
-                        result.push(TraitTyParamBound(tref));
-                    }
+                    let tref = self.parse_trait_ref();
+                    result.push(TraitTyParamBound(tref));
                 }
                 _ => break,
             }
diff --git a/src/libsyntax/parse/token.rs b/src/libsyntax/parse/token.rs
index a9f0db32d3e..3365222036c 100644
--- a/src/libsyntax/parse/token.rs
+++ b/src/libsyntax/parse/token.rs
@@ -125,7 +125,7 @@ pub fn binop_to_str(o: binop) -> ~str {
     }
 }
 
-pub fn to_str(in: @ident_interner, t: &Token) -> ~str {
+pub fn to_str(input: @ident_interner, t: &Token) -> ~str {
     match *t {
       EQ => ~"=",
       LT => ~"<",
@@ -195,8 +195,8 @@ pub fn to_str(in: @ident_interner, t: &Token) -> ~str {
       LIT_STR(ref s) => { fmt!("\"%s\"", ident_to_str(s).escape_default()) }
 
       /* Name components */
-      IDENT(s, _) => in.get(s.name).to_owned(),
-      LIFETIME(s) => fmt!("'%s", in.get(s.name)),
+      IDENT(s, _) => input.get(s.name).to_owned(),
+      LIFETIME(s) => fmt!("'%s", input.get(s.name)),
       UNDERSCORE => ~"_",
 
       /* Other */
@@ -204,7 +204,7 @@ pub fn to_str(in: @ident_interner, t: &Token) -> ~str {
       EOF => ~"<eof>",
       INTERPOLATED(ref nt) => {
         match nt {
-            &nt_expr(e) => ::print::pprust::expr_to_str(e, in),
+            &nt_expr(e) => ::print::pprust::expr_to_str(e, input),
             _ => {
                 ~"an interpolated " +
                     match (*nt) {
@@ -440,42 +440,41 @@ fn mk_fresh_ident_interner() -> @ident_interner {
         "as",                 // 32
         "break",              // 33
         "const",              // 34
-        "copy",               // 35
-        "do",                 // 36
-        "else",               // 37
-        "enum",               // 38
-        "extern",             // 39
-        "false",              // 40
-        "fn",                 // 41
-        "for",                // 42
-        "if",                 // 43
-        "impl",               // 44
-        "let",                // 45
-        "__log",              // 46
-        "loop",               // 47
-        "match",              // 48
-        "mod",                // 49
-        "mut",                // 50
-        "once",               // 51
-        "priv",               // 52
-        "pub",                // 53
-        "pure",               // 54
-        "ref",                // 55
-        "return",             // 56
+        "do",                 // 35
+        "else",               // 36
+        "enum",               // 37
+        "extern",             // 38
+        "false",              // 39
+        "fn",                 // 40
+        "for",                // 41
+        "if",                 // 42
+        "impl",               // 43
+        "let",                // 44
+        "__log",              // 45
+        "loop",               // 46
+        "match",              // 47
+        "mod",                // 48
+        "mut",                // 49
+        "once",               // 50
+        "priv",               // 51
+        "pub",                // 52
+        "ref",                // 53
+        "return",             // 54
         "static",             // 27 -- also a special ident
         "self",               //  8 -- also a special ident
-        "struct",             // 57
-        "super",              // 58
-        "true",               // 59
-        "trait",              // 60
-        "type",               // 61
-        "unsafe",             // 62
-        "use",                // 63
-        "while",              // 64
+        "struct",             // 55
+        "super",              // 56
+        "true",               // 57
+        "trait",              // 58
+        "type",               // 59
+        "unsafe",             // 60
+        "use",                // 61
+        "while",              // 62
+        "in",                 // 63
+        "foreach",            // 64
 
         "be",                 // 65
-        "in",                 // 66
-        "foreach",            // 67
+        "pure",               // 66
     ];
 
     @ident_interner {
@@ -609,39 +608,39 @@ pub mod keywords {
                 As => ident { name: 32, ctxt: 0 },
                 Break => ident { name: 33, ctxt: 0 },
                 Const => ident { name: 34, ctxt: 0 },
-                Do => ident { name: 36, ctxt: 0 },
-                Else => ident { name: 37, ctxt: 0 },
-                Enum => ident { name: 38, ctxt: 0 },
-                Extern => ident { name: 39, ctxt: 0 },
-                False => ident { name: 40, ctxt: 0 },
-                Fn => ident { name: 41, ctxt: 0 },
-                For => ident { name: 42, ctxt: 0 },
-                ForEach => ident { name: 67, ctxt: 0 },
-                If => ident { name: 43, ctxt: 0 },
-                Impl => ident { name: 44, ctxt: 0 },
-                In => ident { name: 66, ctxt: 0 },
-                Let => ident { name: 45, ctxt: 0 },
-                __Log => ident { name: 46, ctxt: 0 },
-                Loop => ident { name: 47, ctxt: 0 },
-                Match => ident { name: 48, ctxt: 0 },
-                Mod => ident { name: 49, ctxt: 0 },
-                Mut => ident { name: 50, ctxt: 0 },
-                Once => ident { name: 51, ctxt: 0 },
-                Priv => ident { name: 52, ctxt: 0 },
-                Pub => ident { name: 53, ctxt: 0 },
-                Pure => ident { name: 54, ctxt: 0 },
-                Ref => ident { name: 55, ctxt: 0 },
-                Return => ident { name: 56, ctxt: 0 },
+                Do => ident { name: 35, ctxt: 0 },
+                Else => ident { name: 36, ctxt: 0 },
+                Enum => ident { name: 37, ctxt: 0 },
+                Extern => ident { name: 38, ctxt: 0 },
+                False => ident { name: 39, ctxt: 0 },
+                Fn => ident { name: 40, ctxt: 0 },
+                For => ident { name: 41, ctxt: 0 },
+                ForEach => ident { name: 64, ctxt: 0 },
+                If => ident { name: 42, ctxt: 0 },
+                Impl => ident { name: 43, ctxt: 0 },
+                In => ident { name: 63, ctxt: 0 },
+                Let => ident { name: 44, ctxt: 0 },
+                __Log => ident { name: 45, ctxt: 0 },
+                Loop => ident { name: 46, ctxt: 0 },
+                Match => ident { name: 47, ctxt: 0 },
+                Mod => ident { name: 48, ctxt: 0 },
+                Mut => ident { name: 49, ctxt: 0 },
+                Once => ident { name: 50, ctxt: 0 },
+                Priv => ident { name: 51, ctxt: 0 },
+                Pub => ident { name: 52, ctxt: 0 },
+                Pure => ident { name: 66, ctxt: 0 },
+                Ref => ident { name: 53, ctxt: 0 },
+                Return => ident { name: 54, ctxt: 0 },
                 Static => ident { name: 27, ctxt: 0 },
                 Self => ident { name: 8, ctxt: 0 },
-                Struct => ident { name: 57, ctxt: 0 },
-                Super => ident { name: 58, ctxt: 0 },
-                True => ident { name: 59, ctxt: 0 },
-                Trait => ident { name: 60, ctxt: 0 },
-                Type => ident { name: 61, ctxt: 0 },
-                Unsafe => ident { name: 62, ctxt: 0 },
-                Use => ident { name: 63, ctxt: 0 },
-                While => ident { name: 64, ctxt: 0 },
+                Struct => ident { name: 55, ctxt: 0 },
+                Super => ident { name: 56, ctxt: 0 },
+                True => ident { name: 57, ctxt: 0 },
+                Trait => ident { name: 58, ctxt: 0 },
+                Type => ident { name: 59, ctxt: 0 },
+                Unsafe => ident { name: 60, ctxt: 0 },
+                Use => ident { name: 61, ctxt: 0 },
+                While => ident { name: 62, ctxt: 0 },
                 Be => ident { name: 65, ctxt: 0 },
             }
         }
@@ -658,7 +657,7 @@ pub fn is_keyword(kw: keywords::Keyword, tok: &Token) -> bool {
 pub fn is_any_keyword(tok: &Token) -> bool {
     match *tok {
         token::IDENT(sid, false) => match sid.name {
-            8 | 27 | 32 .. 65 => true,
+            8 | 27 | 32 .. 66 => true,
             _ => false,
         },
         _ => false
@@ -678,14 +677,13 @@ pub fn is_strict_keyword(tok: &Token) -> bool {
 pub fn is_reserved_keyword(tok: &Token) -> bool {
     match *tok {
         token::IDENT(sid, false) => match sid.name {
-            65 => true,
+            65 .. 66 => true,
             _ => false,
         },
         _ => false,
     }
 }
 
-
 #[cfg(test)]
 mod test {
     use super::*;