Remove '.' after nullary tags in patterns

Does what it says on the tin.

The next commit will remove support for this syntax.

4 files changed, 123 insertions, 123 deletions

diff --git a/src/comp/syntax/parse/eval.rs b/src/comp/syntax/parse/eval.rs
index 4e3f2711a2f..897cfe03e09 100644
--- a/src/comp/syntax/parse/eval.rs
+++ b/src/comp/syntax/parse/eval.rs
@@ -58,7 +58,7 @@ fn parse_companion_mod(cx: ctx, prefix: str, suffix: option::t<str>)
     fn companion_file(prefix: str, suffix: option::t<str>) -> str {
         ret alt suffix {
           option::some(s) { fs::connect(prefix, s) }
-          option::none. { prefix }
+          option::none { prefix }
         } + ".rs";
     }
 
@@ -93,7 +93,7 @@ fn cdir_path_opt(id: str, attrs: [ast::attribute]) -> str {
       some(d) {
         ret d;
       }
-      none. { ret id; }
+      none { ret id; }
     }
 }
 
diff --git a/src/comp/syntax/parse/lexer.rs b/src/comp/syntax/parse/lexer.rs
index c0aae11f212..176e70cc65a 100644
--- a/src/comp/syntax/parse/lexer.rs
+++ b/src/comp/syntax/parse/lexer.rs
@@ -240,7 +240,7 @@ fn scan_number(c: char, rdr: reader) -> token::token {
         is_float = true;
         num_str += s;
       }
-      none. {}
+      none {}
     }
     if rdr.curr == 'f' {
         rdr.bump();
diff --git a/src/comp/syntax/parse/parser.rs b/src/comp/syntax/parse/parser.rs
index 13804d735e4..7515a393ee9 100644
--- a/src/comp/syntax/parse/parser.rs
+++ b/src/comp/syntax/parse/parser.rs
@@ -489,7 +489,7 @@ fn parse_ty(p: parser, colons_before_params: bool) -> @ast::ty {
     } else if eat_word(p, "fn") {
         let proto = parse_fn_ty_proto(p);
         alt proto {
-          ast::proto_bare. { p.warn("fn is deprecated, use native fn"); }
+          ast::proto_bare { p.warn("fn is deprecated, use native fn"); }
           _ { /* fallthrough */ }
         }
         t = parse_ty_fn(proto, p);
@@ -625,7 +625,7 @@ fn lit_from_token(p: parser, tok: token::token) -> ast::lit_ {
       token::LIT_UINT(u, ut) { ast::lit_uint(u, ut) }
       token::LIT_FLOAT(s, ft) { ast::lit_float(p.get_str(s), ft) }
       token::LIT_STR(s) { ast::lit_str(p.get_str(s)) }
-      token::LPAREN. { expect(p, token::RPAREN); ast::lit_nil }
+      token::LPAREN { expect(p, token::RPAREN); ast::lit_nil }
       _ { unexpected(p, tok); }
     }
 }
@@ -703,7 +703,7 @@ fn mk_mac_expr(p: parser, lo: uint, hi: uint, m: ast::mac_) -> @ast::expr {
 }
 
 fn is_bar(t: token::token) -> bool {
-    alt t { token::BINOP(token::OR.) | token::OROR. { true } _ { false } }
+    alt t { token::BINOP(token::OR) | token::OROR { true } _ { false } }
 }
 
 fn mk_lit_u32(p: parser, i: u32) -> @ast::expr {
@@ -797,8 +797,8 @@ fn parse_bottom_expr(p: parser) -> pexpr {
     } else if eat_word(p, "fn") {
         let proto = parse_fn_ty_proto(p);
         alt proto {
-          ast::proto_bare. { p.fatal("fn expr are deprecated, use fn@"); }
-          ast::proto_any. { p.fatal("fn* cannot be used in an expression"); }
+          ast::proto_bare { p.fatal("fn expr are deprecated, use fn@"); }
+          ast::proto_any { p.fatal("fn* cannot be used in an expression"); }
           _ { /* fallthrough */ }
         }
         ret pexpr(parse_fn_expr(p, proto));
@@ -836,7 +836,7 @@ fn parse_bottom_expr(p: parser) -> pexpr {
         let e = parse_expr_res(p, RESTRICT_NO_CALL_EXPRS);
         fn parse_expr_opt(p: parser) -> option::t<@ast::expr> {
             alt p.token {
-              token::UNDERSCORE. { p.bump(); ret none; }
+              token::UNDERSCORE { p.bump(); ret none; }
               _ { ret some(parse_expr(p)); }
             }
         }
@@ -971,7 +971,7 @@ fn parse_dot_or_call_expr_with(p: parser, e0: pexpr) -> pexpr {
     while !expr_is_complete(p, e) {
         alt p.token {
           // expr(...)
-          token::LPAREN. if permits_call(p) {
+          token::LPAREN if permits_call(p) {
             let es = parse_seq(token::LPAREN, token::RPAREN,
                                seq_sep(token::COMMA), parse_expr, p);
             hi = es.span.hi;
@@ -980,7 +980,7 @@ fn parse_dot_or_call_expr_with(p: parser, e0: pexpr) -> pexpr {
           }
 
           // expr {|| ... }
-          token::LBRACE. if is_bar(p.look_ahead(1u)) && permits_call(p) {
+          token::LBRACE if is_bar(p.look_ahead(1u)) && permits_call(p) {
             p.bump();
             let blk = parse_fn_block_expr(p);
             alt e.node {
@@ -996,7 +996,7 @@ fn parse_dot_or_call_expr_with(p: parser, e0: pexpr) -> pexpr {
           }
 
           // expr[...]
-          token::LBRACKET. {
+          token::LBRACKET {
             p.bump();
             let ix = parse_expr(p);
             hi = ix.span.hi;
@@ -1005,7 +1005,7 @@ fn parse_dot_or_call_expr_with(p: parser, e0: pexpr) -> pexpr {
           }
 
           // expr.f
-          token::DOT. {
+          token::DOT {
             p.bump();
             alt p.token {
               token::IDENT(i, _) {
@@ -1037,7 +1037,7 @@ fn parse_prefix_expr(p: parser) -> pexpr {
 
     let ex;
     alt p.token {
-      token::NOT. {
+      token::NOT {
         p.bump();
         let e = to_expr(parse_prefix_expr(p));
         hi = e.span.hi;
@@ -1045,13 +1045,13 @@ fn parse_prefix_expr(p: parser) -> pexpr {
       }
       token::BINOP(b) {
         alt b {
-          token::MINUS. {
+          token::MINUS {
             p.bump();
             let e = to_expr(parse_prefix_expr(p));
             hi = e.span.hi;
             ex = ast::expr_unary(ast::neg, e);
           }
-          token::STAR. {
+          token::STAR {
             p.bump();
             let e = to_expr(parse_prefix_expr(p));
             hi = e.span.hi;
@@ -1060,14 +1060,14 @@ fn parse_prefix_expr(p: parser) -> pexpr {
           _ { ret parse_dot_or_call_expr(p); }
         }
       }
-      token::AT. {
+      token::AT {
         p.bump();
         let m = parse_mutability(p);
         let e = to_expr(parse_prefix_expr(p));
         hi = e.span.hi;
         ex = ast::expr_unary(ast::box(m), e);
       }
-      token::TILDE. {
+      token::TILDE {
         p.bump();
         let m = parse_mutability(p);
         let e = to_expr(parse_prefix_expr(p));
@@ -1157,7 +1157,7 @@ fn parse_assign_expr(p: parser) -> @ast::expr {
     let lo = p.span.lo;
     let lhs = parse_ternary(p);
     alt p.token {
-      token::EQ. {
+      token::EQ {
         p.bump();
         let rhs = parse_expr(p);
         ret mk_expr(p, lo, rhs.span.hi, ast::expr_assign(lhs, rhs));
@@ -1167,26 +1167,26 @@ fn parse_assign_expr(p: parser) -> @ast::expr {
         let rhs = parse_expr(p);
         let aop = ast::add;
         alt op {
-          token::PLUS. { aop = ast::add; }
-          token::MINUS. { aop = ast::subtract; }
-          token::STAR. { aop = ast::mul; }
-          token::SLASH. { aop = ast::div; }
-          token::PERCENT. { aop = ast::rem; }
-          token::CARET. { aop = ast::bitxor; }
-          token::AND. { aop = ast::bitand; }
-          token::OR. { aop = ast::bitor; }
-          token::LSL. { aop = ast::lsl; }
-          token::LSR. { aop = ast::lsr; }
-          token::ASR. { aop = ast::asr; }
+          token::PLUS { aop = ast::add; }
+          token::MINUS { aop = ast::subtract; }
+          token::STAR { aop = ast::mul; }
+          token::SLASH { aop = ast::div; }
+          token::PERCENT { aop = ast::rem; }
+          token::CARET { aop = ast::bitxor; }
+          token::AND { aop = ast::bitand; }
+          token::OR { aop = ast::bitor; }
+          token::LSL { aop = ast::lsl; }
+          token::LSR { aop = ast::lsr; }
+          token::ASR { aop = ast::asr; }
         }
         ret mk_expr(p, lo, rhs.span.hi, ast::expr_assign_op(aop, lhs, rhs));
       }
-      token::LARROW. {
+      token::LARROW {
         p.bump();
         let rhs = parse_expr(p);
         ret mk_expr(p, lo, rhs.span.hi, ast::expr_move(lhs, rhs));
       }
-      token::DARROW. {
+      token::DARROW {
         p.bump();
         let rhs = parse_expr(p);
         ret mk_expr(p, lo, rhs.span.hi, ast::expr_swap(lhs, rhs));
@@ -1363,11 +1363,11 @@ fn parse_expr_res(p: parser, r: restriction) -> @ast::expr {
 
 fn parse_initializer(p: parser) -> option::t<ast::initializer> {
     alt p.token {
-      token::EQ. {
+      token::EQ {
         p.bump();
         ret some({op: ast::init_assign, expr: parse_expr(p)});
       }
-      token::LARROW. {
+      token::LARROW {
         p.bump();
         ret some({op: ast::init_move, expr: parse_expr(p)});
       }
@@ -1398,20 +1398,20 @@ fn parse_pat(p: parser) -> @ast::pat {
     let hi = p.span.hi;
     let pat;
     alt p.token {
-      token::UNDERSCORE. { p.bump(); pat = ast::pat_wild; }
-      token::AT. {
+      token::UNDERSCORE { p.bump(); pat = ast::pat_wild; }
+      token::AT {
         p.bump();
         let sub = parse_pat(p);
         pat = ast::pat_box(sub);
         hi = sub.span.hi;
       }
-      token::TILDE. {
+      token::TILDE {
         p.bump();
         let sub = parse_pat(p);
         pat = ast::pat_uniq(sub);
         hi = sub.span.hi;
       }
-      token::LBRACE. {
+      token::LBRACE {
         p.bump();
         let fields = [];
         let etc = false;
@@ -1452,7 +1452,7 @@ fn parse_pat(p: parser) -> @ast::pat {
         p.bump();
         pat = ast::pat_rec(fields, etc);
       }
-      token::LPAREN. {
+      token::LPAREN {
         p.bump();
         if p.token == token::RPAREN {
             hi = p.span.hi;
@@ -1486,9 +1486,9 @@ fn parse_pat(p: parser) -> @ast::pat {
         } else if is_plain_ident(p) &&
                       alt p.look_ahead(1u) {
                     // Take this out once the libraries change
-                        token::DOT. |
-                        token::LPAREN. | token::LBRACKET. |
-                            token::LT. {
+                        token::DOT |
+                        token::LPAREN | token::LBRACKET |
+                            token::LT {
                           false
                         }
                         _ { true }
@@ -1501,7 +1501,7 @@ fn parse_pat(p: parser) -> @ast::pat {
             hi = tag_path.span.hi;
             let args: [@ast::pat];
             alt p.token {
-              token::LPAREN. {
+              token::LPAREN {
                 let a =
                     parse_seq(token::LPAREN, token::RPAREN,
                               seq_sep(token::COMMA), parse_pat, p);
@@ -1565,7 +1565,7 @@ fn parse_stmt(p: parser, first_item_attrs: [ast::attribute]) -> @ast::stmt {
     } else {
         let item_attrs;
         alt parse_outer_attrs_or_ext(p, first_item_attrs) {
-          none. { item_attrs = []; }
+          none { item_attrs = []; }
           some(left(attrs)) { item_attrs = attrs; }
           some(right(ext)) {
             ret @spanned(lo, ext.span.hi, ast::stmt_expr(ext, p.get_id()));
@@ -1692,7 +1692,7 @@ fn parse_block_tail_(p: parser, lo: uint, s: ast::blk_check_mode,
 
     while p.token != token::RBRACE {
         alt p.token {
-          token::SEMI. {
+          token::SEMI {
             p.bump(); // empty
           }
           _ {
@@ -1701,11 +1701,11 @@ fn parse_block_tail_(p: parser, lo: uint, s: ast::blk_check_mode,
             alt stmt.node {
               ast::stmt_expr(e, stmt_id) { // Expression without semicolon:
                 alt p.token {
-                  token::SEMI. {
+                  token::SEMI {
                     p.bump();
                     stmts += [@{node: ast::stmt_semi(e, stmt_id) with *stmt}];
                   }
-                  token::RBRACE. {
+                  token::RBRACE {
                     expr = some(e);
                   }
                   t {
@@ -1856,7 +1856,7 @@ fn parse_item_impl(p: parser, attrs: [ast::attribute]) -> @ast::item {
     } else { none };
     let ident = alt ident {
         some(name) { name }
-        none. { expect_word(p, "of"); fail; }
+        none { expect_word(p, "of"); fail; }
     };
     expect_word(p, "for");
     let ty = parse_ty(p, false), meths = [];
@@ -2059,7 +2059,7 @@ fn parse_item_tag(p: parser, attrs: [ast::attribute]) -> @ast::item {
             let vhi = p.span.hi;
             let disr_expr = none;
             alt p.token {
-              token::LPAREN. {
+              token::LPAREN {
                 all_nullary = false;
                 let arg_tys = parse_seq(token::LPAREN, token::RPAREN,
                                         seq_sep(token::COMMA),
@@ -2069,7 +2069,7 @@ fn parse_item_tag(p: parser, attrs: [ast::attribute]) -> @ast::item {
                 }
                 vhi = arg_tys.span.hi;
               }
-              token::EQ. {
+              token::EQ {
                 have_disr = true;
                 p.bump();
                 disr_expr = some(parse_expr(p));
@@ -2078,11 +2078,11 @@ fn parse_item_tag(p: parser, attrs: [ast::attribute]) -> @ast::item {
             }
 
             alt p.token {
-              token::SEMI. | token::COMMA. {
+              token::SEMI | token::COMMA {
                 p.bump();
                 if p.token == token::RBRACE { done = true; }
               }
-              token::RBRACE. { done = true; }
+              token::RBRACE { done = true; }
               _ { /* fall through */ }
             }
 
@@ -2107,19 +2107,19 @@ fn parse_item_tag(p: parser, attrs: [ast::attribute]) -> @ast::item {
 
 fn parse_fn_ty_proto(p: parser) -> ast::proto {
     alt p.token {
-      token::AT. {
+      token::AT {
         p.bump();
         ast::proto_box
       }
-      token::TILDE. {
+      token::TILDE {
         p.bump();
         ast::proto_uniq
       }
-      token::BINOP(token::AND.) {
+      token::BINOP(token::AND) {
         p.bump();
         ast::proto_block
       }
-      token::BINOP(token::STAR.) {
+      token::BINOP(token::STAR) {
         p.bump(); // temporary: fn* for any closure
         ast::proto_any
       }
@@ -2131,7 +2131,7 @@ fn parse_fn_ty_proto(p: parser) -> ast::proto {
 
 fn fn_expr_lookahead(tok: token::token) -> bool {
     alt tok {
-      token::LPAREN. | token::AT. | token::TILDE. | token::BINOP(_) {
+      token::LPAREN | token::AT | token::TILDE | token::BINOP(_) {
         true
       }
       _ {
@@ -2255,13 +2255,13 @@ fn parse_meta_item(p: parser) -> @ast::meta_item {
     let lo = p.span.lo;
     let ident = parse_ident(p);
     alt p.token {
-      token::EQ. {
+      token::EQ {
         p.bump();
         let lit = parse_lit(p);
         let hi = p.span.hi;
         ret @spanned(lo, hi, ast::meta_name_value(ident, lit));
       }
-      token::LPAREN. {
+      token::LPAREN {
         let inner_items = parse_meta_seq(p);
         let hi = p.span.hi;
         ret @spanned(lo, hi, ast::meta_list(ident, inner_items));
@@ -2279,7 +2279,7 @@ fn parse_meta_seq(p: parser) -> [@ast::meta_item] {
 }
 
 fn parse_optional_meta(p: parser) -> [@ast::meta_item] {
-    alt p.token { token::LPAREN. { ret parse_meta_seq(p); } _ { ret []; } }
+    alt p.token { token::LPAREN { ret parse_meta_seq(p); } _ { ret []; } }
 }
 
 fn parse_use(p: parser) -> ast::view_item_ {
@@ -2296,8 +2296,8 @@ fn parse_rest_import_name(p: parser, first: ast::ident,
     let from_idents = option::none::<[ast::import_ident]>;
     while true {
         alt p.token {
-          token::SEMI. { break; }
-          token::MOD_SEP. {
+          token::SEMI { break; }
+          token::MOD_SEP {
             if glob { p.fatal("cannot path into a glob"); }
             if option::is_some(from_idents) {
                 p.fatal("cannot path into import list");
@@ -2314,7 +2314,7 @@ fn parse_rest_import_name(p: parser, first: ast::ident,
 
 
           //the lexer can't tell the different kinds of stars apart ) :
-          token::BINOP(token::STAR.) {
+          token::BINOP(token::STAR) {
             glob = true;
             p.bump();
           }
@@ -2323,7 +2323,7 @@ fn parse_rest_import_name(p: parser, first: ast::ident,
 
 
 
-          token::LBRACE. {
+          token::LBRACE {
             fn parse_import_ident(p: parser) -> ast::import_ident {
                 let lo = p.span.lo;
                 let ident = parse_ident(p);
@@ -2388,7 +2388,7 @@ fn parse_import(p: parser) -> ast::view_item_ {
       token::IDENT(i, _) {
         p.bump();
         alt p.token {
-          token::EQ. {
+          token::EQ {
             p.bump();
             ret parse_full_import_name(p, p.get_str(i));
           }
@@ -2523,13 +2523,13 @@ fn parse_crate_directive(p: parser, first_outer_attr: [ast::attribute]) ->
         let id = parse_ident(p);
         alt p.token {
           // mod x = "foo.rs";
-          token::SEMI. {
+          token::SEMI {
             let hi = p.span.hi;
             p.bump();
             ret spanned(lo, hi, ast::cdir_src_mod(id, outer_attrs));
           }
           // mod x = "foo_dir" { ...directives... }
-          token::LBRACE. {
+          token::LBRACE {
             p.bump();
             let inner_attrs = parse_inner_attrs_and_next(p);
             let mod_attrs = outer_attrs + inner_attrs.inner;
diff --git a/src/comp/syntax/parse/token.rs b/src/comp/syntax/parse/token.rs
index d04396ad9b4..e5dcc8b61f7 100644
--- a/src/comp/syntax/parse/token.rs
+++ b/src/comp/syntax/parse/token.rs
@@ -74,62 +74,62 @@ tag token {
 
 fn binop_to_str(o: binop) -> str {
     alt o {
-      PLUS. { ret "+"; }
-      MINUS. { ret "-"; }
-      STAR. { ret "*"; }
-      SLASH. { ret "/"; }
-      PERCENT. { ret "%"; }
-      CARET. { ret "^"; }
-      AND. { ret "&"; }
-      OR. { ret "|"; }
-      LSL. { ret "<<"; }
-      LSR. { ret ">>"; }
-      ASR. { ret ">>>"; }
+      PLUS { ret "+"; }
+      MINUS { ret "-"; }
+      STAR { ret "*"; }
+      SLASH { ret "/"; }
+      PERCENT { ret "%"; }
+      CARET { ret "^"; }
+      AND { ret "&"; }
+      OR { ret "|"; }
+      LSL { ret "<<"; }
+      LSR { ret ">>"; }
+      ASR { ret ">>>"; }
     }
 }
 
 fn to_str(r: reader, t: token) -> str {
     alt t {
-      EQ. { ret "="; }
-      LT. { ret "<"; }
-      LE. { ret "<="; }
-      EQEQ. { ret "=="; }
-      NE. { ret "!="; }
-      GE. { ret ">="; }
-      GT. { ret ">"; }
-      NOT. { ret "!"; }
-      TILDE. { ret "~"; }
-      OROR. { ret "||"; }
-      ANDAND. { ret "&&"; }
+      EQ { ret "="; }
+      LT { ret "<"; }
+      LE { ret "<="; }
+      EQEQ { ret "=="; }
+      NE { ret "!="; }
+      GE { ret ">="; }
+      GT { ret ">"; }
+      NOT { ret "!"; }
+      TILDE { ret "~"; }
+      OROR { ret "||"; }
+      ANDAND { ret "&&"; }
       BINOP(op) { ret binop_to_str(op); }
       BINOPEQ(op) { ret binop_to_str(op) + "="; }
 
       /* Structural symbols */
-      AT. {
+      AT {
         ret "@";
       }
-      DOT. { ret "."; }
-      ELLIPSIS. { ret "..."; }
-      COMMA. { ret ","; }
-      SEMI. { ret ";"; }
-      COLON. { ret ":"; }
-      MOD_SEP. { ret "::"; }
-      QUES. { ret "?"; }
-      RARROW. { ret "->"; }
-      LARROW. { ret "<-"; }
-      DARROW. { ret "<->"; }
-      LPAREN. { ret "("; }
-      RPAREN. { ret ")"; }
-      LBRACKET. { ret "["; }
-      RBRACKET. { ret "]"; }
-      LBRACE. { ret "{"; }
-      RBRACE. { ret "}"; }
-      POUND. { ret "#"; }
-      POUND_LBRACE. { ret "#{"; }
-      POUND_LT. { ret "#<"; }
+      DOT { ret "."; }
+      ELLIPSIS { ret "..."; }
+      COMMA { ret ","; }
+      SEMI { ret ";"; }
+      COLON { ret ":"; }
+      MOD_SEP { ret "::"; }
+      QUES { ret "?"; }
+      RARROW { ret "->"; }
+      LARROW { ret "<-"; }
+      DARROW { ret "<->"; }
+      LPAREN { ret "("; }
+      RPAREN { ret ")"; }
+      LBRACKET { ret "["; }
+      RBRACKET { ret "]"; }
+      LBRACE { ret "{"; }
+      RBRACE { ret "}"; }
+      POUND { ret "#"; }
+      POUND_LBRACE { ret "#{"; }
+      POUND_LT { ret "#<"; }
 
       /* Literals */
-      LIT_INT(c, ast::ty_char.) {
+      LIT_INT(c, ast::ty_char) {
         // FIXME: escape.
         let tmp = "'";
         str::push_char(tmp, c as char);
@@ -156,31 +156,31 @@ fn to_str(r: reader, t: token) -> str {
         ret interner::get::<str>(*r.interner, s);
       }
       IDX(i) { ret "_" + int::to_str(i, 10u); }
-      UNDERSCORE. { ret "_"; }
+      UNDERSCORE { ret "_"; }
       BRACEQUOTE(_) { ret "<bracequote>"; }
-      EOF. { ret "<eof>"; }
+      EOF { ret "<eof>"; }
     }
 }
 
 
 pure fn can_begin_expr(t: token) -> bool {
     alt t {
-      LPAREN. { true }
-      LBRACE. { true }
-      LBRACKET. { true }
+      LPAREN { true }
+      LBRACE { true }
+      LBRACKET { true }
       IDENT(_, _) { true }
-      UNDERSCORE. { true }
-      TILDE. { true }
+      UNDERSCORE { true }
+      TILDE { true }
       LIT_INT(_, _) { true }
       LIT_UINT(_, _) { true }
       LIT_FLOAT(_, _) { true }
       LIT_STR(_) { true }
-      POUND. { true }
-      AT. { true }
-      NOT. { true }
-      BINOP(MINUS.) { true }
-      BINOP(STAR.) { true }
-      MOD_SEP. { true }
+      POUND { true }
+      AT { true }
+      NOT { true }
+      BINOP(MINUS) { true }
+      BINOP(STAR) { true }
+      MOD_SEP { true }
       _ { false }
     }
 }