From bdb8f6cf52a2a4e2f78e6fa95d42140aa26ec31c Mon Sep 17 00:00:00 2001 From: Patrick Walton Date: Thu, 19 Jan 2012 14:24:03 -0800 Subject: [PATCH] rustc: "tag" -> "enum" --- src/comp/back/link.rs | 2 +- src/comp/driver/diagnostic.rs | 2 +- src/comp/driver/driver.rs | 2 +- src/comp/driver/rustc.rs | 2 +- src/comp/driver/session.rs | 6 +-- src/comp/lib/llvm.rs | 2 +- src/comp/metadata/common.rs | 2 +- src/comp/metadata/cstore.rs | 4 +- src/comp/metadata/decoder.rs | 4 +- src/comp/metadata/tyencode.rs | 2 +- src/comp/middle/alias.rs | 8 ++-- src/comp/middle/ast_map.rs | 2 +- src/comp/middle/capture.rs | 2 +- src/comp/middle/debuginfo.rs | 2 +- src/comp/middle/last_use.rs | 4 +- src/comp/middle/mut.rs | 4 +- src/comp/middle/resolve.rs | 46 +++++++++--------- src/comp/middle/shape.rs | 22 ++++----- src/comp/middle/trans.rs | 38 +++++++-------- src/comp/middle/trans_alt.rs | 10 ++-- src/comp/middle/trans_closure.rs | 2 +- src/comp/middle/trans_common.rs | 14 +++--- src/comp/middle/tstate/auxiliary.rs | 8 ++-- src/comp/middle/tstate/tritv.rs | 2 +- src/comp/middle/ty.rs | 28 +++++------ src/comp/middle/typeck.rs | 26 +++++------ src/comp/syntax/ast.rs | 72 ++++++++++++++--------------- src/comp/syntax/ast_util.rs | 2 +- src/comp/syntax/codemap.rs | 2 +- src/comp/syntax/ext/base.rs | 2 +- src/comp/syntax/ext/simplext.rs | 4 +- src/comp/syntax/parse/lexer.rs | 2 +- src/comp/syntax/parse/parser.rs | 14 +++--- src/comp/syntax/parse/token.rs | 4 +- src/comp/syntax/print/pp.rs | 6 +-- src/comp/syntax/print/pprust.rs | 6 +-- src/comp/syntax/visit.rs | 6 +-- 37 files changed, 183 insertions(+), 183 deletions(-) diff --git a/src/comp/back/link.rs b/src/comp/back/link.rs index c7a195db90a..49b63731291 100644 --- a/src/comp/back/link.rs +++ b/src/comp/back/link.rs @@ -22,7 +22,7 @@ import lib::llvm::False; import util::filesearch; -tag output_type { +enum output_type { output_type_none; output_type_bitcode; output_type_assembly; diff --git a/src/comp/driver/diagnostic.rs b/src/comp/driver/diagnostic.rs index 6a44c5763de..6011f35ab92 100644 --- a/src/comp/driver/diagnostic.rs +++ b/src/comp/driver/diagnostic.rs @@ -107,7 +107,7 @@ fn mk_handler(cm: codemap::codemap, } as handler } -tag level { +enum level { fatal; error; warning; diff --git a/src/comp/driver/driver.rs b/src/comp/driver/driver.rs index f14d351c4fc..7d0d1741918 100644 --- a/src/comp/driver/driver.rs +++ b/src/comp/driver/driver.rs @@ -18,7 +18,7 @@ import getopts::{optopt, optmulti, optflag, optflagopt, opt_present}; import back::{x86, x86_64}; -tag pp_mode { ppm_normal; ppm_expanded; ppm_typed; ppm_identified; } +enum pp_mode { ppm_normal; ppm_expanded; ppm_typed; ppm_identified; } fn default_configuration(sess: session, argv0: str, input: str) -> ast::crate_cfg { diff --git a/src/comp/driver/rustc.rs b/src/comp/driver/rustc.rs index 8ca9a3e6f72..9e6bb565cad 100644 --- a/src/comp/driver/rustc.rs +++ b/src/comp/driver/rustc.rs @@ -127,7 +127,7 @@ fn run_compiler(args: [str], demitter: diagnostic::emitter) { bug and need to present an error. */ fn monitor(f: fn~(diagnostic::emitter)) { - tag monitor_msg { + enum monitor_msg { fatal; done; }; diff --git a/src/comp/driver/session.rs b/src/comp/driver/session.rs index 67a8268f5fd..bef939bb1c8 100644 --- a/src/comp/driver/session.rs +++ b/src/comp/driver/session.rs @@ -10,11 +10,11 @@ import back::target_strs; import middle::lint; -tag os { os_win32; os_macos; os_linux; os_freebsd; } +enum os { os_win32; os_macos; os_linux; os_freebsd; } -tag arch { arch_x86; arch_x86_64; arch_arm; } +enum arch { arch_x86; arch_x86_64; arch_arm; } -tag crate_type { bin_crate; lib_crate; unknown_crate; } +enum crate_type { bin_crate; lib_crate; unknown_crate; } type config = {os: os, diff --git a/src/comp/lib/llvm.rs b/src/comp/lib/llvm.rs index a164ba1e108..1ee0f44297d 100644 --- a/src/comp/lib/llvm.rs +++ b/src/comp/lib/llvm.rs @@ -15,7 +15,7 @@ // Consts for the LLVM CallConv type, pre-cast to uint. // FIXME: figure out a way to merge these with the native -// typedef and/or a tag type in the native module below. +// typedef and/or a enum type in the native module below. const LLVMCCallConv: uint = 0u; const LLVMFastCallConv: uint = 8u; diff --git a/src/comp/metadata/common.rs b/src/comp/metadata/common.rs index b16120d1bec..c4ca48d6b3e 100644 --- a/src/comp/metadata/common.rs +++ b/src/comp/metadata/common.rs @@ -1,4 +1,4 @@ -// EBML tag definitions and utils shared by the encoder and decoder +// EBML enum definitions and utils shared by the encoder and decoder import str; diff --git a/src/comp/metadata/cstore.rs b/src/comp/metadata/cstore.rs index de56aa236f5..6fb9ac4edb4 100644 --- a/src/comp/metadata/cstore.rs +++ b/src/comp/metadata/cstore.rs @@ -36,11 +36,11 @@ cnum: ast::crate_num}; // This is a bit of an experiment at encapsulating the data in cstore. By -// keeping all the data in a non-exported tag variant, it's impossible for +// keeping all the data in a non-exported enum variant, it's impossible for // other modules to access the cstore's private data. This could also be // achieved with an obj, but at the expense of a vtable. Not sure if this is a // good pattern or not. -tag cstore { private(cstore_private); } +enum cstore { private(cstore_private); } type cstore_private = @{metas: map::hashmap, diff --git a/src/comp/metadata/decoder.rs b/src/comp/metadata/decoder.rs index e3790e4b09b..6b573de4c50 100644 --- a/src/comp/metadata/decoder.rs +++ b/src/comp/metadata/decoder.rs @@ -252,7 +252,7 @@ fn get_tag_variants(cdata: cmd, id: ast::node_id, tcx: ty::ctxt) ty::ty_fn(f) { for a: ty::arg in f.inputs { arg_tys += [a.ty]; } } - _ { /* Nullary tag variant. */ } + _ { /* Nullary enum variant. */ } } alt variant_disr_val(item) { some(val) { disr_val = val; } @@ -347,7 +347,7 @@ fn item_family_to_str(fam: u8) -> str { 't' { ret "type"; } 'm' { ret "mod"; } 'n' { ret "native mod"; } - 'v' { ret "tag"; } + 'v' { ret "enum"; } 'i' { ret "impl"; } 'I' { ret "iface"; } } diff --git a/src/comp/metadata/tyencode.rs b/src/comp/metadata/tyencode.rs index d4c562b67f9..539d3fad079 100644 --- a/src/comp/metadata/tyencode.rs +++ b/src/comp/metadata/tyencode.rs @@ -25,7 +25,7 @@ // Whatever format you choose should not contain pipe characters. type ty_abbrev = {pos: uint, len: uint, s: @str}; -tag abbrev_ctxt { ac_no_abbrevs; ac_use_abbrevs(hashmap); } +enum abbrev_ctxt { ac_no_abbrevs; ac_use_abbrevs(hashmap); } fn cx_uses_abbrevs(cx: @ctxt) -> bool { alt cx.abbrevs { diff --git a/src/comp/middle/alias.rs b/src/comp/middle/alias.rs index c799e9956b0..adb08f3e563 100644 --- a/src/comp/middle/alias.rs +++ b/src/comp/middle/alias.rs @@ -15,13 +15,13 @@ // getting input from one, to be more precise). It is a pass that checks // whether aliases are used in a safe way. -tag copied { not_allowed; copied; not_copied; } -tag invalid_reason { overwritten; val_taken; } +enum copied { not_allowed; copied; not_copied; } +enum invalid_reason { overwritten; val_taken; } type invalid = {reason: invalid_reason, node_id: node_id, sp: span, path: @ast::path}; -tag unsafe_ty { contains(ty::t); mut_contains(ty::t); } +enum unsafe_ty { contains(ty::t); mut_contains(ty::t); } type binding = @{node_id: node_id, span: span, @@ -46,7 +46,7 @@ fn mk_binding(cx: ctx, id: node_id, span: span, root_var: option::t, mutable copied: not_copied}; } -tag local_info { local(uint); } +enum local_info { local(uint); } type copy_map = std::map::hashmap; type ref_map = std::map::hashmap; diff --git a/src/comp/middle/ast_map.rs b/src/comp/middle/ast_map.rs index de04da49014..eeb44ce3a51 100644 --- a/src/comp/middle/ast_map.rs +++ b/src/comp/middle/ast_map.rs @@ -4,7 +4,7 @@ import syntax::ast_util; import syntax::{visit, codemap}; -tag ast_node { +enum ast_node { node_item(@item); node_native_item(@native_item); node_method(@method); diff --git a/src/comp/middle/capture.rs b/src/comp/middle/capture.rs index 9fb600d41c7..7d4bd45256e 100644 --- a/src/comp/middle/capture.rs +++ b/src/comp/middle/capture.rs @@ -12,7 +12,7 @@ export cap_drop; export cap_ref; -tag capture_mode { +enum capture_mode { cap_copy; //< Copy the value into the closure. cap_move; //< Move the value into the closure. cap_drop; //< Drop value after creating closure. diff --git a/src/comp/middle/debuginfo.rs b/src/comp/middle/debuginfo.rs index 096fc2fb99d..fc56e39b63a 100644 --- a/src/comp/middle/debuginfo.rs +++ b/src/comp/middle/debuginfo.rs @@ -108,7 +108,7 @@ fn update_cache(cache: metadata_cache, mdtag: int, val: debug_metadata) { type metadata_cache = hashmap; -tag debug_metadata { +enum debug_metadata { file_metadata(@metadata); compile_unit_metadata(@metadata); subprogram_metadata(@metadata); diff --git a/src/comp/middle/last_use.rs b/src/comp/middle/last_use.rs index c5c7c544831..ce860506feb 100644 --- a/src/comp/middle/last_use.rs +++ b/src/comp/middle/last_use.rs @@ -26,8 +26,8 @@ // Marks expr_paths that are last uses. type last_uses = std::map::hashmap; -tag seen { unset; seen(node_id); } -tag block_type { func; loop; } +enum seen { unset; seen(node_id); } +enum block_type { func; loop; } type set = [{def: node_id, exprs: list}]; type bl = @{type: block_type, mutable second: bool, mutable exits: [set]}; diff --git a/src/comp/middle/mut.rs b/src/comp/middle/mut.rs index 0eebf4e1ef9..953b430a21b 100644 --- a/src/comp/middle/mut.rs +++ b/src/comp/middle/mut.rs @@ -5,7 +5,7 @@ import syntax::ast_util; import driver::session::session; -tag deref_t { unbox; field; index; } +enum deref_t { unbox; field; index; } type deref = @{mut: bool, kind: deref_t, outer_t: ty::t}; @@ -121,7 +121,7 @@ fn check_crate(tcx: ty::ctxt, crate: @crate) -> mut_map { ret cx.mut_map; } -tag msg { msg_assign; msg_move_out; msg_mut_ref; } +enum msg { msg_assign; msg_move_out; msg_mut_ref; } fn mk_err(cx: @ctx, span: syntax::codemap::span, msg: msg, name: str) { cx.tcx.sess.span_err(span, alt msg { diff --git a/src/comp/middle/resolve.rs b/src/comp/middle/resolve.rs index 487ea536688..0f19721d56e 100644 --- a/src/comp/middle/resolve.rs +++ b/src/comp/middle/resolve.rs @@ -30,7 +30,7 @@ // locates all names (in expressions, types, and alt patterns) and resolves // them, storing the resulting def in the AST nodes. -tag scope { +enum scope { scope_crate; scope_item(@ast::item); scope_bare_fn(ast::fn_decl, node_id, [ast::ty_param]); @@ -44,7 +44,7 @@ type scopes = list; -tag import_state { +enum import_state { todo(ast::node_id, ast::ident, @[ast::ident], codemap::span, scopes); is_glob(@[ast::ident], scopes, codemap::span); resolving(span); @@ -56,7 +56,7 @@ ast::ident, codemap::span); } -tag glob_import_state { +enum glob_import_state { glob_resolving(span); glob_resolved(option::t, /* value */ option::t, /* type */ @@ -98,12 +98,12 @@ fn eq(v1: key, v2: key) -> bool { ret std::map::mk_hashmap::(hash, eq); } -tag mod_index_entry { +enum mod_index_entry { mie_view_item(@ast::view_item); mie_import_ident(node_id, codemap::span); mie_item(@ast::item); mie_native_item(@ast::native_item); - mie_tag_variant(/* tag item */@ast::item, /* variant index */uint); + mie_tag_variant(/* enum item */@ast::item, /* variant index */uint); } type mod_index = hashmap>; @@ -151,14 +151,14 @@ fn eq(v1: key, v2: key) -> bool { // Used to distinguish between lookups from outside and from inside modules, // since export restrictions should only be applied for the former. -tag dir { inside; outside; } +enum dir { inside; outside; } -// There are two types of ns_value tag: "definitely a tag"; +// There are two types of ns_value enum: "definitely a enum"; // and "any value". This is so that lookup can behave differently // when looking up a variable name that's not yet in scope to check -// if it's already bound to a tag. -tag namespace { ns_val(ns_value_type); ns_type; ns_module; } -tag ns_value_type { ns_a_tag; ns_any_value; } +// if it's already bound to a enum. +enum namespace { ns_val(ns_value_type); ns_type; ns_module; } +enum ns_value_type { ns_a_tag; ns_any_value; } fn resolve_crate(sess: session, amap: ast_map::map, crate: @ast::crate) -> {def_map: def_map, exp_map: exp_map, impl_map: impl_map} { @@ -186,7 +186,7 @@ fn resolve_crate(sess: session, amap: ast_map::map, crate: @ast::crate) -> resolve_names(e, crate); resolve_impls(e, crate); // check_for_collisions must happen after resolve_names so we - // don't complain if a pattern uses the same nullary tag twice + // don't complain if a pattern uses the same nullary enum twice check_for_collisions(e, *crate); if sess.opts.warn_unused_imports { check_unused_imports(e); @@ -415,13 +415,13 @@ fn walk_pat(e: @env, pat: @ast::pat, sc: scopes, v: vt) { } _ { e.sess.span_err(p.span, - "not a tag variant: " + + "not a enum variant: " + ast_util::path_name(p)); } } } /* Here we determine whether a given pat_ident binds a new - variable a refers to a nullary tag. */ + variable a refers to a nullary enum. */ ast::pat_ident(p, none) { let fnd = lookup_in_scope(*e, sc, p.span, path_to_ident(p), ns_val(ns_a_tag)); @@ -557,13 +557,13 @@ fn visit_expr_with_scope(x: @ast::expr, sc: scopes, v: vt) { } // This is only for irrefutable patterns (e.g. ones that appear in a let) -// So if x occurs, and x is already known to be a tag, that's always an error +// So if x occurs, and x is already known to be a enum, that's always an error fn visit_local_with_scope(e: @env, loc: @local, sc:scopes, v:vt) { - // Check whether the given local has the same name as a tag that's + // Check whether the given local has the same name as a enum that's // in scope // We disallow this, in order to make alt patterns consisting of // a single identifier unambiguous (does the pattern "foo" refer - // to tag foo, or is it binding a new name foo?) + // to enum foo, or is it binding a new name foo?) alt loc.node.pat.node { pat_ident(an_ident,_) { // Be sure to pass ns_a_tag to lookup_in_scope so that @@ -571,10 +571,10 @@ fn visit_local_with_scope(e: @env, loc: @local, sc:scopes, v:vt) { alt lookup_in_scope(*e, sc, loc.span, path_to_ident(an_ident), ns_val(ns_a_tag)) { some(ast::def_variant(tag_id,variant_id)) { - // Declaration shadows a tag that's in scope. + // Declaration shadows a enum that's in scope. // That's an error. e.sess.span_err(loc.span, - #fmt("Declaration of %s shadows a tag that's in scope", + #fmt("Declaration of %s shadows a enum that's in scope", path_to_ident(an_ident))); } _ {} @@ -742,14 +742,14 @@ fn ns_name(ns: namespace) -> str { ns_val(v) { alt (v) { ns_any_value { "name" } - ns_a_tag { "tag" } + ns_a_tag { "enum" } } } ns_module { ret "modulename" } } } -tag ctxt { in_mod(def); in_scope(scopes); } +enum ctxt { in_mod(def); in_scope(scopes); } fn unresolved_err(e: env, cx: ctxt, sp: span, name: ident, kind: str) { fn find_fn_or_mod_scope(sc: scopes) -> option::t { @@ -967,8 +967,8 @@ fn in_scope(e: env, sp: span, name: ident, s: scope, ns: namespace) -> } ns_val(v) { alt(v) { - /* If we were looking for a tag, at this point - we know it's bound to a non-tag value, and + /* If we were looking for a enum, at this point + we know it's bound to a non-enum value, and we can return none instead of failing */ ns_a_tag { ret none; } _ { "attempted dynamic environment-capture" } @@ -1468,7 +1468,7 @@ fn ns_for_def(d: def) -> namespace { } // if we're searching for a value, it's ok if we found -// a tag +// a enum fn ns_ok(wanted:namespace, actual:namespace) -> bool { alt actual { ns_val(ns_a_tag) { diff --git a/src/comp/middle/shape.rs b/src/comp/middle/shape.rs index bb3de341df1..0f391f4161a 100644 --- a/src/comp/middle/shape.rs +++ b/src/comp/middle/shape.rs @@ -98,8 +98,8 @@ fn mk_global(ccx: @crate_ctxt, name: str, llval: ValueRef, internal: bool) -> } -// Computes a set of variants of a tag that are guaranteed to have size and -// alignment at least as large as any other variant of the tag. This is an +// Computes a set of variants of a enum that are guaranteed to have size and +// alignment at least as large as any other variant of the enum. This is an // important performance optimization. // // TODO: Use this in dynamic_size_of() as well. @@ -180,7 +180,7 @@ fn largest_variants(ccx: @crate_ctxt, tag_id: ast::def_id) -> [uint] { ret result; } -// Computes the static size of a tag, without using mk_tup(), which is +// Computes the static size of a enum, without using mk_tup(), which is // bad for performance. // // TODO: Migrate trans over to use this. @@ -217,8 +217,8 @@ fn compute_static_tag_size(ccx: @crate_ctxt, largest_variants: [uint], if max_align < variant_align { max_align = variant_align; } } - // Add space for the tag if applicable. - // FIXME (issue #792): This is wrong. If the tag starts with an 8 byte + // Add space for the enum if applicable. + // FIXME (issue #792): This is wrong. If the enum starts with an 8 byte // aligned quantity, we don't align it. if vec::len(*variants) > 1u { let variant_t = T_tag_variant(ccx); @@ -230,7 +230,7 @@ fn compute_static_tag_size(ccx: @crate_ctxt, largest_variants: [uint], ret {size: max_size, align: max_align}; } -tag tag_kind { tk_unit; tk_enum; tk_complex; } +enum tag_kind { tk_unit; tk_enum; tk_complex; } fn tag_kind(ccx: @crate_ctxt, did: ast::def_id) -> tag_kind { let variants = ty::tag_variants(ccx.tcx, did); @@ -469,7 +469,7 @@ fn shape_of_variant(ccx: @crate_ctxt, v: ty::variant_info, //} fn gen_tag_shapes(ccx: @crate_ctxt) -> ValueRef { - // Loop over all the tag variants and write their shapes into a data + // Loop over all the enum variants and write their shapes into a data // buffer. As we do this, it's possible for us to discover new tags, so we // must do this first. let i = 0u; @@ -495,7 +495,7 @@ fn gen_tag_shapes(ccx: @crate_ctxt) -> ValueRef { } // Now calculate the sizes of the header space (which contains offsets to - // info records for each tag) and the info space (which contains offsets + // info records for each enum) and the info space (which contains offsets // to each variant shape). As we do so, build up the header. let header = []; @@ -512,7 +512,7 @@ fn gen_tag_shapes(ccx: @crate_ctxt) -> ValueRef { } // Construct the info tables, which contain offsets to the shape of each - // variant. Also construct the largest-variant table for each tag, which + // variant. Also construct the largest-variant table for each enum, which // contains the variants that the size-of operation needs to look at. let lv_table = []; @@ -530,7 +530,7 @@ fn gen_tag_shapes(ccx: @crate_ctxt) -> ValueRef { add_u16(lv_table, vec::len(lv) as u16); for v: uint in lv { add_u16(lv_table, v as u16); } - // Determine whether the tag has dynamic size. + // Determine whether the enum has dynamic size. let dynamic = false; for variant: ty::variant_info in *variants { for typ: ty::t in variant.args { @@ -538,7 +538,7 @@ fn gen_tag_shapes(ccx: @crate_ctxt) -> ValueRef { } } - // If we can, write in the static size and alignment of the tag. + // If we can, write in the static size and alignment of the enum. // Otherwise, write a placeholder. let size_align; if dynamic { diff --git a/src/comp/middle/trans.rs b/src/comp/middle/trans.rs index 92a37ab36d9..8b85b78fde1 100644 --- a/src/comp/middle/trans.rs +++ b/src/comp/middle/trans.rs @@ -498,7 +498,7 @@ fn simplifier(ccx: @crate_ctxt, typ: ty::t) -> ty::t { } -// Computes the size of the data part of a non-dynamically-sized tag. +// Computes the size of the data part of a non-dynamically-sized enum. fn static_size_of_tag(cx: @crate_ctxt, sp: span, t: ty::t) : type_has_static_size(cx, t) -> uint { if cx.tag_sizes.contains_key(t) { ret cx.tag_sizes.get(t); } @@ -526,7 +526,7 @@ fn static_size_of_tag(cx: @crate_ctxt, sp: span, t: ty::t) ret max_size; } _ { - cx.tcx.sess.span_fatal(sp, "non-tag passed to static_size_of_tag()"); + cx.tcx.sess.span_fatal(sp, "non-enum passed to static_size_of_tag()"); } } } @@ -736,9 +736,9 @@ fn compute_off(bcx: @block_ctxt, } -// Replacement for the LLVM 'GEP' instruction when field indexing into a tag. +// Replacement for the LLVM 'GEP' instruction when field indexing into a enum. // This function uses GEP_tup_like() above and automatically performs casts as -// appropriate. @llblobptr is the data part of a tag value; its actual type is +// appropriate. @llblobptr is the data part of a enum value; its actual type is // meaningless, as it will be cast away. fn GEP_tag(cx: @block_ctxt, llblobptr: ValueRef, tag_id: ast::def_id, variant_id: ast::def_id, ty_substs: [ty::t], @@ -1470,7 +1470,7 @@ fn maybe_name_value(cx: @crate_ctxt, v: ValueRef, s: str) { // Used only for creating scalar comparison glue. -tag scalar_type { nil_type; signed_int; unsigned_int; floating_point; } +enum scalar_type { nil_type; signed_int; unsigned_int; floating_point; } fn compare_scalar_types(cx: @block_ctxt, lhs: ValueRef, rhs: ValueRef, @@ -1658,14 +1658,14 @@ fn iter_variant(cx: @block_ctxt, a_tup: ValueRef, // NB: we must hit the discriminant first so that structural // comparison know not to proceed when the discriminants differ. cx = f(cx, lldiscrim_a_ptr, ty::mk_int(bcx_tcx(cx))); - let unr_cx = new_sub_block_ctxt(cx, "tag-iter-unr"); + let unr_cx = new_sub_block_ctxt(cx, "enum-iter-unr"); Unreachable(unr_cx); let llswitch = Switch(cx, lldiscrim_a, unr_cx.llbb, n_variants); - let next_cx = new_sub_block_ctxt(cx, "tag-iter-next"); + let next_cx = new_sub_block_ctxt(cx, "enum-iter-next"); for variant: ty::variant_info in *variants { let variant_cx = new_sub_block_ctxt(cx, - "tag-iter-variant-" + + "enum-iter-variant-" + int::to_str(variant.disr_val, 10u)); AddCase(llswitch, C_int(ccx, variant.disr_val), variant_cx.llbb); variant_cx = @@ -1938,7 +1938,7 @@ fn memmove_ty(bcx: @block_ctxt, dst: ValueRef, src: ValueRef, t: ty::t) -> ret call_memmove(bcx, dst, src, llsz).bcx; } -tag copy_action { INIT; DROP_EXISTING; } +enum copy_action { INIT; DROP_EXISTING; } // These are the types that are passed by pointer. fn type_is_structural_or_param(tcx: ty::ctxt, t: ty::t) -> bool { @@ -2244,7 +2244,7 @@ fn autoderef(cx: @block_ctxt, v: ValueRef, t: ty::t) -> result_t { t1 = mt.ty; // Since we're changing levels of box indirection, we may have - // to cast this pointer, since statically-sized tag types have + // to cast this pointer, since statically-sized enum types have // different types depending on whether they're behind a box // or not. if check type_has_static_size(ccx, t1) { @@ -2330,7 +2330,7 @@ fn trans_binary(cx: @block_ctxt, op: ast::binop, a: @ast::expr, b: @ast::expr, } } -tag dest { +enum dest { by_val(@mutable ValueRef); save_in(ValueRef); ignore; @@ -2495,14 +2495,14 @@ fn trans_do_while(cx: @block_ctxt, body: ast::blk, cond: @ast::expr) -> origins: option::t }; -tag lval_kind { +enum lval_kind { temporary; //< Temporary value passed by value if of immediate type owned; //< Non-temporary value passed by pointer owned_imm; //< Non-temporary value passed by value } type local_var_result = {val: ValueRef, kind: lval_kind}; type lval_result = {bcx: @block_ctxt, val: ValueRef, kind: lval_kind}; -tag callee_env { +enum callee_env { null_env; is_closure; self_env(ValueRef); @@ -2896,7 +2896,7 @@ fn trans_cast(cx: @block_ctxt, e: @ast::expr, id: ast::node_id, check (type_has_static_size(ccx, t_out)); let ll_t_out = type_of(ccx, e.span, t_out); - tag kind { pointer; integral; float; tag_; other; } + enum kind { pointer; integral; float; tag_; other; } fn t_kind(tcx: ty::ctxt, t: ty::t) -> kind { ret if ty::type_is_fp(tcx, t) { float @@ -3540,7 +3540,7 @@ fn trans_expr(bcx: @block_ctxt, e: @ast::expr, dest: dest) -> @block_ctxt { ret trans_ret(bcx, ex); } ast::expr_be(ex) { - // Ideally, the expr_be tag would have a precondition + // Ideally, the expr_be enum would have a precondition // that is_call_expr(ex) -- but we don't support that // yet // FIXME @@ -4409,7 +4409,7 @@ fn finish_fn(fcx: @fn_ctxt, lltop: BasicBlockRef) { RetVoid(ret_cx); } -tag self_arg { impl_self(ty::t); no_self; } +enum self_arg { impl_self(ty::t); no_self; } // trans_closure: Builds an LLVM function out of a source function. // If the function closes over its environment a closure will be @@ -4557,7 +4557,7 @@ fn trans_tag_variant(cx: @local_ctxt, tag_id: ast::node_id, let lltop = bcx.llbb; bcx = copy_args_to_allocas(fcx, bcx, fn_args, arg_tys); - // Cast the tag to a type we can GEP into. + // Cast the enum to a type we can GEP into. let llblobptr = if is_degen { fcx.llretptr @@ -4576,7 +4576,7 @@ fn trans_tag_variant(cx: @local_ctxt, tag_id: ast::node_id, let rslt = GEP_tag(bcx, llblobptr, t_id, v_id, ty_param_substs, i); bcx = rslt.bcx; let lldestptr = rslt.val; - // If this argument to this function is a tag, it'll have come in to + // If this argument to this function is a enum, it'll have come in to // this function as an opaque blob due to the way that type_of() // works. So we have to cast to the destination's view of the type. let llarg = alt fcx.llargs.find(va.id) { some(local_mem(x)) { x } }; @@ -5222,7 +5222,7 @@ fn collect_item(ccx: @crate_ctxt, abi: @mutable option::t, for variant in variants { if vec::len(variant.node.args) != 0u { register_fn(ccx, i.span, new_pt + [variant.node.name], - "tag", tps, variant.node.id); + "enum", tps, variant.node.id); } } } diff --git a/src/comp/middle/trans_alt.rs b/src/comp/middle/trans_alt.rs index cef43dc25e5..dbe46f6e456 100644 --- a/src/comp/middle/trans_alt.rs +++ b/src/comp/middle/trans_alt.rs @@ -16,8 +16,8 @@ import trans_common::*; -// An option identifying a branch (either a literal, a tag variant or a range) -tag opt { +// An option identifying a branch (either a literal, a enum variant or a range) +enum opt { lit(@ast::expr); var(/* disr val */int, /* variant dids */{tg: def_id, var: def_id}); range(@ast::expr, @ast::expr); @@ -34,7 +34,7 @@ fn opt_eq(a: opt, b: opt) -> bool { } } -tag opt_result { +enum opt_result { single_result(result); range_result(result, result); } @@ -284,7 +284,7 @@ fn extract_variant_args(bcx: @block_ctxt, pat_id: ast::node_id, let r = // invariant needed: // how do we know it even makes sense to pass in ty_param_substs - // here? What if it's [] and the tag type has variables in it? + // here? What if it's [] and the enum type has variables in it? trans::GEP_tag(bcx, blobptr, vdefs_tg, vdefs_var, ty_param_substs, i); bcx = r.bcx; @@ -472,7 +472,7 @@ fn compile_submatch(bcx: @block_ctxt, m: match, vals: [ValueRef], f: mk_fail, // Decide what kind of branch we need let opts = get_options(ccx, m, col); - tag branch_kind { no_branch; single; switch; compare; } + enum branch_kind { no_branch; single; switch; compare; } let kind = no_branch; let test_val = val; if vec::len(opts) > 0u { diff --git a/src/comp/middle/trans_closure.rs b/src/comp/middle/trans_closure.rs index 4915a975322..9b864603b0c 100644 --- a/src/comp/middle/trans_closure.rs +++ b/src/comp/middle/trans_closure.rs @@ -109,7 +109,7 @@ // // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -tag environment_value { +enum environment_value { // Evaluate expr and store result in env (used for bind). env_expr(@ast::expr); diff --git a/src/comp/middle/trans_common.rs b/src/comp/middle/trans_common.rs index 0a2045dcb2b..56a8c7016eb 100644 --- a/src/comp/middle/trans_common.rs +++ b/src/comp/middle/trans_common.rs @@ -32,7 +32,7 @@ fn new_namegen() -> namegen { type derived_tydesc_info = {lltydesc: ValueRef, escapes: bool}; -tag tydesc_kind { +enum tydesc_kind { tk_static; // Static (monomorphic) type descriptor tk_param; // Type parameter. tk_derived; // Derived from a typaram or another derived tydesc. @@ -131,7 +131,7 @@ fn new_namegen() -> namegen { // Types used for llself. type val_self_pair = {v: ValueRef, t: ty::t}; -tag local_val { local_mem(ValueRef); local_imm(ValueRef); } +enum local_val { local_mem(ValueRef); local_imm(ValueRef); } type fn_ty_param = {desc: ValueRef, dicts: option::t<[ValueRef]>}; @@ -242,7 +242,7 @@ fn new_namegen() -> namegen { sp: span, lcx: @local_ctxt}; -tag cleanup { +enum cleanup { clean(fn@(@block_ctxt) -> @block_ctxt); clean_temp(ValueRef, fn@(@block_ctxt) -> @block_ctxt); } @@ -331,7 +331,7 @@ fn get_res_dtor(ccx: @crate_ctxt, sp: span, did: ast::def_id, inner_t: ty::t) did), f_t); } -tag block_kind { +enum block_kind { // A scope block is a basic block created by translating a block { ... } @@ -387,8 +387,8 @@ fn get_res_dtor(ccx: @crate_ctxt, sp: span, did: ast::def_id, inner_t: ty::t) fcx: @fn_ctxt}; // FIXME: we should be able to use option::t<@block_parent> here but -// the infinite-tag check in rustboot gets upset. -tag block_parent { parent_none; parent_some(@block_ctxt); } +// the infinite-enum check in rustboot gets upset. +enum block_parent { parent_none; parent_some(@block_ctxt); } type result = {bcx: @block_ctxt, val: ValueRef}; type result_t = {bcx: @block_ctxt, val: ValueRef, ty: ty::t}; @@ -885,7 +885,7 @@ fn C_shape(ccx: @crate_ctxt, bytes: [u8]) -> ValueRef { } // Used to identify cached dictionaries -tag dict_param { +enum dict_param { dict_param_dict(dict_id); dict_param_ty(ty::t); } diff --git a/src/comp/middle/tstate/auxiliary.rs b/src/comp/middle/tstate/auxiliary.rs index 04469cda4eb..e3a85c41692 100644 --- a/src/comp/middle/tstate/auxiliary.rs +++ b/src/comp/middle/tstate/auxiliary.rs @@ -22,7 +22,7 @@ // Used to communicate which operands should be invalidated // to helper functions -tag oper_type { +enum oper_type { oper_move; oper_swap; oper_assign; @@ -198,7 +198,7 @@ fn print_idents(&idents: [ident]) { // for this local. type constr_arg_use = spanned>; -tag constraint { +enum constraint { cinit(uint, span, ident); // FIXME: really only want it to be mutable during collect_locals. @@ -211,7 +211,7 @@ fn print_idents(&idents: [ident]) { // predicate need not be local. // FIXME: would be nice to give both a def_id field, // and give ninit a constraint saying it's local. -tag tsconstr { +enum tsconstr { ninit(node_id, ident); npred(@path, def_id, [@constr_arg_use]); } @@ -780,7 +780,7 @@ fn replace(subst: subst, d: pred_args) -> [constr_arg_general_] { ret rslt; } -tag if_ty { if_check; plain_if; } +enum if_ty { if_check; plain_if; } fn local_node_id_to_def_id_strict(fcx: fn_ctxt, sp: span, i: node_id) -> def_id { diff --git a/src/comp/middle/tstate/tritv.rs b/src/comp/middle/tstate/tritv.rs index 6a7504de5c3..6bb47139059 100644 --- a/src/comp/middle/tstate/tritv.rs +++ b/src/comp/middle/tstate/tritv.rs @@ -30,7 +30,7 @@ */ type t = {uncertain: bitv::t, val: bitv::t, nbits: uint}; -tag trit { ttrue; tfalse; dont_care; } +enum trit { ttrue; tfalse; dont_care; } fn create_tritv(len: uint) -> t { ret {uncertain: bitv::create(len, true), diff --git a/src/comp/middle/ty.rs b/src/comp/middle/ty.rs index 03802e04d88..9a54c58ab0b 100644 --- a/src/comp/middle/ty.rs +++ b/src/comp/middle/ty.rs @@ -235,7 +235,7 @@ type t = uint; -tag closure_kind { +enum closure_kind { ck_any; ck_block; ck_box; @@ -250,7 +250,7 @@ // NB: If you change this, you'll probably want to change the corresponding // AST structure in front/ast::rs as well. -tag sty { +enum sty { ty_nil; ty_bot; ty_bool; @@ -271,7 +271,7 @@ ty_tup([t]); ty_var(int); // type variable - ty_param(uint, def_id); // fn/tag type param + ty_param(uint, def_id); // fn/enum type param ty_type; // type_desc* ty_send_type; // type_desc* that has been cloned into exchange heap @@ -288,7 +288,7 @@ type constr = constr_general; // Data structures used in type unification -tag type_err { +enum type_err { terr_mismatch; terr_ret_style_mismatch(ast::ret_style, ast::ret_style); terr_box_mutability; @@ -303,7 +303,7 @@ terr_constr_mismatch(@type_constr, @type_constr); } -tag param_bound { +enum param_bound { bound_copy; bound_send; bound_iface(t); @@ -712,7 +712,7 @@ fn walk_ty(cx: ctxt, walker: ty_walk, ty: t) { walker(ty); } -tag fold_mode { +enum fold_mode { fm_var(fn@(int) -> t); fm_param(fn@(uint, def_id) -> t); fm_general(fn@(t) -> t); @@ -973,7 +973,7 @@ fn type_needs_drop(cx: ctxt, ty: t) -> bool { ret result; } -tag kind { kind_sendable; kind_copyable; kind_noncopyable; } +enum kind { kind_sendable; kind_copyable; kind_noncopyable; } // Using these query functons is preferable to direct comparison or matching // against the kind constants, as we may modify the kind hierarchy in the @@ -1245,7 +1245,7 @@ fn type_is_tag(cx: ctxt, ty: t) -> bool { } } -// Whether a type is enum like, that is a tag type with only nullary +// Whether a type is enum like, that is a enum type with only nullary // constructors fn type_is_c_like_enum(cx: ctxt, ty: t) -> bool { alt struct(cx, ty) { @@ -1732,16 +1732,16 @@ mod unify { export var_bindings; export precise, in_bindings; - tag result { ures_ok(t); ures_err(type_err); } - tag union_result { unres_ok; unres_err(type_err); } - tag fixup_result { + enum result { ures_ok(t); ures_err(type_err); } + enum union_result { unres_ok; unres_err(type_err); } + enum fixup_result { fix_ok(t); // fixup succeeded fix_err(int); // fixup failed because a type variable was unresolved } type var_bindings = {sets: ufind::ufind, types: smallintmap::smallintmap}; - tag unify_style { + enum unify_style { precise; in_bindings(@var_bindings); } @@ -2041,7 +2041,7 @@ fn resolve_type_structure(tcx: ty_ctxt, vb: @var_bindings, typ: t) -> } // Specifies the allowable subtyping between expected and actual types - tag variance { + enum variance { // Actual may be a subtype of expected covariant; // Actual may be a supertype of expected @@ -2676,7 +2676,7 @@ fn tag_variants(cx: ctxt, id: ast::def_id) -> @[variant_info] { } -// Returns information about the tag variant with the given ID: +// Returns information about the enum variant with the given ID: fn tag_variant_with_id(cx: ctxt, tag_id: ast::def_id, variant_id: ast::def_id) -> variant_info { let variants = tag_variants(cx, tag_id); diff --git a/src/comp/middle/typeck.rs b/src/comp/middle/typeck.rs index d16c0d315dd..15c247bd81b 100644 --- a/src/comp/middle/typeck.rs +++ b/src/comp/middle/typeck.rs @@ -23,7 +23,7 @@ export method_map, method_origin, method_static, method_param, method_iface; export dict_map, dict_res, dict_origin, dict_static, dict_param, dict_iface; -tag method_origin { +enum method_origin { method_static(ast::def_id); // iface id, method num, param num, bound num method_param(ast::def_id, uint, uint, uint); @@ -33,7 +33,7 @@ // Resolutions for bounds of all parameters, left to right, for a given path. type dict_res = @[dict_origin]; -tag dict_origin { +enum dict_origin { dict_static(ast::def_id, [ty::t], dict_res); // Param number, bound number dict_param(uint, uint); @@ -44,7 +44,7 @@ type ty_table = hashmap; // Used for typechecking the methods of an impl -tag self_info { +enum self_info { self_impl(ty::t); } @@ -231,7 +231,7 @@ fn default_arg_mode_for_ty(tcx: ty::ctxt, m: ast::mode, } } -tag mode { m_collect; m_check; m_check_tyvar(@fn_ctxt); } +enum mode { m_collect; m_check; m_check_tyvar(@fn_ctxt); } fn ast_ty_to_ty(tcx: ty::ctxt, mode: mode, &&ast_ty: @ast::ty) -> ty::t { fn getter(tcx: ty::ctxt, mode: mode, id: ast::def_id) @@ -263,7 +263,7 @@ fn ast_arg_to_arg(tcx: ty::ctxt, mode: mode, arg: ast::arg) some(none) { tcx.sess.span_fatal(ast_ty.span, "illegal recursive type \ - insert a tag in the cycle, \ + insert a enum in the cycle, \ if this is desired)"); } none { } @@ -650,7 +650,7 @@ fn get_tag_variant_types(cx: @ctxt, tag_ty: ty::t, // Create a set of parameter types shared among all the variants. for variant: ast::variant in variants { - // Nullary tag constructors get turned into constants; n-ary tag + // Nullary enum constructors get turned into constants; n-ary enum // constructors get turned into functions. let result_ty = if vec::len(variant.node.args) == 0u { @@ -921,7 +921,7 @@ fn are_compatible(fcx: @fn_ctxt, expected: ty::t, actual: ty::t) -> bool { } -// Returns the types of the arguments to a tag variant. +// Returns the types of the arguments to a enum variant. fn variant_arg_types(ccx: @crate_ctxt, _sp: span, vid: ast::def_id, tag_ty_params: [ty::t]) -> [ty::t] { let result: [ty::t] = []; @@ -1243,10 +1243,10 @@ fn check_pat(fcx: @fn_ctxt, map: pat_util::pat_id_map, pat: @ast::pat, let tag_tpt = ty::lookup_item_type(fcx.ccx.tcx, v_def_ids.tg); let path_tpot = instantiate_path(fcx, path, tag_tpt, pat.span); - // Take the tag type params out of `expected`. + // Take the enum type params out of `expected`. alt structure_of(fcx, pat.span, expected) { ty::ty_tag(_, expected_tps) { - // Unify with the expected tag type. + // Unify with the expected enum type. let ctor_ty = ty::ty_param_substs_opt_and_ty_to_monotype(fcx.ccx.tcx, path_tpot); @@ -1257,7 +1257,7 @@ fn check_pat(fcx: @fn_ctxt, map: pat_util::pat_id_map, pat: @ast::pat, path_tpot = {substs: some::<[ty::t]>(path_tpt.substs), ty: path_tpt.ty}; - // Get the number of arguments in this tag variant. + // Get the number of arguments in this enum variant. let arg_types = variant_arg_types(fcx.ccx, pat.span, v_def_ids.var, expected_tps); @@ -1267,7 +1267,7 @@ fn check_pat(fcx: @fn_ctxt, map: pat_util::pat_id_map, pat: @ast::pat, let arg_len = vec::len::(arg_types); if arg_len != subpats_len { - // TODO: note definition of tag variant + // TODO: note definition of enum variant // TODO (issue #448): Wrap a #fmt string over multiple // lines... let s = @@ -1287,7 +1287,7 @@ fn check_pat(fcx: @fn_ctxt, map: pat_util::pat_id_map, pat: @ast::pat, i += 1u; } } else if subpats_len > 0u { - // TODO: note definition of tag variant + // TODO: note definition of enum variant fcx.ccx.tcx.sess.span_fatal (pat.span, #fmt["this pattern has %u field%s, \ @@ -1305,7 +1305,7 @@ fn check_pat(fcx: @fn_ctxt, map: pat_util::pat_id_map, pat: @ast::pat, // can never tell. fcx.ccx.tcx.sess.span_fatal (pat.span, - #fmt["mismatched types: expected `%s` but found tag", + #fmt["mismatched types: expected `%s` but found enum", ty_to_str(fcx.ccx.tcx, expected)]); } } diff --git a/src/comp/syntax/ast.rs b/src/comp/syntax/ast.rs index 7449d8a53f8..a8bbf75aaa2 100644 --- a/src/comp/syntax/ast.rs +++ b/src/comp/syntax/ast.rs @@ -24,7 +24,7 @@ const local_crate: crate_num = 0; const crate_node_id: node_id = 0; -tag ty_param_bound { +enum ty_param_bound { bound_copy; bound_send; bound_iface(@ty); @@ -32,7 +32,7 @@ type ty_param = {ident: ident, id: node_id, bounds: @[ty_param_bound]}; -tag def { +enum def { def_fn(def_id, purity); def_self(def_id); def_mod(def_id); @@ -40,7 +40,7 @@ def_const(def_id); def_arg(def_id, mode); def_local(def_id, let_style); - def_variant(def_id /* tag */, def_id /* variant */); + def_variant(def_id /* enum */, def_id /* variant */); def_ty(def_id); def_ty_param(def_id, uint); def_binding(def_id); @@ -62,13 +62,13 @@ attrs: [attribute], config: crate_cfg}; -tag crate_directive_ { +enum crate_directive_ { cdir_src_mod(ident, [attribute]); cdir_dir_mod(ident, [@crate_directive], [attribute]); // NB: cdir_view_item is *not* processed by the rest of the compiler; the // attached view_items are sunk into the crate's module during parsing, - // and processed (resolved, imported, etc.) there. This tag-variant exists + // and processed (resolved, imported, etc.) there. This enum-variant exists // only to preserve the view items in order in case we decide to // pretty-print crates in the future. cdir_view_item(@view_item); @@ -80,7 +80,7 @@ type meta_item = spanned; -tag meta_item_ { +enum meta_item_ { meta_word(ident); meta_list(ident, [@meta_item]); meta_name_value(ident, lit); @@ -95,12 +95,12 @@ type field_pat = {ident: ident, pat: @pat}; -tag pat_ { +enum pat_ { pat_wild; // A pat_ident may either be a new bound variable, - // or a nullary tag (in which case the second field + // or a nullary enum (in which case the second field // is none). - // In the nullary tag case, the parser can't determine + // In the nullary enum case, the parser can't determine // which it is. The resolver determines this, and // records this pattern's node_id in an auxiliary // set (of "pat_idents that refer to nullary tags") @@ -117,9 +117,9 @@ pat_range(@expr, @expr); } -tag mutability { mut; imm; maybe_mut; } +enum mutability { mut; imm; maybe_mut; } -tag proto { +enum proto { proto_bare; // native fn proto_any; // fn proto_uniq; // fn~ @@ -134,7 +134,7 @@ } } -tag binop { +enum binop { add; subtract; mul; @@ -156,17 +156,17 @@ gt; } -tag unop { +enum unop { box(mutability); uniq(mutability); deref; not; neg; } -tag mode { by_ref; by_val; by_mut_ref; by_move; by_copy; mode_infer; } +enum mode { by_ref; by_val; by_mut_ref; by_move; by_copy; mode_infer; } type stmt = spanned; -tag stmt_ { +enum stmt_ { stmt_decl(@decl, node_id); // expr without trailing semi-colon (must have unit type): @@ -176,7 +176,7 @@ stmt_semi(@expr, node_id); } -tag init_op { init_assign; init_move; } +enum init_op { init_assign; init_move; } type initializer = {op: init_op, expr: @expr}; @@ -187,9 +187,9 @@ type decl = spanned; -tag let_style { let_copy; let_ref; } +enum let_style { let_copy; let_ref; } -tag decl_ { decl_local([(let_style, @local)]); decl_item(@item); } +enum decl_ { decl_local([(let_style, @local)]); decl_item(@item); } type arm = {pats: [@pat], guard: option::t<@expr>, body: blk}; @@ -197,13 +197,13 @@ type field = spanned; -tag blk_check_mode { default_blk; unchecked_blk; unsafe_blk; } +enum blk_check_mode { default_blk; unchecked_blk; unsafe_blk; } -tag expr_check_mode { claimed_expr; checked_expr; } +enum expr_check_mode { claimed_expr; checked_expr; } type expr = {id: node_id, node: expr_, span: span}; -tag expr_ { +enum expr_ { expr_vec([@expr], mutability); expr_rec([field], option::t<@expr>); expr_call(@expr, [@expr], bool); @@ -267,7 +267,7 @@ /* // Says whether this is a block the user marked as // "unchecked" -tag blk_sort { +enum blk_sort { blk_unchecked; // declared as "exception to effect-checking rules" blk_checked; // all typing rules apply } @@ -275,7 +275,7 @@ type mac = spanned; -tag mac_ { +enum mac_ { mac_invoc(@path, @expr, option::t); mac_embed_type(@ty); mac_embed_block(blk); @@ -284,7 +284,7 @@ type lit = spanned; -tag lit_ { +enum lit_ { lit_str(str); lit_int(i64, int_ty); lit_uint(u64, uint_ty); @@ -303,15 +303,15 @@ type ty_method = {ident: ident, decl: fn_decl, tps: [ty_param], span: span}; -tag int_ty { ty_i; ty_char; ty_i8; ty_i16; ty_i32; ty_i64; } +enum int_ty { ty_i; ty_char; ty_i8; ty_i16; ty_i32; ty_i64; } -tag uint_ty { ty_u; ty_u8; ty_u16; ty_u32; ty_u64; } +enum uint_ty { ty_u; ty_u8; ty_u16; ty_u32; ty_u64; } -tag float_ty { ty_f; ty_f32; ty_f64; } +enum float_ty { ty_f; ty_f32; ty_f64; } type ty = spanned; -tag ty_ { +enum ty_ { ty_nil; ty_bot; /* return type of ! functions and type of ret/fail/break/cont. there is no syntax @@ -354,7 +354,7 @@ So, the constr_arg type is parameterized: it's instantiated with uint for declarations, and ident for uses. */ -tag constr_arg_general_ { carg_base; carg_ident(T); carg_lit(@lit); } +enum constr_arg_general_ { carg_base; carg_ident(T); carg_lit(@lit); } type fn_constr_arg = constr_arg_general_; type sp_constr_arg = spanned>; @@ -389,13 +389,13 @@ cf: ret_style, constraints: [@constr]}; -tag purity { +enum purity { pure_fn; // declared with "pure fn" unsafe_fn; // declared with "unsafe fn" impure_fn; // declared with "fn" } -tag ret_style { +enum ret_style { noreturn; // functions with return type _|_ that always // raise an error or exit (i.e. never return to the caller) return_val; // everything else @@ -406,7 +406,7 @@ type _mod = {view_items: [@view_item], items: [@item]}; -tag native_abi { +enum native_abi { native_abi_rust_intrinsic; native_abi_cdecl; native_abi_stdcall; @@ -433,7 +433,7 @@ type import_ident = spanned; -tag view_item_ { +enum view_item_ { view_item_use(ident, [@meta_item], node_id); view_item_import(ident, @simple_path, node_id); view_item_import_glob(@simple_path, node_id); @@ -448,14 +448,14 @@ // Distinguishes between attributes that decorate items and attributes that // are contained as statements within items. These two cases need to be // distinguished for pretty-printing. -tag attr_style { attr_outer; attr_inner; } +enum attr_style { attr_outer; attr_inner; } type attribute_ = {style: attr_style, value: meta_item}; type item = {ident: ident, attrs: [attribute], id: node_id, node: item_, span: span}; -tag item_ { +enum item_ { item_const(@ty, @expr); item_fn(fn_decl, [ty_param], blk); item_mod(_mod); @@ -476,7 +476,7 @@ id: node_id, span: span}; -tag native_item_ { +enum native_item_ { native_item_ty; native_item_fn(fn_decl, [ty_param]); } diff --git a/src/comp/syntax/ast_util.rs b/src/comp/syntax/ast_util.rs index 6e8de806348..b1513b24e24 100644 --- a/src/comp/syntax/ast_util.rs +++ b/src/comp/syntax/ast_util.rs @@ -201,7 +201,7 @@ fn ternary_to_if(e: @expr) -> @expr { // FIXME this doesn't handle big integer/float literals correctly (nor does // the rest of our literal handling) -tag const_val { +enum const_val { const_float(float); const_int(i64); const_uint(u64); diff --git a/src/comp/syntax/codemap.rs b/src/comp/syntax/codemap.rs index 3bedf018eb7..7844e9c197e 100644 --- a/src/comp/syntax/codemap.rs +++ b/src/comp/syntax/codemap.rs @@ -65,7 +65,7 @@ fn lookup_byte_pos(map: codemap, pos: uint) -> loc { ret lookup_pos(map, pos, lookup); } -tag opt_span { +enum opt_span { //hack (as opposed to option::t), to make `span` compile os_none; diff --git a/src/comp/syntax/ext/base.rs b/src/comp/syntax/ext/base.rs index 0dee29db0f9..bead9a5d85b 100644 --- a/src/comp/syntax/ext/base.rs +++ b/src/comp/syntax/ext/base.rs @@ -11,7 +11,7 @@ type macro_definer = fn@(ext_ctxt, span, @ast::expr, option::t) -> macro_def; -tag syntax_extension { +enum syntax_extension { normal(syntax_expander); macro_defining(macro_definer); } diff --git a/src/comp/syntax/ext/simplext.rs b/src/comp/syntax/ext/simplext.rs index a71bb650f3c..85d6d451810 100644 --- a/src/comp/syntax/ext/simplext.rs +++ b/src/comp/syntax/ext/simplext.rs @@ -25,10 +25,10 @@ fn path_to_ident(pth: @path) -> option::t { type clause = {params: binders, body: @expr}; /* logically, an arb_depth should contain only one kind of matchable */ -tag arb_depth { leaf(T); seq(@[arb_depth], span); } +enum arb_depth { leaf(T); seq(@[arb_depth], span); } -tag matchable { +enum matchable { match_expr(@expr); match_path(@path); match_ident(ast::spanned); diff --git a/src/comp/syntax/parse/lexer.rs b/src/comp/syntax/parse/lexer.rs index 176e70cc65a..78cde98a9c5 100644 --- a/src/comp/syntax/parse/lexer.rs +++ b/src/comp/syntax/parse/lexer.rs @@ -510,7 +510,7 @@ fn binop(rdr: reader, op: token::binop) -> token::token { } } -tag cmnt_style { +enum cmnt_style { isolated; // No code on either side of each line of the comment trailing; // Code exists to the left of the comment mixed; // Code before /* foo */ and after the comment diff --git a/src/comp/syntax/parse/parser.rs b/src/comp/syntax/parse/parser.rs index a5980465048..373b1f22a44 100644 --- a/src/comp/syntax/parse/parser.rs +++ b/src/comp/syntax/parse/parser.rs @@ -13,14 +13,14 @@ import lexer::reader; import driver::diagnostic; -tag restriction { +enum restriction { UNRESTRICTED; RESTRICT_STMT_EXPR; RESTRICT_NO_CALL_EXPRS; RESTRICT_NO_BAR_OP; } -tag file_type { CRATE_FILE; SOURCE_FILE; } +enum file_type { CRATE_FILE; SOURCE_FILE; } type parse_sess = @{ cm: codemap::codemap, @@ -147,7 +147,7 @@ fn bad_expr_word_table() -> hashmap { "cont", "ret", "be", "fail", "type", "resource", "check", "assert", "claim", "native", "fn", "pure", "unsafe", "block", "import", "export", "let", "const", - "log", "copy", "sendfn", "impl", "iface", "enum"] { + "log", "copy", "sendfn", "impl", "iface", "tag", "enum"] { words.insert(word, ()); } words @@ -719,9 +719,9 @@ fn mk_lit_u32(p: parser, i: u32) -> @ast::expr { // parsing because `(while{...})+3` parses differently from `while{...}+3`. // // To reflect the fact that the @ast::expr is not a true expr that should be -// part of the AST, we wrap such expressions in the pexpr tag. They +// part of the AST, we wrap such expressions in the pexpr enum. They // can then be converted to true expressions by a call to `to_expr()`. -tag pexpr { +enum pexpr { pexpr(@ast::expr); } @@ -1508,7 +1508,7 @@ fn parse_pat(p: parser) -> @ast::pat { } _ { args = []; } } - // at this point, we're not sure whether it's a tag or a bind + // at this point, we're not sure whether it's a enum or a bind if vec::len(args) == 0u && vec::len(tag_path.node.idents) == 1u { pat = ast::pat_ident(tag_path, none); @@ -2026,7 +2026,7 @@ fn parse_item_tag(p: parser, attrs: [ast::attribute]) -> @ast::item { // Newtype syntax if p.token == token::EQ { if p.bad_expr_words.contains_key(id) { - p.fatal("found " + id + " in tag constructor position"); + p.fatal("found " + id + " in enum constructor position"); } p.bump(); let ty = parse_ty(p, false); diff --git a/src/comp/syntax/parse/token.rs b/src/comp/syntax/parse/token.rs index e5dcc8b61f7..e1851d831b1 100644 --- a/src/comp/syntax/parse/token.rs +++ b/src/comp/syntax/parse/token.rs @@ -5,7 +5,7 @@ type str_num = uint; -tag binop { +enum binop { PLUS; MINUS; STAR; @@ -19,7 +19,7 @@ ASR; } -tag token { +enum token { /* Expression-operator symbols. */ EQ; LT; diff --git a/src/comp/syntax/print/pp.rs b/src/comp/syntax/print/pp.rs index 455e9d916c9..4950af7b624 100644 --- a/src/comp/syntax/print/pp.rs +++ b/src/comp/syntax/print/pp.rs @@ -55,13 +55,13 @@ * line (which it can't) and so naturally place the content on its own line to * avoid combining it with other lines and making matters even worse. */ -tag breaks { consistent; inconsistent; } +enum breaks { consistent; inconsistent; } type break_t = {offset: int, blank_space: int}; type begin_t = {offset: int, breaks: breaks}; -tag token { STRING(str, int); BREAK(break_t); BEGIN(begin_t); END; EOF; } +enum token { STRING(str, int); BREAK(break_t); BEGIN(begin_t); END; EOF; } fn tok_str(t: token) -> str { alt t { @@ -91,7 +91,7 @@ fn buf_str(toks: [mutable token], szs: [mutable int], left: uint, right: uint, ret s; } -tag print_stack_break { fits; broken(breaks); } +enum print_stack_break { fits; broken(breaks); } type print_stack_elt = {offset: int, pbreak: print_stack_break}; diff --git a/src/comp/syntax/print/pprust.rs b/src/comp/syntax/print/pprust.rs index d666e0e3fab..3717dc83780 100644 --- a/src/comp/syntax/print/pprust.rs +++ b/src/comp/syntax/print/pprust.rs @@ -12,8 +12,8 @@ import driver::diagnostic; // The ps is stored here to prevent recursive type. -// FIXME use a nominal tag instead -tag ann_node { +// FIXME use a nominal enum instead +enum ann_node { node_block(ps, ast::blk); node_item(ps, @ast::item); node_expr(ps, @ast::expr); @@ -565,7 +565,7 @@ fn print_block_with_attrs(s: ps, blk: ast::blk, attrs: [ast::attribute]) { print_possibly_embedded_block_(s, blk, block_normal, indent_unit, attrs); } -tag embed_type { block_macro; block_block_fn; block_normal; } +enum embed_type { block_macro; block_block_fn; block_normal; } fn print_possibly_embedded_block(s: ps, blk: ast::blk, embedded: embed_type, indented: uint) { diff --git a/src/comp/syntax/visit.rs b/src/comp/syntax/visit.rs index bf544c09900..8f0f1f6f558 100644 --- a/src/comp/syntax/visit.rs +++ b/src/comp/syntax/visit.rs @@ -12,10 +12,10 @@ // override the context), or prevent deeper traversal by doing nothing. // Our typesystem doesn't do circular types, so the visitor record can not -// hold functions that take visitors. A vt tag is used to break the cycle. -tag vt { mk_vt(visitor); } +// hold functions that take visitors. A vt enum is used to break the cycle. +enum vt { mk_vt(visitor); } -tag fn_kind { +enum fn_kind { fk_item_fn(ident, [ty_param]); //< an item declared with fn() fk_method(ident, [ty_param]); fk_res(ident, [ty_param]);