diff options
Diffstat (limited to 'src/comp/middle')
29 files changed, 724 insertions, 724 deletions
diff --git a/src/comp/middle/alias.rs b/src/comp/middle/alias.rs index 93239ec116e..c799e9956b0 100644 --- a/src/comp/middle/alias.rs +++ b/src/comp/middle/alias.rs @@ -90,10 +90,10 @@ fn visit_fn(cx: @ctx, _fk: visit::fn_kind, decl: ast::fn_decl, // be called multiple times. let proto = ty::ty_fn_proto(cx.tcx, fty); alt proto { - ast::proto_block. | ast::proto_any. { + ast::proto_block | ast::proto_any { check_loop(*cx, sc) {|| v.visit_block(body, sc, v);} } - ast::proto_box. | ast::proto_uniq. | ast::proto_bare. { + ast::proto_box | ast::proto_uniq | ast::proto_bare { let sc = {bs: [], invalid: @mutable list::nil}; v.visit_block(body, sc, v); } @@ -156,7 +156,7 @@ fn visit_block(cx: @ctx, b: ast::blk, sc: scope, v: vt<scope>) { check_lval(cx, init.expr, sc, v); } } - none. { } + none { } } } } @@ -197,9 +197,9 @@ fn add_bindings_for_let(cx: ctx, &bs: [binding], loc: @ast::local) { fn cant_copy(cx: ctx, b: binding) -> bool { alt b.copied { - not_allowed. { ret true; } - copied. { ret false; } - not_copied. {} + not_allowed { ret true; } + copied { ret false; } + not_copied {} } let ty = ty::node_id_to_type(cx.tcx, b.node_id); if ty::type_allows_implicit_copy(cx.tcx, ty) { @@ -240,8 +240,8 @@ fn check_call(cx: ctx, sc: scope, f: @ast::expr, args: [@ast::expr]) local_id: 0u, unsafe_tys: unsafe_set(root.mut), mutable copied: alt arg_t.mode { - ast::by_move. | ast::by_copy. { copied } - ast::by_mut_ref. { not_allowed } + ast::by_move | ast::by_copy { copied } + ast::by_mut_ref { not_allowed } _ { not_copied } }}]; i += 1u; @@ -306,7 +306,7 @@ fn check_call(cx: ctx, sc: scope, f: @ast::expr, args: [@ast::expr]) break; } } - none. { } + none { } } } i += 1u; @@ -335,7 +335,7 @@ fn check_alt(cx: ctx, input: @ast::expr, arms: [ast::arm], sc: scope, let canon_id = pat_id_map.get(proot.name); alt vec::find(binding_info, {|x| x.id == canon_id}) { some(s) { s.unsafe_tys += unsafe_set(proot.mut); } - none. { + none { binding_info += [ {id: canon_id, mutable unsafe_tys: unsafe_set(proot.mut), @@ -466,8 +466,8 @@ fn test_scope(cx: ctx, sc: scope, b: binding, p: @ast::path) { if !is_none(prob) && cant_copy(cx, b) { let i = option::get(prob); let msg = alt i.reason { - overwritten. { "overwriting " + ast_util::path_name(i.path) } - val_taken. { "taking the value of " + ast_util::path_name(i.path) } + overwritten { "overwriting " + ast_util::path_name(i.path) } + val_taken { "taking the value of " + ast_util::path_name(i.path) } }; err(cx, i.sp, msg + " will invalidate reference " + ast_util::path_name(p) + ", which is still used"); @@ -523,7 +523,7 @@ fn ty_can_unsafely_include(cx: ctx, needle: unsafe_ty, haystack: ty::t, for t in ts { if helper(tcx, needle, t, mut) { ret true; } } ret false; } - ty::ty_fn({proto: ast::proto_bare., _}) { ret false; } + ty::ty_fn({proto: ast::proto_bare, _}) { ret false; } // These may contain anything. ty::ty_fn(_) | ty::ty_iface(_, _) { ret true; } // A type param may include everything, but can only be @@ -557,13 +557,13 @@ fn local_id_of_node(cx: ctx, id: node_id) -> uint { fn copy_is_expensive(tcx: ty::ctxt, ty: ty::t) -> bool { fn score_ty(tcx: ty::ctxt, ty: ty::t) -> uint { ret alt ty::struct(tcx, ty) { - ty::ty_nil. | ty::ty_bot. | ty::ty_bool. | ty::ty_int(_) | - ty::ty_uint(_) | ty::ty_float(_) | ty::ty_type. | ty::ty_native(_) | + ty::ty_nil | ty::ty_bot | ty::ty_bool | ty::ty_int(_) | + ty::ty_uint(_) | ty::ty_float(_) | ty::ty_type | ty::ty_native(_) | ty::ty_ptr(_) { 1u } ty::ty_box(_) | ty::ty_iface(_, _) { 3u } ty::ty_constr(t, _) | ty::ty_res(_, t, _) { score_ty(tcx, t) } ty::ty_fn(_) | ty::ty_native_fn(_, _) { 4u } - ty::ty_str. | ty::ty_vec(_) | ty::ty_param(_, _) { 50u } + 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) { let sum = 0u; @@ -590,7 +590,7 @@ fn pattern_roots(tcx: ty::ctxt, mut: option::t<unsafe_ty>, pat: @ast::pat) fn walk(tcx: ty::ctxt, mut: option::t<unsafe_ty>, pat: @ast::pat, &set: [pattern_root]) { alt normalize_pat(tcx, pat).node { - ast::pat_wild. | ast::pat_lit(_) | ast::pat_range(_, _) {} + ast::pat_wild | ast::pat_lit(_) | ast::pat_range(_, _) {} ast::pat_ident(nm, sub) { set += [{id: pat.id, name: path_to_ident(nm), mut: mut, span: pat.span}]; @@ -648,7 +648,7 @@ fn find_invalid(id: node_id, lst: list<@invalid>) let cur = lst; while true { alt cur { - list::nil. { break; } + list::nil { break; } list::cons(head, tail) { if head.node_id == id { ret some(head); } cur = *tail; diff --git a/src/comp/middle/capture.rs b/src/comp/middle/capture.rs index b9e9a02c0f0..9fb600d41c7 100644 --- a/src/comp/middle/capture.rs +++ b/src/comp/middle/capture.rs @@ -75,11 +75,11 @@ fn check_capture_clause(tcx: ty::ctxt, }; alt fn_proto { - ast::proto_any. | ast::proto_block. { + ast::proto_any | ast::proto_block { check_block_captures(cap_clause.copies); check_block_captures(cap_clause.moves); } - ast::proto_bare. | ast::proto_box. | ast::proto_uniq. { + ast::proto_bare | ast::proto_box | ast::proto_uniq { vec::iter(cap_clause.copies, check_capture_item); vec::iter(cap_clause.moves, check_capture_item); vec::iter(cap_clause.moves, check_not_upvar); @@ -113,15 +113,15 @@ fn compute_capture_vars(tcx: ty::ctxt, } let implicit_mode = alt fn_proto { - ast::proto_any. | ast::proto_block. { cap_ref } - ast::proto_bare. | ast::proto_box. | ast::proto_uniq. { cap_copy } + ast::proto_any | ast::proto_block { cap_ref } + ast::proto_bare | ast::proto_box | ast::proto_uniq { cap_copy } }; vec::iter(*freevars) { |fvar| let fvar_def_id = ast_util::def_id_of_def(fvar.def).node; alt cap_map.find(fvar_def_id) { option::some(_) { /* was explicitly named, do nothing */ } - option::none. { + option::none { cap_map.insert(fvar_def_id, {def:fvar.def, mode:implicit_mode}); } } diff --git a/src/comp/middle/check_alt.rs b/src/comp/middle/check_alt.rs index e32866e5749..15b4a074b37 100644 --- a/src/comp/middle/check_alt.rs +++ b/src/comp/middle/check_alt.rs @@ -73,7 +73,7 @@ fn pattern_supersedes(tcx: ty::ctxt, a: @pat, b: @pat) -> bool { alt a.node { pat_ident(_, some(p)) { pattern_supersedes(tcx, p, b) } - pat_wild. | pat_ident(_, none.) { true } + pat_wild | pat_ident(_, none) { true } pat_lit(la) { alt b.node { pat_lit(lb) { lit_expr_eq(la, lb) } @@ -142,7 +142,7 @@ fn is_refutable(tcx: ty::ctxt, pat: @pat) -> bool { pat_box(sub) | pat_uniq(sub) | pat_ident(_, some(sub)) { is_refutable(tcx, sub) } - pat_wild. | pat_ident(_, none.) { false } + pat_wild | pat_ident(_, none) { false } pat_lit(_) { true } pat_rec(fields, _) { for field: field_pat in fields { diff --git a/src/comp/middle/check_const.rs b/src/comp/middle/check_const.rs index 943c9184fe2..b623bfc1795 100644 --- a/src/comp/middle/check_const.rs +++ b/src/comp/middle/check_const.rs @@ -45,7 +45,7 @@ fn check_expr(sess: session, e: @expr, &&is_const: bool, v: visit::vt<bool>) { if is_const { alt e.node { expr_unary(box(_), _) | expr_unary(uniq(_), _) | - expr_unary(deref., _){ + expr_unary(deref, _){ sess.span_err(e.span, "disallowed operator in constant expression"); ret; diff --git a/src/comp/middle/debuginfo.rs b/src/comp/middle/debuginfo.rs index e7401fb888b..0a0259ec584 100644 --- a/src/comp/middle/debuginfo.rs +++ b/src/comp/middle/debuginfo.rs @@ -160,7 +160,7 @@ fn create_compile_unit(cx: @crate_ctxt, full_path: str) alt cached_metadata::<@metadata<compile_unit_md>>(cache, tg, {|md| md.data.path == full_path}) { option::some(md) { ret md; } - option::none. {} + option::none {} } let work_dir = cx.sess.working_dir; @@ -202,7 +202,7 @@ fn create_file(cx: @crate_ctxt, full_path: str) -> @metadata<file_md> { alt cached_metadata::<@metadata<file_md>>( cache, tg, {|md| md.data.path == full_path}) { option::some(md) { ret md; } - option::none. {} + option::none {} } let fname = fs::basename(full_path); @@ -234,17 +234,17 @@ fn create_block(cx: @block_ctxt) -> @metadata<block_md> { cache, tg, {|md| start == md.data.start && end == md.data.end}) { option::some(md) { ret md; } - option::none. {} + option::none {} } let parent = alt cx.parent { - trans_common::parent_none. { create_function(cx.fcx).node } + trans_common::parent_none { create_function(cx.fcx).node } trans_common::parent_some(bcx) { create_block(cx).node } }; let file_node = create_file(bcx_ccx(cx), fname); let unique_id = alt cache.find(LexicalBlockTag) { option::some(v) { vec::len(v) as int } - option::none. { 0 } + option::none { 0 } }; let lldata = [lltag(tg), parent, @@ -270,30 +270,30 @@ fn create_basic_type(cx: @crate_ctxt, t: ty::t, ty: @ast::ty) alt cached_metadata::<@metadata<tydesc_md>>( cache, tg, {|md| t == md.data.hash}) { option::some(md) { ret md; } - option::none. {} + option::none {} } let (name, (size, align), encoding) = alt ty.node { - ast::ty_bool. {("bool", size_and_align_of::<bool>(), DW_ATE_boolean)} + ast::ty_bool {("bool", size_and_align_of::<bool>(), DW_ATE_boolean)} ast::ty_int(m) { alt m { - ast::ty_char. {("char", size_and_align_of::<char>(), DW_ATE_unsigned)} - ast::ty_i. {("int", size_and_align_of::<int>(), DW_ATE_signed)} - ast::ty_i8. {("i8", size_and_align_of::<i8>(), DW_ATE_signed_char)} - ast::ty_i16. {("i16", size_and_align_of::<i16>(), DW_ATE_signed)} - ast::ty_i32. {("i32", size_and_align_of::<i32>(), DW_ATE_signed)} - ast::ty_i64. {("i64", size_and_align_of::<i64>(), DW_ATE_signed)} + ast::ty_char {("char", size_and_align_of::<char>(), DW_ATE_unsigned)} + ast::ty_i {("int", size_and_align_of::<int>(), DW_ATE_signed)} + ast::ty_i8 {("i8", size_and_align_of::<i8>(), DW_ATE_signed_char)} + ast::ty_i16 {("i16", size_and_align_of::<i16>(), DW_ATE_signed)} + ast::ty_i32 {("i32", size_and_align_of::<i32>(), DW_ATE_signed)} + ast::ty_i64 {("i64", size_and_align_of::<i64>(), DW_ATE_signed)} }} ast::ty_uint(m) { alt m { - ast::ty_u. {("uint", size_and_align_of::<uint>(), DW_ATE_unsigned)} - ast::ty_u8. {("u8", size_and_align_of::<u8>(), DW_ATE_unsigned_char)} - ast::ty_u16. {("u16", size_and_align_of::<u16>(), DW_ATE_unsigned)} - ast::ty_u32. {("u32", size_and_align_of::<u32>(), DW_ATE_unsigned)} - ast::ty_u64. {("u64", size_and_align_of::<u64>(), DW_ATE_unsigned)} + ast::ty_u {("uint", size_and_align_of::<uint>(), DW_ATE_unsigned)} + ast::ty_u8 {("u8", size_and_align_of::<u8>(), DW_ATE_unsigned_char)} + ast::ty_u16 {("u16", size_and_align_of::<u16>(), DW_ATE_unsigned)} + ast::ty_u32 {("u32", size_and_align_of::<u32>(), DW_ATE_unsigned)} + ast::ty_u64 {("u64", size_and_align_of::<u64>(), DW_ATE_unsigned)} }} ast::ty_float(m) { alt m { - ast::ty_f. {("float", size_and_align_of::<float>(), DW_ATE_float)} - ast::ty_f32. {("f32", size_and_align_of::<f32>(), DW_ATE_float)} - ast::ty_f64. {("f64", size_and_align_of::<f64>(), DW_ATE_float)} + ast::ty_f {("float", size_and_align_of::<float>(), DW_ATE_float)} + ast::ty_f32 {("f32", size_and_align_of::<f32>(), DW_ATE_float)} + ast::ty_f64 {("f64", size_and_align_of::<f64>(), DW_ATE_float)} }} }; @@ -325,7 +325,7 @@ fn create_pointer_type(cx: @crate_ctxt, t: ty::t, span: codemap::span, alt cached_metadata::<@metadata<tydesc_md>>( cache, tg, {|md| ty::hash_ty(t) == ty::hash_ty(md.data.hash)}) { option::some(md) { ret md; } - option::none. {} + option::none {} }*/ let (size, align) = size_and_align_of::<ctypes::intptr_t>(); let fname = filename_from_span(cx, span); @@ -418,7 +418,7 @@ fn create_boxed_type(cx: @crate_ctxt, outer: ty::t, _inner: ty::t, alt cached_metadata::<@metadata<tydesc_md>>( cache, tg, {|md| ty::hash_ty(outer) == ty::hash_ty(md.data.hash)}) { option::some(md) { ret md; } - option::none. {} + option::none {} }*/ let fname = filename_from_span(cx, span); let file_node = create_file(cx, fname); @@ -492,24 +492,24 @@ fn create_vec(cx: @crate_ctxt, vec_t: ty::t, elem_t: ty::t, vec_ty: @ast::ty) fn member_size_and_align(ty: @ast::ty) -> (int, int) { alt ty.node { - ast::ty_bool. { size_and_align_of::<bool>() } + ast::ty_bool { size_and_align_of::<bool>() } ast::ty_int(m) { alt m { - ast::ty_char. { size_and_align_of::<char>() } - ast::ty_i. { size_and_align_of::<int>() } - ast::ty_i8. { size_and_align_of::<i8>() } - ast::ty_i16. { size_and_align_of::<i16>() } - ast::ty_i32. { size_and_align_of::<i32>() } + ast::ty_char { size_and_align_of::<char>() } + ast::ty_i { size_and_align_of::<int>() } + ast::ty_i8 { size_and_align_of::<i8>() } + ast::ty_i16 { size_and_align_of::<i16>() } + ast::ty_i32 { size_and_align_of::<i32>() } }} ast::ty_uint(m) { alt m { - ast::ty_u. { size_and_align_of::<uint>() } - ast::ty_u8. { size_and_align_of::<i8>() } - ast::ty_u16. { size_and_align_of::<u16>() } - ast::ty_u32. { size_and_align_of::<u32>() } + ast::ty_u { size_and_align_of::<uint>() } + ast::ty_u8 { size_and_align_of::<i8>() } + ast::ty_u16 { size_and_align_of::<u16>() } + ast::ty_u32 { size_and_align_of::<u32>() } }} ast::ty_float(m) { alt m { - ast::ty_f. { size_and_align_of::<float>() } - ast::ty_f32. { size_and_align_of::<f32>() } - ast::ty_f64. { size_and_align_of::<f64>() } + ast::ty_f { size_and_align_of::<float>() } + ast::ty_f32 { size_and_align_of::<f32>() } + ast::ty_f64 { size_and_align_of::<f64>() } }} ast::ty_box(_) | ast::ty_uniq(_) { size_and_align_of::<ctypes::uintptr_t>() @@ -534,14 +534,14 @@ fn create_ty(cx: @crate_ctxt, t: ty::t, ty: @ast::ty) alt cached_metadata::<@metadata<tydesc_md>>( cache, tg, {|md| t == md.data.hash}) { option::some(md) { ret md; } - option::none. {} + option::none {} }*/ fn t_to_ty(cx: @crate_ctxt, t: ty::t, span: codemap::span) -> @ast::ty { let ty = alt ty::struct(ccx_tcx(cx), t) { - ty::ty_nil. { ast::ty_nil } - ty::ty_bot. { ast::ty_bot } - ty::ty_bool. { ast::ty_bool } + ty::ty_nil { ast::ty_nil } + ty::ty_bot { ast::ty_bot } + ty::ty_bool { ast::ty_bool } ty::ty_int(t) { ast::ty_int(t) } ty::ty_float(t) { ast::ty_float(t) } ty::ty_uint(t) { ast::ty_uint(t) } @@ -627,7 +627,7 @@ fn create_local_var(bcx: @block_ctxt, local: @ast::local) alt cached_metadata::<@metadata<local_var_md>>( cache, tg, {|md| md.data.id == local.node.id}) { option::some(md) { ret md; } - option::none. {} + option::none {} } let name = path_to_ident(alt pat_util::normalize_pat(bcx_tcx(bcx), @@ -640,7 +640,7 @@ fn create_local_var(bcx: @block_ctxt, local: @ast::local) let tymd = create_ty(cx, ty, local.node.ty); let filemd = create_file(cx, loc.filename); let context = alt bcx.parent { - trans_common::parent_none. { create_function(bcx.fcx).node } + trans_common::parent_none { create_function(bcx.fcx).node } trans_common::parent_some(_) { create_block(bcx).node } }; let mdnode = create_var(tg, context, name, filemd.node, @@ -650,7 +650,7 @@ fn create_local_var(bcx: @block_ctxt, local: @ast::local) let llptr = alt bcx.fcx.lllocals.find(local.node.id) { option::some(local_mem(v)) { v } - option::none. { + option::none { alt bcx.fcx.lllocals.get(local.node.pat.id) { local_imm(v) { v } } @@ -671,7 +671,7 @@ fn create_arg(bcx: @block_ctxt, arg: ast::arg) alt cached_metadata::<@metadata<argument_md>>( cache, ArgVariableTag, {|md| md.data.id == arg.id}) { option::some(md) { ret md; } - option::none. {} + option::none {} } /*let arg_n = alt cx.ast_map.get(arg.id) { @@ -759,7 +759,7 @@ fn create_function(fcx: @fn_ctxt) -> @metadata<subprogram_md> { cache, SubprogramTag, {|md| md.data.path == path && /*md.data.path == ??*/ true}) { option::some(md) { ret md; } - option::none. {} + option::none {} } let loc = codemap::lookup_char_pos(cx.sess.codemap, @@ -769,7 +769,7 @@ fn create_function(fcx: @fn_ctxt) -> @metadata<subprogram_md> { let mangled = cx.item_symbols.get(key); let ty_node = if cx.sess.opts.extra_debuginfo { alt ret_ty.node { - ast::ty_nil. { llnull() } + ast::ty_nil { llnull() } _ { create_ty(cx, ty::node_id_to_type(ccx_tcx(cx), id), ret_ty).node } } diff --git a/src/comp/middle/fn_usage.rs b/src/comp/middle/fn_usage.rs index 6901ae9d9f9..79ded67a2a9 100644 --- a/src/comp/middle/fn_usage.rs +++ b/src/comp/middle/fn_usage.rs @@ -19,8 +19,8 @@ fn fn_usage_expr(expr: @ast::expr, ast::expr_path(path) { if !ctx.unsafe_fn_legal { alt ctx.tcx.def_map.find(expr.id) { - some(ast::def_fn(_, ast::unsafe_fn.)) | - some(ast::def_native_fn(_, ast::unsafe_fn.)) { + some(ast::def_fn(_, ast::unsafe_fn)) | + some(ast::def_native_fn(_, ast::unsafe_fn)) { log(error, ("expr=", expr_to_str(expr))); ctx.tcx.sess.span_fatal( expr.span, @@ -33,7 +33,7 @@ fn fn_usage_expr(expr: @ast::expr, if !ctx.generic_bare_fn_legal && ty::expr_has_ty_params(ctx.tcx, expr) { alt ty::struct(ctx.tcx, ty::expr_ty(ctx.tcx, expr)) { - ty::ty_fn({proto: ast::proto_bare., _}) { + ty::ty_fn({proto: ast::proto_bare, _}) { ctx.tcx.sess.span_fatal( expr.span, "generic bare functions can only be called or bound"); diff --git a/src/comp/middle/freevars.rs b/src/comp/middle/freevars.rs index 8578556b28e..cce5b3973b8 100644 --- a/src/comp/middle/freevars.rs +++ b/src/comp/middle/freevars.rs @@ -49,7 +49,7 @@ fn collect_freevars(def_map: resolve::def_map, blk: ast::blk) ast::expr_path(path) { let i = 0; alt def_map.find(expr.id) { - none. { fail ("Not found: " + path_to_str(path)) } + none { fail ("Not found: " + path_to_str(path)) } some(df) { let def = df; while i < depth { @@ -104,7 +104,7 @@ fn annotate_freevars(def_map: resolve::def_map, crate: @ast::crate) -> fn get_freevars(tcx: ty::ctxt, fid: ast::node_id) -> freevar_info { alt tcx.freevars.find(fid) { - none. { fail "get_freevars: " + int::str(fid) + " has no freevars"; } + none { fail "get_freevars: " + int::str(fid) + " has no freevars"; } some(d) { ret d; } } } diff --git a/src/comp/middle/gc.rs b/src/comp/middle/gc.rs index ebd1d4ff9f4..f67ac128b5e 100644 --- a/src/comp/middle/gc.rs +++ b/src/comp/middle/gc.rs @@ -51,7 +51,7 @@ fn add_gc_root(cx: @block_ctxt, llval: ValueRef, ty: ty::t) -> @block_ctxt { let llvalptr = bld::PointerCast(bcx, llval, T_ptr(T_ptr(T_i8()))); alt td_r.kind { - tk_derived. { + tk_derived { // It's a derived type descriptor. First, spill it. let lltydescptr = trans::alloca(bcx, val_ty(lltydesc)); @@ -81,11 +81,11 @@ fn add_gc_root(cx: @block_ctxt, llval: ValueRef, ty: ty::t) -> @block_ctxt { bld::Call(llderivedtydescs, gcroot, [lltydescptr, lldestindex]); bld::Call(bcx, gcroot, [llvalptr, llsrcindex]); } - tk_param. { + tk_param { bcx_tcx(cx).sess.bug("we should never be trying to root values " + "of a type parameter"); } - tk_static. { + tk_static { // Static type descriptor. let llstaticgcmeta = @@ -103,9 +103,9 @@ fn add_gc_root(cx: @block_ctxt, llval: ValueRef, ty: ty::t) -> @block_ctxt { fn type_is_gc_relevant(cx: ty::ctxt, ty: ty::t) -> bool { alt ty::struct(cx, ty) { - ty::ty_nil. | ty::ty_bot. | ty::ty_bool. | ty::ty_int(_) | - ty::ty_float(_) | ty::ty_uint(_) | ty::ty_str. | - ty::ty_type. | ty::ty_native(_) | ty::ty_ptr(_) | ty::ty_type. | + ty::ty_nil | ty::ty_bot | ty::ty_bool | ty::ty_int(_) | + ty::ty_float(_) | ty::ty_uint(_) | ty::ty_str | + ty::ty_type | ty::ty_native(_) | ty::ty_ptr(_) | ty::ty_type. | ty::ty_native(_) { ret false; } diff --git a/src/comp/middle/kind.rs b/src/comp/middle/kind.rs index 575b1cc0189..600389b3058 100644 --- a/src/comp/middle/kind.rs +++ b/src/comp/middle/kind.rs @@ -22,9 +22,9 @@ import driver::session::session; fn kind_to_str(k: kind) -> str { alt k { - kind_sendable. { "sendable" } - kind_copyable. { "copyable" } - kind_noncopyable. { "noncopyable" } + kind_sendable { "sendable" } + kind_copyable { "copyable" } + kind_noncopyable { "noncopyable" } } } @@ -61,10 +61,10 @@ fn with_appropriate_checker(cx: ctx, id: node_id, b: block(fn@(ctx, ty::t, sp: span))) { let fty = ty::node_id_to_monotype(cx.tcx, id); alt ty::ty_fn_proto(cx.tcx, fty) { - proto_uniq. { b(check_send); } - proto_box. { b(check_copy); } - proto_bare. { b(check_none); } - proto_any. | proto_block. { /* no check needed */ } + proto_uniq { b(check_send); } + proto_box { b(check_copy); } + proto_bare { b(check_none); } + proto_any | proto_block { /* no check needed */ } } } @@ -135,7 +135,7 @@ fn check_expr(e: @expr, cx: ctx, v: visit::vt<ctx>) { expr_ret(some(ex)) { maybe_copy(cx, ex); } expr_copy(expr) { check_copy_ex(cx, expr, false); } // Vector add copies. - expr_binary(add., ls, rs) { maybe_copy(cx, ls); maybe_copy(cx, rs); } + expr_binary(add, ls, rs) { maybe_copy(cx, ls); maybe_copy(cx, rs); } expr_rec(fields, def) { for field in fields { maybe_copy(cx, field.node.expr); } alt def { @@ -163,7 +163,7 @@ fn check_expr(e: @expr, cx: ctx, v: visit::vt<ctx>) { expr_call(f, args, _) { let i = 0u; for arg_t in ty::ty_fn_args(cx.tcx, ty::expr_ty(cx.tcx, f)) { - alt arg_t.mode { by_copy. { maybe_copy(cx, args[i]); } _ {} } + alt arg_t.mode { by_copy { maybe_copy(cx, args[i]); } _ {} } i += 1u; } } @@ -186,7 +186,7 @@ fn check_expr(e: @expr, cx: ctx, v: visit::vt<ctx>) { i += 1u; } } - none. {} + none {} } } expr_ternary(_, a, b) { maybe_copy(cx, a); maybe_copy(cx, b); } @@ -203,7 +203,7 @@ fn check_stmt(stmt: @stmt, cx: ctx, v: visit::vt<ctx>) { stmt_decl(@{node: decl_local(locals), _}, _) { for (_, local) in locals { alt local.node.init { - some({op: init_assign., expr}) { maybe_copy(cx, expr); } + some({op: init_assign, expr}) { maybe_copy(cx, expr); } _ {} } } diff --git a/src/comp/middle/last_use.rs b/src/comp/middle/last_use.rs index 7126199349d..c5c7c544831 100644 --- a/src/comp/middle/last_use.rs +++ b/src/comp/middle/last_use.rs @@ -80,7 +80,7 @@ fn visit_expr(ex: @expr, cx: ctx, v: visit::vt<ctx>) { visit::visit_expr_opt(oexpr, cx, v); leave_fn(cx); } - expr_break. { add_block_exit(cx, loop); } + expr_break { add_block_exit(cx, loop); } expr_while(_, _) | expr_do_while(_, _) { visit_block(loop, cx) {|| visit::visit_expr(ex, cx, v);} } @@ -160,7 +160,7 @@ fn visit_expr(ex: @expr, cx: ctx, v: visit::vt<ctx>) { } _ { alt arg_ts[i].mode { - by_mut_ref. { clear_if_path(cx, arg, v, false); } + by_mut_ref { clear_if_path(cx, arg, v, false); } _ { v.visit_expr(arg, cx, v); } } } @@ -179,12 +179,12 @@ fn visit_fn(fk: visit::fn_kind, decl: fn_decl, body: blk, let fty = ty::node_id_to_type(cx.tcx, id); let proto = ty::ty_fn_proto(cx.tcx, fty); alt proto { - proto_any. | proto_block. { + proto_any | proto_block { visit_block(func, cx, {|| visit::visit_fn(fk, decl, body, sp, id, cx, v); }); } - proto_box. | proto_uniq. | proto_bare. { + proto_box | proto_uniq | proto_bare { alt cx.tcx.freevars.find(id) { some(vars) { for v in *vars { @@ -283,8 +283,8 @@ fn clear_in_current(cx: ctx, my_def: node_id, to: bool) { fn clear_def_if_path(cx: ctx, d: def, to: bool) -> option<node_id> { alt d { - def_local(def_id, let_copy.) | def_arg(def_id, by_copy.) | - def_arg(def_id, by_move.) { + def_local(def_id, let_copy) | def_arg(def_id, by_copy) | + def_arg(def_id, by_move) { clear_in_current(cx, def_id.node, to); some(def_id.node) } diff --git a/src/comp/middle/mut.rs b/src/comp/middle/mut.rs index 8071ea0972f..d67a03d4a53 100644 --- a/src/comp/middle/mut.rs +++ b/src/comp/middle/mut.rs @@ -75,7 +75,7 @@ fn expr_root(tcx: ty::ctxt, ex: @expr, autoderef: bool) -> kind: index, outer_t: auto_unbox.t}]; } - ty::ty_str. { + ty::ty_str { ds += [@{mut: false, kind: index, outer_t: auto_unbox.t}]; } } @@ -125,9 +125,9 @@ tag 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 { - msg_assign. { "assigning to " + name } - msg_move_out. { "moving out of " + name } - msg_mut_ref. { "passing " + name + " by mutable reference" } + msg_assign { "assigning to " + name } + msg_move_out { "moving out of " + name } + msg_mut_ref { "passing " + name + " by mutable reference" } }); } @@ -140,7 +140,7 @@ fn visit_decl(cx: @ctx, d: @decl, &&e: (), v: visit::vt<()>) { some(init) { if init.op == init_move { check_move_rhs(cx, init.expr); } } - none. { } + none { } } } } @@ -224,8 +224,8 @@ fn check_call(cx: @ctx, f: @expr, args: [@expr]) { let i = 0u; for arg_t: ty::arg in arg_ts { alt arg_t.mode { - by_mut_ref. { check_lval(cx, args[i], msg_mut_ref); } - by_move. { check_lval(cx, args[i], msg_move_out); } + by_mut_ref { check_lval(cx, args[i], msg_mut_ref); } + by_move { check_lval(cx, args[i], msg_move_out); } _ {} } i += 1u; @@ -239,15 +239,15 @@ fn check_bind(cx: @ctx, f: @expr, args: [option::t<@expr>]) { alt arg { some(expr) { alt (alt arg_ts[i].mode { - by_mut_ref. { some("by mutable reference") } - by_move. { some("by move") } + by_mut_ref { some("by mutable reference") } + by_move { some("by move") } _ { none } }) { some(name) { cx.tcx.sess.span_err( expr.span, "can not bind an argument passed " + name); } - none. {} + none {} } } _ {} @@ -262,19 +262,19 @@ fn is_immutable_def(cx: @ctx, def: def) -> option::t<str> { def_use(_) { some("static item") } - def_arg(_, by_ref.) | def_arg(_, by_val.) | - def_arg(_, mode_infer.) { some("argument") } + def_arg(_, by_ref) | def_arg(_, by_val) | + def_arg(_, mode_infer) { some("argument") } def_self(_) { some("self argument") } def_upvar(_, inner, node_id) { let ty = ty::node_id_to_monotype(cx.tcx, node_id); let proto = ty::ty_fn_proto(cx.tcx, ty); ret alt proto { - proto_any. | proto_block. { is_immutable_def(cx, *inner) } + proto_any | proto_block { is_immutable_def(cx, *inner) } _ { some("upvar") } }; } def_binding(_) { some("binding") } - def_local(_, let_ref.) { some("by-reference binding") } + def_local(_, let_ref) { some("by-reference binding") } _ { none } } } diff --git a/src/comp/middle/pat_util.rs b/src/comp/middle/pat_util.rs index f2d1b6ea6ca..b949dce004d 100644 --- a/src/comp/middle/pat_util.rs +++ b/src/comp/middle/pat_util.rs @@ -16,8 +16,8 @@ fn normalize_pat_def_map(dm: resolve::def_map, p: @pat) -> @pat { // have to do it the hard way b/c ast fold doesn't pass around // node IDs. bother. alt p.node { - pat_wild. { p } - pat_ident(_, none.) { normalize_one(dm, p) } + pat_wild { p } + pat_ident(_, none) { normalize_one(dm, p) } pat_ident(q, some(r)) { @{node: pat_ident(q, some(normalize_pat_def_map(dm, r))) with *p} @@ -58,7 +58,7 @@ fn normalize_one(dm: resolve::def_map, p: @pat) -> @pat { _ { p } } } - none. { p } + none { p } } } @@ -93,14 +93,14 @@ fn pat_id_map(tcx: ty::ctxt, pat: @pat) -> pat_id_map { // Could return a constrained type in order to express that (future work) fn pat_bindings(pat: @pat, it: block(@pat)) { alt pat.node { - pat_ident(_, option::none.) { it(pat); } + 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_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); } pat_uniq(sub) { pat_bindings(sub, it); } - pat_wild. | pat_lit(_) | pat_range(_, _) { } + pat_wild | pat_lit(_) | pat_range(_, _) { } } } @@ -112,7 +112,7 @@ fn pat_binding_ids(pat: @pat) -> [node_id] { fn path_to_ident(p: @path) -> ident { alt vec::last(p.node.idents) { - none. { // sigh + none { // sigh fail "Malformed path"; } some(i) { ret i; } } diff --git a/src/comp/middle/resolve.rs b/src/comp/middle/resolve.rs index 6ccc8cc12be..487ea536688 100644 --- a/src/comp/middle/resolve.rs +++ b/src/comp/middle/resolve.rs @@ -71,8 +71,8 @@ fn new_ext_hash() -> ext_hash { ret str::hash(v.ident) + util::common::hash_def(v.did) + alt v.ns { ns_val(_) { 1u } - ns_type. { 2u } - ns_module. { 3u } + ns_type { 2u } + ns_module { 3u } }; } fn eq(v1: key, v2: key) -> bool { @@ -88,8 +88,8 @@ fn new_exp_hash() -> exp_map { ret str::hash(v.path) + alt v.ns { ns_val(_) { 1u } - ns_type. { 2u } - ns_module. { 3u } + ns_type { 2u } + ns_module { 3u } }; } fn eq(v1: key, v2: key) -> bool { @@ -286,11 +286,11 @@ fn map_crate(e: @env, c: @ast::crate) { } scope_block(b, _, _) { let globs = alt e.block_map.find(b.node.id) { - some(globs) { globs + [glob] } none. { [glob] } + some(globs) { globs + [glob] } none { [glob] } }; e.block_map.insert(b.node.id, globs); } - scope_crate. { + scope_crate { e.mod_map.get(ast::crate_node_id).glob_imports += [glob]; } } @@ -422,7 +422,7 @@ fn resolve_names(e: @env, c: @ast::crate) { } /* Here we determine whether a given pat_ident binds a new variable a refers to a nullary tag. */ - ast::pat_ident(p, none.) { + ast::pat_ident(p, none) { let fnd = lookup_in_scope(*e, sc, p.span, path_to_ident(p), ns_val(ns_a_tag)); alt fnd { @@ -504,8 +504,8 @@ fn visit_fn_with_scope(e: @env, fk: visit::fn_kind, decl: ast::fn_decl, let scope = alt fk { visit::fk_item_fn(_, tps) | visit::fk_res(_, tps) | visit::fk_method(_, tps) { scope_bare_fn(decl, id, tps) } - visit::fk_anon(ast::proto_bare.) { scope_bare_fn(decl, id, []) } - visit::fk_anon(_) | visit::fk_fn_block. { scope_fn_expr(decl, id, []) } + visit::fk_anon(ast::proto_bare) { scope_bare_fn(decl, id, []) } + visit::fk_anon(_) | visit::fk_fn_block { scope_fn_expr(decl, id, []) } }; visit::visit_fn(fk, decl, body, sp, id, cons(scope, @sc), v); @@ -557,7 +557,7 @@ fn visit_expr_with_scope(x: @ast::expr, sc: scopes, v: vt<scopes>) { } // 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 tag, that's always an error fn visit_local_with_scope(e: @env, loc: @local, sc:scopes, v:vt<scopes>) { // Check whether the given local has the same name as a tag that's // in scope @@ -616,7 +616,7 @@ fn resolve_constr(e: @env, c: @ast::constr, sc: scopes, _v: vt<scopes>) { ns_val(ns_any_value)); if option::is_some(new_def) { alt option::get(new_def) { - ast::def_fn(pred_id, ast::pure_fn.) { + ast::def_fn(pred_id, ast::pure_fn) { e.def_map.insert(c.node.id, ast::def_fn(pred_id, ast::pure_fn)); } _ { @@ -675,7 +675,7 @@ fn resolve_import(e: env, defid: ast::def_id, name: ast::ident, cons(scope_block(b, _, _), _) { lst(id, b.node.view_items) } - cons(scope_crate., _) { + cons(scope_crate, _) { lst(id, option::get(e.mod_map.get(ast::crate_node_id).m).view_items) } @@ -693,7 +693,7 @@ fn resolve_import(e: env, defid: ast::def_id, name: ast::ident, {|ns| lookup_in_scope(e, sc, sp, end_id, ns) }, []); } else { alt lookup_in_scope(e, sc, sp, ids[0], ns_module) { - none. { + none { unresolved_err(e, in_scope(sc), sp, ids[0], ns_name(ns_module)); } some(dcur_) { @@ -710,7 +710,7 @@ fn resolve_import(e: env, defid: ast::def_id, name: ast::ident, dcur = alt lookup_in_mod(e, dcur, sp, ids[i], ns_module, outside) { some(dcur) { dcur } - none. { + none { unresolved_err(e, in_mod(dcur), sp, ids[i], ns_name(ns_module)); break; @@ -738,14 +738,14 @@ fn resolve_import(e: env, defid: ast::def_id, name: ast::ident, // Utilities fn ns_name(ns: namespace) -> str { alt ns { - ns_type. { "typename" } + ns_type { "typename" } ns_val(v) { alt (v) { - ns_any_value. { "name" } - ns_a_tag. { "tag" } + ns_any_value { "name" } + ns_a_tag { "tag" } } } - ns_module. { ret "modulename" } + ns_module { ret "modulename" } } } @@ -758,7 +758,7 @@ fn unresolved_err(e: env, cx: ctxt, sp: span, name: ident, kind: str) { alt sc { cons(cur, rest) { alt cur { - scope_crate. | scope_bare_fn(_, _, _) | + scope_crate | scope_bare_fn(_, _, _) | scope_fn_expr(_, _, _) | scope_item(@{node: ast::item_mod(_), _}) { ret some(cur); @@ -835,7 +835,7 @@ fn lookup_path_strict(e: env, sc: scopes, sp: span, pth: ast::path_, fn lookup_in_scope_strict(e: env, sc: scopes, sp: span, name: ident, ns: namespace) -> option::t<def> { alt lookup_in_scope(e, sc, sp, name, ns) { - none. { + none { unresolved_err(e, in_scope(sc), sp, name, ns_name(ns)); ret none; } @@ -884,7 +884,7 @@ fn lookup_in_scope(e: env, sc: scopes, sp: span, name: ident, ns: namespace) fn in_scope(e: env, sp: span, name: ident, s: scope, ns: namespace) -> option::t<def> { alt s { - scope_crate. { + scope_crate { ret lookup_in_local_mod(e, ast::crate_node_id, sp, name, ns, inside); } @@ -953,7 +953,7 @@ fn lookup_in_scope(e: env, sc: scopes, sp: span, name: ident, ns: namespace) let sc = sc; while true { alt copy sc { - nil. { ret none::<def>; } + nil { ret none::<def>; } cons(hd, tl) { let fnd = in_scope(e, sp, name, hd, ns); if !is_none(fnd) { @@ -962,7 +962,7 @@ fn lookup_in_scope(e: env, sc: scopes, sp: span, name: ident, ns: namespace) if left_fn && local || left_fn_level2 && self_scope || scope_is_fn(hd) && left_fn && def_is_ty_arg(df) { let msg = alt ns { - ns_type. { + ns_type { "attempt to use a type argument out of scope" } ns_val(v) { @@ -970,7 +970,7 @@ fn lookup_in_scope(e: env, sc: scopes, sp: span, name: ident, ns: namespace) /* If we were looking for a tag, at this point we know it's bound to a non-tag value, and we can return none instead of failing */ - ns_a_tag. { ret none; } + ns_a_tag { ret none; } _ { "attempted dynamic environment-capture" } } } @@ -1009,7 +1009,7 @@ fn lookup_in_ty_params(e: env, name: ident, ty_params: [ast::ty_param]) let n = 0u; for tp: ast::ty_param in ty_params { if str::eq(tp.ident, name) && alt e.current_tp { - some(cur) { n < cur } none. { true } + some(cur) { n < cur } none { true } } { ret some(ast::def_ty_param(local_def(tp.id), n)); } n += 1u; } @@ -1031,7 +1031,7 @@ fn lookup_in_fn(e: env, name: ident, decl: ast::fn_decl, ty_params: [ast::ty_param], ns: namespace) -> option::t<def> { alt ns { - ns_val(ns_any_value.) { + ns_val(ns_any_value) { for a: ast::arg in decl.inputs { if str::eq(a.ident, name) { ret some(ast::def_arg(local_def(a.id), a.mode)); @@ -1039,7 +1039,7 @@ fn lookup_in_fn(e: env, name: ident, decl: ast::fn_decl, } ret none::<def>; } - ns_type. { ret lookup_in_ty_params(e, name, ty_params); } + ns_type { ret lookup_in_ty_params(e, name, ty_params); } _ { ret none::<def>; } } } @@ -1155,10 +1155,10 @@ fn found_def_item(i: @ast::item, ns: namespace) -> option::t<def> { } ast::item_res(_, _, _, _, ctor_id) { alt ns { - ns_val(ns_any_value.) { + ns_val(ns_any_value) { ret some(ast::def_fn(local_def(ctor_id), ast::impure_fn)); } - ns_type. { ret some(ast::def_ty(local_def(i.id))); } + ns_type { ret some(ast::def_ty(local_def(i.id))); } _ { } } } @@ -1170,7 +1170,7 @@ fn found_def_item(i: @ast::item, ns: namespace) -> option::t<def> { fn lookup_in_mod_strict(e: env, m: def, sp: span, name: ident, ns: namespace, dr: dir) -> option::t<def> { alt lookup_in_mod(e, m, sp, name, ns, dr) { - none. { + none { unresolved_err(e, in_mod(m), sp, name, ns_name(ns)); ret none; } @@ -1231,8 +1231,8 @@ fn lookup_import(e: env, defid: def_id, ns: namespace) -> option::t<def> { if e.used_imports.track { e.used_imports.data += [defid.node]; } - ret alt ns { ns_val(_) { val } ns_type. { typ } - ns_module. { md } }; + ret alt ns { ns_val(_) { val } ns_type { typ } + ns_module { md } }; } } } @@ -1254,12 +1254,12 @@ fn lookup_in_local_mod(e: env, node_id: node_id, sp: span, id: ident, ret none::<def>; // name is not visible } alt info.index.find(id) { - none. { } + none { } some(lst_) { let lst = lst_; while true { alt lst { - nil. { break; } + nil { break; } cons(hd, tl) { let found = lookup_in_mie(e, hd, ns); if !is_none(found) { ret found; } @@ -1284,7 +1284,7 @@ fn lookup_in_globs(e: env, globs: [glob_imp_def], sp: span, id: ident, } alt lookup_in_mod(e, def.def, sp, name, ns, dr) { some(d) { option::some({def: d, item: def.item}) } - none. { none } + none { none } } } let matches = vec::filter_map(copy globs, @@ -1326,8 +1326,8 @@ fn lookup_glob_in_mod(e: env, info: @indexed_mod, sp: span, id: ident, glob_resolved(val, typ, md) { ret alt wanted_ns { ns_val(_) { val } - ns_type. { typ } - ns_module. { md } + ns_type { typ } + ns_module { md } }; } } @@ -1357,7 +1357,7 @@ fn lookup_in_mie(e: env, mie: mod_index_entry, ns: namespace) -> } mie_native_item(native_item) { alt native_item.node { - ast::native_item_ty. { + ast::native_item_ty { if ns == ns_type { ret some(ast::def_native_ty(local_def(native_item.id))); } @@ -1380,7 +1380,7 @@ fn lookup_in_mie(e: env, mie: mod_index_entry, ns: namespace) -> fn add_to_index(index: hashmap<ident, list<mod_index_entry>>, id: ident, ent: mod_index_entry) { alt index.find(id) { - none. { index.insert(id, cons(ent, @nil::<mod_index_entry>)); } + none { index.insert(id, cons(ent, @nil::<mod_index_entry>)); } some(prev) { index.insert(id, cons(ent, @prev)); } } } @@ -1471,7 +1471,7 @@ fn ns_for_def(d: def) -> namespace { // a tag fn ns_ok(wanted:namespace, actual:namespace) -> bool { alt actual { - ns_val(ns_a_tag.) { + ns_val(ns_a_tag) { alt wanted { ns_val(_) { true } _ { false } @@ -1556,7 +1556,7 @@ fn check_mod_name(e: env, name: ident, entries: list<mod_index_entry>) { } entries = *rest; } - nil. { break; } + nil { break; } } } } @@ -1798,7 +1798,7 @@ fn check_exports(e: @env) { } } } - none. { } + none { } } }; } @@ -1892,7 +1892,7 @@ fn find_impls_in_mod(e: env, m: def, &impls: [@_impl], let cached; alt e.impl_cache.find(defid) { some(v) { cached = v; } - none. { + none { cached = if defid.crate == ast::local_crate { let tmp = []; for i in option::get(e.mod_map.get(defid.node).m).items { diff --git a/src/comp/middle/shape.rs b/src/comp/middle/shape.rs index a4fbb78e114..39835854fea 100644 --- a/src/comp/middle/shape.rs +++ b/src/comp/middle/shape.rs @@ -313,24 +313,24 @@ fn shape_of(ccx: @crate_ctxt, t: ty::t, ty_param_map: [uint]) -> [u8] { let s = []; alt ty::struct(ccx.tcx, t) { - ty::ty_nil. | ty::ty_bool. | ty::ty_uint(ast::ty_u8.) | - ty::ty_bot. { s += [shape_u8]; } - ty::ty_int(ast::ty_i.) { s += [s_int(ccx.tcx)]; } - ty::ty_float(ast::ty_f.) { s += [s_float(ccx.tcx)]; } - ty::ty_uint(ast::ty_u.) | ty::ty_ptr(_) | + ty::ty_nil | ty::ty_bool | ty::ty_uint(ast::ty_u8) | + ty::ty_bot { s += [shape_u8]; } + ty::ty_int(ast::ty_i) { s += [s_int(ccx.tcx)]; } + ty::ty_float(ast::ty_f) { s += [s_float(ccx.tcx)]; } + ty::ty_uint(ast::ty_u) | ty::ty_ptr(_) | ty::ty_native(_) { s += [s_uint(ccx.tcx)]; } - ty::ty_type. { s += [s_tydesc(ccx.tcx)]; } - ty::ty_send_type. { s += [s_send_tydesc(ccx.tcx)]; } - ty::ty_int(ast::ty_i8.) { s += [shape_i8]; } - ty::ty_uint(ast::ty_u16.) { s += [shape_u16]; } - ty::ty_int(ast::ty_i16.) { s += [shape_i16]; } - ty::ty_uint(ast::ty_u32.) { s += [shape_u32]; } - ty::ty_int(ast::ty_i32.) | ty::ty_int(ast::ty_char.) {s += [shape_i32];} - ty::ty_uint(ast::ty_u64.) { s += [shape_u64]; } - ty::ty_int(ast::ty_i64.) { s += [shape_i64]; } - ty::ty_float(ast::ty_f32.) { s += [shape_f32]; } - ty::ty_float(ast::ty_f64.) { s += [shape_f64]; } - ty::ty_str. { + ty::ty_type { s += [s_tydesc(ccx.tcx)]; } + ty::ty_send_type { s += [s_send_tydesc(ccx.tcx)]; } + ty::ty_int(ast::ty_i8) { s += [shape_i8]; } + ty::ty_uint(ast::ty_u16) { s += [shape_u16]; } + ty::ty_int(ast::ty_i16) { s += [shape_i16]; } + ty::ty_uint(ast::ty_u32) { s += [shape_u32]; } + ty::ty_int(ast::ty_i32) | ty::ty_int(ast::ty_char) {s += [shape_i32];} + ty::ty_uint(ast::ty_u64) { s += [shape_u64]; } + ty::ty_int(ast::ty_i64) { s += [shape_i64]; } + ty::ty_float(ast::ty_f32) { s += [shape_f32]; } + ty::ty_float(ast::ty_f64) { s += [shape_f64]; } + ty::ty_str { s += [shape_vec]; add_bool(s, true); // type is POD let unit_ty = ty::mk_mach_uint(ccx.tcx, ast::ty_u8); @@ -338,19 +338,19 @@ fn shape_of(ccx: @crate_ctxt, t: ty::t, ty_param_map: [uint]) -> [u8] { } ty::ty_tag(did, tps) { alt tag_kind(ccx, did) { - tk_unit. { + tk_unit { // FIXME: For now we do this. s += [s_variant_tag_t(ccx.tcx)]; } - tk_enum. { s += [s_variant_tag_t(ccx.tcx)]; } - tk_complex. { + tk_enum { s += [s_variant_tag_t(ccx.tcx)]; } + tk_complex { s += [shape_tag]; let sub = []; let id; alt ccx.shape_cx.tag_id_to_index.find(did) { - none. { + none { id = ccx.shape_cx.next_tag_id; ccx.shape_cx.tag_id_to_index.insert(did, id); ccx.shape_cx.tag_order += [did]; @@ -423,19 +423,19 @@ fn shape_of(ccx: @crate_ctxt, t: ty::t, ty_param_map: [uint]) -> [u8] { // Find the type parameter in the parameter list. alt vec::position(n, ty_param_map) { some(i) { s += [shape_var, i as u8]; } - none. { fail "ty param not found in ty_param_map"; } + none { fail "ty param not found in ty_param_map"; } } } - ty::ty_fn({proto: ast::proto_box., _}) { + ty::ty_fn({proto: ast::proto_box, _}) { s += [shape_box_fn]; } - ty::ty_fn({proto: ast::proto_uniq., _}) { + ty::ty_fn({proto: ast::proto_uniq, _}) { s += [shape_uniq_fn]; } - ty::ty_fn({proto: ast::proto_block., _}) { + ty::ty_fn({proto: ast::proto_block, _}) { s += [shape_stack_fn]; } - ty::ty_fn({proto: ast::proto_bare., _}) { + ty::ty_fn({proto: ast::proto_bare, _}) { s += [shape_bare_fn]; } ty::ty_opaque_closure_ptr(_) { diff --git a/src/comp/middle/trans.rs b/src/comp/middle/trans.rs index 13d17eecb83..825a76f32b1 100644 --- a/src/comp/middle/trans.rs +++ b/src/comp/middle/trans.rs @@ -126,15 +126,15 @@ fn type_of_inner(cx: @crate_ctxt, sp: span, t: ty::t) if cx.lltypes.contains_key(t) { ret cx.lltypes.get(t); } let llty = alt ty::struct(cx.tcx, t) { ty::ty_native(_) { T_ptr(T_i8()) } - ty::ty_nil. { T_nil() } - ty::ty_bot. { + ty::ty_nil { T_nil() } + ty::ty_bot { T_nil() /* ...I guess? */ } - ty::ty_bool. { T_bool() } + ty::ty_bool { T_bool() } ty::ty_int(t) { T_int_ty(cx, t) } ty::ty_uint(t) { T_uint_ty(cx, t) } ty::ty_float(t) { T_float_ty(cx, t) } - ty::ty_str. { T_ptr(T_vec(cx, T_i8())) } + ty::ty_str { T_ptr(T_vec(cx, T_i8())) } ty::ty_tag(did, _) { type_of_tag(cx, sp, did, t) } ty::ty_box(mt) { let mt_ty = mt.ty; @@ -188,7 +188,7 @@ fn type_of_inner(cx: @crate_ctxt, sp: span, t: ty::t) std::util::unreachable() } ty::ty_param(_, _) { T_typaram(cx.tn) } - ty::ty_send_type. | ty::ty_type. { T_ptr(cx.tydesc_type) } + ty::ty_send_type | ty::ty_type { T_ptr(cx.tydesc_type) } ty::ty_tup(elts) { let tys = []; for elt in elts { @@ -442,7 +442,7 @@ fn dynastack_alloca(cx: @block_ctxt, t: TypeRef, n: ValueRef, ty: ty::t) -> let bcx = cx; let dy_cx = new_raw_block_ctxt(cx.fcx, cx.fcx.lldynamicallocas); alt bcx_fcx(cx).llobstacktoken { - none. { + none { bcx_fcx(cx).llobstacktoken = some(mk_obstack_token(bcx_ccx(cx), cx.fcx)); } @@ -935,7 +935,7 @@ fn get_derived_tydesc(cx: @block_ctxt, t: ty::t, escapes: bool, ret rslt(cx, info.lltydesc); } } - none. {/* fall through */ } + none {/* fall through */ } } bcx_ccx(cx).stats.n_derived_tydescs += 1u; @@ -1015,7 +1015,7 @@ fn get_tydesc(cx: @block_ctxt, t: ty::t, escapes: bool, uint::str(id)); } } - none. {/* fall through */ } + none {/* fall through */ } } // Does it contain a type param? If so, generate a derived tydesc. @@ -1033,7 +1033,7 @@ fn get_static_tydesc(cx: @block_ctxt, t: ty::t, ty_params: [uint]) -> @tydesc_info { alt bcx_ccx(cx).tydescs.find(t) { some(info) { ret info; } - none. { + none { bcx_ccx(cx).stats.n_static_tydescs += 1u; let info = declare_tydesc(cx.fcx.lcx, cx.sp, t, ty_params); bcx_ccx(cx).tydescs.insert(t, info); @@ -1199,22 +1199,22 @@ fn emit_tydescs(ccx: @crate_ctxt) { let ti = val; let take_glue = alt ti.take_glue { - none. { ccx.stats.n_null_glues += 1u; C_null(glue_fn_ty) } + none { ccx.stats.n_null_glues += 1u; C_null(glue_fn_ty) } some(v) { ccx.stats.n_real_glues += 1u; v } }; let drop_glue = alt ti.drop_glue { - none. { ccx.stats.n_null_glues += 1u; C_null(glue_fn_ty) } + none { ccx.stats.n_null_glues += 1u; C_null(glue_fn_ty) } some(v) { ccx.stats.n_real_glues += 1u; v } }; let free_glue = alt ti.free_glue { - none. { ccx.stats.n_null_glues += 1u; C_null(glue_fn_ty) } + none { ccx.stats.n_null_glues += 1u; C_null(glue_fn_ty) } some(v) { ccx.stats.n_real_glues += 1u; v } }; let cmp_glue = alt ti.cmp_glue { - none. { ccx.stats.n_null_glues += 1u; C_null(cmp_fn_ty) } + none { ccx.stats.n_null_glues += 1u; C_null(cmp_fn_ty) } some(v) { ccx.stats.n_real_glues += 1u; v } }; @@ -1264,12 +1264,12 @@ fn make_take_glue(cx: @block_ctxt, v: ValueRef, t: ty::t) { Store(r.bcx, r.val, v); r.bcx } - ty::ty_vec(_) | ty::ty_str. { + ty::ty_vec(_) | ty::ty_str { let r = tvec::duplicate(bcx, Load(bcx, v), t); Store(r.bcx, r.val, v); r.bcx } - ty::ty_send_type. { + ty::ty_send_type { // sendable type descriptors are basically unique pointers, // they must be cloned when copied: let r = Load(bcx, v); @@ -1328,7 +1328,7 @@ fn make_free_glue(bcx: @block_ctxt, v: ValueRef, t: ty::t) { let v = PointerCast(bcx, v, type_of_1(bcx, t)); trans_uniq::make_free_glue(bcx, v, t) } - ty::ty_vec(_) | ty::ty_str. { + ty::ty_vec(_) | ty::ty_str { tvec::make_free_glue(bcx, PointerCast(bcx, v, type_of_1(bcx, t)), t) } ty::ty_iface(_, _) { @@ -1345,7 +1345,7 @@ fn make_free_glue(bcx: @block_ctxt, v: ValueRef, t: ty::t) { abi::tydesc_field_drop_glue, ti); trans_free_if_not_gc(bcx, b) } - ty::ty_send_type. { + ty::ty_send_type { // sendable type descriptors are basically unique pointers, // they must be freed. let ccx = bcx_ccx(bcx); @@ -1372,7 +1372,7 @@ fn make_drop_glue(bcx: @block_ctxt, v0: ValueRef, t: ty::t) { ty::ty_box(_) | ty::ty_iface(_, _) { decr_refcnt_maybe_free(bcx, Load(bcx, v0), t) } - ty::ty_uniq(_) | ty::ty_vec(_) | ty::ty_str. | ty::ty_send_type. { + ty::ty_uniq(_) | ty::ty_vec(_) | ty::ty_str | ty::ty_send_type { free_ty(bcx, Load(bcx, v0), t) } ty::ty_res(did, inner, tps) { @@ -1478,12 +1478,12 @@ fn compare_scalar_types(cx: @block_ctxt, lhs: ValueRef, rhs: ValueRef, let f = bind compare_scalar_values(cx, lhs, rhs, _, op); alt ty::struct(bcx_tcx(cx), t) { - ty::ty_nil. { ret rslt(cx, f(nil_type)); } - ty::ty_bool. | ty::ty_ptr(_) { ret rslt(cx, f(unsigned_int)); } + ty::ty_nil { ret rslt(cx, f(nil_type)); } + ty::ty_bool | ty::ty_ptr(_) { ret rslt(cx, f(unsigned_int)); } ty::ty_int(_) { ret rslt(cx, f(signed_int)); } ty::ty_uint(_) { ret rslt(cx, f(unsigned_int)); } ty::ty_float(_) { ret rslt(cx, f(floating_point)); } - ty::ty_type. { + ty::ty_type { ret rslt(trans_fail(cx, none, "attempt to compare values of type type"), C_nil()); @@ -1506,44 +1506,44 @@ fn compare_scalar_types(cx: @block_ctxt, lhs: ValueRef, rhs: ValueRef, fn compare_scalar_values(cx: @block_ctxt, lhs: ValueRef, rhs: ValueRef, nt: scalar_type, op: ast::binop) -> ValueRef { alt nt { - nil_type. { + nil_type { // We don't need to do actual comparisons for nil. // () == () holds but () < () does not. alt op { - ast::eq. | ast::le. | ast::ge. { ret C_bool(true); } - ast::ne. | ast::lt. | ast::gt. { ret C_bool(false); } + ast::eq | ast::le | ast::ge { ret C_bool(true); } + ast::ne | ast::lt | ast::gt { ret C_bool(false); } } } - floating_point. { + floating_point { let cmp = alt op { - ast::eq. { lib::llvm::LLVMRealOEQ } - ast::ne. { lib::llvm::LLVMRealUNE } - ast::lt. { lib::llvm::LLVMRealOLT } - ast::le. { lib::llvm::LLVMRealOLE } - ast::gt. { lib::llvm::LLVMRealOGT } - ast::ge. { lib::llvm::LLVMRealOGE } + ast::eq { lib::llvm::LLVMRealOEQ } + ast::ne { lib::llvm::LLVMRealUNE } + ast::lt { lib::llvm::LLVMRealOLT } + ast::le { lib::llvm::LLVMRealOLE } + ast::gt { lib::llvm::LLVMRealOGT } + ast::ge { lib::llvm::LLVMRealOGE } }; ret FCmp(cx, cmp, lhs, rhs); } - signed_int. { + signed_int { let cmp = alt op { - ast::eq. { lib::llvm::LLVMIntEQ } - ast::ne. { lib::llvm::LLVMIntNE } - ast::lt. { lib::llvm::LLVMIntSLT } - ast::le. { lib::llvm::LLVMIntSLE } - ast::gt. { lib::llvm::LLVMIntSGT } - ast::ge. { lib::llvm::LLVMIntSGE } + ast::eq { lib::llvm::LLVMIntEQ } + ast::ne { lib::llvm::LLVMIntNE } + ast::lt { lib::llvm::LLVMIntSLT } + ast::le { lib::llvm::LLVMIntSLE } + ast::gt { lib::llvm::LLVMIntSGT } + ast::ge { lib::llvm::LLVMIntSGE } }; ret ICmp(cx, cmp, lhs, rhs); } - unsigned_int. { + unsigned_int { let cmp = alt op { - ast::eq. { lib::llvm::LLVMIntEQ } - ast::ne. { lib::llvm::LLVMIntNE } - ast::lt. { lib::llvm::LLVMIntULT } - ast::le. { lib::llvm::LLVMIntULE } - ast::gt. { lib::llvm::LLVMIntUGT } - ast::ge. { lib::llvm::LLVMIntUGE } + ast::eq { lib::llvm::LLVMIntEQ } + ast::ne { lib::llvm::LLVMIntNE } + ast::lt { lib::llvm::LLVMIntULT } + ast::le { lib::llvm::LLVMIntULE } + ast::gt { lib::llvm::LLVMIntUGT } + ast::ge { lib::llvm::LLVMIntUGE } }; ret ICmp(cx, cmp, lhs, rhs); } @@ -1697,12 +1697,12 @@ fn lazily_emit_all_generic_info_tydesc_glues(cx: @block_ctxt, fn lazily_emit_tydesc_glue(cx: @block_ctxt, field: int, static_ti: option::t<@tydesc_info>) { alt static_ti { - none. { } + none { } some(ti) { if field == abi::tydesc_field_take_glue { alt ti.take_glue { some(_) { } - none. { + none { #debug("+++ lazily_emit_tydesc_glue TAKE %s", ty_to_str(bcx_tcx(cx), ti.ty)); let lcx = cx.fcx.lcx; @@ -1720,7 +1720,7 @@ fn lazily_emit_tydesc_glue(cx: @block_ctxt, field: int, } else if field == abi::tydesc_field_drop_glue { alt ti.drop_glue { some(_) { } - none. { + none { #debug("+++ lazily_emit_tydesc_glue DROP %s", ty_to_str(bcx_tcx(cx), ti.ty)); let lcx = cx.fcx.lcx; @@ -1738,7 +1738,7 @@ fn lazily_emit_tydesc_glue(cx: @block_ctxt, field: int, } else if field == abi::tydesc_field_free_glue { alt ti.free_glue { some(_) { } - none. { + none { #debug("+++ lazily_emit_tydesc_glue FREE %s", ty_to_str(bcx_tcx(cx), ti.ty)); let lcx = cx.fcx.lcx; @@ -1756,7 +1756,7 @@ fn lazily_emit_tydesc_glue(cx: @block_ctxt, field: int, } else if field == abi::tydesc_field_cmp_glue { alt ti.cmp_glue { some(_) { } - none. { + none { #debug("+++ lazily_emit_tydesc_glue CMP %s", ty_to_str(bcx_tcx(cx), ti.ty)); ti.cmp_glue = some(bcx_ccx(cx).upcalls.cmp_type); @@ -1775,7 +1775,7 @@ fn call_tydesc_glue_full(cx: @block_ctxt, v: ValueRef, tydesc: ValueRef, let static_glue_fn = none; alt static_ti { - none. {/* no-op */ } + none {/* no-op */ } some(sti) { if field == abi::tydesc_field_take_glue { static_glue_fn = sti.take_glue; @@ -1794,7 +1794,7 @@ fn call_tydesc_glue_full(cx: @block_ctxt, v: ValueRef, tydesc: ValueRef, let llfn; alt static_glue_fn { - none. { + none { let llfnptr = GEPi(cx, tydesc, [0, field]); llfn = Load(cx, llfnptr); } @@ -1840,7 +1840,7 @@ fn call_cmp_glue(cx: @block_ctxt, lhs: ValueRef, rhs: ValueRef, t: ty::t, let llfn; alt ti { - none. { + none { let llfnptr = GEPi(bcx, lltydesc, [0, abi::tydesc_field_cmp_glue]); llfn = Load(bcx, llfnptr); @@ -1870,7 +1870,7 @@ fn drop_ty(cx: @block_ctxt, v: ValueRef, t: ty::t) -> @block_ctxt { fn drop_ty_immediate(bcx: @block_ctxt, v: ValueRef, t: ty::t) -> @block_ctxt { alt ty::struct(bcx_tcx(bcx), t) { - ty::ty_uniq(_) | ty::ty_vec(_) | ty::ty_str. { free_ty(bcx, v, t) } + ty::ty_uniq(_) | ty::ty_vec(_) | ty::ty_str { free_ty(bcx, v, t) } ty::ty_box(_) | ty::ty_iface(_, _) { decr_refcnt_maybe_free(bcx, v, t) } } } @@ -1884,7 +1884,7 @@ fn take_ty_immediate(bcx: @block_ctxt, v: ValueRef, t: ty::t) -> result { check trans_uniq::type_is_unique_box(bcx, t); trans_uniq::duplicate(bcx, v, t) } - ty::ty_str. | ty::ty_vec(_) { tvec::duplicate(bcx, v, t) } + ty::ty_str | ty::ty_vec(_) { tvec::duplicate(bcx, v, t) } _ { rslt(bcx, v) } } } @@ -2046,7 +2046,7 @@ fn trans_crate_lit(cx: @crate_ctxt, lit: ast::lit) -> ValueRef { ast::lit_uint(u, t) { C_integral(T_uint_ty(cx, t), u, False) } ast::lit_float(fs, t) { C_floating(fs, T_float_ty(cx, t)) } ast::lit_bool(b) { C_bool(b) } - ast::lit_nil. { C_nil() } + ast::lit_nil { C_nil() } ast::lit_str(s) { cx.sess.span_unimpl(lit.span, "unique string in this context"); } @@ -2083,11 +2083,11 @@ fn trans_unary(bcx: @block_ctxt, op: ast::unop, e: @ast::expr, if dest == ignore { ret trans_expr(bcx, e, ignore); } let e_ty = ty::expr_ty(bcx_tcx(bcx), e); alt op { - ast::not. { + ast::not { let {bcx, val} = trans_temp_expr(bcx, e); ret store_in_dest(bcx, Not(bcx, val), dest); } - ast::neg. { + ast::neg { let {bcx, val} = trans_temp_expr(bcx, e); let neg = if ty::type_is_fp(bcx_tcx(bcx), e_ty) { FNeg(bcx, val) @@ -2099,7 +2099,7 @@ fn trans_unary(bcx: @block_ctxt, op: ast::unop, e: @ast::expr, add_clean_free(bcx, box, false); // Cast the body type to the type of the value. This is needed to // make tags work, since tags have a different LLVM type depending - // on whether they're boxed or not. + // on whether they're boxed or not let ccx = bcx_ccx(bcx); if check type_has_static_size(ccx, e_ty) { let e_sp = e.span; @@ -2113,7 +2113,7 @@ fn trans_unary(bcx: @block_ctxt, op: ast::unop, e: @ast::expr, ast::uniq(_) { ret trans_uniq::trans_uniq(bcx, e, id, dest); } - ast::deref. { + ast::deref { bcx_ccx(bcx).sess.bug("deref expressions should have been \ translated using trans_lval(), not \ trans_unary()"); @@ -2131,17 +2131,17 @@ fn trans_compare(cx: @block_ctxt, op: ast::binop, lhs: ValueRef, // Determine the operation we need. let llop; alt op { - ast::eq. | ast::ne. { llop = C_u8(abi::cmp_glue_op_eq); } - ast::lt. | ast::ge. { llop = C_u8(abi::cmp_glue_op_lt); } - ast::le. | ast::gt. { llop = C_u8(abi::cmp_glue_op_le); } + ast::eq | ast::ne { llop = C_u8(abi::cmp_glue_op_eq); } + ast::lt | ast::ge { llop = C_u8(abi::cmp_glue_op_lt); } + ast::le | ast::gt { llop = C_u8(abi::cmp_glue_op_le); } } let rs = call_cmp_glue(cx, lhs, rhs, rhs_t, llop); // Invert the result if necessary. alt op { - ast::eq. | ast::lt. | ast::le. { ret rslt(rs.bcx, rs.val); } - ast::ne. | ast::ge. | ast::gt. { + ast::eq | ast::lt | ast::le { ret rslt(rs.bcx, rs.val); } + ast::ne | ast::ge | ast::gt { ret rslt(rs.bcx, Not(rs.bcx, rs.val)); } } @@ -2161,36 +2161,36 @@ fn trans_eager_binop(cx: @block_ctxt, op: ast::binop, lhs: ValueRef, ret tvec::trans_add(cx, intype, lhs, rhs, dest); } let cx = cx, val = alt op { - ast::add. { + ast::add { if is_float { FAdd(cx, lhs, rhs) } else { Add(cx, lhs, rhs) } } - ast::subtract. { + ast::subtract { if is_float { FSub(cx, lhs, rhs) } else { Sub(cx, lhs, rhs) } } - ast::mul. { + ast::mul { if is_float { FMul(cx, lhs, rhs) } else { Mul(cx, lhs, rhs) } } - ast::div. { + ast::div { if is_float { FDiv(cx, lhs, rhs) } else if ty::type_is_signed(bcx_tcx(cx), intype) { SDiv(cx, lhs, rhs) } else { UDiv(cx, lhs, rhs) } } - ast::rem. { + ast::rem { if is_float { FRem(cx, lhs, rhs) } else if ty::type_is_signed(bcx_tcx(cx), intype) { SRem(cx, lhs, rhs) } else { URem(cx, lhs, rhs) } } - ast::bitor. { Or(cx, lhs, rhs) } - ast::bitand. { And(cx, lhs, rhs) } - ast::bitxor. { Xor(cx, lhs, rhs) } - ast::lsl. { Shl(cx, lhs, rhs) } - ast::lsr. { LShr(cx, lhs, rhs) } - ast::asr. { AShr(cx, lhs, rhs) } + ast::bitor { Or(cx, lhs, rhs) } + ast::bitand { And(cx, lhs, rhs) } + ast::bitxor { Xor(cx, lhs, rhs) } + ast::lsl { Shl(cx, lhs, rhs) } + ast::lsr { LShr(cx, lhs, rhs) } + ast::asr { AShr(cx, lhs, rhs) } _ { let cmpr = trans_compare(cx, op, lhs, lhs_t, rhs, rhs_t); cx = cmpr.bcx; @@ -2222,7 +2222,7 @@ fn trans_assign_op(bcx: @block_ctxt, op: ast::binop, dst: @ast::expr, let {bcx, val: rhs_val} = trans_temp_expr(lhs_res.bcx, src); if ty::type_is_sequence(tcx, t) { alt op { - ast::add. { + ast::add { ret tvec::trans_append(bcx, t, lhs_res.val, rhs_val); } _ { } @@ -2283,7 +2283,7 @@ fn autoderef(cx: @block_ctxt, v: ValueRef, t: ty::t) -> result_t { fn trans_lazy_binop(bcx: @block_ctxt, op: ast::binop, a: @ast::expr, b: @ast::expr, dest: dest) -> @block_ctxt { - let is_and = alt op { ast::and. { true } ast::or. { false } }; + let is_and = alt op { ast::and { true } ast::or { false } }; let lhs_res = trans_temp_expr(bcx, a); if lhs_res.bcx.unreachable { ret lhs_res.bcx; } let rhs_cx = new_scope_block_ctxt(lhs_res.bcx, "rhs"); @@ -2316,7 +2316,7 @@ fn trans_binary(cx: @block_ctxt, op: ast::binop, a: @ast::expr, b: @ast::expr, dest: dest) -> @block_ctxt { // First couple cases are lazy: alt op { - ast::and. | ast::or. { + ast::and | ast::or { ret trans_lazy_binop(cx, op, a, b, dest); } _ { @@ -2381,7 +2381,7 @@ fn join_returns(parent_cx: @block_ctxt, in_cxs: [@block_ctxt], // Used to put an immediate value in a dest. fn store_in_dest(bcx: @block_ctxt, val: ValueRef, dest: dest) -> @block_ctxt { alt dest { - ignore. {} + ignore {} by_val(cell) { *cell = val; } save_in(addr) { Store(bcx, val, addr); } } @@ -2578,7 +2578,7 @@ fn lval_static_fn(bcx: @block_ctxt, fn_id: ast::def_id, id: ast::node_id) fn lookup_discriminant(lcx: @local_ctxt, vid: ast::def_id) -> ValueRef { let ccx = lcx.ccx; alt ccx.discrims.find(vid) { - none. { + none { // It's an external discriminant that we haven't seen yet. assert (vid.crate != ast::local_crate); let sym = csearch::get_symbol(lcx.ccx.sess.cstore, vid); @@ -2788,7 +2788,7 @@ fn trans_lval(cx: @block_ctxt, e: @ast::expr) -> lval_result { ast::expr_index(base, idx) { ret trans_index(cx, e.span, base, idx, e.id); } - ast::expr_unary(ast::deref., base) { + ast::expr_unary(ast::deref, base) { let ccx = bcx_ccx(cx); let sub = trans_temp_expr(cx, base); let t = ty::expr_ty(ccx.tcx, base); @@ -2826,11 +2826,11 @@ fn trans_lval(cx: @block_ctxt, e: @ast::expr) -> lval_result { fn maybe_add_env(bcx: @block_ctxt, c: lval_maybe_callee) -> (lval_kind, ValueRef) { alt c.env { - is_closure. { (c.kind, c.val) } + is_closure { (c.kind, c.val) } self_env(_) | dict_env(_, _) { fail "Taking the value of a method does not work yet (issue #435)"; } - null_env. { + null_env { let llfnty = llvm::LLVMGetElementType(val_ty(c.val)); (temporary, create_real_fn_pair(bcx, llfnty, c.val, null_env_ptr(bcx))) @@ -2849,7 +2849,7 @@ fn lval_maybe_callee_to_lval(c: lval_maybe_callee, ty: ty::t) -> lval_result { add_clean_temp(bcx, space.val, ty); ret {bcx: bcx, val: space.val, kind: temporary}; } - none. { + none { let (kind, val) = maybe_add_env(c.bcx, c); ret {bcx: c.bcx, val: val, kind: kind}; } @@ -2915,41 +2915,41 @@ fn trans_cast(cx: @block_ctxt, e: @ast::expr, id: ast::node_id, let newval = alt {in: k_in, out: k_out} { - {in: integral., out: integral.} { + {in: integral, out: integral.} { int_cast(e_res.bcx, ll_t_out, ll_t_in, e_res.val, s_in) } - {in: float., out: float.} { + {in: float, out: float.} { float_cast(e_res.bcx, ll_t_out, ll_t_in, e_res.val) } - {in: integral., out: float.} { + {in: integral, out: float} { if s_in { SIToFP(e_res.bcx, e_res.val, ll_t_out) } else { UIToFP(e_res.bcx, e_res.val, ll_t_out) } } - {in: float., out: integral.} { + {in: float, out: integral} { if ty::type_is_signed(ccx.tcx, t_out) { FPToSI(e_res.bcx, e_res.val, ll_t_out) } else { FPToUI(e_res.bcx, e_res.val, ll_t_out) } } - {in: integral., out: pointer.} { + {in: integral, out: pointer} { IntToPtr(e_res.bcx, e_res.val, ll_t_out) } - {in: pointer., out: integral.} { + {in: pointer, out: integral} { PtrToInt(e_res.bcx, e_res.val, ll_t_out) } - {in: pointer., out: pointer.} { + {in: pointer, out: pointer.} { PointerCast(e_res.bcx, e_res.val, ll_t_out) } - {in: tag_., out: integral.} | {in: tag_., out: float.} { + {in: tag_, out: integral} | {in: tag_., out: float} { let cx = e_res.bcx; let lltagty = T_opaque_tag_ptr(ccx); let av_tag = PointerCast(cx, e_res.val, lltagty); let lldiscrim_a_ptr = GEPi(cx, av_tag, [0, 0]); let lldiscrim_a = Load(cx, lldiscrim_a_ptr); alt k_out { - integral. {int_cast(e_res.bcx, ll_t_out, + integral {int_cast(e_res.bcx, ll_t_out, val_ty(lldiscrim_a), lldiscrim_a, true)} - float. {SIToFP(e_res.bcx, lldiscrim_a, ll_t_out)} + float {SIToFP(e_res.bcx, lldiscrim_a, ll_t_out)} } } _ { ccx.sess.bug("Translating unsupported cast.") } @@ -3081,7 +3081,7 @@ fn trans_args(cx: @block_ctxt, llenv: ValueRef, } // Arg 0: Output pointer. let llretslot = alt dest { - ignore. { + ignore { if ty::type_is_nil(tcx, retty) { llvm::LLVMGetUndef(T_ptr(T_nil())) } else { @@ -3153,12 +3153,12 @@ fn trans_call(in_cx: @block_ctxt, f: @ast::expr, let faddr = f_res.val; let llenv, dict_param = none; alt f_res.env { - null_env. { + null_env { llenv = llvm::LLVMGetUndef(T_opaque_cbox_ptr(bcx_ccx(cx))); } self_env(e) { llenv = e; } dict_env(dict, e) { llenv = e; dict_param = some(dict); } - is_closure. { + is_closure { // It's a closure. Have to fetch the elements if f_res.kind == owned { faddr = load_if_immediate(bcx, faddr, fn_expr_ty); @@ -3186,7 +3186,7 @@ fn trans_call(in_cx: @block_ctxt, f: @ast::expr, bcx = invoke_full(bcx, faddr, llargs, args_res.to_zero, args_res.to_revoke); alt dest { - ignore. { + ignore { if llvm::LLVMIsUndef(llretslot) != lib::llvm::True { bcx = drop_ty(bcx, llretslot, ret_ty); } @@ -3271,7 +3271,7 @@ fn get_landing_pad(bcx: @block_ctxt, } else { scope_bcx = alt scope_bcx.parent { parent_some(b) { b } - parent_none. { + parent_none { ret scope_bcx; } }; @@ -3316,7 +3316,7 @@ fn trans_landing_pad(bcx: @block_ctxt, bcx = trans_block_cleanups(bcx, scope_cx); scope_cx = alt scope_cx.parent { parent_some(b) { b } - parent_none. { break; } + parent_none { break; } }; } @@ -3330,7 +3330,7 @@ fn trans_tup(bcx: @block_ctxt, elts: [@ast::expr], id: ast::node_id, let t = node_id_type(bcx.fcx.lcx.ccx, id); let bcx = bcx; let addr = alt dest { - ignore. { + ignore { for ex in elts { bcx = trans_expr(bcx, ex, ignore); } ret bcx; } @@ -3355,7 +3355,7 @@ fn trans_rec(bcx: @block_ctxt, fields: [ast::field], let t = node_id_type(bcx_ccx(bcx), id); let bcx = bcx; let addr = alt dest { - ignore. { + ignore { for fld in fields { bcx = trans_expr(bcx, fld.node.expr, ignore); } @@ -3390,7 +3390,7 @@ fn trans_rec(bcx: @block_ctxt, fields: [ast::field], i += 1; } } - none. {} + none {} }; // Now revoke the cleanups as we pass responsibility for the data @@ -3527,11 +3527,11 @@ fn trans_expr(bcx: @block_ctxt, e: @ast::expr, dest: dest) -> @block_ctxt { } // These return nothing - ast::expr_break. { + ast::expr_break { assert dest == ignore; ret trans_break(e.span, bcx); } - ast::expr_cont. { + ast::expr_cont { assert dest == ignore; ret trans_cont(e.span, bcx); } @@ -3657,7 +3657,7 @@ fn lval_to_dps(bcx: @block_ctxt, e: @ast::expr, dest: dest) -> @block_ctxt { save_in(loc) { bcx = store_temp_expr(bcx, INIT, loc, lv, ty, last_use); } - ignore. {} + ignore {} } ret bcx; } @@ -3805,7 +3805,7 @@ fn trans_fail_value(bcx: @block_ctxt, sp_opt: option::t<span>, V_filename = C_cstr(bcx_ccx(bcx), loc.filename); V_line = loc.line as int; } - none. { V_filename = C_cstr(bcx_ccx(bcx), "<runtime>"); V_line = 0; } + none { V_filename = C_cstr(bcx_ccx(bcx), "<runtime>"); V_line = 0; } } let V_str = PointerCast(bcx, V_fail_str, T_ptr(T_i8())); V_filename = PointerCast(bcx, V_filename, T_ptr(T_i8())); @@ -3837,7 +3837,7 @@ fn trans_break_cont(sp: span, bcx: @block_ctxt, to_end: bool) _ { alt cleanup_cx.parent { parent_some(cx) { cleanup_cx = cx; } - parent_none. { + parent_none { bcx_ccx(bcx).sess.span_fatal (sp, if to_end { "Break" } else { "Cont" } + " outside a loop"); @@ -3871,7 +3871,7 @@ fn trans_ret(bcx: @block_ctxt, e: option::t<@ast::expr>) -> @block_ctxt { bcx = trans_block_cleanups(bcx, cleanup_cx); alt cleanup_cx.parent { parent_some(b) { cleanup_cx = b; } - parent_none. { more_cleanups = false; } + parent_none { more_cleanups = false; } } } build_return(bcx); @@ -3894,7 +3894,7 @@ fn init_local(bcx: @block_ctxt, local: @ast::local) -> @block_ctxt { let llptr = alt bcx.fcx.lllocals.find(local.node.id) { some(local_mem(v)) { v } // This is a local that is kept immediate - none. { + none { let initexpr = alt local.node.init { some({expr, _}) { expr } }; let {bcx, val, kind} = trans_temp_lval(bcx, initexpr); if kind != temporary { @@ -3929,8 +3929,8 @@ fn init_ref_local(bcx: @block_ctxt, local: @ast::local) -> @block_ctxt { let init_expr = option::get(local.node.init).expr; let {bcx, val, kind} = trans_lval(bcx, init_expr); alt kind { - owned_imm. { val = do_spill_noroot(bcx, val); } - owned. {} + owned_imm { val = do_spill_noroot(bcx, val); } + owned {} } ret trans_alt::bind_irrefutable_pat(bcx, local.node.pat, val, false); } @@ -4096,7 +4096,7 @@ fn trans_fn_cleanups(fcx: @fn_ctxt, cx: @block_ctxt) { let lltoken = lltoken_; // satisfy alias checker Call(cx, fcx_ccx(fcx).upcalls.dynastack_free, [lltoken]); } - none. {/* nothing to do */ } + none {/* nothing to do */ } } } @@ -4181,7 +4181,7 @@ fn alloc_local(cx: @block_ctxt, local: @ast::local) -> @block_ctxt { let t = node_id_type(bcx_ccx(cx), local.node.id); let p = normalize_pat(bcx_tcx(cx), local.node.pat); let is_simple = alt p.node { - ast::pat_ident(_, none.) { true } _ { false } + ast::pat_ident(_, none) { true } _ { false } }; // Do not allocate space for locals that can be kept immediate. let ccx = bcx_ccx(cx); @@ -4189,13 +4189,13 @@ fn alloc_local(cx: @block_ctxt, local: @ast::local) -> @block_ctxt { !ccx.last_uses.contains_key(local.node.pat.id) && ty::type_is_immediate(ccx.tcx, t) { alt local.node.init { - some({op: ast::init_assign., _}) { ret cx; } + some({op: ast::init_assign, _}) { ret cx; } _ {} } } let r = alloc_ty(cx, t); alt p.node { - ast::pat_ident(pth, none.) { + ast::pat_ident(pth, none) { if bcx_ccx(cx).sess.opts.debuginfo { let _: () = str::as_buf(path_to_ident(pth), {|buf| llvm::LLVMSetValueName(r.val, buf) @@ -4326,7 +4326,7 @@ fn create_llargs_for_fn_args(cx: @fn_ctxt, ty_self: self_arg, impl_self(tt) { cx.llself = some({v: cx.llenv, t: tt}); } - no_self. {} + no_self {} } for tp in ty_params { let lltydesc = llvm::LLVMGetParam(cx.llfn, arg_n as c_uint); @@ -4338,7 +4338,7 @@ fn create_llargs_for_fn_args(cx: @fn_ctxt, ty_self: self_arg, let dict = llvm::LLVMGetParam(cx.llfn, arg_n as c_uint); arg_n += 1u; dicts = some(alt dicts { - none. { [dict] } + none { [dict] } some(ds) { ds + [dict] } }); } @@ -4368,9 +4368,9 @@ fn copy_args_to_allocas(fcx: @fn_ctxt, bcx: @block_ctxt, args: [ast::arg], let id = args[arg_n].id; let argval = alt fcx.llargs.get(id) { local_mem(v) { v } }; alt arg.mode { - ast::by_mut_ref. { } - ast::by_move. | ast::by_copy. { add_clean(bcx, argval, arg.ty); } - ast::by_val. { + ast::by_mut_ref { } + ast::by_move | ast::by_copy { add_clean(bcx, argval, arg.ty); } + ast::by_val { if !ty::type_is_immediate(bcx_tcx(bcx), arg.ty) { let {bcx: cx, val: alloc} = alloc_ty(bcx, arg.ty); bcx = cx; @@ -4380,7 +4380,7 @@ fn copy_args_to_allocas(fcx: @fn_ctxt, bcx: @block_ctxt, args: [ast::arg], fcx.llargs.insert(id, local_imm(argval)); } } - ast::by_ref. {} + ast::by_ref {} } if fcx_ccx(fcx).sess.opts.extra_debuginfo { debuginfo::create_arg(bcx, args[arg_n]); @@ -4607,42 +4607,42 @@ fn trans_const_expr(cx: @crate_ctxt, e: @ast::expr) -> ValueRef { let is_float = ty::type_is_fp(ccx_tcx(cx), ty); let signed = ty::type_is_signed(ccx_tcx(cx), ty); ret alt b { - ast::add. { + ast::add { if is_float { llvm::LLVMConstFAdd(te1, te2) } else { llvm::LLVMConstAdd(te1, te2) } } - ast::subtract. { + ast::subtract { if is_float { llvm::LLVMConstFSub(te1, te2) } else { llvm::LLVMConstSub(te1, te2) } } - ast::mul. { + ast::mul { if is_float { llvm::LLVMConstFMul(te1, te2) } else { llvm::LLVMConstMul(te1, te2) } } - ast::div. { + ast::div { if is_float { llvm::LLVMConstFDiv(te1, te2) } else if signed { llvm::LLVMConstSDiv(te1, te2) } else { llvm::LLVMConstUDiv(te1, te2) } } - ast::rem. { + ast::rem { if is_float { llvm::LLVMConstFRem(te1, te2) } else if signed { llvm::LLVMConstSRem(te1, te2) } else { llvm::LLVMConstURem(te1, te2) } } - ast::and. | - ast::or. { cx.sess.span_unimpl(e.span, "binop logic"); } - ast::bitxor. { llvm::LLVMConstXor(te1, te2) } - ast::bitand. { llvm::LLVMConstAnd(te1, te2) } - ast::bitor. { llvm::LLVMConstOr(te1, te2) } - ast::lsl. { llvm::LLVMConstShl(te1, te2) } - ast::lsr. { llvm::LLVMConstLShr(te1, te2) } - ast::asr. { llvm::LLVMConstAShr(te1, te2) } - ast::eq. | - ast::lt. | - ast::le. | - ast::ne. | - ast::ge. | - ast::gt. { cx.sess.span_unimpl(e.span, "binop comparator"); } + ast::and | + ast::or { cx.sess.span_unimpl(e.span, "binop logic"); } + ast::bitxor { llvm::LLVMConstXor(te1, te2) } + ast::bitand { llvm::LLVMConstAnd(te1, te2) } + ast::bitor { llvm::LLVMConstOr(te1, te2) } + ast::lsl { llvm::LLVMConstShl(te1, te2) } + ast::lsr { llvm::LLVMConstLShr(te1, te2) } + ast::asr { llvm::LLVMConstAShr(te1, te2) } + ast::eq | + ast::lt | + ast::le | + ast::ne | + ast::ge | + ast::gt { cx.sess.span_unimpl(e.span, "binop comparator"); } } } ast::expr_unary(u, e) { @@ -4652,10 +4652,10 @@ fn trans_const_expr(cx: @crate_ctxt, e: @ast::expr) -> ValueRef { ret alt u { ast::box(_) | ast::uniq(_) | - ast::deref. { cx.sess.span_bug(e.span, + ast::deref { cx.sess.span_bug(e.span, "bad unop type in trans_const_expr"); } - ast::not. { llvm::LLVMConstNot(te) } - ast::neg. { + ast::not { llvm::LLVMConstNot(te) } + ast::neg { if is_float { llvm::LLVMConstFNeg(te) } else { llvm::LLVMConstNeg(te) } } @@ -4848,7 +4848,7 @@ fn trans_native_mod(lcx: @local_ctxt, native_mod: ast::native_mod, for native_item in native_mod.items { alt native_item.node { - ast::native_item_ty. {} + ast::native_item_ty {} ast::native_item_fn(fn_decl, tps) { let span = native_item.span; let id = native_item.id; @@ -4860,7 +4860,7 @@ fn trans_native_mod(lcx: @local_ctxt, native_mod: ast::native_mod, vec::len(tps), llshimfn, llwrapfn); } - none. { + none { ccx.sess.span_fatal( native_item.span, "unbound function item in trans_native_mod"); @@ -4933,7 +4933,7 @@ fn trans_item(cx: @local_ctxt, item: ast::item) { } } -// Translate a module. Doing this amounts to translating the items in the +// Translate a module. Doing this amounts to translating the items in the // module; there ends up being no artifact (aside from linkage names) of // separate modules in the compiled program. That's because modules exist // only as a convenience for humans working with the code, to organize names @@ -5084,7 +5084,7 @@ fn native_fn_ty_param_count(cx: @crate_ctxt, id: ast::node_id) -> uint { let native_item = alt cx.ast_map.find(id) { some(ast_map::node_native_item(i)) { i } }; alt native_item.node { - ast::native_item_ty. { + ast::native_item_ty { cx.sess.bug("register_native_fn(): native fn isn't \ actually a fn"); } @@ -5113,7 +5113,7 @@ fn raw_native_fn_type(ccx: @crate_ctxt, sp: span, args: [ty::arg], fn link_name(i: @ast::native_item) -> str { alt attr::get_meta_item_value_str_by_name(i.attrs, "link_name") { - none. { ret i.ident; } + none { ret i.ident; } option::some(ln) { ret ln; } } } @@ -5130,7 +5130,7 @@ fn collect_native_item(ccx: @crate_ctxt, let node_type = node_id_type(ccx, id); let fn_abi = alt attr::get_meta_item_value_str_by_name(i.attrs, "abi") { - option::none. { + option::none { // if abi isn't specified for this function, inherit from // its enclosing native module option::get(*abi) diff --git a/src/comp/middle/trans_alt.rs b/src/comp/middle/trans_alt.rs index 5addbebddc1..cef43dc25e5 100644 --- a/src/comp/middle/trans_alt.rs +++ b/src/comp/middle/trans_alt.rs @@ -129,7 +129,7 @@ fn enter_match(m: match, col: uint, val: ValueRef, e: enter_pat) -> match { vec::slice(br.pats, col + 1u, vec::len(br.pats)); let new_br = @{pats: pats, bound: alt br.pats[col].node { - ast::pat_ident(name, none.) { + ast::pat_ident(name, none) { br.bound + [{ident: path_to_ident(name), val: val}] } @@ -137,7 +137,7 @@ fn enter_match(m: match, col: uint, val: ValueRef, e: enter_pat) -> match { } with *br}; result += [new_br]; } - none. { } + none { } } } ret result; @@ -146,8 +146,8 @@ fn enter_match(m: match, col: uint, val: ValueRef, e: enter_pat) -> match { fn enter_default(m: match, col: uint, val: ValueRef) -> match { fn matches_always(p: @ast::pat) -> bool { alt p.node { - ast::pat_wild. | ast::pat_rec(_, _) | - ast::pat_ident(_, none.) | ast::pat_tup(_) { true } + ast::pat_wild | ast::pat_rec(_, _) | + ast::pat_ident(_, none) | ast::pat_tup(_) { true } _ { false } } } @@ -508,7 +508,7 @@ fn compile_submatch(bcx: @block_ctxt, m: match, vals: [ValueRef], f: mk_fail, } let else_cx = alt kind { - no_branch. | single. { bcx } + no_branch | single { bcx } _ { new_sub_block_ctxt(bcx, "match_else") } }; let sw; @@ -525,8 +525,8 @@ fn compile_submatch(bcx: @block_ctxt, m: match, vals: [ValueRef], f: mk_fail, for opt: opt in opts { let opt_cx = new_sub_block_ctxt(bcx, "match_case"); alt kind { - single. { Br(bcx, opt_cx.llbb); } - switch. { + single { Br(bcx, opt_cx.llbb); } + switch { let res = trans_opt(bcx, opt); alt res { single_result(r) { @@ -535,7 +535,7 @@ fn compile_submatch(bcx: @block_ctxt, m: match, vals: [ValueRef], f: mk_fail, } } } - compare. { + compare { let compare_cx = new_scope_block_ctxt(bcx, "compare_scope"); Br(bcx, compare_cx.llbb); bcx = compare_cx; @@ -603,7 +603,7 @@ fn make_phi_bindings(bcx: @block_ctxt, map: [exit_node], if ex.to as uint == our_block { alt assoc(name, ex.bound) { some(val) { llbbs += [ex.from]; vals += [val]; } - none. { } + none { } } } } @@ -767,7 +767,7 @@ fn bind_irrefutable_pat(bcx: @block_ctxt, pat: @ast::pat, val: ValueRef, let val = Load(bcx, val); bcx = bind_irrefutable_pat(bcx, inner, val, true); } - ast::pat_wild. | ast::pat_lit(_) | ast::pat_range(_, _) { } + ast::pat_wild | ast::pat_lit(_) | ast::pat_range(_, _) { } } ret bcx; } diff --git a/src/comp/middle/trans_closure.rs b/src/comp/middle/trans_closure.rs index fe7752994cf..66002c89979 100644 --- a/src/comp/middle/trans_closure.rs +++ b/src/comp/middle/trans_closure.rs @@ -137,8 +137,8 @@ fn ev_to_str(ccx: @crate_ctxt, ev: environment_value) -> str { fn mk_tydesc_ty(tcx: ty::ctxt, ck: ty::closure_kind) -> ty::t { ret alt ck { - ty::ck_block. | ty::ck_box. { ty::mk_type(tcx) } - ty::ck_uniq. { ty::mk_send_type(tcx) } + ty::ck_block | ty::ck_box { ty::mk_type(tcx) } + ty::ck_uniq { ty::mk_send_type(tcx) } }; } @@ -237,15 +237,15 @@ fn allocate_cbox(bcx: @block_ctxt, // Allocate the box: let temp_cleanups = []; let (bcx, box, rc) = alt ck { - ty::ck_box. { + ty::ck_box { let (bcx, box) = alloc_in_heap(bcx, false, temp_cleanups); (bcx, box, 1) } - ty::ck_uniq. { + ty::ck_uniq { let (bcx, box) = alloc_in_heap(bcx, true, temp_cleanups); (bcx, box, 0x12345678) // use arbitrary value for debugging } - ty::ck_block. { + ty::ck_block { let {bcx, val: box} = trans::alloc_ty(bcx, cbox_ty); (bcx, box, 0x12345678) // use arbitrary value for debugging } @@ -289,10 +289,10 @@ fn store_environment( ck: ty::closure_kind, td: ValueRef) -> ValueRef { ret alt ck { - ty::ck_block. | ty::ck_box. { + ty::ck_block | ty::ck_box { td } - ty::ck_uniq. { + ty::ck_uniq { Call(bcx, bcx_ccx(bcx).upcalls.create_shared_type_desc, [td]) } }; @@ -311,7 +311,7 @@ fn store_environment( // store data tydesc. alt ck { - ty::ck_box. | ty::ck_uniq. { + ty::ck_box | ty::ck_uniq { let bound_tydesc = GEPi(bcx, llbox, [0, abi::cbox_elt_tydesc]); let ti = none; @@ -324,7 +324,7 @@ fn store_environment( let td = maybe_clone_tydesc(bcx, ck, closure_td.val); Store(bcx, td, bound_tydesc); } - ty::ck_block. { /* skip this for blocks, not really relevant */ } + ty::ck_block { /* skip this for blocks, not really relevant */ } } // cbox_ty has the form of a tuple: (a, b, c) we want a ptr to a @@ -371,28 +371,28 @@ fn store_environment( add_clean_temp_mem(bcx, bound_data, bound_tys[i]); temp_cleanups += [bound_data]; } - env_copy(val, ty, owned.) { + env_copy(val, ty, owned) { let val1 = load_if_immediate(bcx, val, ty); bcx = trans::copy_val(bcx, INIT, bound_data, val1, ty); } - env_copy(val, ty, owned_imm.) { + env_copy(val, ty, owned_imm) { bcx = trans::copy_val(bcx, INIT, bound_data, val, ty); } - env_copy(_, _, temporary.) { + env_copy(_, _, temporary) { fail "Cannot capture temporary upvar"; } env_move(val, ty, kind) { let src = {bcx:bcx, val:val, kind:kind}; bcx = move_val(bcx, INIT, bound_data, src, ty); } - env_ref(val, ty, owned.) { + env_ref(val, ty, owned) { Store(bcx, val, bound_data); } - env_ref(val, ty, owned_imm.) { + env_ref(val, ty, owned_imm) { let addr = do_spill_noroot(bcx, val); Store(bcx, addr, bound_data); } - env_ref(_, _, temporary.) { + env_ref(_, _, temporary) { fail "Cannot capture temporary upvar"; } } @@ -489,8 +489,8 @@ fn load_environment(enclosing_cx: @block_ctxt, bcx = upvarptr.bcx; let llupvarptr = upvarptr.val; alt ck { - ty::ck_block. { llupvarptr = Load(bcx, llupvarptr); } - ty::ck_uniq. | ty::ck_box. { } + ty::ck_block { llupvarptr = Load(bcx, llupvarptr); } + ty::ck_uniq | ty::ck_box { } } let def_id = ast_util::def_id_of_def(cap_var.def); fcx.llupvars.insert(def_id.node, llupvarptr); @@ -528,11 +528,11 @@ fn trans_expr_fn(bcx: @block_ctxt, }; let closure = alt proto { - ast::proto_any. { fail "proto_any cannot appear in an expr"; } - ast::proto_block. { trans_closure_env(ty::ck_block) } - ast::proto_box. { trans_closure_env(ty::ck_box) } - ast::proto_uniq. { trans_closure_env(ty::ck_uniq) } - ast::proto_bare. { + ast::proto_any { fail "proto_any cannot appear in an expr"; } + ast::proto_block { trans_closure_env(ty::ck_block) } + ast::proto_box { trans_closure_env(ty::ck_box) } + ast::proto_uniq { trans_closure_env(ty::ck_uniq) } + ast::proto_bare { let closure = C_null(T_opaque_cbox_ptr(ccx)); trans_closure(sub_cx, sp, decl, body, llfn, no_self, [], id, {|_fcx|}); @@ -556,7 +556,7 @@ fn trans_bind_1(cx: @block_ctxt, outgoing_fty: ty::t, dest: dest) -> @block_ctxt { let bound: [@ast::expr] = []; for argopt: option::t<@ast::expr> in args { - alt argopt { none. { } some(e) { bound += [e]; } } + alt argopt { none { } some(e) { bound += [e]; } } } let bcx = f_res.bcx; if dest == ignore { @@ -566,7 +566,7 @@ fn trans_bind_1(cx: @block_ctxt, outgoing_fty: ty::t, // Figure out which tydescs we need to pass, if any. let (outgoing_fty_real, lltydescs, param_bounds) = alt f_res.generic { - none. { (outgoing_fty, [], @[]) } + none { (outgoing_fty, [], @[]) } some(ginfo) { let tds = [], orig = 0u; vec::iter2(ginfo.tydescs, *ginfo.param_bounds) {|td, bounds| @@ -596,7 +596,7 @@ fn trans_bind_1(cx: @block_ctxt, outgoing_fty: ty::t, ret memmove_ty(bcx, get_dest_addr(dest), lv.val, pair_ty); } let closure = alt f_res.env { - null_env. { none } + null_env { none } _ { let (_, cl) = maybe_add_env(cx, f_res); some(cl) } }; @@ -616,7 +616,7 @@ fn trans_bind_1(cx: @block_ctxt, outgoing_fty: ty::t, let src_loc = PointerCast(bcx, cl, llclosurety); ([env_copy(src_loc, pair_ty, owned)], none) } - none. { ([], some(f_res.val)) } + none { ([], some(f_res.val)) } }; // Actually construct the closure @@ -668,11 +668,11 @@ fn make_fn_glue( }; ret alt ty::struct(tcx, t) { - ty::ty_native_fn(_, _) | ty::ty_fn({proto: ast::proto_bare., _}) { bcx } - ty::ty_fn({proto: ast::proto_block., _}) { bcx } - ty::ty_fn({proto: ast::proto_any., _}) { bcx } - ty::ty_fn({proto: ast::proto_uniq., _}) { fn_env(ty::ck_uniq) } - ty::ty_fn({proto: ast::proto_box., _}) { fn_env(ty::ck_box) } + ty::ty_native_fn(_, _) | ty::ty_fn({proto: ast::proto_bare, _}) { bcx } + ty::ty_fn({proto: ast::proto_block, _}) { bcx } + ty::ty_fn({proto: ast::proto_any, _}) { bcx } + ty::ty_fn({proto: ast::proto_uniq, _}) { fn_env(ty::ck_uniq) } + ty::ty_fn({proto: ast::proto_box, _}) { fn_env(ty::ck_box) } _ { fail "make_fn_glue invoked on non-function type" } }; } @@ -684,9 +684,9 @@ fn make_opaque_cbox_take_glue( -> @block_ctxt { // Easy cases: alt ck { - ty::ck_block. { ret bcx; } - ty::ck_box. { ret incr_refcnt_of_boxed(bcx, Load(bcx, cboxptr)); } - ty::ck_uniq. { /* hard case: */ } + ty::ck_block { ret bcx; } + ty::ck_box { ret incr_refcnt_of_boxed(bcx, Load(bcx, cboxptr)); } + ty::ck_uniq { /* hard case: */ } } // Hard case, a deep copy: @@ -722,12 +722,12 @@ fn make_opaque_cbox_drop_glue( cboxptr: ValueRef) // ptr to the opaque closure -> @block_ctxt { alt ck { - ty::ck_block. { bcx } - ty::ck_box. { + ty::ck_block { bcx } + ty::ck_box { decr_refcnt_maybe_free(bcx, Load(bcx, cboxptr), ty::mk_opaque_closure_ptr(bcx_tcx(bcx), ck)) } - ty::ck_uniq. { + ty::ck_uniq { free_ty(bcx, Load(bcx, cboxptr), ty::mk_opaque_closure_ptr(bcx_tcx(bcx), ck)) } @@ -740,8 +740,8 @@ fn make_opaque_cbox_free_glue( cbox: ValueRef) // ptr to the opaque closure -> @block_ctxt { alt ck { - ty::ck_block. { ret bcx; } - ty::ck_box. | ty::ck_uniq. { /* hard cases: */ } + ty::ck_block { ret bcx; } + ty::ck_box | ty::ck_uniq { /* hard cases: */ } } let ccx = bcx_ccx(bcx); @@ -768,11 +768,11 @@ fn make_opaque_cbox_free_glue( // Free the ty descr (if necc) and the box itself alt ck { - ty::ck_block. { fail "Impossible."; } - ty::ck_box. { + ty::ck_block { fail "Impossible"; } + ty::ck_box { trans_free_if_not_gc(bcx, cbox) } - ty::ck_uniq. { + ty::ck_uniq { let bcx = free_ty(bcx, tydesc, mk_tydesc_ty(tcx, ck)); trans_shared_free(bcx, cbox) } @@ -858,7 +858,7 @@ fn trans_bind_thunk(cx: @local_ctxt, some(fptr) { (fptr, llvm::LLVMGetUndef(T_opaque_cbox_ptr(ccx)), 0) } - none. { + none { // Silly check check type_is_tup_like(bcx, cbox_ty); let {bcx: cx, val: pair} = @@ -915,7 +915,7 @@ fn trans_bind_thunk(cx: @local_ctxt, llargs += [dict]; off += 1; dicts = some(alt dicts { - none. { [dict] } + none { [dict] } some(ds) { ds + [dict] } }); } @@ -961,7 +961,7 @@ fn trans_bind_thunk(cx: @local_ctxt, } // Arg will be provided when the thunk is invoked. - none. { + none { let arg: ValueRef = llvm::LLVMGetParam(llthunk, a as c_uint); if ty::type_contains_params(cx.ccx.tcx, out_arg.ty) { arg = PointerCast(bcx, arg, llout_arg_ty); diff --git a/src/comp/middle/trans_common.rs b/src/comp/middle/trans_common.rs index 835f8cc5c5e..db1e615804f 100644 --- a/src/comp/middle/trans_common.rs +++ b/src/comp/middle/trans_common.rs @@ -33,7 +33,7 @@ fn new_namegen() -> namegen { type derived_tydesc_info = {lltydesc: ValueRef, escapes: bool}; tag tydesc_kind { - tk_static; // Static (monomorphic) type descriptor. + tk_static; // Static (monomorphic) type descriptor tk_param; // Type parameter. tk_derived; // Derived from a typaram or another derived tydesc. } @@ -335,7 +335,7 @@ tag block_kind { // A scope block is a basic block created by translating a block { ... } - // the the source language. Since these blocks create variable scope, any + // in the source language. Since these blocks create variable scope, any // variables created in them that are still live at the end of the block // must be dropped and cleaned up when the block ends. SCOPE_BLOCK; @@ -422,7 +422,7 @@ fn find_scope_cx(cx: @block_ctxt) -> @block_ctxt { if cx.kind != NON_SCOPE_BLOCK { ret cx; } alt cx.parent { parent_some(b) { ret find_scope_cx(b); } - parent_none. { + parent_none { cx.fcx.lcx.ccx.sess.bug("trans::find_scope_cx() " + "called on parentless block_ctxt"); } @@ -491,30 +491,30 @@ fn T_int(targ_cfg: @session::config) -> TypeRef { fn T_int_ty(cx: @crate_ctxt, t: ast::int_ty) -> TypeRef { alt t { - ast::ty_i. { cx.int_type } - ast::ty_char. { T_char() } - ast::ty_i8. { T_i8() } - ast::ty_i16. { T_i16() } - ast::ty_i32. { T_i32() } - ast::ty_i64. { T_i64() } + ast::ty_i { cx.int_type } + ast::ty_char { T_char() } + ast::ty_i8 { T_i8() } + ast::ty_i16 { T_i16() } + ast::ty_i32 { T_i32() } + ast::ty_i64 { T_i64() } } } fn T_uint_ty(cx: @crate_ctxt, t: ast::uint_ty) -> TypeRef { alt t { - ast::ty_u. { cx.int_type } - ast::ty_u8. { T_i8() } - ast::ty_u16. { T_i16() } - ast::ty_u32. { T_i32() } - ast::ty_u64. { T_i64() } + ast::ty_u { cx.int_type } + ast::ty_u8 { T_i8() } + ast::ty_u16 { T_i16() } + ast::ty_u32 { T_i32() } + ast::ty_u64 { T_i64() } } } fn T_float_ty(cx: @crate_ctxt, t: ast::float_ty) -> TypeRef { alt t { - ast::ty_f. { cx.float_type } - ast::ty_f32. { T_f32() } - ast::ty_f64. { T_f64() } + ast::ty_f { cx.float_type } + ast::ty_f32 { T_f32() } + ast::ty_f64 { T_f64() } } } diff --git a/src/comp/middle/trans_impl.rs b/src/comp/middle/trans_impl.rs index e5a0e9a4ac7..9a0430481a4 100644 --- a/src/comp/middle/trans_impl.rs +++ b/src/comp/middle/trans_impl.rs @@ -341,7 +341,7 @@ fn get_static_dict(bcx: @block_ctxt, origin: typeck::dict_origin) let id = dict_id(ccx.tcx, origin); alt ccx.dicts.find(id) { some(d) { ret d; } - none. {} + none {} } let ptrs = C_struct(get_dict_ptrs(bcx, origin).ptrs); let name = ccx.names("dict"); diff --git a/src/comp/middle/trans_vec.rs b/src/comp/middle/trans_vec.rs index c33d5178790..feccfc413bf 100644 --- a/src/comp/middle/trans_vec.rs +++ b/src/comp/middle/trans_vec.rs @@ -153,7 +153,7 @@ fn trans_append(cx: @block_ctxt, vec_ty: ty::t, lhsptr: ValueRef, (PointerCast(cx, lhsptr, T_ptr(T_ptr(ccx.opaque_vec_type))), PointerCast(cx, rhs, T_ptr(ccx.opaque_vec_type))); let strings = alt ty::struct(bcx_tcx(cx), vec_ty) { - ty::ty_str. { true } + ty::ty_str { true } ty::ty_vec(_) { false } }; @@ -221,7 +221,7 @@ fn trans_add(bcx: @block_ctxt, vec_ty: ty::t, lhs: ValueRef, rhs: ValueRef, dest: dest) -> @block_ctxt { let ccx = bcx_ccx(bcx); let strings = alt ty::struct(bcx_tcx(bcx), vec_ty) { - ty::ty_str. { true } + ty::ty_str { true } ty::ty_vec(_) { false } }; let unit_ty = ty::sequence_element_type(bcx_tcx(bcx), vec_ty); diff --git a/src/comp/middle/tstate/ann.rs b/src/comp/middle/tstate/ann.rs index 18fe58ae8ee..f3862e3d20f 100644 --- a/src/comp/middle/tstate/ann.rs +++ b/src/comp/middle/tstate/ann.rs @@ -240,7 +240,7 @@ fn implies(a: t, b: t) -> bool { } fn trit_str(t: trit) -> str { - alt t { dont_care. { "?" } ttrue. { "1" } tfalse. { "0" } } + alt t { dont_care { "?" } ttrue { "1" } tfalse { "0" } } } // // Local Variables: diff --git a/src/comp/middle/tstate/auxiliary.rs b/src/comp/middle/tstate/auxiliary.rs index cb592be250c..04469cda4eb 100644 --- a/src/comp/middle/tstate/auxiliary.rs +++ b/src/comp/middle/tstate/auxiliary.rs @@ -41,7 +41,7 @@ fn comma_str(args: [@constr_arg_use]) -> str { for a: @constr_arg_use in args { if comma { rslt += ", "; } else { comma = true; } alt a.node { - carg_base. { rslt += "*"; } + carg_base { rslt += "*"; } carg_ident(i) { rslt += i.ident; } carg_lit(l) { rslt += lit_to_str(l); } } @@ -69,7 +69,7 @@ fn tritv_to_str(fcx: fn_ctxt, v: tritv::t) -> str { let comma = false; for p: norm_constraint in constraints(fcx) { alt tritv_get(v, p.bit_num) { - dont_care. { } + dont_care { } tt { s += if comma { ", " } else { comma = true; "" } + @@ -310,7 +310,7 @@ fn get_ts_ann(ccx: crate_ctxt, i: node_id) -> option::t<ts_ann> { /********* utils ********/ fn node_id_to_ts_ann(ccx: crate_ctxt, id: node_id) -> ts_ann { alt get_ts_ann(ccx, id) { - none. { + none { #error("node_id_to_ts_ann: no ts_ann for node_id %d", id); fail; } @@ -507,7 +507,7 @@ fn constraints_expr(cx: ty::ctxt, e: @expr) -> [@ty::constr] { fn node_id_to_def_strict(cx: ty::ctxt, id: node_id) -> def { alt cx.def_map.find(id) { - none. { + none { #error("node_id_to_def: node_id %d has no def", id); fail; } @@ -565,7 +565,7 @@ fn match_args(fcx: fn_ctxt, occs: @mutable [pred_args], fn def_id_for_constr(tcx: ty::ctxt, t: node_id) -> def_id { alt tcx.def_map.find(t) { - none. { + none { tcx.sess.bug("node_id_for_constr: bad node_id " + int::str(t)); } some(def_fn(i, _)) { ret i; } @@ -658,7 +658,7 @@ fn substitute_arg(cx: ty::ctxt, actuals: [@expr], a: @constr_arg) -> cx.sess.span_fatal(a.span, "Constraint argument out of bounds"); } } - carg_base. { ret @respan(a.span, carg_base); } + carg_base { ret @respan(a.span, carg_base); } carg_lit(l) { ret @respan(a.span, carg_lit(l)); } } } @@ -675,7 +675,7 @@ fn pred_args_matches(pattern: [constr_arg_general_<inst>], desc: pred_args) -> _ { ret false; } } } - carg_base. { if n != carg_base { ret false; } } + carg_base { if n != carg_base { ret false; } } carg_lit(l) { alt n { carg_lit(m) { if !lit_eq(l, m) { ret false; } } @@ -741,7 +741,7 @@ fn insts_to_str(stuff: [constr_arg_general_<inst>]) -> str { " " + alt i { carg_ident(p) { p.ident } - carg_base. { "*" } + carg_base { "*" } carg_lit(_) { "[lit]" } } + " "; } @@ -794,7 +794,7 @@ fn local_node_id_to_def_id_strict(fcx: fn_ctxt, sp: span, i: node_id) -> "local_node_id_to_def_id: id \ isn't a local"); } - none. { + none { // should really be bug. span_bug()? fcx.ccx.tcx.sess.span_fatal(sp, "local_node_id_to_def_id: id \ @@ -848,8 +848,8 @@ fn copy_in_poststate_two(fcx: fn_ctxt, src_post: poststate, ty: oper_type) { let subst; alt ty { - oper_swap. { subst = [{from: dest, to: src}, {from: src, to: dest}]; } - oper_assign_op. { + oper_swap { subst = [{from: dest, to: src}, {from: src, to: dest}]; } + oper_assign_op { ret; // Don't do any propagation } _ { subst = [{from: src, to: dest}]; } @@ -1003,7 +1003,7 @@ fn vec_contains(v: @mutable [node_id], i: node_id) -> bool { } fn op_to_oper_ty(io: init_op) -> oper_type { - alt io { init_move. { oper_move } _ { oper_assign } } + alt io { init_move { oper_move } _ { oper_assign } } } // default function visitor @@ -1021,7 +1021,7 @@ fn args_to_constr_args(tcx: ty::ctxt, args: [arg], actuals += [@respan(a.span, alt a.node { - carg_base. { carg_base } + carg_base { carg_base } carg_ident(i) { if i < num_args { carg_ident({ident: args[i].ident, @@ -1090,7 +1090,7 @@ fn callee_modes(fcx: fn_ctxt, callee: node_id) -> [ty::mode] { fn callee_arg_init_ops(fcx: fn_ctxt, callee: node_id) -> [init_op] { fn mode_to_op(m: ty::mode) -> init_op { - alt m { by_move. { init_move } _ { init_assign } } + alt m { by_move { init_move } _ { init_assign } } } vec::map(callee_modes(fcx, callee), mode_to_op) } diff --git a/src/comp/middle/tstate/bitvectors.rs b/src/comp/middle/tstate/bitvectors.rs index c4e09873085..f9209d60c16 100644 --- a/src/comp/middle/tstate/bitvectors.rs +++ b/src/comp/middle/tstate/bitvectors.rs @@ -48,7 +48,7 @@ fn promises_(n: uint, p: poststate) -> bool { ret tritv_get(p, n) == ttrue; } // v "happens after" u fn seq_trit(u: trit, v: trit) -> trit { - alt v { ttrue. { ttrue } tfalse. { tfalse } dont_care. { u } } + alt v { ttrue { ttrue } tfalse { tfalse } dont_care { u } } } // idea: q "happens after" p -- so if something is diff --git a/src/comp/middle/tstate/collect_locals.rs b/src/comp/middle/tstate/collect_locals.rs index 102451a6985..200aef3b6db 100644 --- a/src/comp/middle/tstate/collect_locals.rs +++ b/src/comp/middle/tstate/collect_locals.rs @@ -84,7 +84,7 @@ fn add_constraint(tcx: ty::ctxt, c: sp_constr, next: uint, tbl: constr_map) -> } } } - none. { + none { let rslt: @mutable [pred_args] = @mutable [respan(c.span, {args: args, bit_num: next})]; tbl.insert(d_id, cpred(p, rslt)); diff --git a/src/comp/middle/tstate/pre_post_conditions.rs b/src/comp/middle/tstate/pre_post_conditions.rs index 57bb0379779..5b7322fbb16 100644 --- a/src/comp/middle/tstate/pre_post_conditions.rs +++ b/src/comp/middle/tstate/pre_post_conditions.rs @@ -132,9 +132,9 @@ fn join_then_else(fcx: fn_ctxt, antec: @expr, conseq: blk, find_pre_post_expr(fcx, antec); find_pre_post_block(fcx, conseq); alt maybe_alt { - none. { + none { alt chck { - if_check. { + if_check { let c: sp_constr = expr_to_constr(fcx.ccx.tcx, antec); gen(fcx, antec.id, c.node); } @@ -166,7 +166,7 @@ fn join_then_else(fcx: fn_ctxt, antec: @expr, conseq: blk, /* Be sure to set the bit for the check condition here, so that it's *not* set in the alternative. */ alt chck { - if_check. { + if_check { let c: sp_constr = expr_to_constr(fcx.ccx.tcx, antec); gen(fcx, antec.id, c.node); } @@ -219,14 +219,14 @@ fn handle_update(fcx: fn_ctxt, parent: @expr, lhs: @expr, rhs: @expr, let tmp = tritv_clone(post); alt ty { - oper_move. { + oper_move { if is_path(rhs) { forget_in_postcond(fcx, parent.id, rhs.id); } } - oper_swap. { + oper_swap { forget_in_postcond_still_init(fcx, parent.id, lhs.id); forget_in_postcond_still_init(fcx, parent.id, rhs.id); } - oper_assign. { + oper_assign { forget_in_postcond_still_init(fcx, parent.id, lhs.id); } _ { @@ -336,7 +336,7 @@ fn find_pre_post_expr(fcx: fn_ctxt, e: @expr) { /* if this is a failing call, its postcondition sets everything */ alt controlflow_expr(fcx.ccx, operator) { - noreturn. { set_postcond_false(fcx.ccx, e.id); } + noreturn { set_postcond_false(fcx.ccx, e.id); } _ { } } } @@ -374,7 +374,7 @@ fn find_pre_post_expr(fcx: fn_ctxt, e: @expr) { } expr_rec(fields, maybe_base) { let es = field_exprs(fields); - alt maybe_base { none. {/* no-op */ } some(b) { es += [b]; } } + alt maybe_base { none {/* no-op */ } some(b) { es += [b]; } } find_pre_post_exprs(fcx, es, e.id); } expr_tup(elts) { find_pre_post_exprs(fcx, elts, e.id); } @@ -395,7 +395,7 @@ fn find_pre_post_expr(fcx: fn_ctxt, e: @expr) { expr_lit(_) { clear_pp(expr_pp(fcx.ccx, e)); } expr_ret(maybe_val) { alt maybe_val { - none. { + none { clear_precond(fcx.ccx, e.id); set_postcond_false(fcx.ccx, e.id); } @@ -503,7 +503,7 @@ fn find_pre_post_expr(fcx: fn_ctxt, e: @expr) { expr_fail(maybe_val) { let prestate; alt maybe_val { - none. { prestate = empty_prestate(num_local_vars); } + none { prestate = empty_prestate(num_local_vars); } some(fail_val) { find_pre_post_expr(fcx, fail_val); prestate = expr_precond(fcx.ccx, fail_val); @@ -542,7 +542,7 @@ fn find_pre_post_expr(fcx: fn_ctxt, e: @expr) { let i = 0; for expr_opt: option::t<@expr> in maybe_args { alt expr_opt { - none. {/* no-op */ } + none {/* no-op */ } some(expr) { modes += [cmodes[i]]; args += [expr]; } } i += 1; @@ -551,8 +551,8 @@ fn find_pre_post_expr(fcx: fn_ctxt, e: @expr) { forget_args_moved_in(fcx, e, modes, args); find_pre_post_exprs(fcx, args, e.id); } - expr_break. { clear_pp(expr_pp(fcx.ccx, e)); } - expr_cont. { clear_pp(expr_pp(fcx.ccx, e)); } + expr_break { clear_pp(expr_pp(fcx.ccx, e)); } + expr_cont { clear_pp(expr_pp(fcx.ccx, e)); } expr_mac(_) { fcx.ccx.tcx.sess.bug("unexpanded macro"); } } } @@ -601,7 +601,7 @@ fn find_pre_post_stmt(fcx: fn_ctxt, s: stmt) { node: an_init.expr.id}, op_to_oper_ty(an_init.op)); } - none. { } + none { } } gen(fcx, id, ninit(pat.id, ident)); }; @@ -631,7 +631,7 @@ fn find_pre_post_stmt(fcx: fn_ctxt, s: stmt) { copy_pre_post_(fcx.ccx, id, prev_pp.precondition, prev_pp.postcondition); } - none. { + none { pat_bindings(alocal.node.pat) {|p| clear_pp(node_id_to_ts_ann(fcx.ccx, p.id).conditions); }; @@ -689,7 +689,7 @@ fn find_pre_post_block(fcx: fn_ctxt, b: blk) { let pps: [pre_and_post] = []; for s: @stmt in b.node.stmts { pps += [stmt_pp(fcx.ccx, *s)]; } alt b.node.expr { - none. {/* no-op */ } + none {/* no-op */ } some(e) { pps += [expr_pp(fcx.ccx, e)]; } } @@ -721,7 +721,7 @@ fn find_pre_post_fn(fcx: fn_ctxt, body: blk) { // Treat the tail expression as a return statement alt body.node.expr { some(tailexpr) { set_postcond_false(fcx.ccx, tailexpr.id); } - none. {/* fallthrough */ } + none {/* fallthrough */ } } } diff --git a/src/comp/middle/tstate/states.rs b/src/comp/middle/tstate/states.rs index 50208b9dacf..6256ea11b3f 100644 --- a/src/comp/middle/tstate/states.rs +++ b/src/comp/middle/tstate/states.rs @@ -15,7 +15,7 @@ import driver::session::session; fn forbid_upvar(fcx: fn_ctxt, rhs_id: node_id, sp: span, t: oper_type) { alt t { - oper_move. { + oper_move { alt local_node_id_to_def(fcx, rhs_id) { some(def_upvar(_, _, _)) { fcx.ccx.tcx.sess.span_err(sp, @@ -94,7 +94,7 @@ fn find_pre_post_state_sub(fcx: fn_ctxt, pres: prestate, e: @expr, let post = tritv_clone(expr_poststate(fcx.ccx, e)); alt c { - none. { } + none { } some(c1) { set_in_poststate_(bit_num(fcx, c1), post); } } @@ -123,11 +123,11 @@ fn find_pre_post_state_two(fcx: fn_ctxt, pres: prestate, lhs: @expr, let tmp = tritv_clone(post); alt ty { - oper_move. { + oper_move { if is_path(rhs) { forget_in_poststate(fcx, post, rhs.id); } forget_in_poststate_still_init(fcx, post, lhs.id); } - oper_swap. { + oper_swap { forget_in_poststate_still_init(fcx, post, lhs.id); forget_in_poststate_still_init(fcx, post, rhs.id); } @@ -187,7 +187,7 @@ fn find_pre_post_state_exprs(fcx: fn_ctxt, pres: prestate, id: node_id, let changed = rs.changed | set_prestate_ann(fcx.ccx, id, pres); /* if this is a failing call, it sets everything as initialized */ alt cf { - noreturn. { + noreturn { let post = false_postcond(num_constraints(fcx.enclosing)); changed |= set_poststate_ann(fcx.ccx, id, post); } @@ -265,9 +265,9 @@ fn join_then_else(fcx: fn_ctxt, antec: @expr, conseq: blk, */ alt maybe_alt { - none. { + none { alt chk { - if_check. { + if_check { let c: sp_constr = expr_to_constr(fcx.ccx.tcx, antec); let conseq_prestate = tritv_clone(expr_poststate(fcx.ccx, antec)); tritv_set(bit_num(fcx, c.node), conseq_prestate, ttrue); @@ -292,7 +292,7 @@ fn join_then_else(fcx: fn_ctxt, antec: @expr, conseq: blk, let conseq_prestate = expr_poststate(fcx.ccx, antec); alt chk { - if_check. { + if_check { let c: sp_constr = expr_to_constr(fcx.ccx.tcx, antec); conseq_prestate = tritv_clone(conseq_prestate); tritv_set(bit_num(fcx, c.node), conseq_prestate, ttrue); @@ -360,7 +360,7 @@ fn find_pre_post_state_expr(fcx: fn_ctxt, pres: prestate, e: @expr) -> bool { let i = 0; for a_opt: option::t<@expr> in maybe_args { alt a_opt { - none. {/* no-op */ } + none {/* no-op */ } some(a) { ops += [callee_ops[i]]; args += [a]; } } i += 1; @@ -390,7 +390,7 @@ fn find_pre_post_state_expr(fcx: fn_ctxt, pres: prestate, e: @expr) -> bool { vec::len(fields)), field_exprs(fields), return_val); alt maybe_base { - none. {/* do nothing */ } + none {/* do nothing */ } some(base) { changed |= find_pre_post_state_expr(fcx, pres, base) | @@ -431,7 +431,7 @@ fn find_pre_post_state_expr(fcx: fn_ctxt, pres: prestate, e: @expr) -> bool { set_poststate_ann(fcx.ccx, e.id, post); alt maybe_ret_val { - none. {/* do nothing */ } + none {/* do nothing */ } some(ret_val) { changed |= find_pre_post_state_expr(fcx, pres, ret_val); } @@ -586,13 +586,13 @@ fn find_pre_post_state_expr(fcx: fn_ctxt, pres: prestate, e: @expr) -> bool { woo! */ let post = false_postcond(num_constrs); alt fcx.enclosing.cf { - noreturn. { kill_poststate_(fcx, ninit(fcx.id, fcx.name), post); } + noreturn { kill_poststate_(fcx, ninit(fcx.id, fcx.name), post); } _ { } } ret set_prestate_ann(fcx.ccx, e.id, pres) | set_poststate_ann(fcx.ccx, e.id, post) | alt maybe_fail_val { - none. { false } + none { false } some(fail_val) { find_pre_post_state_expr(fcx, pres, fail_val) } @@ -609,8 +609,8 @@ fn find_pre_post_state_expr(fcx: fn_ctxt, pres: prestate, e: @expr) -> bool { expr_if_check(p, conseq, maybe_alt) { ret join_then_else(fcx, p, conseq, maybe_alt, e.id, if_check, pres); } - expr_break. { ret pure_exp(fcx.ccx, e.id, pres); } - expr_cont. { ret pure_exp(fcx.ccx, e.id, pres); } + expr_break { ret pure_exp(fcx.ccx, e.id, pres); } + expr_cont { ret pure_exp(fcx.ccx, e.id, pres); } } } @@ -704,7 +704,7 @@ fn find_pre_post_state_block(fcx: fn_ctxt, pres0: prestate, b: blk) -> bool { } let post = pres; alt b.node.expr { - none. { } + none { } some(e) { changed |= find_pre_post_state_expr(fcx, pres, e); post = expr_poststate(fcx.ccx, e); @@ -767,7 +767,7 @@ fn find_pre_post_state_fn(fcx: fn_ctxt, set_poststate_ann(fcx.ccx, f_body.node.id, post); } } - none. {/* fallthrough */ } + none {/* fallthrough */ } } /* diff --git a/src/comp/middle/tstate/tritv.rs b/src/comp/middle/tstate/tritv.rs index c979b1aa74e..6a7504de5c3 100644 --- a/src/comp/middle/tstate/tritv.rs +++ b/src/comp/middle/tstate/tritv.rs @@ -49,25 +49,25 @@ fn trit_minus(a: trit, b: trit) -> trit { 0 - anything else - 0 */ alt a { - dont_care. { dont_care } - ttrue. { + dont_care { dont_care } + ttrue { alt b { - ttrue. { dont_care } - tfalse. { ttrue } + ttrue { dont_care } + tfalse { ttrue } /* internally contradictory, but I guess it'll get flagged? */ - dont_care. { + dont_care { ttrue } } } - tfalse. { + tfalse { alt b { - ttrue. { tfalse } + ttrue { tfalse } @@ -83,11 +83,11 @@ fn trit_minus(a: trit, b: trit) -> trit { fn trit_or(a: trit, b: trit) -> trit { alt a { - dont_care. { b } - ttrue. { ttrue } - tfalse. { + dont_care { b } + ttrue { ttrue } + tfalse { alt b { - ttrue. { dont_care } + ttrue { dont_care } @@ -108,21 +108,21 @@ fn trit_or(a: trit, b: trit) -> trit { // (we consider a constraint false until proven true), too. fn trit_and(a: trit, b: trit) -> trit { alt a { - dont_care. { b } + dont_care { b } // also seems wrong for case b = ttrue - ttrue. { + ttrue { alt b { - dont_care. { ttrue } + dont_care { ttrue } // ??? Seems wrong - ttrue. { + ttrue { ttrue } @@ -135,7 +135,7 @@ fn trit_and(a: trit, b: trit) -> trit { // (Rationale: it's always safe to assume that // a var is uninitialized or that a constraint // needs to be re-established) - tfalse. { + tfalse { tfalse } } @@ -147,7 +147,7 @@ fn trit_and(a: trit, b: trit) -> trit { // Rationale: if it's uninit on one path, // we can consider it as uninit on all paths - tfalse. { + tfalse { tfalse } } @@ -214,12 +214,12 @@ fn tritv_get(v: t, i: uint) -> trit { fn tritv_set(i: uint, v: t, t: trit) -> bool { let old = tritv_get(v, i); alt t { - dont_care. { + dont_care { bitv::set(v.uncertain, i, true); bitv::set(v.val, i, false); } - ttrue. { bitv::set(v.uncertain, i, false); bitv::set(v.val, i, true); } - tfalse. { + ttrue { bitv::set(v.uncertain, i, false); bitv::set(v.val, i, true); } + tfalse { bitv::set(v.uncertain, i, false); bitv::set(v.val, i, false); } @@ -273,9 +273,9 @@ fn to_vec(v: t) -> [uint] { while i < v.nbits { rslt += [alt tritv_get(v, i) { - dont_care. { 2u } - ttrue. { 1u } - tfalse. { 0u } + dont_care { 2u } + ttrue { 1u } + tfalse { 0u } }]; i += 1u; } @@ -288,9 +288,9 @@ fn to_str(v: t) -> str { while i < v.nbits { rs += alt tritv_get(v, i) { - dont_care. { "?" } - ttrue. { "1" } - tfalse. { "0" } + dont_care { "?" } + ttrue { "1" } + tfalse { "0" } }; i += 1u; } diff --git a/src/comp/middle/ty.rs b/src/comp/middle/ty.rs index 88a25126168..b376af652aa 100644 --- a/src/comp/middle/ty.rs +++ b/src/comp/middle/ty.rs @@ -313,10 +313,10 @@ fn param_bounds_to_kind(bounds: param_bounds) -> kind { let kind = kind_noncopyable; for bound in *bounds { alt bound { - bound_copy. { + bound_copy { if kind != kind_sendable { kind = kind_copyable; } } - bound_send. { kind = kind_sendable; } + bound_send { kind = kind_sendable; } _ {} } } @@ -468,8 +468,8 @@ fn mk_raw_ty(cx: ctxt, st: sty) -> @raw_t { derive_flags_t(cx, has_params, has_vars, tt); } alt st { - ty_nil. | ty_bot. | ty_bool. | ty_int(_) | ty_float(_) | ty_uint(_) | - ty_str. | ty_send_type. | ty_type. | ty_native(_) | + ty_nil | ty_bot | ty_bool | ty_int(_) | ty_float(_) | ty_uint(_) | + ty_str | ty_send_type | ty_type | ty_native(_) | ty_opaque_closure_ptr(_) { /* no-op */ } @@ -535,30 +535,30 @@ fn mk_uint(_cx: ctxt) -> t { ret idx_uint; } fn mk_mach_int(_cx: ctxt, tm: ast::int_ty) -> t { alt tm { - ast::ty_i. { ret idx_int; } - ast::ty_char. { ret idx_char; } - ast::ty_i8. { ret idx_i8; } - ast::ty_i16. { ret idx_i16; } - ast::ty_i32. { ret idx_i32; } - ast::ty_i64. { ret idx_i64; } + ast::ty_i { ret idx_int; } + ast::ty_char { ret idx_char; } + ast::ty_i8 { ret idx_i8; } + ast::ty_i16 { ret idx_i16; } + ast::ty_i32 { ret idx_i32; } + ast::ty_i64 { ret idx_i64; } } } fn mk_mach_uint(_cx: ctxt, tm: ast::uint_ty) -> t { alt tm { - ast::ty_u. { ret idx_uint; } - ast::ty_u8. { ret idx_u8; } - ast::ty_u16. { ret idx_u16; } - ast::ty_u32. { ret idx_u32; } - ast::ty_u64. { ret idx_u64; } + ast::ty_u { ret idx_uint; } + ast::ty_u8 { ret idx_u8; } + ast::ty_u16 { ret idx_u16; } + ast::ty_u32 { ret idx_u32; } + ast::ty_u64 { ret idx_u64; } } } fn mk_mach_float(_cx: ctxt, tm: ast::float_ty) -> t { alt tm { - ast::ty_f. { ret idx_float; } - ast::ty_f32. { ret idx_f32; } - ast::ty_f64. { ret idx_f64; } + ast::ty_f { ret idx_float; } + ast::ty_f32 { ret idx_f32; } + ast::ty_f64 { ret idx_f64; } } } @@ -659,9 +659,9 @@ pure fn mach_struct(cx: ctxt, cfg: @session::config, typ: t) -> sty { // Converts s to its machine type equivalent pure fn mach_sty(cfg: @session::config, s: sty) -> sty { alt s { - ty_int(ast::ty_i.) { ty_int(cfg.int_type) } - ty_uint(ast::ty_u.) { ty_uint(cfg.uint_type) } - ty_float(ast::ty_f.) { ty_float(cfg.float_type) } + ty_int(ast::ty_i) { ty_int(cfg.int_type) } + ty_uint(ast::ty_u) { ty_uint(cfg.uint_type) } + ty_float(ast::ty_f) { ty_float(cfg.float_type) } s { s } } } @@ -679,8 +679,8 @@ type ty_walk = fn@(t); fn walk_ty(cx: ctxt, walker: ty_walk, ty: t) { alt struct(cx, ty) { - ty_nil. | ty_bot. | ty_bool. | ty_int(_) | ty_uint(_) | ty_float(_) | - ty_str. | ty_send_type. | ty_type. | ty_native(_) | + ty_nil | ty_bot | ty_bool | ty_int(_) | ty_uint(_) | ty_float(_) | + ty_str | ty_send_type | ty_type | ty_native(_) | ty_opaque_closure_ptr(_) { /* no-op */ } @@ -728,8 +728,8 @@ fn fold_ty(cx: ctxt, fld: fold_mode, ty_0: t) -> t { fm_general(_) {/* no fast path */ } } alt interner::get(*cx.ts, ty).struct { - ty_nil. | ty_bot. | ty_bool. | ty_int(_) | ty_uint(_) | ty_float(_) | - ty_str. | ty_send_type. | ty_type. | ty_native(_) | + ty_nil | ty_bot | ty_bool | ty_int(_) | ty_uint(_) | ty_float(_) | + ty_str | ty_send_type | ty_type | ty_native(_) | ty_opaque_closure_ptr(_) { /* no-op */ } @@ -813,15 +813,15 @@ fn fold_ty(cx: ctxt, fld: fold_mode, ty_0: t) -> t { // Type utilities fn type_is_nil(cx: ctxt, ty: t) -> bool { - alt struct(cx, ty) { ty_nil. { ret true; } _ { ret false; } } + alt struct(cx, ty) { ty_nil { ret true; } _ { ret false; } } } fn type_is_bot(cx: ctxt, ty: t) -> bool { - alt struct(cx, ty) { ty_bot. { ret true; } _ { ret false; } } + alt struct(cx, ty) { ty_bot { ret true; } _ { ret false; } } } fn type_is_bool(cx: ctxt, ty: t) -> bool { - alt struct(cx, ty) { ty_bool. { ret true; } _ { ret false; } } + alt struct(cx, ty) { ty_bool { ret true; } _ { ret false; } } } fn type_is_structural(cx: ctxt, ty: t) -> bool { @@ -838,19 +838,19 @@ fn type_is_copyable(cx: ctxt, ty: t) -> bool { fn type_is_sequence(cx: ctxt, ty: t) -> bool { alt struct(cx, ty) { - ty_str. { ret true; } + ty_str { ret true; } ty_vec(_) { ret true; } _ { ret false; } } } fn type_is_str(cx: ctxt, ty: t) -> bool { - alt struct(cx, ty) { ty_str. { ret true; } _ { ret false; } } + alt struct(cx, ty) { ty_str { ret true; } _ { ret false; } } } fn sequence_element_type(cx: ctxt, ty: t) -> t { alt struct(cx, ty) { - ty_str. { ret mk_mach_uint(cx, ast::ty_u8); } + ty_str { ret mk_mach_uint(cx, ast::ty_u8); } ty_vec(mt) { ret mt.ty; } _ { cx.sess.bug("sequence_element_type called on non-sequence value"); } } @@ -907,7 +907,7 @@ pure fn type_is_unsafe_ptr(cx: ctxt, ty: t) -> bool { pure fn type_is_vec(cx: ctxt, ty: t) -> bool { ret alt struct(cx, ty) { ty_vec(_) { true } - ty_str. { true } + ty_str { true } _ { false } }; } @@ -916,15 +916,15 @@ pure fn type_is_unique(cx: ctxt, ty: t) -> bool { alt struct(cx, ty) { ty_uniq(_) { ret true; } ty_vec(_) { true } - ty_str. { true } + ty_str { true } _ { ret false; } } } pure fn type_is_scalar(cx: ctxt, ty: t) -> bool { alt struct(cx, ty) { - ty_nil. | ty_bool. | ty_int(_) | ty_float(_) | ty_uint(_) | - ty_send_type. | ty_type. | ty_native(_) | ty_ptr(_) { true } + ty_nil | ty_bool | ty_int(_) | ty_float(_) | ty_uint(_) | + ty_send_type | ty_type | ty_native(_) | ty_ptr(_) { true } _ { false } } } @@ -938,14 +938,14 @@ fn type_is_immediate(cx: ctxt, ty: t) -> bool { fn type_needs_drop(cx: ctxt, ty: t) -> bool { alt cx.needs_drop_cache.find(ty) { some(result) { ret result; } - none. {/* fall through */ } + none {/* fall through */ } } let accum = false; let result = alt struct(cx, ty) { // scalar types - ty_nil. | ty_bot. | ty_bool. | ty_int(_) | ty_float(_) | ty_uint(_) | - ty_type. | ty_native(_) | ty_ptr(_) { false } + ty_nil | ty_bot | ty_bool | ty_int(_) | ty_float(_) | ty_uint(_) | + ty_type | ty_native(_) | ty_ptr(_) { false } ty_rec(flds) { for f in flds { if type_needs_drop(cx, f.mt.ty) { accum = true; } } accum @@ -980,35 +980,35 @@ tag kind { kind_sendable; kind_copyable; kind_noncopyable; } // future. pure fn kind_can_be_copied(k: kind) -> bool { ret alt k { - kind_sendable. { true } - kind_copyable. { true } - kind_noncopyable. { false } + kind_sendable { true } + kind_copyable { true } + kind_noncopyable { false } }; } pure fn kind_can_be_sent(k: kind) -> bool { ret alt k { - kind_sendable. { true } - kind_copyable. { false } - kind_noncopyable. { false } + kind_sendable { true } + kind_copyable { false } + kind_noncopyable { false } }; } fn proto_kind(p: proto) -> kind { alt p { - ast::proto_any. { kind_noncopyable } - ast::proto_block. { kind_noncopyable } - ast::proto_box. { kind_copyable } - ast::proto_uniq. { kind_sendable } - ast::proto_bare. { kind_sendable } + ast::proto_any { kind_noncopyable } + ast::proto_block { kind_noncopyable } + ast::proto_box { kind_copyable } + ast::proto_uniq { kind_sendable } + ast::proto_bare { kind_sendable } } } fn kind_lteq(a: kind, b: kind) -> bool { alt a { - kind_noncopyable. { true } - kind_copyable. { b != kind_noncopyable } - kind_sendable. { b == kind_sendable } + kind_noncopyable { true } + kind_copyable { b != kind_noncopyable } + kind_sendable { b == kind_sendable } } } @@ -1019,7 +1019,7 @@ fn lower_kind(a: kind, b: kind) -> kind { fn type_kind(cx: ctxt, ty: t) -> kind { alt cx.kind_cache.find(ty) { some(result) { ret result; } - none. {/* fall through */ } + none {/* fall through */ } } // Insert a default in case we loop back on self recursively. @@ -1027,14 +1027,14 @@ fn type_kind(cx: ctxt, ty: t) -> kind { let result = alt struct(cx, ty) { // Scalar and unique types are sendable - ty_nil. | ty_bot. | ty_bool. | ty_int(_) | ty_uint(_) | ty_float(_) | + ty_nil | ty_bot | ty_bool | ty_int(_) | ty_uint(_) | ty_float(_) | ty_native(_) | ty_ptr(_) | - ty_send_type. | ty_str. | ty_native_fn(_, _) { kind_sendable } - ty_type. { kind_copyable } + ty_send_type | ty_str | ty_native_fn(_, _) { kind_sendable } + ty_type { kind_copyable } ty_fn(f) { proto_kind(f.proto) } - ty_opaque_closure_ptr(ck_block.) { kind_noncopyable } - ty_opaque_closure_ptr(ck_box.) { kind_copyable } - ty_opaque_closure_ptr(ck_uniq.) { kind_sendable } + ty_opaque_closure_ptr(ck_block) { kind_noncopyable } + ty_opaque_closure_ptr(ck_box) { kind_copyable } + ty_opaque_closure_ptr(ck_uniq) { kind_sendable } // Those with refcounts-to-inner raise pinned to shared, // lower unique to shared. Therefore just set result to shared. ty_box(_) | ty_iface(_, _) { kind_copyable } @@ -1164,7 +1164,7 @@ fn type_structurally_contains_uniques(cx: ctxt, ty: t) -> bool { ret alt sty { ty_uniq(_) { ret true; } ty_vec(_) { true } - ty_str. { true } + ty_str { true } _ { ret false; } }; }); @@ -1172,7 +1172,7 @@ fn type_structurally_contains_uniques(cx: ctxt, ty: t) -> bool { fn type_is_integral(cx: ctxt, ty: t) -> bool { alt struct(cx, ty) { - ty_int(_) | ty_uint(_) | ty_bool. { true } + ty_int(_) | ty_uint(_) | ty_bool { true } _ { false } } } @@ -1201,10 +1201,10 @@ fn type_is_pod(cx: ctxt, ty: t) -> bool { let result = true; alt struct(cx, ty) { // Scalar types - ty_nil. | ty_bot. | ty_bool. | ty_int(_) | ty_float(_) | ty_uint(_) | - ty_send_type. | ty_type. | ty_native(_) | ty_ptr(_) { result = true; } + ty_nil | ty_bot | ty_bool | ty_int(_) | ty_float(_) | ty_uint(_) | + ty_send_type | ty_type | ty_native(_) | ty_ptr(_) { result = true; } // Boxed types - ty_str. | ty_box(_) | ty_uniq(_) | ty_vec(_) | ty_fn(_) | + ty_str | ty_box(_) | ty_uniq(_) | ty_vec(_) | ty_fn(_) | ty_native_fn(_, _) | ty_iface(_, _) { result = false; } // Structural types ty_tag(did, tps) { @@ -1334,7 +1334,7 @@ fn hash_type_structure(st: sty) -> uint { let h = id; for a: @ty_constr_arg in args { alt a.node { - carg_base. { h += h << 5u; } + carg_base { h += h << 5u; } carg_lit(_) { // FIXME fail "lit args not implemented yet"; @@ -1355,23 +1355,23 @@ fn hash_type_structure(st: sty) -> uint { ret h; } alt st { - ty_nil. { 0u } ty_bool. { 1u } + ty_nil { 0u } ty_bool { 1u } ty_int(t) { alt t { - ast::ty_i. { 2u } ast::ty_char. { 3u } ast::ty_i8. { 4u } - ast::ty_i16. { 5u } ast::ty_i32. { 6u } ast::ty_i64. { 7u } + ast::ty_i { 2u } ast::ty_char { 3u } ast::ty_i8 { 4u } + ast::ty_i16 { 5u } ast::ty_i32 { 6u } ast::ty_i64 { 7u } } } ty_uint(t) { alt t { - ast::ty_u. { 8u } ast::ty_u8. { 9u } ast::ty_u16. { 10u } - ast::ty_u32. { 11u } ast::ty_u64. { 12u } + ast::ty_u { 8u } ast::ty_u8 { 9u } ast::ty_u16 { 10u } + ast::ty_u32 { 11u } ast::ty_u64 { 12u } } } ty_float(t) { - alt t { ast::ty_f. { 13u } ast::ty_f32. { 14u } ast::ty_f64. { 15u } } + alt t { ast::ty_f { 13u } ast::ty_f32 { 14u } ast::ty_f64 { 15u } } } - ty_str. { ret 17u; } + ty_str { ret 17u; } ty_tag(did, tys) { let h = hash_def(18u, did); for typ: t in tys { h += (h << 5u) + typ; } @@ -1391,9 +1391,9 @@ fn hash_type_structure(st: sty) -> uint { ty_native_fn(args, rty) { ret hash_fn(28u, args, rty); } ty_var(v) { ret hash_uint(30u, v as uint); } ty_param(pid, _) { ret hash_uint(31u, pid); } - ty_type. { ret 32u; } + ty_type { ret 32u; } ty_native(did) { ret hash_def(33u, did); } - ty_bot. { ret 34u; } + ty_bot { ret 34u; } ty_ptr(mt) { ret hash_subty(35u, mt.ty); } ty_res(did, sub, tps) { let h = hash_subty(hash_def(18u, did), sub); @@ -1405,16 +1405,16 @@ fn hash_type_structure(st: sty) -> uint { ret h; } ty_uniq(mt) { ret hash_subty(37u, mt.ty); } - ty_send_type. { ret 38u; } + ty_send_type { ret 38u; } ty_named(t, name) { (str::hash(*name) << 5u) + hash_subty(39u, t) } ty_iface(did, tys) { let h = hash_def(40u, did); for typ: t in tys { h = hash_subty(h, typ); } ret h; } - ty_opaque_closure_ptr(ck_block.) { ret 41u; } - ty_opaque_closure_ptr(ck_box.) { ret 42u; } - ty_opaque_closure_ptr(ck_uniq.) { ret 43u; } + ty_opaque_closure_ptr(ck_block) { ret 41u; } + ty_opaque_closure_ptr(ck_box) { ret 42u; } + ty_opaque_closure_ptr(ck_uniq) { ret 43u; } } } @@ -1425,8 +1425,8 @@ fn arg_eq<T>(eq: block(T, T) -> bool, b: @sp_constr_arg<T>) -> bool { alt a.node { - ast::carg_base. { - alt b.node { ast::carg_base. { ret true; } _ { ret false; } } + ast::carg_base { + alt b.node { ast::carg_base { ret true; } _ { ret false; } } } ast::carg_ident(s) { alt b.node { ast::carg_ident(t) { ret eq(s, t); } _ { ret false; } } @@ -1469,7 +1469,7 @@ fn node_id_to_ty_param_substs_opt_and_ty(cx: ctxt, id: ast::node_id) -> ty_param_substs_opt_and_ty { // Pull out the node type table. alt smallintmap::find(*cx.node_types, id as uint) { - none. { + none { cx.sess.bug("node_id_to_ty_param_substs_opt_and_ty() called on " + "an untyped node (" + int::to_str(id, 10u) + ")"); @@ -1484,7 +1484,7 @@ fn node_id_to_type(cx: ctxt, id: ast::node_id) -> t { fn node_id_to_type_params(cx: ctxt, id: ast::node_id) -> [t] { alt node_id_to_ty_param_substs_opt_and_ty(cx, id).substs { - none. { ret []; } + none { ret []; } some(tps) { ret tps; } } } @@ -1494,19 +1494,19 @@ fn node_id_has_type_params(cx: ctxt, id: ast::node_id) -> bool { } -// Returns a type with type parameter substitutions performed if applicable. +// Returns a type with type parameter substitutions performed if applicable fn ty_param_substs_opt_and_ty_to_monotype(cx: ctxt, tpot: ty_param_substs_opt_and_ty) -> t { alt tpot.substs { - none. { ret tpot.ty; } + none { ret tpot.ty; } some(tps) { ret substitute_type_params(cx, tps, tpot.ty); } } } // Returns the type of an annotation, with type parameter substitutions -// performed if applicable. +// performed if applicable fn node_id_to_monotype(cx: ctxt, id: ast::node_id) -> t { let tpot = node_id_to_ty_param_substs_opt_and_ty(cx, id); ret ty_param_substs_opt_and_ty_to_monotype(cx, tpot); @@ -1643,7 +1643,7 @@ fn expr_has_ty_params(cx: ctxt, expr: @ast::expr) -> bool { fn expr_is_lval(method_map: typeck::method_map, e: @ast::expr) -> bool { alt e.node { ast::expr_path(_) | ast::expr_index(_, _) | - ast::expr_unary(ast::deref., _) { true } + ast::expr_unary(ast::deref, _) { true } ast::expr_field(base, ident, _) { !method_map.contains_key(e.id) } _ { false } } @@ -1771,15 +1771,15 @@ mod unify { alt smallintmap::find(vb.types, root_a) { - none. { + none { alt smallintmap::find(vb.types, root_b) { - none. { ufind::union(vb.sets, set_a, set_b); ret unres_ok; } + none { ufind::union(vb.sets, set_a, set_b); ret unres_ok; } some(t_b) { replace_type(vb, t_b); ret unres_ok; } } } some(t_a) { alt smallintmap::find(vb.types, root_b) { - none. { replace_type(vb, t_a); ret unres_ok; } + none { replace_type(vb, t_a); ret unres_ok; } some(t_b) { alt unify_step(cx, t_a, t_b, variance) { ures_ok(t_c) { replace_type(vb, t_c); ret unres_ok; } @@ -1818,7 +1818,7 @@ mod unify { rs { ret rs; } } } - none. {/* fall through */ } + none {/* fall through */ } } smallintmap::insert::<t>(vb.types, root, result_type); ret ures_ok(typ); @@ -1866,8 +1866,8 @@ mod unify { for a: @ty_constr_arg in expected.node.args { actual = actual_constr.node.args[i]; alt a.node { - carg_base. { - alt actual.node { carg_base. { } _ { ret err_res; } } + carg_base { + alt actual.node { carg_base { } _ { ret err_res; } } } carg_lit(l) { alt actual.node { @@ -1895,7 +1895,7 @@ mod unify { // If you're unifying on something mutable then we have to // be invariant on the inner type let newvariance = alt expected { - ast::mut. { + ast::mut { variance_transform(variance, invariant) } _ { @@ -1929,9 +1929,9 @@ mod unify { // subtype). fn sub_proto(p_sub: ast::proto, p_sup: ast::proto) -> bool { ret alt (p_sub, p_sup) { - (_, ast::proto_any.) { true } - (_, ast::proto_block.) { true } /* NDM temporary */ - (ast::proto_bare., _) { true } + (_, ast::proto_any) { true } + (_, ast::proto_block) { true } /* NDM temporary */ + (ast::proto_bare, _) { true } // Equal prototypes are always subprotos: (_, _) { p_sub == p_sup } @@ -1939,9 +1939,9 @@ mod unify { } ret alt variance { - invariant. if e_proto == a_proto { none } - covariant. if sub_proto(a_proto, e_proto) { none } - contravariant. if sub_proto(e_proto, a_proto) { none } + invariant if e_proto == a_proto { none } + covariant if sub_proto(a_proto, e_proto) { none } + contravariant if sub_proto(e_proto, a_proto) { none } _ { some(ures_err(terr_mismatch)) } }; } @@ -1981,7 +1981,7 @@ mod unify { -> result { alt unify_fn_proto(e_f.proto, a_f.proto, variance) { some(err) { ret err; } - none. { /* fall through */ } + none { /* fall through */ } } if a_f.ret_style != ast::noreturn && a_f.ret_style != e_f.ret_style { @@ -2032,7 +2032,7 @@ mod unify { if vid as uint >= ufind::set_count(vb.sets) { ret fix_err(vid); } let root_id = ufind::find(vb.sets, vid as uint); alt smallintmap::find::<t>(vb.types, root_id) { - none. { ret fix_err(vid); } + none { ret fix_err(vid); } some(rt) { ret fix_ok(rt); } } } @@ -2058,25 +2058,25 @@ mod unify { // read the paper (yet). fn variance_transform(a: variance, b: variance) -> variance { alt a { - covariant. { + covariant { alt b { - covariant. { covariant } - contravariant. { contravariant } - invariant. { invariant } + covariant { covariant } + contravariant { contravariant } + invariant { invariant } } } - contravariant. { + contravariant { alt b { - covariant. { contravariant } - contravariant. { covariant } - invariant. { invariant } + covariant { contravariant } + contravariant { covariant } + invariant { invariant } } } - invariant. { + invariant { alt b { - covariant. { invariant } - contravariant. { invariant } - invariant. { invariant } + covariant { invariant } + contravariant { invariant } + invariant { invariant } } } } @@ -2108,7 +2108,7 @@ mod unify { if expected == actual { ret ures_ok(expected); } // Stage 1: Handle the cases in which one side or another is a type - // variable. + // variable alt struct(cx.tcx, actual) { // If the RHS is a variable type, then just do the @@ -2119,7 +2119,7 @@ mod unify { ty::ty_var(expected_id) { let expected_n = expected_id as uint; alt union(cx, expected_n, actual_n, variance) { - unres_ok. {/* fall through */ } + unres_ok {/* fall through */ } unres_err(t_e) { ret ures_err(t_e); } } } @@ -2152,17 +2152,17 @@ mod unify { // Stage 2: Handle all other cases. alt struct(cx.tcx, actual) { - ty::ty_bot. { ret ures_ok(expected); } + ty::ty_bot { ret ures_ok(expected); } _ {/* fall through */ } } alt struct(cx.tcx, expected) { - ty::ty_nil. { ret struct_cmp(cx, expected, actual); } + ty::ty_nil { ret struct_cmp(cx, expected, actual); } // _|_ unifies with anything - ty::ty_bot. { + ty::ty_bot { ret ures_ok(actual); } - ty::ty_bool. | ty::ty_int(_) | ty_uint(_) | ty_float(_) | - ty::ty_str. | ty::ty_type. | ty::ty_send_type. { + ty::ty_bool | ty::ty_int(_) | ty_uint(_) | ty_float(_) | + ty::ty_str | ty::ty_type | ty::ty_send_type { ret struct_cmp(cx, expected, actual); } ty::ty_native(ex_id) { @@ -2216,7 +2216,7 @@ mod unify { ty::ty_box(actual_mt) { let (mutt, var) = alt unify_mut( expected_mt.mut, actual_mt.mut, variance) { - none. { ret ures_err(terr_box_mutability); } + none { ret ures_err(terr_box_mutability); } some(mv) { mv } }; let result = unify_step( @@ -2237,7 +2237,7 @@ mod unify { ty::ty_uniq(actual_mt) { let (mutt, var) = alt unify_mut( expected_mt.mut, actual_mt.mut, variance) { - none. { ret ures_err(terr_box_mutability); } + none { ret ures_err(terr_box_mutability); } some(mv) { mv } }; let result = unify_step( @@ -2258,7 +2258,7 @@ mod unify { ty::ty_vec(actual_mt) { let (mutt, var) = alt unify_mut( expected_mt.mut, actual_mt.mut, variance) { - none. { ret ures_err(terr_vec_mutability); } + none { ret ures_err(terr_vec_mutability); } some(mv) { mv } }; let result = unify_step( @@ -2279,7 +2279,7 @@ mod unify { ty::ty_ptr(actual_mt) { let (mutt, var) = alt unify_mut( expected_mt.mut, actual_mt.mut, variance) { - none. { ret ures_err(terr_vec_mutability); } + none { ret ures_err(terr_vec_mutability); } some(mv) { mv } }; let result = unify_step( @@ -2344,7 +2344,7 @@ mod unify { let (mutt, var) = alt unify_mut( expected_field.mt.mut, actual_field.mt.mut, variance) { - none. { ret ures_err(terr_record_mutability); } + none { ret ures_err(terr_record_mutability); } some(mv) { mv } }; if !str::eq(expected_field.ident, actual_field.ident) { @@ -2462,7 +2462,7 @@ mod unify { } let typespec; alt smallintmap::find::<t>(vb.types, i) { - none. { typespec = ""; } + none { typespec = ""; } some(typ) { typespec = " =" + ty_to_str(tcx, typ); } } #error("set %u:%s%s", i, typespec, sets); @@ -2486,7 +2486,7 @@ mod unify { } let root_id = ufind::find(vb.sets, vid as uint); alt smallintmap::find::<t>(vb.types, root_id) { - none. { *unresolved = some(vid); ret ty::mk_var(tcx, vid); } + none { *unresolved = some(vid); ret ty::mk_var(tcx, vid); } some(rt) { if occurs_check_fails(tcx, sp, vid, rt) { // Return the type unchanged, so we can error out @@ -2505,7 +2505,7 @@ mod unify { typ); let ur = *unresolved; alt ur { - none. { ret fix_ok(rty); } + none { ret fix_ok(rty); } some(var_id) { ret fix_err(var_id); } } } @@ -2514,7 +2514,7 @@ mod unify { if vid as uint >= ufind::set_count(vb.sets) { ret fix_err(vid); } let root_id = ufind::find(vb.sets, vid as uint); alt smallintmap::find::<t>(vb.types, root_id) { - none. { ret fix_err(vid); } + none { ret fix_err(vid); } some(rt) { ret fixup_vars(tcx, sp, vb, rt); } } } @@ -2529,19 +2529,19 @@ fn same_type(cx: ctxt, a: t, b: t) -> bool { fn type_err_to_str(err: ty::type_err) -> str { alt err { - terr_mismatch. { ret "types differ"; } + terr_mismatch { ret "types differ"; } terr_ret_style_mismatch(expect, actual) { fn to_str(s: ast::ret_style) -> str { alt s { - ast::noreturn. { "non-returning" } + ast::noreturn { "non-returning" } ast::return_val. { "return-by-value" } } } ret to_str(actual) + " function found where " + to_str(expect) + " function was expected"; } - terr_box_mutability. { ret "boxed values differ in mutability"; } - terr_vec_mutability. { ret "vectors differ in mutability"; } + terr_box_mutability { ret "boxed values differ in mutability"; } + terr_vec_mutability { ret "vectors differ in mutability"; } terr_tuple_size(e_sz, a_sz) { ret "expected a tuple with " + uint::to_str(e_sz, 10u) + " elements but found one with " + uint::to_str(a_sz, 10u) + @@ -2552,12 +2552,12 @@ fn type_err_to_str(err: ty::type_err) -> str { " fields but found one with " + uint::to_str(a_sz, 10u) + " fields"; } - terr_record_mutability. { ret "record elements differ in mutability"; } + terr_record_mutability { ret "record elements differ in mutability"; } terr_record_fields(e_fld, a_fld) { ret "expected a record with field '" + e_fld + "' but found one with field '" + a_fld + "'"; } - terr_arg_count. { ret "incorrect number of function parameters"; } + terr_arg_count { ret "incorrect number of function parameters"; } terr_mode_mismatch(e_mode, a_mode) { ret "expected argument mode " + mode_str(e_mode) + " but found " + mode_str(a_mode); @@ -2701,7 +2701,7 @@ fn lookup_item_type(cx: ctxt, did: ast::def_id) -> ty_param_bounds_and_ty { } alt cx.tcache.find(did) { some(tpt) { ret tpt; } - none. { + none { let tyt = csearch::get_type(cx, did); cx.tcache.insert(did, tyt); ret tyt; @@ -2735,40 +2735,40 @@ fn is_binopable(cx: ctxt, ty: t, op: ast::binop) -> bool { fn opcat(op: ast::binop) -> int { alt op { - ast::add. { opcat_add } - ast::subtract. { opcat_sub } - ast::mul. { opcat_mult } - ast::div. { opcat_mult } - ast::rem. { opcat_mult } - ast::and. { opcat_logic } - ast::or. { opcat_logic } - ast::bitxor. { opcat_bit } - ast::bitand. { opcat_bit } - ast::bitor. { opcat_bit } - ast::lsl. { opcat_shift } - ast::lsr. { opcat_shift } - ast::asr. { opcat_shift } - ast::eq. { opcat_eq } - ast::ne. { opcat_eq } - ast::lt. { opcat_rel } - ast::le. { opcat_rel } - ast::ge. { opcat_rel } - ast::gt. { opcat_rel } + ast::add { opcat_add } + ast::subtract { opcat_sub } + ast::mul { opcat_mult } + ast::div { opcat_mult } + ast::rem { opcat_mult } + ast::and { opcat_logic } + ast::or { opcat_logic } + ast::bitxor { opcat_bit } + ast::bitand { opcat_bit } + ast::bitor { opcat_bit } + ast::lsl { opcat_shift } + ast::lsr { opcat_shift } + ast::asr { opcat_shift } + ast::eq { opcat_eq } + ast::ne { opcat_eq } + ast::lt { opcat_rel } + ast::le { opcat_rel } + ast::ge { opcat_rel } + ast::gt { opcat_rel } } } fn tycat(cx: ctxt, ty: t) -> int { alt struct(cx, ty) { - ty_bool. { tycat_bool } + ty_bool { tycat_bool } ty_int(_) { tycat_int } ty_uint(_) { tycat_int } ty_float(_) { tycat_float } - ty_str. { tycat_str } + ty_str { tycat_str } ty_vec(_) { tycat_vec } ty_rec(_) { tycat_struct } ty_tup(_) { tycat_struct } ty_tag(_, _) { tycat_struct } - ty_bot. { tycat_bot } + ty_bot { tycat_bot } _ { tycat_other } } } @@ -2798,7 +2798,7 @@ fn is_binopable(cx: ctxt, ty: t, op: ast::binop) -> bool { fn ast_constr_to_constr<T>(tcx: ty::ctxt, c: @ast::constr_general<T>) -> @ty::constr_general<T> { alt tcx.def_map.find(c.node.id) { - some(ast::def_fn(pred_id, ast::pure_fn.)) { + some(ast::def_fn(pred_id, ast::pure_fn)) { ret @ast_util::respan(c.span, {path: c.node.path, args: c.node.args, diff --git a/src/comp/middle/typeck.rs b/src/comp/middle/typeck.rs index 7c8e21464c4..ea64d5f3f11 100644 --- a/src/comp/middle/typeck.rs +++ b/src/comp/middle/typeck.rs @@ -218,7 +218,7 @@ fn type_is_c_like_enum(fcx: @fn_ctxt, sp: span, typ: ty::t) -> bool { fn default_arg_mode_for_ty(tcx: ty::ctxt, m: ast::mode, ty: ty::t) -> ast::mode { alt m { - ast::mode_infer. { + ast::mode_infer { alt ty::struct(tcx, ty) { ty::ty_var(_) { ast::mode_infer } _ { @@ -237,8 +237,8 @@ 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) -> ty::ty_param_bounds_and_ty { alt mode { - m_check. | m_check_tyvar(_) { ty::lookup_item_type(tcx, id) } - m_collect. { + m_check | m_check_tyvar(_) { ty::lookup_item_type(tcx, id) } + m_collect { if id.crate != ast::local_crate { csearch::get_type(tcx, id) } else { alt tcx.items.find(id.node) { @@ -260,13 +260,13 @@ fn ast_ty_to_ty(tcx: ty::ctxt, mode: mode, &&ast_ty: @ast::ty) -> ty::t { } alt tcx.ast_ty_to_ty_cache.find(ast_ty) { some(some(ty)) { ret ty; } - some(none.) { + some(none) { tcx.sess.span_fatal(ast_ty.span, "illegal recursive type \ insert a tag in the cycle, \ if this is desired)"); } - none. { } + none { } } /* go on */ tcx.ast_ty_to_ty_cache.insert(ast_ty, none::<ty::t>); @@ -299,13 +299,13 @@ fn ast_ty_to_ty(tcx: ty::ctxt, mode: mode, &&ast_ty: @ast::ty) -> ty::t { } let typ; alt ast_ty.node { - ast::ty_nil. { typ = ty::mk_nil(tcx); } - ast::ty_bot. { typ = ty::mk_bot(tcx); } - ast::ty_bool. { typ = ty::mk_bool(tcx); } + ast::ty_nil { typ = ty::mk_nil(tcx); } + ast::ty_bot { typ = ty::mk_bot(tcx); } + ast::ty_bool { typ = ty::mk_bool(tcx); } ast::ty_int(it) { typ = ty::mk_mach_int(tcx, it); } ast::ty_uint(uit) { typ = ty::mk_mach_uint(tcx, uit); } ast::ty_float(ft) { typ = ty::mk_mach_float(tcx, ft); } - ast::ty_str. { typ = ty::mk_str(tcx); } + ast::ty_str { typ = ty::mk_str(tcx); } ast::ty_box(mt) { typ = ty::mk_box(tcx, ast_mt_to_mt(tcx, mode, mt)); } @@ -385,7 +385,7 @@ fn ty_of_item(tcx: ty::ctxt, mode: mode, it: @ast::item) ast::item_ty(t, tps) { alt tcx.tcache.find(local_def(it.id)) { some(tpt) { ret tpt; } - none. { } + none { } } // Tell ast_ty_to_ty() that we want to perform a recursive // call to resolve any named types. @@ -434,10 +434,10 @@ fn ty_of_native_item(tcx: ty::ctxt, mode: mode, it: @ast::native_item) ret ty_of_native_fn_decl(tcx, mode, fn_decl, params, ast_util::local_def(it.id)); } - ast::native_item_ty. { + ast::native_item_ty { alt tcx.tcache.find(local_def(it.id)) { some(tpt) { ret tpt; } - none. { } + none { } } let t = ty::mk_native(tcx, ast_util::local_def(it.id)); let t = ty::mk_named(tcx, t, @it.ident); @@ -491,12 +491,12 @@ fn ty_param_bounds(tcx: ty::ctxt, mode: mode, params: [ast::ty_param]) for param in params { result += [alt tcx.ty_param_bounds.find(param.id) { some(bs) { bs } - none. { + none { let bounds = []; for b in *param.bounds { bounds += [alt b { - ast::bound_send. { ty::bound_send } - ast::bound_copy. { ty::bound_copy } + ast::bound_send { ty::bound_send } + ast::bound_copy { ty::bound_copy } ast::bound_iface(t) { let ity = ast_ty_to_ty(tcx, mode, t); alt ty::struct(tcx, ity) { @@ -545,7 +545,7 @@ fn ast_ty_to_ty_crate_infer(ccx: @crate_ctxt, &&ast_ty: @ast::ty) -> } -// Functions that write types into the node type table. +// Functions that write types into the node type table mod write { fn inner(ntt: node_type_table, node_id: ast::node_id, tpot: ty_param_substs_opt_and_ty) { @@ -713,7 +713,7 @@ mod collect { compare_impl_method(cx.tcx, t.span, m, vec::len(tps), if_m, tys); } - none. { + none { cx.tcx.sess.span_err(t.span, "missing method `" + if_m.ident + "`"); } @@ -773,7 +773,7 @@ mod collect { // table. let tpt = ty_of_native_item(cx.tcx, m_collect, i); alt i.node { - ast::native_item_ty. { + ast::native_item_ty { // FIXME: Native types have no annotation. Should they? --pcw } ast::native_item_fn(_, _) { @@ -975,17 +975,17 @@ mod writeback { let new_ty = alt resolve_type_vars_in_type(fcx, sp, tpot.ty) { some(t) { t } - none. { wbcx.success = false; ret } + none { wbcx.success = false; ret } }; let new_substs_opt; alt tpot.substs { - none. { new_substs_opt = none; } + none { new_substs_opt = none; } some(substs) { let new_substs: [ty::t] = []; for subst: ty::t in substs { alt resolve_type_vars_in_type(fcx, sp, subst) { some(t) { new_substs += [t]; } - none. { wbcx.success = false; ret; } + none { wbcx.success = false; ret; } } } new_substs_opt = some(new_substs); @@ -1095,7 +1095,7 @@ fn gather_locals(ccx: @crate_ctxt, old_fcx: option::t<@fn_ctxt>) -> gather_result { let {vb: vb, locals: locals, nvi: nvi} = alt old_fcx { - none. { + none { {vb: ty::unify::mk_var_bindings(), locals: new_int_hash::<int>(), nvi: @mutable 0} @@ -1113,7 +1113,7 @@ fn gather_locals(ccx: @crate_ctxt, let var_id = next_var_id(); locals.insert(nid, var_id); alt ty_opt { - none. {/* nothing to do */ } + none {/* nothing to do */ } some(typ) { ty::unify::unify(ty::mk_var(tcx, var_id), typ, ty::unify::in_bindings(vb), tcx); @@ -1171,7 +1171,7 @@ fn check_lit(ccx: @crate_ctxt, lit: @ast::lit) -> ty::t { ast::lit_int(_, t) { ty::mk_mach_int(ccx.tcx, t) } ast::lit_uint(_, t) { ty::mk_mach_uint(ccx.tcx, t) } ast::lit_float(_, t) { ty::mk_mach_float(ccx.tcx, t) } - ast::lit_nil. { ty::mk_nil(ccx.tcx) } + ast::lit_nil { ty::mk_nil(ccx.tcx) } ast::lit_bool(_) { ty::mk_bool(ccx.tcx) } } } @@ -1185,7 +1185,7 @@ fn valid_range_bounds(from: @ast::expr, to: @ast::expr) -> bool { fn check_pat(fcx: @fn_ctxt, map: pat_util::pat_id_map, pat: @ast::pat, expected: ty::t) { alt normalize_pat(fcx.ccx.tcx, pat).node { - ast::pat_wild. { + ast::pat_wild { alt structure_of(fcx, pat.span, expected) { ty::ty_tag(_, expected_tps) { let path_tpt = {substs: some(expected_tps), @@ -1337,7 +1337,7 @@ fn check_pat(fcx: @fn_ctxt, map: pat_util::pat_id_map, pat: @ast::pat, for f: ast::field_pat in fields { alt vec::find(ex_fields, bind matches(f.ident, _)) { some(field) { check_pat(fcx, map, f.pat, field.mt.ty); } - none. { + none { fcx.ccx.tcx.sess.span_fatal(pat.span, #fmt["mismatched types: did not \ expect a record with a field `%s`", @@ -1402,7 +1402,7 @@ fn check_pat(fcx: @fn_ctxt, map: pat_util::pat_id_map, pat: @ast::pat, fn require_unsafe(sess: session, f_purity: ast::purity, sp: span) { alt f_purity { - ast::unsafe_fn. { ret; } + ast::unsafe_fn { ret; } _ { sess.span_err( sp, @@ -1413,9 +1413,9 @@ fn require_unsafe(sess: session, f_purity: ast::purity, sp: span) { fn require_impure(sess: session, f_purity: ast::purity, sp: span) { alt f_purity { - ast::unsafe_fn. { ret; } - ast::impure_fn. { ret; } - ast::pure_fn. { + ast::unsafe_fn { ret; } + ast::impure_fn { ret; } + ast::pure_fn { sess.span_err(sp, "Found impure expression in pure function decl"); } } @@ -1424,11 +1424,11 @@ fn require_impure(sess: session, f_purity: ast::purity, sp: span) { fn require_pure_call(ccx: @crate_ctxt, caller_purity: ast::purity, callee: @ast::expr, sp: span) { alt caller_purity { - ast::unsafe_fn. { ret; } - ast::impure_fn. { + ast::unsafe_fn { ret; } + ast::impure_fn { alt ccx.tcx.def_map.find(callee.id) { - some(ast::def_fn(_, ast::unsafe_fn.)) | - some(ast::def_native_fn(_, ast::unsafe_fn.)) { + some(ast::def_fn(_, ast::unsafe_fn)) | + some(ast::def_native_fn(_, ast::unsafe_fn)) { ccx.tcx.sess.span_err( sp, "safe function calls function marked unsafe"); @@ -1438,10 +1438,10 @@ fn require_pure_call(ccx: @crate_ctxt, caller_purity: ast::purity, } ret; } - ast::pure_fn. { + ast::pure_fn { alt ccx.tcx.def_map.find(callee.id) { - some(ast::def_fn(_, ast::pure_fn.)) | - some(ast::def_native_fn(_, ast::pure_fn.)) | + some(ast::def_fn(_, ast::pure_fn)) | + some(ast::def_native_fn(_, ast::pure_fn)) | some(ast::def_variant(_, _)) { ret; } _ { ccx.tcx.sess.span_err @@ -1677,7 +1677,7 @@ fn check_expr_with_unifier(fcx: @fn_ctxt, expr: @ast::expr, unify: unifier, arg_tys[i].ty); } } - none. { } + none { } } i += 1u; } @@ -1772,7 +1772,7 @@ fn check_expr_with_unifier(fcx: @fn_ctxt, expr: @ast::expr, unify: unifier, }; (if_t, thn_bot & els_bot) } - none. { + none { check_block_no_value(fcx, thn); (ty::mk_nil(fcx.ccx.tcx), false) } @@ -1814,12 +1814,12 @@ fn check_expr_with_unifier(fcx: @fn_ctxt, expr: @ast::expr, unify: unifier, let t = alt binop { - ast::eq. { ty::mk_bool(tcx) } - ast::lt. { ty::mk_bool(tcx) } - ast::le. { ty::mk_bool(tcx) } - ast::ne. { ty::mk_bool(tcx) } - ast::ge. { ty::mk_bool(tcx) } - ast::gt. { ty::mk_bool(tcx) } + ast::eq { ty::mk_bool(tcx) } + ast::lt { ty::mk_bool(tcx) } + ast::le { ty::mk_bool(tcx) } + ast::ne { ty::mk_bool(tcx) } + ast::ge { ty::mk_bool(tcx) } + ast::gt { ty::mk_bool(tcx) } _ { lhs_t } }; write::ty_only_fixup(fcx, id, t); @@ -1832,7 +1832,7 @@ fn check_expr_with_unifier(fcx: @fn_ctxt, expr: @ast::expr, unify: unifier, ast::uniq(mut) { oper_t = ty::mk_uniq(tcx, {ty: oper_t, mut: mut}); } - ast::deref. { + ast::deref { alt structure_of(fcx, expr.span, oper_t) { ty::ty_box(inner) { oper_t = inner.ty; } ty::ty_uniq(inner) { oper_t = inner.ty; } @@ -1861,7 +1861,7 @@ fn check_expr_with_unifier(fcx: @fn_ctxt, expr: @ast::expr, unify: unifier, } } } - ast::not. { + ast::not { if !type_is_integral(fcx, oper.span, oper_t) && structure_of(fcx, oper.span, oper_t) != ty::ty_bool { tcx.sess.span_err(expr.span, @@ -1870,7 +1870,7 @@ fn check_expr_with_unifier(fcx: @fn_ctxt, expr: @ast::expr, unify: unifier, ty_to_str(tcx, oper_t)]); } } - ast::neg. { + ast::neg { oper_t = structurally_resolved_type(fcx, oper.span, oper_t); if !(ty::type_is_integral(tcx, oper_t) || ty::type_is_fp(tcx, oper_t)) { @@ -1892,7 +1892,7 @@ fn check_expr_with_unifier(fcx: @fn_ctxt, expr: @ast::expr, unify: unifier, write::ty_fixup(fcx, id, path_tpot); } else { // The definition doesn't take type parameters. If the programmer - // supplied some, that's an error. + // supplied some, that's an error if vec::len::<@ast::ty>(pth.node.types) > 0u { tcx.sess.span_fatal(expr.span, "this kind of value does not \ @@ -1905,17 +1905,17 @@ fn check_expr_with_unifier(fcx: @fn_ctxt, expr: @ast::expr, unify: unifier, ast::expr_fail(expr_opt) { bot = true; alt expr_opt { - none. {/* do nothing */ } + none {/* do nothing */ } some(e) { check_expr_with(fcx, e, ty::mk_str(tcx)); } } write::bot_ty(tcx, id); } - ast::expr_break. { write::bot_ty(tcx, id); bot = true; } - ast::expr_cont. { write::bot_ty(tcx, id); bot = true; } + ast::expr_break { write::bot_ty(tcx, id); bot = true; } + ast::expr_cont { write::bot_ty(tcx, id); bot = true; } ast::expr_ret(expr_opt) { bot = true; alt expr_opt { - none. { + none { let nil = ty::mk_nil(tcx); if !are_compatible(fcx, fcx.ret_ty, nil) { tcx.sess.span_err(expr.span, @@ -1989,7 +1989,7 @@ fn check_expr_with_unifier(fcx: @fn_ctxt, expr: @ast::expr, unify: unifier, let ety = expr_ty(tcx, seq); alt structure_of(fcx, expr.span, ety) { ty::ty_vec(vec_elt_ty) { elt_ty = vec_elt_ty.ty; } - ty::ty_str. { elt_ty = ty::mk_mach_uint(tcx, ast::ty_u8); } + ty::ty_str { elt_ty = ty::mk_mach_uint(tcx, ast::ty_u8); } _ { tcx.sess.span_fatal(expr.span, "mismatched types: expected vector or string " @@ -2026,7 +2026,7 @@ fn check_expr_with_unifier(fcx: @fn_ctxt, expr: @ast::expr, unify: unifier, for arm: ast::arm in arms { alt arm.guard { some(e) { check_expr_with(fcx, e, ty::mk_bool(tcx)); } - none. { } + none { } } if !check_block(fcx, arm.body) { arm_non_bot = true; } let bty = block_ty(tcx, arm.body); @@ -2065,7 +2065,7 @@ fn check_expr_with_unifier(fcx: @fn_ctxt, expr: @ast::expr, unify: unifier, let typ = alt b.node.expr { some(expr) { expr_ty(tcx, expr) } - none. { ty::mk_nil(tcx) } + none { ty::mk_nil(tcx) } }; write::ty_only_fixup(fcx, id, typ); } @@ -2103,7 +2103,7 @@ fn check_expr_with_unifier(fcx: @fn_ctxt, expr: @ast::expr, unify: unifier, while i < vec::len(args) { alt args[i] { some(_) {/* no-op */ } - none. { out_args += [arg_tys[i]]; } + none { out_args += [arg_tys[i]]; } } i += 1u; } @@ -2112,7 +2112,7 @@ fn check_expr_with_unifier(fcx: @fn_ctxt, expr: @ast::expr, unify: unifier, fn lower_bound_proto(proto: ast::proto) -> ast::proto { // FIXME: This is right for bare fns, possibly not others alt proto { - ast::proto_bare. { ast::proto_box } + ast::proto_bare { ast::proto_box } _ { proto } } } @@ -2176,7 +2176,7 @@ fn check_expr_with_unifier(fcx: @fn_ctxt, expr: @ast::expr, unify: unifier, write::ty_only_fixup(fcx, id, typ); } ast::expr_rec(fields, base) { - alt base { none. {/* no-op */ } some(b_0) { check_expr(fcx, b_0); } } + alt base { none {/* no-op */ } some(b_0) { check_expr(fcx, b_0); } } let fields_t: [spanned<field>] = []; for f: ast::field in fields { bot |= check_expr(fcx, f.node.expr); @@ -2189,7 +2189,7 @@ fn check_expr_with_unifier(fcx: @fn_ctxt, expr: @ast::expr, unify: unifier, {ident: f.node.ident, mt: expr_mt})]; } alt base { - none. { + none { fn get_node(f: spanned<field>) -> field { f.node } let typ = ty::mk_rec(tcx, vec::map(fields_t, get_node)); write::ty_only_fixup(fcx, id, typ); @@ -2279,7 +2279,7 @@ fn check_expr_with_unifier(fcx: @fn_ctxt, expr: @ast::expr, unify: unifier, } fcx.ccx.method_map.insert(id, origin); } - none. { + none { let t_err = resolve_type_vars_if_possible(fcx, expr_t); let msg = #fmt["attempted access of field %s on type %s, but \ no method implementation was found", @@ -2303,7 +2303,7 @@ fn check_expr_with_unifier(fcx: @fn_ctxt, expr: @ast::expr, unify: unifier, } alt structure_of(fcx, expr.span, base_t) { ty::ty_vec(mt) { write::ty_only_fixup(fcx, id, mt.ty); } - ty::ty_str. { + ty::ty_str { let typ = ty::mk_mach_uint(tcx, ast::ty_u8); write::ty_only_fixup(fcx, id, typ); } @@ -2427,7 +2427,7 @@ fn check_block(fcx0: @fn_ctxt, blk: ast::blk) -> bool { bot |= check_stmt(fcx, s); } alt blk.node.expr { - none. { write::nil_ty(fcx.ccx.tcx, blk.node.id); } + none { write::nil_ty(fcx.ccx.tcx, blk.node.id); } some(e) { if bot && !warned { fcx.ccx.tcx.sess.span_warn(e.span, "unreachable expression"); @@ -2490,7 +2490,7 @@ fn check_tag_variants(ccx: @crate_ctxt, _sp: span, vs: [ast::variant], // FIXME: issue #1417 // Also, check_expr (from check_const pass) doesn't guarantee that // the expression in an form that eval_const_expr can handle, so - // we may still get an internal compiler error. + // we may still get an internal compiler error alt syntax::ast_util::eval_const_expr(e) { syntax::ast_util::const_int(val) { disr_val = val as int; @@ -2530,7 +2530,7 @@ fn check_pred_expr(fcx: @fn_ctxt, e: @ast::expr) -> bool { alt operator.node { ast::expr_path(oper_name) { alt fcx.ccx.tcx.def_map.find(operator.id) { - some(ast::def_fn(_, ast::pure_fn.)) { + some(ast::def_fn(_, ast::pure_fn)) { // do nothing } _ { @@ -2577,7 +2577,7 @@ fn check_constraints(fcx: @fn_ctxt, cs: [@ast::constr], args: [ast::arg]) { that's my justification. */ @alt a.node { - ast::carg_base. { + ast::carg_base { fcx.ccx.tcx.sess.span_bug(a.span, "check_constraints:\ unexpected carg_base"); @@ -2630,7 +2630,7 @@ fn check_fn(ccx: @crate_ctxt, // If old_fcx is some(...), this is a block fn { |x| ... }. // In that case, the purity is inherited from the context. let purity = alt old_fcx { - none. { decl.purity } + none { decl.purity } some(f) { assert decl.purity == ast::impure_fn; f.purity } }; @@ -2656,7 +2656,7 @@ fn check_fn(ccx: @crate_ctxt, let tail_expr_ty = expr_ty(ccx.tcx, tail_expr); demand::simple(fcx, tail_expr.span, fcx.ret_ty, tail_expr_ty); } - none. { } + none { } } let args = ty::ty_fn_args(ccx.tcx, ty::node_id_to_type(ccx.tcx, id)); @@ -2684,12 +2684,12 @@ fn check_native_fn(ccx: @crate_ctxt, decl: ast::fn_decl) { let tys = vec::map(decl.inputs) {|a| a.ty }; for ty in (tys + [decl.output]) { alt ty.node { - ast::ty_int(ast::ty_i.) { + ast::ty_int(ast::ty_i) { ccx.tcx.sess.span_warn( ty.span, "found rust type `int` in native module, while " + "ctypes::c_int or ctypes::long should be used"); } - ast::ty_uint(ast::ty_u.) { + ast::ty_uint(ast::ty_u) { ccx.tcx.sess.span_warn( ty.span, "found rust type `uint` in native module, while " + "ctypes::c_uint or ctypes::ulong should be used"); @@ -2733,7 +2733,7 @@ fn arg_is_argv_ty(tcx: ty::ctxt, a: ty::arg) -> bool { ty::ty_vec(mt) { if mt.mut != ast::imm { ret false; } alt ty::struct(tcx, mt.ty) { - ty::ty_str. { ret true; } + ty::ty_str { ret true; } _ { ret false; } } } @@ -2744,7 +2744,7 @@ fn arg_is_argv_ty(tcx: ty::ctxt, a: ty::arg) -> bool { fn check_main_fn_ty(tcx: ty::ctxt, main_id: ast::node_id) { let main_t = ty::node_id_to_monotype(tcx, main_id); alt ty::struct(tcx, main_t) { - ty::ty_fn({proto: ast::proto_bare., inputs, output, + ty::ty_fn({proto: ast::proto_bare, inputs, output, ret_style: ast::return_val., constraints}) { let ok = vec::len(constraints) == 0u; ok &= ty::type_is_nil(tcx, output); @@ -2771,7 +2771,7 @@ fn check_for_main_fn(tcx: ty::ctxt, crate: @ast::crate) { if !tcx.sess.building_library { alt tcx.sess.main_fn { some(id) { check_main_fn_ty(tcx, id); } - none. { tcx.sess.span_err(crate.span, "main function not found"); } + none { tcx.sess.span_err(crate.span, "main function not found"); } } } } |