Rename tag to enum throughout the compiler

This should reduce confusion of people trying to read the code.

Author: marijnh

src/comp/metadata/common.rs

@@ -30,7 +30,7 @@ const tag_items_data_item_symbol: uint = 0x0du;
 
 const tag_items_data_item_variant: uint = 0x0eu;
 
-const tag_items_data_item_tag_id: uint = 0x0fu;
+const tag_items_data_item_enum_id: uint = 0x0fu;
 
 const tag_index: uint = 0x11u;
 

src/comp/metadata/csearch.rs

@@ -9,7 +9,7 @@ import driver::session;
 export get_symbol;
 export get_type_param_count;
 export lookup_defs;
-export get_tag_variants;
+export get_enum_variants;
 export get_impls_for_mod;
 export get_iface_methods;
 export get_type;
@@ -56,10 +56,10 @@ fn resolve_path(cstore: cstore::cstore, cnum: ast::crate_num,
     ret result;
 }
 
-fn get_tag_variants(tcx: ty::ctxt, def: ast::def_id) -> [ty::variant_info] {
+fn get_enum_variants(tcx: ty::ctxt, def: ast::def_id) -> [ty::variant_info] {
     let cstore = tcx.sess.cstore;
     let cdata = cstore::get_crate_data(cstore, def.crate);
-    ret decoder::get_tag_variants(cdata, def.node, tcx)
+    ret decoder::get_enum_variants(cdata, def.node, tcx)
 }
 
 fn get_impls_for_mod(cstore: cstore::cstore, def: ast::def_id,

src/comp/metadata/decoder.rs

@@ -11,7 +11,7 @@ import syntax::print::pprust;
 import cmd=cstore::crate_metadata;
 
 export get_symbol;
-export get_tag_variants;
+export get_enum_variants;
 export get_type;
 export get_type_param_count;
 export get_impl_iface;
@@ -86,8 +86,8 @@ fn item_symbol(item: ebml::doc) -> str {
     ret str::unsafe_from_bytes(ebml::doc_data(sym));
 }
 
-fn variant_tag_id(d: ebml::doc) -> ast::def_id {
-    let tagdoc = ebml::get_doc(d, tag_items_data_item_tag_id);
+fn variant_enum_id(d: ebml::doc) -> ast::def_id {
+    let tagdoc = ebml::get_doc(d, tag_items_data_item_enum_id);
     ret parse_def_id(ebml::doc_data(tagdoc));
 }
 
@@ -147,7 +147,7 @@ fn item_ty_param_count(item: ebml::doc) -> uint {
     n
 }
 
-fn tag_variant_ids(item: ebml::doc, cdata: cmd) -> [ast::def_id] {
+fn enum_variant_ids(item: ebml::doc, cdata: cmd) -> [ast::def_id] {
     let ids: [ast::def_id] = [];
     let v = tag_items_data_item_variant;
     ebml::tagged_docs(item, v) {|p|
@@ -189,7 +189,7 @@ fn lookup_def(cnum: ast::crate_num, data: @[u8], did_: ast::def_id) ->
     let item = lookup_item(did_.node, data);
     let fam_ch = item_family(item);
     let did = {crate: cnum, node: did_.node};
-    // We treat references to tags as references to types.
+    // We treat references to enums as references to types.
     let def =
         alt fam_ch as char {
           'c' { ast::def_const(did) }
@@ -205,7 +205,7 @@ fn lookup_def(cnum: ast::crate_num, data: @[u8], did_: ast::def_id) ->
           'm' { ast::def_mod(did) }
           'n' { ast::def_native_mod(did) }
           'v' {
-            let tid = variant_tag_id(item);
+            let tid = variant_enum_id(item);
             tid = {crate: cnum, node: tid.node};
             ast::def_variant(tid, did)
           }
@@ -237,13 +237,13 @@ fn get_symbol(data: @[u8], id: ast::node_id) -> str {
     ret item_symbol(lookup_item(id, data));
 }
 
-fn get_tag_variants(cdata: cmd, id: ast::node_id, tcx: ty::ctxt)
+fn get_enum_variants(cdata: cmd, id: ast::node_id, tcx: ty::ctxt)
     -> [ty::variant_info] {
     let data = cdata.data;
     let items = ebml::get_doc(ebml::new_doc(data), tag_items);
     let item = find_item(id, items);
     let infos: [ty::variant_info] = [];
-    let variant_ids = tag_variant_ids(item, cdata);
+    let variant_ids = enum_variant_ids(item, cdata);
     let disr_val = 0;
     for did: ast::def_id in variant_ids {
         let item = find_item(did.node, items);

src/comp/metadata/encoder.rs

@@ -33,7 +33,7 @@ fn encode_def_id(ebml_w: ebml::writer, id: def_id) {
 
 type entry<T> = {val: T, pos: uint};
 
-fn encode_tag_variant_paths(ebml_w: ebml::writer, variants: [variant],
+fn encode_enum_variant_paths(ebml_w: ebml::writer, variants: [variant],
                             path: [str], &index: [entry<str>]) {
     for variant: variant in variants {
         add_to_index(ebml_w, path, index, variant.node.name);
@@ -118,13 +118,13 @@ fn encode_module_item_paths(ebml_w: ebml::writer, module: _mod, path: [str],
             encode_def_id(ebml_w, local_def(it.id));
             ebml::end_tag(ebml_w);
           }
-          item_tag(variants, tps) {
+          item_enum(variants, tps) {
             add_to_index(ebml_w, path, index, it.ident);
             ebml::start_tag(ebml_w, tag_paths_data_item);
             encode_name(ebml_w, it.ident);
             encode_def_id(ebml_w, local_def(it.id));
             ebml::end_tag(ebml_w);
-            encode_tag_variant_paths(ebml_w, variants, path, index);
+            encode_enum_variant_paths(ebml_w, variants, path, index);
           }
           item_iface(_, _) {
             add_to_index(ebml_w, path, index, it.ident);
@@ -222,25 +222,25 @@ fn encode_disr_val(_ecx: @encode_ctxt, ebml_w: ebml::writer, disr_val: int) {
     ebml::end_tag(ebml_w);
 }
 
-fn encode_tag_id(ebml_w: ebml::writer, id: def_id) {
-    ebml::start_tag(ebml_w, tag_items_data_item_tag_id);
+fn encode_enum_id(ebml_w: ebml::writer, id: def_id) {
+    ebml::start_tag(ebml_w, tag_items_data_item_enum_id);
     ebml_w.writer.write(str::bytes(def_to_str(id)));
     ebml::end_tag(ebml_w);
 }
 
-fn encode_tag_variant_info(ecx: @encode_ctxt, ebml_w: ebml::writer,
+fn encode_enum_variant_info(ecx: @encode_ctxt, ebml_w: ebml::writer,
                            id: node_id, variants: [variant],
                            &index: [entry<int>], ty_params: [ty_param]) {
     let disr_val = 0;
     let i = 0;
-    let vi = ty::tag_variants(ecx.ccx.tcx, {crate: local_crate, node: id});
+    let vi = ty::enum_variants(ecx.ccx.tcx, {crate: local_crate, node: id});
     for variant: variant in variants {
         index += [{val: variant.node.id, pos: ebml_w.writer.tell()}];
         ebml::start_tag(ebml_w, tag_items_data_item);
         encode_def_id(ebml_w, local_def(variant.node.id));
         encode_family(ebml_w, 'v' as u8);
         encode_name(ebml_w, variant.node.name);
-        encode_tag_id(ebml_w, local_def(id));
+        encode_enum_id(ebml_w, local_def(id));
         encode_type(ecx, ebml_w,
                     node_id_to_monotype(ecx.ccx.tcx, variant.node.id));
         if vec::len::<variant_arg>(variant.node.args) > 0u {
@@ -324,7 +324,7 @@ fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: ebml::writer, item: @item,
         encode_name(ebml_w, item.ident);
         ebml::end_tag(ebml_w);
       }
-      item_tag(variants, tps) {
+      item_enum(variants, tps) {
         ebml::start_tag(ebml_w, tag_items_data_item);
         encode_def_id(ebml_w, local_def(item.id));
         encode_family(ebml_w, 't' as u8);
@@ -335,7 +335,7 @@ fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: ebml::writer, item: @item,
             encode_variant_id(ebml_w, local_def(v.node.id));
         }
         ebml::end_tag(ebml_w);
-        encode_tag_variant_info(ecx, ebml_w, item.id, variants, index, tps);
+        encode_enum_variant_info(ecx, ebml_w, item.id, variants, index, tps);
       }
       item_res(_, tps, _, _, ctor_id) {
         let fn_ty = node_id_to_monotype(tcx, ctor_id);

src/comp/metadata/tydecode.rs

@@ -202,7 +202,7 @@ fn parse_ty(st: @pstate, conv: conv_did) -> ty::t {
         let params: [ty::t] = [];
         while peek(st) as char != ']' { params += [parse_ty(st, conv)]; }
         st.pos = st.pos + 1u;
-        ret ty::mk_tag(st.tcx, def, params);
+        ret ty::mk_enum(st.tcx, def, params);
       }
       'x' {
         assert (next(st) as char == '[');

src/comp/metadata/tyencode.rs

@@ -117,7 +117,7 @@ fn enc_sty(w: io::writer, cx: @ctxt, st: ty::sty) {
         }
       }
       ty::ty_str { w.write_char('S'); }
-      ty::ty_tag(def, tys) {
+      ty::ty_enum(def, tys) {
         w.write_str("t[");
         w.write_str(cx.ds(def));
         w.write_char('|');

src/comp/middle/alias.rs

@@ -502,7 +502,7 @@ fn ty_can_unsafely_include(cx: ctx, needle: unsafe_ty, haystack: ty::t,
           mut_contains(ty) { mut && ty == haystack }
         } { ret true; }
         alt ty::struct(tcx, haystack) {
-          ty::ty_tag(_, ts) {
+          ty::ty_enum(_, ts) {
             for t: ty::t in ts {
                 if helper(tcx, needle, t, mut) { ret true; }
             }
@@ -565,7 +565,7 @@ fn copy_is_expensive(tcx: ty::ctxt, ty: ty::t) -> bool {
           ty::ty_fn(_) | ty::ty_native_fn(_, _) { 4u }
           ty::ty_str | ty::ty_vec(_) | ty::ty_param(_, _) { 50u }
           ty::ty_uniq(mt) { 1u + score_ty(tcx, mt.ty) }
-          ty::ty_tag(_, ts) | ty::ty_tup(ts) {
+          ty::ty_enum(_, ts) | ty::ty_tup(ts) {
             let sum = 0u;
             for t in ts { sum += score_ty(tcx, t); }
             sum
@@ -596,7 +596,7 @@ fn pattern_roots(tcx: ty::ctxt, mut: option::t<unsafe_ty>, pat: @ast::pat)
                         span: pat.span}];
             alt sub { some(p) { walk(tcx, mut, p, set); } _ {} }
           }
-          ast::pat_tag(_, ps) | ast::pat_tup(ps) {
+          ast::pat_enum(_, ps) | ast::pat_tup(ps) {
             for p in ps { walk(tcx, mut, p, set); }
           }
           ast::pat_rec(fs, _) {

src/comp/middle/check_alt.rs

@@ -80,9 +80,9 @@ fn pattern_supersedes(tcx: ty::ctxt, a: @pat, b: @pat) -> bool {
           _ { false }
         }
       }
-      pat_tag(va, suba) {
+      pat_enum(va, suba) {
         alt b.node {
-          pat_tag(vb, subb) {
+          pat_enum(vb, subb) {
             tcx.def_map.get(a.id) == tcx.def_map.get(b.id) &&
                 patterns_supersede(tcx, suba, subb)
           }
@@ -154,9 +154,9 @@ fn is_refutable(tcx: ty::ctxt, pat: @pat) -> bool {
         for elt in elts { if is_refutable(tcx, elt) { ret true; } }
         false
       }
-      pat_tag(_, args) {
+      pat_enum(_, args) {
         let vdef = variant_def_ids(tcx.def_map.get(pat.id));
-        if vec::len(*ty::tag_variants(tcx, vdef.tg)) != 1u { ret true; }
+        if vec::len(*ty::enum_variants(tcx, vdef.tg)) != 1u { ret true; }
         for p: @pat in args { if is_refutable(tcx, p) { ret true; } }
         false
       }

src/comp/middle/check_const.rs

@@ -15,7 +15,7 @@ fn check_crate(sess: session, crate: @crate) {
 fn check_item(it: @item, &&_is_const: bool, v: visit::vt<bool>) {
     alt it.node {
       item_const(_, ex) { v.visit_expr(ex, true, v); }
-      item_tag(vs, _) {
+      item_enum(vs, _) {
         for var in vs {
             option::may(var.node.disr_expr) {|ex|
                 v.visit_expr(ex, true, v);

src/comp/middle/gc.rs

@@ -108,11 +108,6 @@ fn type_is_gc_relevant(cx: ty::ctxt, ty: ty::t) -> bool {
       ty::ty_type | ty::ty_ptr(_) | ty::ty_native(_) {
         ret false;
       }
-
-
-
-
-
       ty::ty_rec(fields) {
         for f in fields { if type_is_gc_relevant(cx, f.mt.ty) { ret true; } }
         ret false;
@@ -121,13 +116,8 @@ fn type_is_gc_relevant(cx: ty::ctxt, ty: ty::t) -> bool {
         for elt in elts { if type_is_gc_relevant(cx, elt) { ret true; } }
         ret false;
       }
-
-
-
-
-
-      ty::ty_tag(did, tps) {
-        let variants = ty::tag_variants(cx, did);
+      ty::ty_enum(did, tps) {
+        let variants = ty::enum_variants(cx, did);
         for variant in *variants {
             for aty in variant.args {
                 let arg_ty = ty::substitute_type_params(cx, tps, aty);
@@ -136,11 +126,6 @@ fn type_is_gc_relevant(cx: ty::ctxt, ty: ty::t) -> bool {
         }
         ret false;
       }
-
-
-
-
-
       ty::ty_vec(tm) {
         ret type_is_gc_relevant(cx, tm.ty);
       }

src/comp/middle/mut.rs

@@ -31,8 +31,8 @@ fn expr_root(tcx: ty::ctxt, ex: @expr, autoderef: bool) ->
                 ds += [@{mut: false, kind: unbox, outer_t: t}];
                 t = ty::substitute_type_params(tcx, tps, inner);
               }
-              ty::ty_tag(did, tps) {
-                let variants = ty::tag_variants(tcx, did);
+              ty::ty_enum(did, tps) {
+                let variants = ty::enum_variants(tcx, did);
                 if vec::len(*variants) != 1u ||
                        vec::len(variants[0].args) != 1u {
                     break;
@@ -90,7 +90,7 @@ fn expr_root(tcx: ty::ctxt, ex: @expr, autoderef: bool) ->
                   ty::ty_box(mt) { is_mut = mt.mut == mut; }
                   ty::ty_uniq(mt) { is_mut = mt.mut == mut; }
                   ty::ty_res(_, _, _) { }
-                  ty::ty_tag(_, _) { }
+                  ty::ty_enum(_, _) { }
                   ty::ty_ptr(mt) { is_mut = mt.mut == mut; }
                 }
                 ds += [@{mut: is_mut, kind: unbox, outer_t: base_t}];

src/comp/middle/pat_util.rs

@@ -22,8 +22,8 @@ fn normalize_pat_def_map(dm: resolve::def_map, p: @pat) -> @pat {
         @{node: pat_ident(q, some(normalize_pat_def_map(dm, r)))
             with *p}
       }
-      pat_tag(a_path, subs) {
-        @{node: pat_tag(a_path,
+      pat_enum(a_path, subs) {
+        @{node: pat_enum(a_path,
            vec::map(subs, {|p| normalize_pat_def_map(dm, p)})) with *p}
       }
       pat_rec(field_pats, b) {
@@ -52,8 +52,8 @@ fn normalize_one(dm: resolve::def_map, p: @pat) -> @pat {
     alt dm.find(p.id) {
         some(d) {
           alt p.node {
-              pat_ident(tag_path, _) { @{id: p.id,
-                    node: pat_tag(tag_path, []),
+              pat_ident(enum_path, _) { @{id: p.id,
+                    node: pat_enum(enum_path, []),
                     span: p.span} }
               _ { p }
           }
@@ -95,7 +95,7 @@ fn pat_bindings(pat: @pat, it: fn(@pat)) {
   alt pat.node {
       pat_ident(_, option::none) { it(pat); }
       pat_ident(_, option::some(sub)) { it(pat); pat_bindings(sub, it); }
-      pat_tag(_, sub) { for p in sub { pat_bindings(p, it); } }
+      pat_enum(_, sub) { for p in sub { pat_bindings(p, it); } }
       pat_rec(fields, _) { for f in fields { pat_bindings(f.pat, it); } }
       pat_tup(elts) { for elt in elts { pat_bindings(elt, it); } }
       pat_box(sub) { pat_bindings(sub, it); }