make `in` and `foreach` get treated as keywords

6 files changed, 26 insertions, 26 deletions

diff --git a/src/libsyntax/ext/asm.rs b/src/libsyntax/ext/asm.rs
index bf7cccdc9ef..ee0ec664e1b 100644
--- a/src/libsyntax/ext/asm.rs
+++ b/src/libsyntax/ext/asm.rs
@@ -95,10 +95,10 @@ pub fn expand_asm(cx: @ExtCtxt, sp: span, tts: &[ast::token_tree])
 
                     let constraint = p.parse_str();
                     p.expect(&token::LPAREN);
-                    let in = p.parse_expr();
+                    let input = p.parse_expr();
                     p.expect(&token::RPAREN);
 
-                    inputs.push((constraint, in));
+                    inputs.push((constraint, input));
                 }
             }
             Clobbers => {
diff --git a/src/libsyntax/ext/expand.rs b/src/libsyntax/ext/expand.rs
index 72bbc4a96c5..adf014b3a29 100644
--- a/src/libsyntax/ext/expand.rs
+++ b/src/libsyntax/ext/expand.rs
@@ -750,16 +750,16 @@ pub fn std_macros() -> @str {
 
     macro_rules! condition (
 
-        { pub $c:ident: $in:ty -> $out:ty; } => {
+        { pub $c:ident: $input:ty -> $out:ty; } => {
 
             pub mod $c {
                 #[allow(non_uppercase_statics)];
                 static key: ::std::local_data::Key<
-                    @::std::condition::Handler<$in, $out>> =
+                    @::std::condition::Handler<$input, $out>> =
                     &::std::local_data::Key;
 
                 pub static cond :
-                    ::std::condition::Condition<$in,$out> =
+                    ::std::condition::Condition<$input,$out> =
                     ::std::condition::Condition {
                         name: stringify!($c),
                         key: key
@@ -767,17 +767,17 @@ pub fn std_macros() -> @str {
             }
         };
 
-        { $c:ident: $in:ty -> $out:ty; } => {
+        { $c:ident: $input:ty -> $out:ty; } => {
 
             // FIXME (#6009): remove mod's `pub` below once variant above lands.
             pub mod $c {
                 #[allow(non_uppercase_statics)];
                 static key: ::std::local_data::Key<
-                    @::std::condition::Handler<$in, $out>> =
+                    @::std::condition::Handler<$input, $out>> =
                     &::std::local_data::Key;
 
                 pub static cond :
-                    ::std::condition::Condition<$in,$out> =
+                    ::std::condition::Condition<$input,$out> =
                     ::std::condition::Condition {
                         name: stringify!($c),
                         key: key
diff --git a/src/libsyntax/fold.rs b/src/libsyntax/fold.rs
index 3016ee660dc..e3ca36ac12d 100644
--- a/src/libsyntax/fold.rs
+++ b/src/libsyntax/fold.rs
@@ -626,7 +626,7 @@ pub fn noop_fold_expr(e: &expr_, fld: @ast_fold) -> expr_ {
         }
         expr_inline_asm(ref a) => {
             expr_inline_asm(inline_asm {
-                inputs: a.inputs.map(|&(c, in)| (c, fld.fold_expr(in))),
+                inputs: a.inputs.map(|&(c, input)| (c, fld.fold_expr(input))),
                 outputs: a.outputs.map(|&(c, out)| (c, fld.fold_expr(out))),
                 .. (*a).clone()
             })
diff --git a/src/libsyntax/parse/token.rs b/src/libsyntax/parse/token.rs
index 8d979990b31..500d2b1c640 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) {
@@ -471,10 +471,10 @@ fn mk_fresh_ident_interner() -> @ident_interner {
         "unsafe",             // 61
         "use",                // 62
         "while",              // 63
+        "in",                 // 64
+        "foreach",            // 65
 
-        "be",                 // 64
-        "in",                 // 65
-        "foreach",            // 66
+        "be",                 // 66
     ];
 
     @ident_interner {
@@ -615,10 +615,10 @@ pub mod keywords {
                 False => ident { name: 39, ctxt: 0 },
                 Fn => ident { name: 40, ctxt: 0 },
                 For => ident { name: 41, ctxt: 0 },
-                ForEach => ident { name: 66, ctxt: 0 },
+                ForEach => ident { name: 65, ctxt: 0 },
                 If => ident { name: 42, ctxt: 0 },
                 Impl => ident { name: 43, ctxt: 0 },
-                In => ident { name: 65, ctxt: 0 },
+                In => ident { name: 64, ctxt: 0 },
                 Let => ident { name: 44, ctxt: 0 },
                 __Log => ident { name: 45, ctxt: 0 },
                 Loop => ident { name: 46, ctxt: 0 },
@@ -641,7 +641,7 @@ pub mod keywords {
                 Unsafe => ident { name: 61, ctxt: 0 },
                 Use => ident { name: 62, ctxt: 0 },
                 While => ident { name: 63, ctxt: 0 },
-                Be => ident { name: 64, ctxt: 0 },
+                Be => ident { name: 66, ctxt: 0 },
             }
         }
     }
@@ -657,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 .. 64 => true,
+            8 | 27 | 32 .. 66 => true,
             _ => false,
         },
         _ => false
@@ -667,7 +667,7 @@ pub fn is_any_keyword(tok: &Token) -> bool {
 pub fn is_strict_keyword(tok: &Token) -> bool {
     match *tok {
         token::IDENT(sid, false) => match sid.name {
-            8 | 27 | 32 .. 63 => true,
+            8 | 27 | 32 .. 65 => true,
             _ => false,
         },
         _ => false,
@@ -677,7 +677,7 @@ 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 {
-            64 => true,
+            66 => true,
             _ => false,
         },
         _ => false,
diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs
index 4fab3c5779e..7e0e63a29ac 100644
--- a/src/libsyntax/print/pprust.rs
+++ b/src/libsyntax/print/pprust.rs
@@ -108,14 +108,14 @@ pub fn print_crate(cm: @CodeMap,
                    span_diagnostic: @diagnostic::span_handler,
                    crate: &ast::Crate,
                    filename: @str,
-                   in: @io::Reader,
+                   input: @io::Reader,
                    out: @io::Writer,
                    ann: pp_ann,
                    is_expanded: bool) {
     let (cmnts, lits) = comments::gather_comments_and_literals(
         span_diagnostic,
         filename,
-        in
+        input
     );
     let s = @ps {
         s: pp::mk_printer(out, default_columns),
diff --git a/src/libsyntax/visit.rs b/src/libsyntax/visit.rs
index 990aaa99b78..07749c7254b 100644
--- a/src/libsyntax/visit.rs
+++ b/src/libsyntax/visit.rs
@@ -563,8 +563,8 @@ pub fn visit_expr<E:Clone>(ex: @expr, (e, v): (E, vt<E>)) {
         expr_mac(ref mac) => visit_mac(mac, (e.clone(), v)),
         expr_paren(x) => (v.visit_expr)(x, (e.clone(), v)),
         expr_inline_asm(ref a) => {
-            for a.inputs.iter().advance |&(_, in)| {
-                (v.visit_expr)(in, (e.clone(), v));
+            for a.inputs.iter().advance |&(_, input)| {
+                (v.visit_expr)(input, (e.clone(), v));
             }
             for a.outputs.iter().advance |&(_, out)| {
                 (v.visit_expr)(out, (e.clone(), v));