Remove all uses of tuples from the compiler and stdlib

8 files changed, 82 insertions, 77 deletions

diff --git a/src/comp/syntax/ast.rs b/src/comp/syntax/ast.rs
index 3fa40c001c3..feba6b006c6 100644
--- a/src/comp/syntax/ast.rs
+++ b/src/comp/syntax/ast.rs
@@ -26,11 +26,11 @@ fn path_name_i(&ident[] idents) -> str { str::connect_ivec(idents, "::") }
 
 type crate_num = int;
 type node_id = int;
-type def_id = tup(crate_num, node_id);
+type def_id = rec(crate_num crate, node_id node);
 
 const crate_num local_crate = 0;
 fn local_def(node_id id) -> def_id {
-    ret tup(local_crate, id);
+    ret rec(crate=local_crate, node=id);
 }
 
 type ty_param = ident;
@@ -59,9 +59,11 @@ tag def {
     def_upvar(def_id, @def);
 }
 
-fn variant_def_ids(&def d) -> tup(def_id, def_id) {
+fn variant_def_ids(&def d) -> rec(def_id tg, def_id var) {
     alt (d) {
-        case (def_variant(?tag_id, ?var_id)) { ret tup(tag_id, var_id); }
+        case (def_variant(?tag_id, ?var_id)) {
+          ret rec(tg=tag_id, var=var_id);
+        }
     }
 }
 
diff --git a/src/comp/syntax/ext/base.rs b/src/comp/syntax/ext/base.rs
index bdd0421cb23..ac970c64961 100644
--- a/src/comp/syntax/ext/base.rs
+++ b/src/comp/syntax/ext/base.rs
@@ -8,8 +8,9 @@ import codemap;
 
 type syntax_expander =
     fn(&ext_ctxt, span, &(@ast::expr)[], option::t[str]) -> @ast::expr;
+type macro_def = rec(str ident, syntax_extension ext);
 type macro_definer = fn(&ext_ctxt, span, &(@ast::expr)[],
-                        option::t[str]) -> tup(str, syntax_extension);
+                        option::t[str]) -> macro_def;
 
 tag syntax_extension {
     normal(syntax_expander);
diff --git a/src/comp/syntax/ext/expand.rs b/src/comp/syntax/ext/expand.rs
index cb93a4bf45c..3cff1cba5e2 100644
--- a/src/comp/syntax/ext/expand.rs
+++ b/src/comp/syntax/ext/expand.rs
@@ -38,8 +38,8 @@ fn expand_expr(&hashmap[str, base::syntax_extension] exts,
                         case (some(base::macro_defining(?ext))) {
                             auto named_extension
                                 = ext(ext_cx, pth.span, args, body);
-                            exts.insert(named_extension._0,
-                                        named_extension._1);
+                            exts.insert(named_extension.ident,
+                                        named_extension.ext);
                             ast::expr_tup(~[])
                         }
                     }
diff --git a/src/comp/syntax/ext/fmt.rs b/src/comp/syntax/ext/fmt.rs
index 4aae16f01ce..b69b27f5ef4 100644
--- a/src/comp/syntax/ext/fmt.rs
+++ b/src/comp/syntax/ext/fmt.rs
@@ -80,11 +80,12 @@ fn pieces_to_expr(&ext_ctxt cx, span sp, vec[piece] pieces,
         ret @rec(id=cx.next_id(), node=callexpr, span=sp);
     }
     fn make_rec_expr(&ext_ctxt cx, span sp,
-                     vec[tup(ast::ident, @ast::expr)] fields) -> @ast::expr {
+                     vec[rec(ast::ident ident, @ast::expr ex)] fields)
+        -> @ast::expr {
         let ast::field[] astfields = ~[];
-        for (tup(ast::ident, @ast::expr) field in fields) {
-            auto ident = field._0;
-            auto val = field._1;
+        for (rec(ast::ident ident, @ast::expr ex) field in fields) {
+            auto ident = field.ident;
+            auto val = field.ex;
             auto astfield =
                 rec(node=rec(mut=ast::imm, ident=ident, expr=val), span=sp);
             astfields += ~[astfield];
@@ -173,10 +174,10 @@ fn pieces_to_expr(&ext_ctxt cx, span sp, vec[piece] pieces,
                          @ast::expr width_expr, @ast::expr precision_expr,
                          @ast::expr ty_expr) -> @ast::expr {
             ret make_rec_expr(cx, sp,
-                              [tup("flags", flags_expr),
-                               tup("width", width_expr),
-                               tup("precision", precision_expr),
-                               tup("ty", ty_expr)]);
+                              [rec(ident="flags", ex=flags_expr),
+                               rec(ident="width", ex=width_expr),
+                               rec(ident="precision", ex=precision_expr),
+                               rec(ident="ty", ex=ty_expr)]);
         }
         auto rt_conv_flags = make_flags(cx, sp, cnv.flags);
         auto rt_conv_width = make_count(cx, sp, cnv.width);
diff --git a/src/comp/syntax/ext/simplext.rs b/src/comp/syntax/ext/simplext.rs
index 839cf154d75..95cbb069c25 100644
--- a/src/comp/syntax/ext/simplext.rs
+++ b/src/comp/syntax/ext/simplext.rs
@@ -191,10 +191,11 @@ selectors. */
 fn use_selectors_to_bind(&binders b, @expr e) -> option::t[bindings] {
     auto res = new_str_hash[arb_depth[matchable]]();
     let bool never_mind = false;
-    for each(@tup(ident, selector) pair in b.real_binders.items()) {
-        alt (pair._1(match_expr(e))) {
+    for each(@rec(ident key, selector val) pair
+             in b.real_binders.items()) {
+        alt (pair.val(match_expr(e))) {
           case (none) { never_mind = true; }
-          case (some(?mtc)) { res.insert(pair._0, mtc); }
+          case (some(?mtc)) { res.insert(pair.key, mtc); }
         }
     }
     if (never_mind) { ret none; } //HACK: `ret` doesn't work in `for each`
@@ -274,9 +275,7 @@ iter free_vars(&bindings b, @expr e) -> ident {
     auto f = make_fold(f_pre);
     f.fold_expr(e); // ignore result
     dummy_out(f);
-    for each(@tup(ast::ident, ()) it in idents.items()) {
-        put it._0;
-    }
+    for each(ident id in idents.keys()) { put id; }
 }
 
 
@@ -546,7 +545,7 @@ fn p_t_s_r_actual_vector(&ext_ctxt cx, (@expr)[] elts, &selector s,
 }
 
 fn add_new_extension(&ext_ctxt cx, span sp, &(@expr)[] args,
-                     option::t[str] body) -> tup(str, syntax_extension) {
+                     option::t[str] body) -> base::macro_def {
     let option::t[str] macro_name = none;
     let (clause)[] clauses = ~[];
     for (@expr arg in args) {
@@ -596,14 +595,13 @@ fn add_new_extension(&ext_ctxt cx, span sp, &(@expr)[] args,
 
     auto ext = bind generic_extension(_,_,_,_,clauses);
 
-    ret tup(alt (macro_name) {
+    ret rec(ident=alt (macro_name) {
       case (some(?id)) { id }
       case (none) {
         cx.span_fatal(sp, "macro definition must have "
                       + "at least one clause")
       }
-    },
-            normal(ext));
+    }, ext=normal(ext));
 
 
     fn generic_extension(&ext_ctxt cx, span sp, &(@expr)[] args,
@@ -620,9 +618,9 @@ fn add_new_extension(&ext_ctxt cx, span sp, &(@expr)[] args,
                 alt (use_selectors_to_bind(c.params.(i), args.(i))) {
                   case (some(?new_bindings)) {
                     /* ick; I wish macros just took one expr */
-                    for each (@tup(ident,arb_depth[matchable]) it
+                    for each (@rec(ident key, arb_depth[matchable] val) it
                               in new_bindings.items()) {
-                        bdgs.insert(it._0, it._1);
+                        bdgs.insert(it.key, it.val);
                     }
                   }
                   case (none) { abort = true; }
diff --git a/src/comp/syntax/parse/eval.rs b/src/comp/syntax/parse/eval.rs
index 45bc78cdc61..6f551b92943 100644
--- a/src/comp/syntax/parse/eval.rs
+++ b/src/comp/syntax/parse/eval.rs
@@ -60,8 +60,8 @@ fn eval_crate_directive(ctx cx, @ast::crate_directive cdir, str prefix,
                 new_parser_from_file(cx.sess, cx.cfg, full_path, cx.chpos,
                                      cx.byte_pos);
             auto inner_attrs = parse_inner_attrs_and_next(p0);
-            auto mod_attrs = attrs + inner_attrs._0;
-            auto first_item_outer_attrs = inner_attrs._1;
+            auto mod_attrs = attrs + inner_attrs.inner;
+            auto first_item_outer_attrs = inner_attrs.next;
             auto m0 = parse_mod_items(p0, token::EOF, first_item_outer_attrs);
 
             auto i = syntax::parse::parser::mk_item
diff --git a/src/comp/syntax/parse/lexer.rs b/src/comp/syntax/parse/lexer.rs
index cdbc6bafec9..07a07923275 100644
--- a/src/comp/syntax/parse/lexer.rs
+++ b/src/comp/syntax/parse/lexer.rs
@@ -57,8 +57,8 @@ fn new_reader(&codemap::codemap cm, str src, codemap::filemap filemap,
         fn init() {
             if (pos < len) {
                 auto next = str::char_range_at(src, pos);
-                pos = next._1;
-                ch = next._0;
+                pos = next.next;
+                ch = next.ch;
             }
         }
         fn bump() {
@@ -70,8 +70,8 @@ fn new_reader(&codemap::codemap cm, str src, codemap::filemap filemap,
                     col = 0u;
                 }
                 auto next = str::char_range_at(src, pos);
-                pos = next._1;
-                ch = next._0;
+                pos = next.next;
+                ch = next.ch;
             } else { ch = -1 as char; }
         }
         fn get_interner() -> @interner::interner[str] { ret itr; }
@@ -338,13 +338,13 @@ fn scan_numeric_escape(&reader rdr, uint n_hex_digits) -> char {
     ret accum_int as char;
 }
 
-fn next_token(&reader rdr) -> tup(token::token, uint, uint) {
+fn next_token(&reader rdr) -> rec(token::token tok, uint chpos, uint bpos) {
     consume_whitespace_and_comments(rdr);
     auto start_chpos = rdr.get_chpos();
     auto start_bpos = rdr.get_byte_pos();
     auto tok = if rdr.is_eof() { token::EOF }
                else { next_token_inner(rdr) };
-    ret tup(tok, start_chpos, start_bpos);
+    ret rec(tok=tok, chpos=start_chpos, bpos=start_bpos);
 }
 
 fn next_token_inner(&reader rdr) -> token::token {
@@ -768,10 +768,10 @@ fn gather_comments_and_literals(&codemap::codemap cm, str path,
             break;
         }
         auto tok = next_token(rdr);
-        if (is_lit(tok._0)) {
-            literals += ~[rec(lit=rdr.get_str_from(tok._2), pos=tok._1)];
+        if (is_lit(tok.tok)) {
+            literals += ~[rec(lit=rdr.get_str_from(tok.bpos), pos=tok.chpos)];
         }
-        log "tok: " + token::to_str(rdr, tok._0);
+        log "tok: " + token::to_str(rdr, tok.tok);
         first_read = false;
     }
     ret rec(cmnts=comments, lits=literals);
diff --git a/src/comp/syntax/parse/parser.rs b/src/comp/syntax/parse/parser.rs
index e4bb9c6e1e3..43f8a62b23d 100644
--- a/src/comp/syntax/parse/parser.rs
+++ b/src/comp/syntax/parse/parser.rs
@@ -81,7 +81,7 @@ fn new_parser(parse_sess sess, ast::crate_cfg cfg, lexer::reader rdr,
                      mutable token::token tok,
                      mutable span tok_span,
                      mutable span last_tok_span,
-                     mutable tup(token::token, span)[] buffer,
+                     mutable rec(token::token tok, span span)[] buffer,
                      mutable restriction restr,
                      lexer::reader rdr,
                      @op_spec[] precs,
@@ -91,21 +91,21 @@ fn new_parser(parse_sess sess, ast::crate_cfg cfg, lexer::reader rdr,
             last_tok_span = tok_span;
             if ivec::len(buffer) == 0u {
                 auto next = lexer::next_token(rdr);
-                tok = next._0;
-                tok_span = rec(lo=next._1, hi=rdr.get_chpos());
+                tok = next.tok;
+                tok_span = rec(lo=next.chpos, hi=rdr.get_chpos());
             } else {
                 auto next = ivec::pop(buffer);
-                tok = next._0;
-                tok_span = next._1;
+                tok = next.tok;
+                tok_span = next.span;
             }
         }
         fn look_ahead(uint distance) -> token::token {
             while ivec::len(buffer) < distance {
                 auto next = lexer::next_token(rdr);
-                auto sp = rec(lo=next._1, hi=rdr.get_chpos());
-                buffer = ~[tup(next._0, sp)] + buffer;
+                auto sp = rec(lo=next.chpos, hi=rdr.get_chpos());
+                buffer = ~[rec(tok=next.tok, span=sp)] + buffer;
             }
-            ret buffer.(distance-1u)._0;
+            ret buffer.(distance-1u).tok;
         }
         fn fatal(str m) -> ! {
             codemap::emit_error(some(self.get_span()), m, sess.cm);
@@ -137,8 +137,8 @@ fn new_parser(parse_sess sess, ast::crate_cfg cfg, lexer::reader rdr,
     }
 
     auto tok0 = lexer::next_token(rdr);
-    auto span0 = rec(lo=tok0._1, hi=rdr.get_chpos());
-    ret stdio_parser(sess, cfg, ftype, tok0._0,
+    auto span0 = rec(lo=tok0.chpos, hi=rdr.get_chpos());
+    ret stdio_parser(sess, cfg, ftype, tok0.tok,
                      span0, span0, ~[], UNRESTRICTED, rdr,
                      prec_table(), bad_expr_word_table());
 }
@@ -1307,9 +1307,10 @@ fn parse_assign_expr(&parser p) -> @ast::expr {
     ret lhs;
 }
 
-fn parse_if_expr_1(&parser p) -> tup(@ast::expr,
-                                     ast::blk, option::t[@ast::expr],
-                                     uint, uint) {
+fn parse_if_expr_1(&parser p) -> rec(@ast::expr cond,
+                                     ast::blk then,
+                                     option::t[@ast::expr] els,
+                                     uint lo, uint hi) {
     auto lo = p.get_last_lo_pos();
     auto cond = parse_expr(p);
     auto thn = parse_block(p);
@@ -1320,17 +1321,18 @@ fn parse_if_expr_1(&parser p) -> tup(@ast::expr,
         els = some(elexpr);
         hi = elexpr.span.hi;
     }
-    ret tup(cond, thn, els, lo, hi);
+    ret rec(cond=cond, then=thn, els=els, lo=lo, hi=hi);
 }
 
 fn parse_if_expr(&parser p) -> @ast::expr {
     if (eat_word(p, "check")) {
             auto q = parse_if_expr_1(p);
-            ret mk_expr(p, q._3, q._4, ast::expr_if_check(q._0, q._1, q._2));
+            ret mk_expr(p, q.lo, q.hi,
+                        ast::expr_if_check(q.cond, q.then, q.els));
     }
     else {
         auto q = parse_if_expr_1(p);
-        ret mk_expr(p, q._3, q._4, ast::expr_if(q._0, q._1, q._2));
+        ret mk_expr(p, q.lo, q.hi, ast::expr_if(q.cond, q.then, q.els));
     }
 }
 
@@ -1894,10 +1896,10 @@ fn parse_fn(&parser p, ast::proto proto, ast::purity purity) -> ast::_fn {
     ret rec(decl=decl, proto=proto, body=body);
 }
 
-fn parse_fn_header(&parser p) -> tup(ast::ident, ast::ty_param[]) {
+fn parse_fn_header(&parser p) -> rec(ast::ident ident, ast::ty_param[] tps) {
     auto id = parse_value_ident(p);
     auto ty_params = parse_ty_params(p);
-    ret tup(id, ty_params);
+    ret rec(ident=id, tps=ty_params);
 }
 
 fn mk_item(&parser p, uint lo, uint hi, &ast::ident ident, &ast::item_ node,
@@ -1914,7 +1916,8 @@ fn parse_item_fn_or_iter(&parser p, ast::purity purity, ast::proto proto,
     auto lo = p.get_last_lo_pos();
     auto t = parse_fn_header(p);
     auto f = parse_fn(p, proto, purity);
-    ret mk_item(p, lo, f.body.span.hi, t._0, ast::item_fn(f, t._1), attrs);
+    ret mk_item(p, lo, f.body.span.hi, t.ident,
+                ast::item_fn(f, t.tps), attrs);
 }
 
 fn parse_obj_field(&parser p) -> ast::obj_field {
@@ -2045,11 +2048,11 @@ fn parse_item_mod(&parser p, &ast::attribute[] attrs) -> @ast::item {
     auto id = parse_ident(p);
     expect(p, token::LBRACE);
     auto inner_attrs = parse_inner_attrs_and_next(p);
-    auto first_item_outer_attrs = inner_attrs._1;
+    auto first_item_outer_attrs = inner_attrs.next;
     auto m = parse_mod_items(p, token::RBRACE, first_item_outer_attrs);
     auto hi = p.get_hi_pos();
     expect(p, token::RBRACE);
-    ret mk_item(p, lo, hi, id, ast::item_mod(m), attrs + inner_attrs._0);
+    ret mk_item(p, lo, hi, id, ast::item_mod(m), attrs + inner_attrs.inner);
 }
 
 fn parse_item_native_type(&parser p, &ast::attribute[] attrs)
@@ -2057,11 +2060,11 @@ fn parse_item_native_type(&parser p, &ast::attribute[] attrs)
     auto t = parse_type_decl(p);
     auto hi = p.get_hi_pos();
     expect(p, token::SEMI);
-    ret @rec(ident=t._1,
+    ret @rec(ident=t.ident,
              attrs=attrs,
              node=ast::native_item_ty,
              id=p.get_id(),
-             span=rec(lo=t._0, hi=hi));
+             span=rec(lo=t.lo, hi=hi));
 }
 
 fn parse_item_native_fn(&parser p, &ast::attribute[] attrs)
@@ -2076,9 +2079,9 @@ fn parse_item_native_fn(&parser p, &ast::attribute[] attrs)
     }
     auto hi = p.get_hi_pos();
     expect(p, token::SEMI);
-    ret @rec(ident=t._0,
+    ret @rec(ident=t.ident,
              attrs=attrs,
-             node=ast::native_item_fn(link_name, decl, t._1),
+             node=ast::native_item_fn(link_name, decl, t.tps),
              id=p.get_id(),
              span=rec(lo=lo, hi=hi));
 }
@@ -2142,8 +2145,8 @@ fn parse_item_native_mod(&parser p, &ast::attribute[] attrs) -> @ast::item {
     }
     expect(p, token::LBRACE);
     auto more_attrs = parse_inner_attrs_and_next(p);
-    auto inner_attrs = more_attrs._0;
-    auto first_item_outer_attrs = more_attrs._1;
+    auto inner_attrs = more_attrs.inner;
+    auto first_item_outer_attrs = more_attrs.next;
     auto m = parse_native_mod_items(p, native_name, abi,
                                     first_item_outer_attrs);
     auto hi = p.get_hi_pos();
@@ -2151,10 +2154,10 @@ fn parse_item_native_mod(&parser p, &ast::attribute[] attrs) -> @ast::item {
     ret mk_item(p, lo, hi, id, ast::item_native_mod(m), attrs + inner_attrs);
 }
 
-fn parse_type_decl(&parser p) -> tup(uint, ast::ident) {
+fn parse_type_decl(&parser p) -> rec(uint lo, ast::ident ident) {
     auto lo = p.get_last_lo_pos();
     auto id = parse_ident(p);
-    ret tup(lo, id);
+    ret rec(lo=lo, ident=id);
 }
 
 fn parse_item_type(&parser p, &ast::attribute[] attrs) -> @ast::item {
@@ -2164,7 +2167,7 @@ fn parse_item_type(&parser p, &ast::attribute[] attrs) -> @ast::item {
     auto ty = parse_ty(p);
     auto hi = p.get_hi_pos();
     expect(p, token::SEMI);
-    ret mk_item(p, t._0, hi, t._1, ast::item_ty(ty, tps), attrs);
+    ret mk_item(p, t.lo, hi, t.ident, ast::item_ty(ty, tps), attrs);
 }
 
 fn parse_item_tag(&parser p, &ast::attribute[] attrs) -> @ast::item {
@@ -2330,8 +2333,8 @@ fn parse_attribute_naked(&parser p, ast::attr_style style,
 // next item (since we can't know whether the attribute is an inner attribute
 // of the containing item or an outer attribute of the first contained item
 // until we see the semi).
-fn parse_inner_attrs_and_next(&parser p) -> tup(ast::attribute[],
-                                                ast::attribute[]) {
+fn parse_inner_attrs_and_next(&parser p) -> rec(ast::attribute[] inner,
+                                                ast::attribute[] next) {
     let ast::attribute[] inner_attrs = ~[];
     let ast::attribute[] next_outer_attrs = ~[];
     while (p.peek() == token::POUND) {
@@ -2349,7 +2352,7 @@ fn parse_inner_attrs_and_next(&parser p) -> tup(ast::attribute[],
             break;
         }
     }
-    ret tup(inner_attrs, next_outer_attrs);
+    ret rec(inner=inner_attrs, next=next_outer_attrs);
 }
 
 fn parse_meta_item(&parser p) -> @ast::meta_item {
@@ -2527,12 +2530,12 @@ fn parse_crate_mod(&parser p, &ast::crate_cfg cfg, parse_sess sess)
     -> @ast::crate {
     auto lo = p.get_lo_pos();
     auto crate_attrs = parse_inner_attrs_and_next(p);
-    auto first_item_outer_attrs = crate_attrs._1;
+    auto first_item_outer_attrs = crate_attrs.next;
     auto m = parse_mod_items(p, token::EOF,
                              first_item_outer_attrs);
     ret @spanned(lo, p.get_lo_pos(), rec(directives=~[],
                                          module=m,
-                                         attrs=crate_attrs._0,
+                                         attrs=crate_attrs.inner,
                                          config=p.get_cfg()));
 }
 
@@ -2585,8 +2588,8 @@ fn parse_crate_directive(&parser p, &ast::attribute[] first_outer_attr)
                  token::LBRACE) {
                 p.bump();
                 auto inner_attrs = parse_inner_attrs_and_next(p);
-                auto mod_attrs = outer_attrs + inner_attrs._0;
-                auto next_outer_attr = inner_attrs._1;
+                auto mod_attrs = outer_attrs + inner_attrs.inner;
+                auto next_outer_attr = inner_attrs.next;
                 auto cdirs = parse_crate_directives(p, token::RBRACE,
                                                     next_outer_attr);
                 auto hi = p.get_hi_pos();
@@ -2636,8 +2639,8 @@ fn parse_crate_from_crate_file(&str input, &ast::crate_cfg cfg,
     auto lo = p.get_lo_pos();
     auto prefix = std::fs::dirname(p.get_filemap().name);
     auto leading_attrs = parse_inner_attrs_and_next(p);
-    auto crate_attrs = leading_attrs._0;
-    auto first_cdir_attr = leading_attrs._1;
+    auto crate_attrs = leading_attrs.inner;
+    auto first_cdir_attr = leading_attrs.next;
     auto cdirs = parse_crate_directives(p, token::EOF, first_cdir_attr);
     let str[] deps = ~[];
     auto cx = @rec(p=p,