Remove tuple support from the compiler

7 files changed, 1 insertions, 58 deletions

diff --git a/src/comp/syntax/ast.rs b/src/comp/syntax/ast.rs
index feba6b006c6..db5559052e9 100644
--- a/src/comp/syntax/ast.rs
+++ b/src/comp/syntax/ast.rs
@@ -283,7 +283,6 @@ type expr = rec(node_id id,
 
 tag expr_ {
     expr_vec((@expr)[], mutability, seq_kind);
-    expr_tup(elt[]);
     expr_rec(field[], option::t[@expr]);
     expr_call(@expr, (@expr)[]);
     expr_self_method(ident);
@@ -446,7 +445,6 @@ tag ty_ {
     ty_task;
     ty_port(@ty);
     ty_chan(@ty);
-    ty_tup(mt[]);
     ty_rec(ty_field[]);
     ty_fn(proto, ty_arg[], @ty, controlflow, (@constr)[]);
     ty_obj(ty_method[]);
diff --git a/src/comp/syntax/ext/expand.rs b/src/comp/syntax/ext/expand.rs
index 3cff1cba5e2..d6fbae88628 100644
--- a/src/comp/syntax/ext/expand.rs
+++ b/src/comp/syntax/ext/expand.rs
@@ -40,7 +40,7 @@ fn expand_expr(&hashmap[str, base::syntax_extension] exts,
                                 = ext(ext_cx, pth.span, args, body);
                             exts.insert(named_extension.ident,
                                         named_extension.ext);
-                            ast::expr_tup(~[])
+                            ast::expr_rec(~[], none)
                         }
                     }
                 }
diff --git a/src/comp/syntax/fold.rs b/src/comp/syntax/fold.rs
index 47d9dd57135..d3290c75318 100644
--- a/src/comp/syntax/fold.rs
+++ b/src/comp/syntax/fold.rs
@@ -308,10 +308,6 @@ fn noop_fold_decl(&decl_ d, ast_fold fld) -> decl_ {
 }
 
 fn noop_fold_expr(&expr_ e, ast_fold fld) -> expr_ {
-    fn fold_elt_(&elt elt, ast_fold fld) -> elt {
-        ret rec(mut=elt.mut, expr=fld.fold_expr(elt.expr));
-    }
-    auto fold_elt = bind fold_elt_(_,fld);
     fn fold_field_(&field field, ast_fold fld) -> field {
         ret rec(node=rec(mut=field.node.mut,
                          ident=fld.fold_ident(field.node.ident),
@@ -345,9 +341,6 @@ fn noop_fold_expr(&expr_ e, ast_fold fld) -> expr_ {
         case (expr_vec(?exprs, ?mut, ?seq_kind)) {
             expr_vec(fld.map_exprs(fld.fold_expr, exprs), mut, seq_kind)
                 }
-        case (expr_tup(?elts)) {
-            expr_tup(ivec::map(fold_elt, elts))
-                }
         case (expr_rec(?fields, ?maybe_expr)) {
             expr_rec(ivec::map(fold_field, fields),
                      option::map(fld.fold_expr, maybe_expr))
diff --git a/src/comp/syntax/parse/parser.rs b/src/comp/syntax/parse/parser.rs
index 16f91c403ab..eab542e6c54 100644
--- a/src/comp/syntax/parse/parser.rs
+++ b/src/comp/syntax/parse/parser.rs
@@ -564,12 +564,6 @@ fn parse_ty(&parser p) -> @ast::ty {
         t = ast::ty_vec(parse_mt(p));
         hi = p.get_hi_pos();
         expect(p, token::RBRACKET);
-    } else if (eat_word(p, "tup")) {
-        auto elems =
-            parse_seq(token::LPAREN, token::RPAREN, some(token::COMMA),
-                           parse_mt, p);
-        hi = elems.span.hi;
-        t = ast::ty_tup(elems.node);
     } else if (eat_word(p, "rec")) {
         auto elems =
             parse_seq(token::LPAREN, token::RPAREN, some(token::COMMA),
@@ -837,16 +831,6 @@ fn parse_bottom_expr(&parser p) -> @ast::expr {
         ret parse_spawn_expr(p);
     } else if (eat_word(p, "fn")) {
         ret parse_fn_expr(p);
-    } else if (eat_word(p, "tup")) {
-        fn parse_elt(&parser p) -> ast::elt {
-            auto m = parse_mutability(p);
-            auto e = parse_expr(p);
-            ret rec(mut=m, expr=e);
-        }
-        auto es = parse_seq(token::LPAREN, token::RPAREN, some(token::COMMA),
-                            parse_elt, p);
-        hi = es.span.hi;
-        ex = ast::expr_tup(es.node);
     } else if (p.peek() == token::LBRACKET) {
         p.bump();
         auto mut = parse_mutability(p);
@@ -1737,7 +1721,6 @@ fn stmt_ends_with_semi(&ast::stmt stmt) -> bool {
         case (ast::stmt_expr(?e, _)) {
             ret alt (e.node) {
                 case (ast::expr_vec(_, _, _)) { true }
-                case (ast::expr_tup(_)) { true }
                 case (ast::expr_rec(_, _)) { true }
                 case (ast::expr_call(_, _)) { true }
                 case (ast::expr_self_method(_)) { false }
diff --git a/src/comp/syntax/print/pprust.rs b/src/comp/syntax/print/pprust.rs
index 1f67be116d3..2ca445653aa 100644
--- a/src/comp/syntax/print/pprust.rs
+++ b/src/comp/syntax/print/pprust.rs
@@ -294,12 +294,6 @@ fn print_type(&ps s, &ast::ty ty) {
             print_type(s, *t);
             word(s.s, "]");
         }
-        case (ast::ty_tup(?elts)) {
-            word(s.s, "tup");
-            popen(s);
-            commasep(s, inconsistent, elts, print_mt);
-            pclose(s);
-        }
         case (ast::ty_rec(?fields)) {
             word(s.s, "{");
             fn print_field(&ps s, &ast::ty_field f) {
@@ -689,19 +683,6 @@ fn print_expr(&ps s, &@ast::expr expr) {
             word(s.s, "]");
             end(s);
         }
-        case (ast::expr_tup(?exprs)) {
-            fn printElt(&ps s, &ast::elt elt) {
-                ibox(s, indent_unit);
-                if (elt.mut == ast::mut) { word_nbsp(s, "mutable"); }
-                print_expr(s, elt.expr);
-                end(s);
-            }
-            fn get_span(&ast::elt elt) -> codemap::span { ret elt.expr.span; }
-            word(s.s, "tup");
-            popen(s);
-            commasep_cmnt(s, inconsistent, exprs, printElt, get_span);
-            pclose(s);
-        }
         case (ast::expr_rec(?fields, ?wth)) {
             fn print_field(&ps s, &ast::field field) {
                 ibox(s, indent_unit);
diff --git a/src/comp/syntax/visit.rs b/src/comp/syntax/visit.rs
index b1b0023dbc5..1820631011d 100644
--- a/src/comp/syntax/visit.rs
+++ b/src/comp/syntax/visit.rs
@@ -154,9 +154,6 @@ fn visit_ty[E](&@ty t, &E e, &vt[E] v) {
         case (ty_port(?t))      { v.visit_ty(t, e, v); }
         case (ty_chan(?t))      { v.visit_ty(t, e, v); }
         case (ty_task)          { /* no-op */ }
-        case (ty_tup(?mts)) {
-            for (mt mt in mts) { v.visit_ty(mt.ty, e, v); }
-        }
         case (ty_rec(?flds)) {
             for (ty_field f in flds) { v.visit_ty(f.node.mt.ty, e, v); }
         }
@@ -279,9 +276,6 @@ fn visit_mac[E](mac m, &E e, &vt[E] v) {
 fn visit_expr[E](&@expr ex, &E e, &vt[E] v) {
     alt (ex.node) {
         case (expr_vec(?es, _, _)) { visit_exprs(es, e, v); }
-        case (expr_tup(?elts)) {
-            for (elt el in elts) { v.visit_expr(el.expr, e, v); }
-        }
         case (expr_rec(?flds, ?base)) {
             for (field f in flds) { v.visit_expr(f.node.expr, e, v); }
             visit_expr_opt(base, e, v);
diff --git a/src/comp/syntax/walk.rs b/src/comp/syntax/walk.rs
index 7df1f0e085c..d439a2e0aea 100644
--- a/src/comp/syntax/walk.rs
+++ b/src/comp/syntax/walk.rs
@@ -154,9 +154,6 @@ fn walk_ty(&ast_visitor v, @ast::ty t) {
         case (ast::ty_task) { }
         case (ast::ty_port(?t)) { walk_ty(v, t); }
         case (ast::ty_chan(?t)) { walk_ty(v, t); }
-        case (ast::ty_tup(?mts)) {
-            for (ast::mt mt in mts) { walk_ty(v, mt.ty); }
-        }
         case (ast::ty_rec(?flds)) {
             for (ast::ty_field f in flds) { walk_ty(v, f.node.mt.ty); }
         }
@@ -286,9 +283,6 @@ fn walk_expr(&ast_visitor v, @ast::expr e) {
     v.visit_expr_pre(e);
     alt (e.node) {
         case (ast::expr_vec(?es, _, _)) { walk_exprs(v, es); }
-        case (ast::expr_tup(?elts)) {
-            for (ast::elt e in elts) { walk_expr(v, e.expr); }
-        }
         case (ast::expr_rec(?flds, ?base)) {
             for (ast::field f in flds) { walk_expr(v, f.node.expr); }
             walk_expr_opt(v, base);