diff --git a/src/comp/back/link.rs b/src/comp/back/link.rs index a4c35178e3e..c7a195db90a 100644 --- a/src/comp/back/link.rs +++ b/src/comp/back/link.rs @@ -583,9 +583,9 @@ fn link_binary(sess: session, ret str::connect(parts, "."); } ret alt config.os { - session::os_macos. { rmext(rmlib(filename)) } - session::os_linux. { rmext(rmlib(filename)) } - session::os_freebsd. { rmext(rmlib(filename)) } + session::os_macos { rmext(rmlib(filename)) } + session::os_linux { rmext(rmlib(filename)) } + session::os_freebsd { rmext(rmlib(filename)) } _ { rmext(filename) } }; } diff --git a/src/comp/back/rpath.rs b/src/comp/back/rpath.rs index 417d553c36a..b848ca94590 100644 --- a/src/comp/back/rpath.rs +++ b/src/comp/back/rpath.rs @@ -102,9 +102,9 @@ fn get_rpath_relative_to_output(os: session::os, &&lib: fs::path) -> str { // Mac doesn't appear to support $ORIGIN let prefix = alt os { - session::os_linux. { "$ORIGIN" + fs::path_sep() } - session::os_freebsd. { "$ORIGIN" + fs::path_sep() } - session::os_macos. { "@executable_path" + fs::path_sep() } + session::os_linux { "$ORIGIN" + fs::path_sep() } + session::os_freebsd { "$ORIGIN" + fs::path_sep() } + session::os_macos { "@executable_path" + fs::path_sep() } }; prefix + get_relative_to( diff --git a/src/comp/driver/driver.rs b/src/comp/driver/driver.rs index 5b804611335..be5e4ea65fb 100644 --- a/src/comp/driver/driver.rs +++ b/src/comp/driver/driver.rs @@ -24,19 +24,19 @@ fn default_configuration(sess: session, argv0: str, input: str) -> ast::crate_cfg { let libc = alt sess.targ_cfg.os { - session::os_win32. { "msvcrt.dll" } - session::os_macos. { "libc.dylib" } - session::os_linux. { "libc.so.6" } - session::os_freebsd. { "libc.so.7" } + session::os_win32 { "msvcrt.dll" } + session::os_macos { "libc.dylib" } + session::os_linux { "libc.so.6" } + session::os_freebsd { "libc.so.7" } _ { "libc.so" } }; let mk = attr::mk_name_value_item_str; let arch = alt sess.targ_cfg.arch { - session::arch_x86. { "x86" } - session::arch_x86_64. { "x86_64" } - session::arch_arm. { "arm" } + session::arch_x86 { "x86" } + session::arch_x86_64 { "x86_64" } + session::arch_arm { "arm" } }; ret [ // Target bindings. @@ -340,14 +340,14 @@ fn build_target_config(sopts: @session::options, "Unknown architecture! " + sopts.target_triple) } }; let (int_type, uint_type, float_type) = alt arch { - session::arch_x86. {(ast::ty_i32, ast::ty_u32, ast::ty_f64)} - session::arch_x86_64. {(ast::ty_i64, ast::ty_u64, ast::ty_f64)} - session::arch_arm. {(ast::ty_i32, ast::ty_u32, ast::ty_f64)} + session::arch_x86 {(ast::ty_i32, ast::ty_u32, ast::ty_f64)} + session::arch_x86_64 {(ast::ty_i64, ast::ty_u64, ast::ty_f64)} + session::arch_arm {(ast::ty_i32, ast::ty_u32, ast::ty_f64)} }; let target_strs = alt arch { - session::arch_x86. {x86::get_target_strs(os)} - session::arch_x86_64. {x86_64::get_target_strs(os)} - session::arch_arm. {x86::get_target_strs(os)} + session::arch_x86 {x86::get_target_strs(os)} + session::arch_x86_64 {x86_64::get_target_strs(os)} + session::arch_arm {x86::get_target_strs(os)} }; let target_cfg: @session::config = @{os: os, arch: arch, target_strs: target_strs, int_type: int_type, @@ -406,7 +406,7 @@ fn build_session_options(match: getopts::match, let no_asm_comments = getopts::opt_present(match, "no-asm-comments"); alt output_type { // unless we're emitting huamn-readable assembly, omit comments. - link::output_type_llvm_assembly. | link::output_type_assembly. {} + link::output_type_llvm_assembly | link::output_type_assembly {} _ { no_asm_comments = true; } } let opt_level: uint = @@ -540,10 +540,10 @@ fn build_output_filenames(ifile: str, alt sopts.output_type { link::output_type_none { "none" } link::output_type_bitcode { "bc" } - link::output_type_assembly. { "s" } - link::output_type_llvm_assembly. { "ll" } + link::output_type_assembly { "s" } + link::output_type_llvm_assembly { "ll" } // Object and exe output both use the '.o' extension here - link::output_type_object. | link::output_type_exe. { + link::output_type_object | link::output_type_exe { "o" } }; diff --git a/src/comp/driver/rustc.rs b/src/comp/driver/rustc.rs index e7447cc446b..bd4c0471598 100644 --- a/src/comp/driver/rustc.rs +++ b/src/comp/driver/rustc.rs @@ -102,7 +102,7 @@ fn run_compiler(args: [str], demitter: diagnostic::emitter) { bind parse_pretty(sess, _)); alt pretty { some::(ppm) { pretty_print_input(sess, cfg, ifile, ppm); ret; } - none::. {/* continue */ } + none:: {/* continue */ } } let ls = opt_present(match, "ls"); if ls { diff --git a/src/comp/metadata/creader.rs b/src/comp/metadata/creader.rs index 93a6f761306..e4e39730350 100644 --- a/src/comp/metadata/creader.rs +++ b/src/comp/metadata/creader.rs @@ -128,10 +128,10 @@ fn default_native_lib_naming(sess: session::session, static: bool) -> {prefix: str, suffix: str} { if static { ret {prefix: "lib", suffix: ".rlib"}; } alt sess.targ_cfg.os { - session::os_win32. { ret {prefix: "", suffix: ".dll"}; } - session::os_macos. { ret {prefix: "lib", suffix: ".dylib"}; } - session::os_linux. { ret {prefix: "lib", suffix: ".so"}; } - session::os_freebsd. { ret {prefix: "lib", suffix: ".so"}; } + session::os_win32 { ret {prefix: "", suffix: ".dll"}; } + session::os_macos { ret {prefix: "lib", suffix: ".dylib"}; } + session::os_linux { ret {prefix: "lib", suffix: ".so"}; } + session::os_freebsd { ret {prefix: "lib", suffix: ".so"}; } } } diff --git a/src/comp/middle/debuginfo.rs b/src/comp/middle/debuginfo.rs index 0a0259ec584..096fc2fb99d 100644 --- a/src/comp/middle/debuginfo.rs +++ b/src/comp/middle/debuginfo.rs @@ -583,7 +583,7 @@ fn create_ty(cx: @crate_ctxt, t: ty::t, ty: @ast::ty) ret create_pointer_type(cx, t, ty.span, md); } - ast::ty_infer. { + ast::ty_infer { let inferred = t_to_ty(cx, t, ty.span); ret create_ty(cx, t, inferred); } diff --git a/src/comp/middle/gc.rs b/src/comp/middle/gc.rs index f67ac128b5e..86093c5febb 100644 --- a/src/comp/middle/gc.rs +++ b/src/comp/middle/gc.rs @@ -105,8 +105,7 @@ 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_native(_) { + ty::ty_type | ty::ty_ptr(_) | ty::ty_native(_) { ret false; } diff --git a/src/comp/middle/mut.rs b/src/comp/middle/mut.rs index d67a03d4a53..0eebf4e1ef9 100644 --- a/src/comp/middle/mut.rs +++ b/src/comp/middle/mut.rs @@ -187,9 +187,9 @@ fn check_lval(cx: @ctx, dest: @expr, msg: msg) { } else if !root.ds[0].mut { let name = alt root.ds[0].kind { - mut::unbox. { "immutable box" } - mut::field. { "immutable field" } - mut::index. { "immutable vec content" } + mut::unbox { "immutable box" } + mut::field { "immutable field" } + mut::index { "immutable vec content" } }; mk_err(cx, dest.span, msg, name); } diff --git a/src/comp/middle/shape.rs b/src/comp/middle/shape.rs index 39835854fea..9986400dfa3 100644 --- a/src/comp/middle/shape.rs +++ b/src/comp/middle/shape.rs @@ -246,25 +246,25 @@ fn tag_kind(ccx: @crate_ctxt, did: ast::def_id) -> tag_kind { // Returns the code corresponding to the pointer size on this architecture. fn s_int(tcx: ty_ctxt) -> u8 { ret alt tcx.sess.targ_cfg.arch { - session::arch_x86. { shape_i32 } - session::arch_x86_64. { shape_i64 } - session::arch_arm. { shape_i32 } + session::arch_x86 { shape_i32 } + session::arch_x86_64 { shape_i64 } + session::arch_arm { shape_i32 } }; } fn s_uint(tcx: ty_ctxt) -> u8 { ret alt tcx.sess.targ_cfg.arch { - session::arch_x86. { shape_u32 } - session::arch_x86_64. { shape_u64 } - session::arch_arm. { shape_u32 } + session::arch_x86 { shape_u32 } + session::arch_x86_64 { shape_u64 } + session::arch_arm { shape_u32 } }; } fn s_float(tcx: ty_ctxt) -> u8 { ret alt tcx.sess.targ_cfg.arch { - session::arch_x86. { shape_f64 } - session::arch_x86_64. { shape_f64 } - session::arch_arm. { shape_f64 } + session::arch_x86 { shape_f64 } + session::arch_x86_64 { shape_f64 } + session::arch_arm { shape_f64 } }; } diff --git a/src/comp/middle/trans.rs b/src/comp/middle/trans.rs index 825a76f32b1..c519461887d 100644 --- a/src/comp/middle/trans.rs +++ b/src/comp/middle/trans.rs @@ -1904,8 +1904,8 @@ fn call_memmove(cx: @block_ctxt, dst: ValueRef, src: ValueRef, let ccx = bcx_ccx(cx); let key = alt ccx.sess.targ_cfg.arch { - session::arch_x86. | session::arch_arm. { "llvm.memmove.p0i8.p0i8.i32" } - session::arch_x86_64. { "llvm.memmove.p0i8.p0i8.i64" } + session::arch_x86 | session::arch_arm { "llvm.memmove.p0i8.p0i8.i32" } + session::arch_x86_64 { "llvm.memmove.p0i8.p0i8.i64" } }; let i = ccx.intrinsics; assert (i.contains_key(key)); @@ -2915,10 +2915,10 @@ 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} { @@ -2937,10 +2937,10 @@ fn trans_cast(cx: @block_ctxt, e: @ast::expr, id: ast::node_id, {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); @@ -3559,11 +3559,11 @@ fn trans_expr(bcx: @block_ctxt, e: @ast::expr, dest: dest) -> @block_ctxt { assert dest == ignore; ret trans_check_expr(bcx, a, "Assertion"); } - ast::expr_check(ast::checked_expr., a) { + ast::expr_check(ast::checked_expr, a) { assert dest == ignore; ret trans_check_expr(bcx, a, "Predicate"); } - ast::expr_check(ast::claimed_expr., a) { + ast::expr_check(ast::claimed_expr, a) { assert dest == ignore; /* Claims are turned on and off by a global variable that the RTS sets. This case generates code to @@ -3945,8 +3945,8 @@ fn zero_alloca(cx: @block_ctxt, llptr: ValueRef, t: ty::t) Store(bcx, C_null(llty), llptr); } else { let key = alt ccx.sess.targ_cfg.arch { - session::arch_x86. | session::arch_arm. { "llvm.memset.p0i8.i32" } - session::arch_x86_64. { "llvm.memset.p0i8.i64" } + session::arch_x86 | session::arch_arm { "llvm.memset.p0i8.i32" } + session::arch_x86_64 { "llvm.memset.p0i8.i64" } }; let i = ccx.intrinsics; let memset = i.get(key); @@ -4841,9 +4841,9 @@ fn trans_native_mod(lcx: @local_ctxt, native_mod: ast::native_mod, let ccx = lcx_ccx(lcx); let cc = lib::llvm::LLVMCCallConv; alt abi { - ast::native_abi_rust_intrinsic. { ret; } - ast::native_abi_cdecl. { cc = lib::llvm::LLVMCCallConv; } - ast::native_abi_stdcall. { cc = lib::llvm::LLVMX86StdcallCallConv; } + ast::native_abi_rust_intrinsic { ret; } + ast::native_abi_cdecl { cc = lib::llvm::LLVMCCallConv; } + ast::native_abi_stdcall { cc = lib::llvm::LLVMX86StdcallCallConv; } } for native_item in native_mod.items { @@ -5143,7 +5143,7 @@ fn collect_native_item(ccx: @crate_ctxt, } }; alt fn_abi { - ast::native_abi_rust_intrinsic. { + ast::native_abi_rust_intrinsic { // For intrinsics: link the function directly to the intrinsic // function itself. let fn_type = type_of_fn_from_ty( @@ -5157,7 +5157,7 @@ fn collect_native_item(ccx: @crate_ctxt, ccx.item_symbols.insert(id, ri_name); } - ast::native_abi_cdecl. | ast::native_abi_stdcall. { + ast::native_abi_cdecl | ast::native_abi_stdcall { // For true external functions: create a rust wrapper // and link to that. The rust wrapper will handle // switching to the C stack. diff --git a/src/comp/middle/trans_closure.rs b/src/comp/middle/trans_closure.rs index 66002c89979..1e58ea53f9f 100644 --- a/src/comp/middle/trans_closure.rs +++ b/src/comp/middle/trans_closure.rs @@ -419,18 +419,18 @@ fn build_closure(bcx0: @block_ctxt, let nid = ast_util::def_id_of_def(cap_var.def).node; let ty = ty::node_id_to_monotype(tcx, nid); alt cap_var.mode { - capture::cap_ref. { + capture::cap_ref { assert ck == ty::ck_block; ty = ty::mk_mut_ptr(tcx, ty); env_vals += [env_ref(lv.val, ty, lv.kind)]; } - capture::cap_copy. { + capture::cap_copy { env_vals += [env_copy(lv.val, ty, lv.kind)]; } - capture::cap_move. { + capture::cap_move { env_vals += [env_move(lv.val, ty, lv.kind)]; } - capture::cap_drop. { + capture::cap_drop { bcx = drop_ty(bcx, lv.val, ty); } } @@ -481,7 +481,7 @@ fn load_environment(enclosing_cx: @block_ctxt, let i = 0u; vec::iter(cap_vars) { |cap_var| alt cap_var.mode { - capture::cap_drop. { /* ignore */ } + capture::cap_drop { /* ignore */ } _ { check type_is_tup_like(bcx, cbox_ty); let upvarptr = GEP_tup_like( diff --git a/src/comp/middle/trans_common.rs b/src/comp/middle/trans_common.rs index db1e615804f..0a2045dcb2b 100644 --- a/src/comp/middle/trans_common.rs +++ b/src/comp/middle/trans_common.rs @@ -483,9 +483,9 @@ fn T_bool() -> TypeRef { ret T_i1(); } fn T_int(targ_cfg: @session::config) -> TypeRef { ret alt targ_cfg.arch { - session::arch_x86. { T_i32() } - session::arch_x86_64. { T_i64() } - session::arch_arm. { T_i32() } + session::arch_x86 { T_i32() } + session::arch_x86_64 { T_i64() } + session::arch_arm { T_i32() } }; } @@ -520,9 +520,9 @@ fn T_float_ty(cx: @crate_ctxt, t: ast::float_ty) -> TypeRef { fn T_float(targ_cfg: @session::config) -> TypeRef { ret alt targ_cfg.arch { - session::arch_x86. { T_f64() } - session::arch_x86_64. { T_f64() } - session::arch_arm. { T_f64() } + session::arch_x86 { T_f64() } + session::arch_x86_64 { T_f64() } + session::arch_arm { T_f64() } }; } diff --git a/src/comp/middle/ty.rs b/src/comp/middle/ty.rs index b376af652aa..03802e04d88 100644 --- a/src/comp/middle/ty.rs +++ b/src/comp/middle/ty.rs @@ -2534,7 +2534,7 @@ fn type_err_to_str(err: ty::type_err) -> str { fn to_str(s: ast::ret_style) -> str { alt s { ast::noreturn { "non-returning" } - ast::return_val. { "return-by-value" } + ast::return_val { "return-by-value" } } } ret to_str(actual) + " function found where " + to_str(expect) + diff --git a/src/comp/middle/typeck.rs b/src/comp/middle/typeck.rs index ea64d5f3f11..cb159a54c8c 100644 --- a/src/comp/middle/typeck.rs +++ b/src/comp/middle/typeck.rs @@ -358,7 +358,7 @@ fn ast_ty_to_ty(tcx: ty::ctxt, mode: mode, &&ast_ty: @ast::ty) -> ty::t { } typ = ty::mk_constr(tcx, ast_ty_to_ty(tcx, mode, t), out_cs); } - ast::ty_infer. { + ast::ty_infer { alt mode { m_check_tyvar(fcx) { ret next_ty_var(fcx); } _ { tcx.sess.span_bug(ast_ty.span, @@ -539,7 +539,7 @@ fn ast_ty_to_ty_crate(ccx: @crate_ctxt, &&ast_ty: @ast::ty) -> ty::t { fn ast_ty_to_ty_crate_infer(ccx: @crate_ctxt, &&ast_ty: @ast::ty) -> option::t { alt ast_ty.node { - ast::ty_infer. { none } + ast::ty_infer { none } _ { some(ast_ty_to_ty_crate(ccx, ast_ty)) } } } @@ -2406,9 +2406,9 @@ fn check_block_no_value(fcx: @fn_ctxt, blk: ast::blk) -> bool { fn check_block(fcx0: @fn_ctxt, blk: ast::blk) -> bool { let fcx = alt blk.node.rules { - ast::unchecked_blk. { @{purity: ast::impure_fn with *fcx0} } - ast::unsafe_blk. { @{purity: ast::unsafe_fn with *fcx0} } - ast::default_blk. { fcx0 } + ast::unchecked_blk { @{purity: ast::impure_fn with *fcx0} } + ast::unsafe_blk { @{purity: ast::unsafe_fn with *fcx0} } + ast::default_blk { fcx0 } }; let bot = false; let warned = false; @@ -2745,7 +2745,7 @@ 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, - ret_style: ast::return_val., constraints}) { + ret_style: ast::return_val, constraints}) { let ok = vec::len(constraints) == 0u; ok &= ty::type_is_nil(tcx, output); let num_args = vec::len(inputs); diff --git a/src/comp/syntax/fold.rs b/src/comp/syntax/fold.rs index 980950cf545..4d9b697297f 100644 --- a/src/comp/syntax/fold.rs +++ b/src/comp/syntax/fold.rs @@ -453,7 +453,7 @@ fn noop_fold_local(l: local_, fld: ast_fold) -> local_ { pat: fld.fold_pat(l.pat), init: alt l.init { - option::none::. { l.init } + option::none:: { l.init } option::some::(init) { option::some::({op: init.op, expr: fld.fold_expr(init.expr)}) diff --git a/src/comp/syntax/parse/parser.rs b/src/comp/syntax/parse/parser.rs index 7515a393ee9..0da193c2078 100644 --- a/src/comp/syntax/parse/parser.rs +++ b/src/comp/syntax/parse/parser.rs @@ -1485,8 +1485,6 @@ fn parse_pat(p: parser) -> @ast::pat { } } else if is_plain_ident(p) && alt p.look_ahead(1u) { - // Take this out once the libraries change - token::DOT | token::LPAREN | token::LBRACKET | token::LT { false @@ -1508,8 +1506,6 @@ fn parse_pat(p: parser) -> @ast::pat { args = a.node; hi = a.span.hi; } - // take this out once the libraries change - token::DOT. { args = []; p.bump(); } _ { args = []; } } // at this point, we're not sure whether it's a tag or a bind diff --git a/src/comp/syntax/print/pprust.rs b/src/comp/syntax/print/pprust.rs index ebf5484af35..f4aa5646d0b 100644 --- a/src/comp/syntax/print/pprust.rs +++ b/src/comp/syntax/print/pprust.rs @@ -275,7 +275,7 @@ fn print_type(s: ps, &&ty: @ast::ty) { word(s.s, "]"); } ast::ty_ptr(mt) { word(s.s, "*"); print_mt(s, mt); } - ast::ty_task. { word(s.s, "task"); } + ast::ty_task { word(s.s, "task"); } ast::ty_port(t) { word(s.s, "port<"); print_type(s, t); @@ -506,7 +506,7 @@ fn print_outer_attributes(s: ps, attrs: [ast::attribute]) { let count = 0; for attr: ast::attribute in attrs { alt attr.node.style { - ast::attr_outer. { print_attribute(s, attr); count += 1; } + ast::attr_outer { print_attribute(s, attr); count += 1; } _ {/* fallthrough */ } } } @@ -517,7 +517,7 @@ fn print_inner_attributes(s: ps, attrs: [ast::attribute]) { let count = 0; for attr: ast::attribute in attrs { alt attr.node.style { - ast::attr_inner. { + ast::attr_inner { print_attribute(s, attr); word(s.s, ";"); count += 1; @@ -576,9 +576,9 @@ fn print_possibly_embedded_block(s: ps, blk: ast::blk, embedded: embed_type, fn print_possibly_embedded_block_(s: ps, blk: ast::blk, embedded: embed_type, indented: uint, attrs: [ast::attribute]) { alt blk.node.rules { - ast::unchecked_blk. { word(s.s, "unchecked"); } - ast::unsafe_blk. { word(s.s, "unsafe"); } - ast::default_blk. { } + ast::unchecked_blk { word(s.s, "unchecked"); } + ast::unsafe_blk { word(s.s, "unsafe"); } + ast::default_blk { } } maybe_print_comment(s, blk.span.lo); @@ -950,8 +950,8 @@ fn print_expr(s: ps, &&expr: @ast::expr) { } ast::expr_check(m, expr) { alt m { - ast::claimed_expr. { word_nbsp(s, "claim"); } - ast::checked_expr. { word_nbsp(s, "check"); } + ast::claimed_expr { word_nbsp(s, "claim"); } + ast::checked_expr { word_nbsp(s, "check"); } } popen(s); print_expr(s, expr); @@ -989,7 +989,7 @@ fn print_expr_parens_if_not_bot(s: ps, ex: @ast::expr) { fn print_local_decl(s: ps, loc: @ast::local) { print_pat(s, loc.node.pat); alt loc.node.ty.node { - ast::ty_infer. { } + ast::ty_infer { } _ { word_space(s, ":"); print_type(s, loc.node.ty); } } } @@ -1072,7 +1072,7 @@ fn print_pat(s: ps, &&pat: @ast::pat) { popen(s); commasep(s, inconsistent, args, print_pat); pclose(s); - } else { word(s.s, "."); } // FIXME + } else { } } ast::pat_rec(fields, etc) { word(s.s, "{"); @@ -1479,13 +1479,13 @@ fn maybe_print_comment(s: ps, pos: uint) { fn print_comment(s: ps, cmnt: lexer::cmnt) { alt cmnt.style { - lexer::mixed. { + lexer::mixed { assert (vec::len(cmnt.lines) == 1u); zerobreak(s.s); word(s.s, cmnt.lines[0]); zerobreak(s.s); } - lexer::isolated. { + lexer::isolated { pprust::hardbreak_if_not_bol(s); for line: str in cmnt.lines { // Don't print empty lines because they will end up as trailing @@ -1494,7 +1494,7 @@ fn print_comment(s: ps, cmnt: lexer::cmnt) { hardbreak(s.s); } } - lexer::trailing. { + lexer::trailing { word(s.s, " "); if vec::len(cmnt.lines) == 1u { word(s.s, cmnt.lines[0]); diff --git a/src/comp/util/ppaux.rs b/src/comp/util/ppaux.rs index 093b9c49a74..11ccd1cc71f 100644 --- a/src/comp/util/ppaux.rs +++ b/src/comp/util/ppaux.rs @@ -47,7 +47,7 @@ fn ty_to_str(cx: ctxt, typ: t) -> str { s += " -> "; alt cf { ast::noreturn { s += "!"; } - ast::return_val. { s += ty_to_str(cx, output); } + ast::return_val { s += ty_to_str(cx, output); } } } s += constrs_str(constrs); diff --git a/src/fuzzer/fuzzer.rs b/src/fuzzer/fuzzer.rs index be00d8153e6..f40a1a77964 100644 --- a/src/fuzzer/fuzzer.rs +++ b/src/fuzzer/fuzzer.rs @@ -165,7 +165,7 @@ fn safe_to_replace_expr(e: ast::expr_, _tm: test_mode) -> bool { fn safe_to_replace_ty(t: ast::ty_, _tm: test_mode) -> bool { alt t { - ast::ty_infer. { false } // always implicit, always top level + ast::ty_infer { false } // always implicit, always top level ast::ty_bot { false } // in source, can only appear as the out type of a function ast::ty_mac(_) { false } _ { true } diff --git a/src/libcore/vec.rs b/src/libcore/vec.rs index 33ff630e708..1868c79e97b 100644 --- a/src/libcore/vec.rs +++ b/src/libcore/vec.rs @@ -451,7 +451,7 @@ fn filter_map(v: [const T], f: block(T) -> option::t) let result = []; for elem: T in v { alt f(copy elem) { - none. {/* no-op */ } + none {/* no-op */ } some(result_elem) { result += [result_elem]; } } } diff --git a/src/libstd/linux_os.rs b/src/libstd/linux_os.rs index 965d8f1eaff..0dc31f11ab0 100644 --- a/src/libstd/linux_os.rs +++ b/src/libstd/linux_os.rs @@ -97,8 +97,8 @@ fn fclose(file: libc::FILE) { fn fsync_fd(fd: fd_t, level: io::fsync::level) -> c_int { alt level { - io::fsync::fsync. | io::fsync::fullfsync. { ret libc::fsync(fd); } - io::fsync::fdatasync. { ret libc::fdatasync(fd); } + io::fsync::fsync | io::fsync::fullfsync { ret libc::fsync(fd); } + io::fsync::fdatasync { ret libc::fdatasync(fd); } } } diff --git a/src/libstd/macos_os.rs b/src/libstd/macos_os.rs index 5ae33adcc1b..ad042b06c25 100644 --- a/src/libstd/macos_os.rs +++ b/src/libstd/macos_os.rs @@ -100,7 +100,7 @@ fn waitpid(pid: pid_t) -> i32 { fn fsync_fd(fd: fd_t, level: io::fsync::level) -> c_int { alt level { - io::fsync::fsync. { ret libc::fsync(fd); } + io::fsync::fsync { ret libc::fsync(fd); } _ { // According to man fnctl, the ok retval is only specified to be !=-1 if (libc::fcntl(libc_constants::F_FULLFSYNC, fd) == -1 as c_int) diff --git a/src/rustdoc/attr_pass.rs b/src/rustdoc/attr_pass.rs index ee3d8abb8f3..ac42820bf70 100644 --- a/src/rustdoc/attr_pass.rs +++ b/src/rustdoc/attr_pass.rs @@ -155,7 +155,7 @@ fn fold_fn( none { doc } } } - // FIXME: Warning when documenting a non-existant arg + // FIXME: Warning when documenting a non-existent arg } fn merge_ret_attrs( diff --git a/src/test/bench/99bob-pattern.rs b/src/test/bench/99bob-pattern.rs index 9c068c6c747..7665cf30737 100644 --- a/src/test/bench/99bob-pattern.rs +++ b/src/test/bench/99bob-pattern.rs @@ -23,7 +23,7 @@ fn show(b: bottle) { #debug("Take one down and pass it around, \ no more bottles of beer on the wall."); } - dual. { + dual { #debug("2 bottles of beer on the wall, 2 bottles of beer,"); #debug("Take one down and pass it around, \ 1 bottle of beer on the wall."); @@ -40,7 +40,7 @@ fn next(b: bottle) -> bottle { alt b { none { ret none; } single { ret none; } - dual. { ret single; } + dual { ret single; } multiple(3) { ret dual; } multiple(n) { ret multiple(n - 1); } } diff --git a/src/test/bench/task-perf-word-count.rs b/src/test/bench/task-perf-word-count.rs index 02adfd610b0..e10a7fe7301 100644 --- a/src/test/bench/task-perf-word-count.rs +++ b/src/test/bench/task-perf-word-count.rs @@ -116,8 +116,8 @@ mod map_reduce { // #error("all done"); state.is_done = true; } - ref. { state.ref_count += 1; } - release. { state.ref_count -= 1; } + ref { state.ref_count += 1; } + release { state.ref_count -= 1; } } } ret none; diff --git a/src/test/compile-fail/alt-tag-nullary.rs b/src/test/compile-fail/alt-tag-nullary.rs index 3951a51e9c0..8d1e80b77ae 100644 --- a/src/test/compile-fail/alt-tag-nullary.rs +++ b/src/test/compile-fail/alt-tag-nullary.rs @@ -3,5 +3,5 @@ tag a { A; } tag b { B; } -fn main() { let x: a = A; alt x { B. { } } } +fn main() { let x: a = A; alt x { B { } } } diff --git a/src/test/run-fail/alt-bot-fail.rs b/src/test/run-fail/alt-bot-fail.rs index 8b39450be86..dcca16590a5 100644 --- a/src/test/run-fail/alt-bot-fail.rs +++ b/src/test/run-fail/alt-bot-fail.rs @@ -4,6 +4,6 @@ fn foo(s: str) { } fn main() { let i = - alt some::(3) { none::. { fail } some::(_) { fail } }; + alt some::(3) { none:: { fail } some::(_) { fail } }; foo(i); } diff --git a/src/test/run-fail/non-exhaustive-match.rs b/src/test/run-fail/non-exhaustive-match.rs index 4afd83c1b97..829477ce71a 100644 --- a/src/test/run-fail/non-exhaustive-match.rs +++ b/src/test/run-fail/non-exhaustive-match.rs @@ -6,4 +6,4 @@ // error-pattern:non-exhaustive match failure tag t { a; b; } -fn main() { let x = a; alt x { b. { } } } +fn main() { let x = a; alt x { b { } } } diff --git a/src/test/run-pass/alt-join.rs b/src/test/run-pass/alt-join.rs index e1ed1ac6c0b..687cf30f97f 100644 --- a/src/test/run-pass/alt-join.rs +++ b/src/test/run-pass/alt-join.rs @@ -12,7 +12,7 @@ fn foo(y: option::t) { entire if expression */ if true { - } else { alt y { none::. { x = 17; } _ { x = 42; } } rs += [x]; } + } else { alt y { none:: { x = 17; } _ { x = 42; } } rs += [x]; } ret; } diff --git a/src/test/run-pass/alt-path.rs b/src/test/run-pass/alt-path.rs index 84d79220f90..bc2d3463959 100644 --- a/src/test/run-pass/alt-path.rs +++ b/src/test/run-pass/alt-path.rs @@ -4,6 +4,6 @@ mod m1 { tag foo { foo1; foo2; } } -fn bar(x: m1::foo) { alt x { m1::foo1. { } } } +fn bar(x: m1::foo) { alt x { m1::foo1 { } } } fn main() { } diff --git a/src/test/run-pass/alt-pattern-no-type-params.rs b/src/test/run-pass/alt-pattern-no-type-params.rs index 1cd5aa85758..e9c94962452 100644 --- a/src/test/run-pass/alt-pattern-no-type-params.rs +++ b/src/test/run-pass/alt-pattern-no-type-params.rs @@ -1,7 +1,7 @@ tag maybe { nothing; just(T); } fn foo(x: maybe) { - alt x { nothing. { #error("A"); } just(a) { #error("B"); } } + alt x { nothing { #error("A"); } just(a) { #error("B"); } } } fn main() { } diff --git a/src/test/run-pass/alt-phi.rs b/src/test/run-pass/alt-phi.rs index 34f2e5410a4..67b4a9b6a12 100644 --- a/src/test/run-pass/alt-phi.rs +++ b/src/test/run-pass/alt-phi.rs @@ -7,8 +7,8 @@ fn foo(it: block(int)) { it(10); } fn main() { let x = true; alt a { - a. { x = true; foo {|_i|} } - b. { x = false; } - c. { x = false; } + a { x = true; foo {|_i|} } + b { x = false; } + c { x = false; } } } diff --git a/src/test/run-pass/alt-str.rs b/src/test/run-pass/alt-str.rs index e51263db804..884a4da8a3d 100644 --- a/src/test/run-pass/alt-str.rs +++ b/src/test/run-pass/alt-str.rs @@ -7,7 +7,7 @@ fn main() { alt tag1("test") { - tag2. { fail; } + tag2 { fail; } tag1("not-test") { fail; } tag1("test") { } _ { fail; } diff --git a/src/test/run-pass/issue-687.rs b/src/test/run-pass/issue-687.rs index 8ff6b4bab27..cbdadda8e88 100644 --- a/src/test/run-pass/issue-687.rs +++ b/src/test/run-pass/issue-687.rs @@ -49,7 +49,7 @@ fn main() { while true { let msg = recv(p); alt msg { - closed. { #debug("Got close message"); break; } + closed { #debug("Got close message"); break; } received(data) { #debug("Got data. Length is:"); log(debug, vec::len::(data)); diff --git a/src/test/run-pass/nested-alts.rs b/src/test/run-pass/nested-alts.rs index 09481d7e084..29ffe6e4bc0 100644 --- a/src/test/run-pass/nested-alts.rs +++ b/src/test/run-pass/nested-alts.rs @@ -5,10 +5,10 @@ fn foo() { alt some::(5) { some::(x) { let bar; - alt none:: { none::. { bar = 5; } _ { baz(); } } + alt none:: { none:: { bar = 5; } _ { baz(); } } log(debug, bar); } - none::. { #debug("hello"); } + none:: { #debug("hello"); } } } diff --git a/src/test/run-pass/nullary-or-pattern.rs b/src/test/run-pass/nullary-or-pattern.rs index 8d4609f95d0..661d5cc7a38 100644 --- a/src/test/run-pass/nullary-or-pattern.rs +++ b/src/test/run-pass/nullary-or-pattern.rs @@ -1,7 +1,7 @@ tag blah { a; b; } fn or_alt(q: blah) -> int { - alt q { a. | b. { 42 } } + alt q { a | b { 42 } } } fn main() { diff --git a/src/test/run-pass/or-pattern.rs b/src/test/run-pass/or-pattern.rs index 9aa6694892d..cc86fbd3e8b 100644 --- a/src/test/run-pass/or-pattern.rs +++ b/src/test/run-pass/or-pattern.rs @@ -1,7 +1,7 @@ tag blah { a(int, int, uint); b(int, int); c; } fn or_alt(q: blah) -> int { - alt q { a(x, y, _) | b(x, y) { ret x + y; } c. { ret 0; } } + alt q { a(x, y, _) | b(x, y) { ret x + y; } c { ret 0; } } } fn main() { diff --git a/src/test/run-pass/simple-alt-generic-tag.rs b/src/test/run-pass/simple-alt-generic-tag.rs index 3b0776fcd55..fd499bddd8f 100644 --- a/src/test/run-pass/simple-alt-generic-tag.rs +++ b/src/test/run-pass/simple-alt-generic-tag.rs @@ -4,5 +4,5 @@ tag opt { none; } fn main() { let x = none::; - alt x { none::. { #debug("hello world"); } } + alt x { none:: { #debug("hello world"); } } } diff --git a/src/test/run-pass/size-and-align.rs b/src/test/run-pass/size-and-align.rs index d0c4a2f270b..34b2ce242ca 100644 --- a/src/test/run-pass/size-and-align.rs +++ b/src/test/run-pass/size-and-align.rs @@ -7,7 +7,7 @@ tag clam { a(T, int); b; } fn uhoh(v: [clam]) { alt v[1] { a::(t, u) { #debug("incorrect"); log(debug, u); fail; } - b::. { #debug("correct"); } + b:: { #debug("correct"); } } } diff --git a/src/test/run-pass/tag-variant-disr-val.rs b/src/test/run-pass/tag-variant-disr-val.rs index 1efe40d547d..588b4107f13 100644 --- a/src/test/run-pass/tag-variant-disr-val.rs +++ b/src/test/run-pass/tag-variant-disr-val.rs @@ -26,12 +26,12 @@ fn test_color(color: color, val: int, name: str) unsafe { fn get_color_alt(color: color) -> str { alt color { - red. {"red"} - green. {"green"} - blue. {"blue"} - black. {"black"} - white. {"white"} - imaginary. {"imaginary"} + red {"red"} + green {"green"} + blue {"blue"} + black {"black"} + white {"white"} + imaginary {"imaginary"} _ {"unknown"} } } diff --git a/src/test/run-pass/use-uninit-alt.rs b/src/test/run-pass/use-uninit-alt.rs index 5e77cf8f684..8b273543549 100644 --- a/src/test/run-pass/use-uninit-alt.rs +++ b/src/test/run-pass/use-uninit-alt.rs @@ -2,7 +2,7 @@ fn foo(o: myoption) -> int { let x: int = 5; - alt o { none::. { } some::(t) { x += 1; } } + alt o { none:: { } some::(t) { x += 1; } } ret x; } diff --git a/src/test/run-pass/use-uninit-alt2.rs b/src/test/run-pass/use-uninit-alt2.rs index cd54239ec56..cccb1ac14d7 100644 --- a/src/test/run-pass/use-uninit-alt2.rs +++ b/src/test/run-pass/use-uninit-alt2.rs @@ -2,7 +2,7 @@ fn foo(o: myoption) -> int { let x: int; - alt o { none::. { fail; } some::(t) { x = 5; } } + alt o { none:: { fail; } some::(t) { x = 5; } } ret x; }