From 768e7889c03323f9d777cf19bfd0b4f55cd70120 Mon Sep 17 00:00:00 2001 From: Paul Woolcock Date: Sun, 29 Jan 2012 19:43:11 -0500 Subject: [PATCH 1/4] Alter/remove tests that include/concern ternary 3 tests, pretty/block-disambig.rs, run-pass/operator-overloading.rs, and run-pass/weird-exprs.rs, all included the ternary operator. These were changed to use the if-then-else construct instead. 2 tests, run-pass/block-arg-in-ternary.rs and run-pass/ternary.rs, were only there because of the ternary operator, and were removed. --- src/test/pretty/block-disambig.rs | 2 +- src/test/run-pass/block-arg-in-ternary.rs | 6 ---- src/test/run-pass/operator-overloading.rs | 2 +- src/test/run-pass/ternary.rs | 43 ----------------------- src/test/run-pass/weird-exprs.rs | 2 +- 5 files changed, 3 insertions(+), 52 deletions(-) delete mode 100644 src/test/run-pass/block-arg-in-ternary.rs delete mode 100644 src/test/run-pass/ternary.rs diff --git a/src/test/pretty/block-disambig.rs b/src/test/pretty/block-disambig.rs index 7913f1e33bec0..545fe2c12ff7b 100644 --- a/src/test/pretty/block-disambig.rs +++ b/src/test/pretty/block-disambig.rs @@ -24,7 +24,7 @@ fn test7() -> uint { (*regs < 2) as uint } -fn test8() -> int { let val = @0; alt true { true { } } *val < 1 ? 0 : 1 } +fn test8() -> int { let val = @0; alt true { true { } } if *val < 1 { 0 } else { 1 } } fn test9() { let regs = @mutable 0; alt true { true { } } *regs += 1; } diff --git a/src/test/run-pass/block-arg-in-ternary.rs b/src/test/run-pass/block-arg-in-ternary.rs deleted file mode 100644 index 84ad2da4f4e84..0000000000000 --- a/src/test/run-pass/block-arg-in-ternary.rs +++ /dev/null @@ -1,6 +0,0 @@ -// Allow block arguments with ternary... why not, no chance of ambig. -fn main() { - let v = [-1f, 1f]; - let foo = vec::any(v) { |e| float::is_negative(e) } ? true : false; - assert foo; -} diff --git a/src/test/run-pass/operator-overloading.rs b/src/test/run-pass/operator-overloading.rs index 42933578b3bc3..7fc995f93875f 100644 --- a/src/test/run-pass/operator-overloading.rs +++ b/src/test/run-pass/operator-overloading.rs @@ -11,7 +11,7 @@ impl point_ops for point { {x: -self.x, y: -self.y} } fn [](x: bool) -> int { - x ? self.x : self.y + if x { self.x } else { self.y } } } diff --git a/src/test/run-pass/ternary.rs b/src/test/run-pass/ternary.rs deleted file mode 100644 index 6adfada2c90e9..0000000000000 --- a/src/test/run-pass/ternary.rs +++ /dev/null @@ -1,43 +0,0 @@ -fn test_simple() { let x = true ? 10 : 11; assert (x == 10); } - -fn test_precedence() { - let x; - - x = true || true ? 10 : 11; - assert (x == 10); - - x = true == false ? 10 : 11; - assert (x == 11); - - x = true ? false ? 10 : 11 : 12; - assert (x == 11); - - let y = true ? 0xF0 : 0x0 | 0x0F; - assert (y == 0xF0); - - y = true ? 0xF0 | 0x0F : 0x0; - assert (y == 0xFF); -} - -fn test_associativity() { - // Ternary is right-associative - let x = false ? 10 : false ? 11 : 12; - assert (x == 12); -} - -fn test_lval() { - let box1: @mutable int = @mutable 10; - let box2: @mutable int = @mutable 10; - *(true ? box1 : box2) = 100; - assert (*box1 == 100); -} - -fn test_as_stmt() { let s; true ? s = 10 : s = 12; assert (s == 10); } - -fn main() { - test_simple(); - test_precedence(); - test_associativity(); - test_lval(); - test_as_stmt(); -} diff --git a/src/test/run-pass/weird-exprs.rs b/src/test/run-pass/weird-exprs.rs index 6b110e9e275a6..a373c3baf0ae2 100644 --- a/src/test/run-pass/weird-exprs.rs +++ b/src/test/run-pass/weird-exprs.rs @@ -19,7 +19,7 @@ fn zombiejesus() { do { while (ret) { if (ret) { - alt (ret) { _ { ret ? ret : ret } }; + alt (ret) { _ { if ret { ret } else { ret } } }; } else if (ret) { ret; } From f296836ab4d1b53234bfd52f47e99c0db030488a Mon Sep 17 00:00:00 2001 From: Paul Woolcock Date: Sun, 29 Jan 2012 21:33:08 -0500 Subject: [PATCH 2/4] Change all ternary ops to if/then/else All the files below had at least one instance of the ternary operator present in the source. All have been changed to the equivalent if/then/else expression. --- src/comp/driver/driver.rs | 6 ++++- src/comp/front/test.rs | 2 +- src/comp/middle/alias.rs | 15 ++++++----- src/comp/middle/check_const.rs | 4 +-- src/comp/middle/debuginfo.rs | 16 +++++++---- src/comp/middle/resolve.rs | 9 ++++--- src/comp/middle/trans/alt.rs | 13 ++++++--- src/comp/middle/trans/base.rs | 21 ++++++++++----- src/comp/middle/trans/tvec.rs | 23 +++++++++++----- src/comp/middle/typeck.rs | 12 +++++++-- src/comp/syntax/ast_util.rs | 40 +++++++++++++++++++++++++--- src/comp/syntax/parse/lexer.rs | 20 +++++++------- src/comp/syntax/parse/parser.rs | 44 ++++++++++++++++++++++++------- src/comp/util/ppaux.rs | 4 +-- src/libcore/float.rs | 2 +- src/libcore/math.rs | 6 ++--- src/libstd/md4.rs | 2 +- src/test/pretty/block-disambig.rs | 12 ++++++++- 18 files changed, 183 insertions(+), 68 deletions(-) diff --git a/src/comp/driver/driver.rs b/src/comp/driver/driver.rs index 75749722823d9..78ec0330dd96a 100644 --- a/src/comp/driver/driver.rs +++ b/src/comp/driver/driver.rs @@ -333,7 +333,11 @@ fn host_triple() -> str { // grabbing (at compile time) the target triple that this rustc is // built with and calling that (at runtime) the host triple. let ht = #env("CFG_HOST_TRIPLE"); - ret ht != "" ? ht : fail "rustc built without CFG_HOST_TRIPLE"; + ret if ht != "" { + ht + } else { + fail "rustc built without CFG_HOST_TRIPLE" + }; } fn build_session_options(match: getopts::match, diff --git a/src/comp/front/test.rs b/src/comp/front/test.rs index 05eedf09bd712..79ed350932610 100644 --- a/src/comp/front/test.rs +++ b/src/comp/front/test.rs @@ -244,7 +244,7 @@ fn mk_path(cx: test_ctxt, path: [ast::ident]) -> [ast::ident] { _ { false } } }; - (is_std ? [] : ["std"]) + path + (if is_std { [] } else { ["std"] }) + path } // The ast::ty of [std::test::test_desc] diff --git a/src/comp/middle/alias.rs b/src/comp/middle/alias.rs index 10a45349d4a92..0d4ecee7dea8f 100644 --- a/src/comp/middle/alias.rs +++ b/src/comp/middle/alias.rs @@ -602,23 +602,26 @@ fn pattern_roots(tcx: ty::ctxt, mut: option::t, pat: @ast::pat) ast::pat_rec(fs, _) { let ty = ty::node_id_to_type(tcx, pat.id); for f in fs { - let m = ty::get_field(tcx, ty, f.ident).mt.mut != ast::imm; - walk(tcx, m ? some(contains(ty)) : mut, f.pat, set); + let m = ty::get_field(tcx, ty, f.ident).mt.mut != ast::imm, + c = if m { some(contains(ty)) } else { mut }; + walk(tcx, c, f.pat, set); } } ast::pat_box(p) { let ty = ty::node_id_to_type(tcx, pat.id); let m = alt ty::struct(tcx, ty) { ty::ty_box(mt) { mt.mut != ast::imm } - }; - walk(tcx, m ? some(contains(ty)) : mut, p, set); + }, + c = if m {some(contains(ty)) } else { mut }; + walk(tcx, c, p, set); } ast::pat_uniq(p) { let ty = ty::node_id_to_type(tcx, pat.id); let m = alt ty::struct(tcx, ty) { ty::ty_uniq(mt) { mt.mut != ast::imm } - }; - walk(tcx, m ? some(contains(ty)) : mut, p, set); + }, + c = if m { some(contains(ty)) } else { mut }; + walk(tcx, c, p, set); } } } diff --git a/src/comp/middle/check_const.rs b/src/comp/middle/check_const.rs index eec014a47f727..d04abffb3201d 100644 --- a/src/comp/middle/check_const.rs +++ b/src/comp/middle/check_const.rs @@ -73,14 +73,14 @@ fn check_expr(sess: session, method_map: typeck::method_map, e: @expr, expr_lit(@{node: lit_int(v, t), _}) { if t != ty_char { if (v as u64) > ast_util::int_ty_max( - t == ty_i ? sess.targ_cfg.int_type : t) { + if t == ty_i { sess.targ_cfg.int_type } else { t }) { sess.span_err(e.span, "literal out of range for its type"); } } } expr_lit(@{node: lit_uint(v, t), _}) { if v > ast_util::uint_ty_max( - t == ty_u ? sess.targ_cfg.uint_type : t) { + if t == ty_u { sess.targ_cfg.uint_type } else { t }) { sess.span_err(e.span, "literal out of range for its type"); } } diff --git a/src/comp/middle/debuginfo.rs b/src/comp/middle/debuginfo.rs index 05752acbcd4c3..8c92cc16deec3 100644 --- a/src/comp/middle/debuginfo.rs +++ b/src/comp/middle/debuginfo.rs @@ -456,10 +456,16 @@ fn create_composite_type(type_tag: int, name: str, file: ValueRef, line: int, lli64(align), // align lli64(offset), // offset lli32(0), // flags - option::is_none(derived) ? llnull() : // derived from - option::get(derived), - option::is_none(members) ? llnull() : // members - llmdnode(option::get(members)), + if option::is_none(derived) { + llnull() + } else { // derived from + option::get(derived) + }, + if option::is_none(members) { + llnull() + } else { //members + llmdnode(option::get(members)) + }, lli32(0), // runtime language llnull() ]; @@ -766,7 +772,7 @@ fn create_function(fcx: @fn_ctxt, sp: span) -> @metadata { let loc = codemap::lookup_char_pos(cx.sess.codemap, sp.lo); let file_node = create_file(cx, loc.filename).node; - let key = cx.item_symbols.contains_key(fcx.id) ? fcx.id : id; + let key = if cx.item_symbols.contains_key(fcx.id) { fcx.id } else { id }; let mangled = cx.item_symbols.get(key); let ty_node = if cx.sess.opts.extra_debuginfo { alt ret_ty.node { diff --git a/src/comp/middle/resolve.rs b/src/comp/middle/resolve.rs index e08de3d55e798..dbd6177bf7c17 100644 --- a/src/comp/middle/resolve.rs +++ b/src/comp/middle/resolve.rs @@ -1986,7 +1986,7 @@ fn visit_block_with_impl_scope(e: @env, b: ast::blk, sc: iscopes, _ {} } } - let sc = vec::len(impls) > 0u ? cons(@impls, @sc) : sc; + let sc = if vec::len(impls) > 0u { cons(@impls, @sc) } else { sc }; visit::visit_block(b, sc, v); } @@ -1998,8 +1998,11 @@ fn visit_mod_with_impl_scope(e: @env, m: ast::_mod, s: span, id: node_id, } for i in m.items { find_impls_in_item(*e, i, impls, none, none); } let impls = @impls; - visit::visit_mod(m, s, id, - vec::len(*impls) > 0u ? cons(impls, @sc) : sc, v); + visit::visit_mod(m, s, id, if vec::len(*impls) > 0u { + cons(impls, @sc) + } else { + sc + }, v); e.impl_map.insert(id, cons(impls, @nil)); } diff --git a/src/comp/middle/trans/alt.rs b/src/comp/middle/trans/alt.rs index 9cca779a37b78..74ffab2a4ccdf 100644 --- a/src/comp/middle/trans/alt.rs +++ b/src/comp/middle/trans/alt.rs @@ -401,8 +401,11 @@ fn compile_submatch(bcx: @block_ctxt, m: match, vals: [ValueRef], f: mk_fail, let col = pick_col(m); let val = vals[col]; - let m = has_nested_bindings(m, col) ? - expand_nested_bindings(m, col, val) : m; + let m = if has_nested_bindings(m, col) { + expand_nested_bindings(m, col, val) + } else { + m + }; let vals_left = vec::slice(vals, 0u, col) + @@ -492,7 +495,11 @@ fn compile_submatch(bcx: @block_ctxt, m: match, vals: [ValueRef], f: mk_fail, lit(l) { test_val = Load(bcx, val); let pty = ty::node_id_to_monotype(ccx.tcx, pat_id); - kind = ty::type_is_integral(ccx.tcx, pty) ? switch : compare; + kind = if ty::type_is_integral(ccx.tcx, pty) { + switch + } else { + compare + }; } range(_, _) { test_val = Load(bcx, val); diff --git a/src/comp/middle/trans/base.rs b/src/comp/middle/trans/base.rs index 9b423be389e43..02c7147582682 100644 --- a/src/comp/middle/trans/base.rs +++ b/src/comp/middle/trans/base.rs @@ -68,7 +68,7 @@ fn type_of_explicit_args(cx: @crate_ctxt, inputs: [ty::arg]) -> // that would obviate the need for this check check non_ty_var(cx, arg_ty); let llty = type_of_inner(cx, arg_ty); - atys += [arg.mode == ast::by_val ? llty : T_ptr(llty)]; + atys += [if arg.mode == ast::by_val { llty } else { T_ptr(llty) }]; } ret atys; } @@ -2015,8 +2015,11 @@ fn store_temp_expr(cx: @block_ctxt, action: copy_action, dst: ValueRef, -> @block_ctxt { // Lvals in memory are not temporaries. Copy them. if src.kind != temporary && !last_use { - let v = src.kind == owned ? load_if_immediate(cx, src.val, t) - : src.val; + let v = if src.kind == owned { + load_if_immediate(cx, src.val, t) + } else { + src.val + }; ret copy_val(cx, action, dst, v, t); } ret move_val(cx, action, dst, src, t); @@ -3413,7 +3416,7 @@ fn trans_expr_save_in(bcx: @block_ctxt, e: @ast::expr, dest: ValueRef) -> @block_ctxt { let tcx = bcx_tcx(bcx), t = ty::expr_ty(tcx, e); let do_ignore = ty::type_is_bot(tcx, t) || ty::type_is_nil(tcx, t); - ret trans_expr(bcx, e, do_ignore ? ignore : save_in(dest)); + ret trans_expr(bcx, e, if do_ignore { ignore } else { save_in(dest) }); } // Call this to compile an expression that you need as an intermediate value, @@ -4241,7 +4244,7 @@ fn trans_block_dps(bcx: @block_ctxt, b: ast::blk, dest: dest) some(e) { let bt = ty::type_is_bot(bcx_tcx(bcx), ty::expr_ty(bcx_tcx(bcx), e)); debuginfo::update_source_pos(bcx, e.span); - bcx = trans_expr(bcx, e, bt ? ignore : dest); + bcx = trans_expr(bcx, e, if bt { ignore } else { dest }); } _ { assert dest == ignore || bcx.unreachable; } } @@ -4476,7 +4479,11 @@ fn trans_fn(cx: @local_ctxt, sp: span, decl: ast::fn_decl, body: ast::blk, llfndecl: ValueRef, ty_self: self_arg, ty_params: [ast::ty_param], id: ast::node_id) { let do_time = cx.ccx.sess.opts.stats; - let start = do_time ? time::get_time() : {sec: 0u32, usec: 0u32}; + let start = if do_time { + time::get_time() + } else { + {sec: 0u32, usec: 0u32} + }; let fcx = option::none; trans_closure(cx, decl, body, llfndecl, ty_self, ty_params, id, {|new_fcx| fcx = option::some(new_fcx);}); @@ -5379,7 +5386,7 @@ fn decl_crate_map(sess: session::session, mapname: str, let n_subcrates = 1; let cstore = sess.cstore; while cstore::have_crate_data(cstore, n_subcrates) { n_subcrates += 1; } - let mapname = sess.building_library ? mapname : "toplevel"; + let mapname = if sess.building_library { mapname } else { "toplevel" }; let sym_name = "_rust_crate_map_" + mapname; let arrtype = T_array(int_type, n_subcrates as uint); let maptype = T_struct([int_type, arrtype]); diff --git a/src/comp/middle/trans/tvec.rs b/src/comp/middle/trans/tvec.rs index 91af1ffb8454f..0b7df351d7aa1 100644 --- a/src/comp/middle/trans/tvec.rs +++ b/src/comp/middle/trans/tvec.rs @@ -149,9 +149,13 @@ fn trans_append(cx: @block_ctxt, vec_ty: ty::t, lhsptr: ValueRef, let ccx = bcx_ccx(cx); let unit_ty = ty::sequence_element_type(bcx_tcx(cx), vec_ty); let dynamic = ty::type_has_dynamic_size(bcx_tcx(cx), unit_ty); - let (lhsptr, rhs) = !dynamic ? (lhsptr, rhs) : - (PointerCast(cx, lhsptr, T_ptr(T_ptr(ccx.opaque_vec_type))), - PointerCast(cx, rhs, T_ptr(ccx.opaque_vec_type))); + let (lhsptr, rhs) = + if !dynamic { + (lhsptr, rhs) + } else { + (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_vec(_) { false } @@ -187,7 +191,11 @@ fn trans_append(cx: @block_ctxt, vec_ty: ty::t, lhsptr: ValueRef, copy_val(bcx, INIT, write_ptr, load_if_immediate(bcx, addr, unit_ty), unit_ty); - let incr = dynamic ? unit_sz : C_int(ccx, 1); + let incr = if dynamic { + unit_sz + } else { + C_int(ccx, 1) + }; Store(bcx, InBoundsGEP(bcx, write_ptr, [incr]), write_ptr_ptr); ret bcx; @@ -244,8 +252,11 @@ fn trans_add(bcx: @block_ctxt, vec_ty: ty::t, lhs: ValueRef, let bcx = copy_val(bcx, INIT, write_ptr, load_if_immediate(bcx, addr, unit_ty), unit_ty); let incr = - ty::type_has_dynamic_size(bcx_tcx(bcx), unit_ty) ? - llunitsz : C_int(ccx, 1); + if ty::type_has_dynamic_size(bcx_tcx(bcx), unit_ty) { + llunitsz + } else { + C_int(ccx, 1) + }; Store(bcx, InBoundsGEP(bcx, write_ptr, [incr]), write_ptr_ptr); ret bcx; diff --git a/src/comp/middle/typeck.rs b/src/comp/middle/typeck.rs index 8a06314a96bcd..3a656ca8829af 100644 --- a/src/comp/middle/typeck.rs +++ b/src/comp/middle/typeck.rs @@ -1635,9 +1635,17 @@ fn check_expr_with_unifier(fcx: @fn_ctxt, expr: @ast::expr, unify: unifier, fcx.ccx.tcx.sess.span_err( sp, #fmt["this function takes %u parameter%s but %u \ parameter%s supplied", expected_arg_count, - expected_arg_count == 1u ? "" : "s", + if expected_arg_count == 1u { + "" + } else { + "s" + }, supplied_arg_count, - supplied_arg_count == 1u ? " was" : "s were"]); + if supplied_arg_count == 1u { + " was" + } else { + "s were" + }]); // HACK: build an arguments list with dummy arguments to // check against let dummy = {mode: ast::by_ref, ty: ty::mk_bot(fcx.ccx.tcx)}; diff --git a/src/comp/syntax/ast_util.rs b/src/comp/syntax/ast_util.rs index 65c117cfa6bf5..32df1e95fdd62 100644 --- a/src/comp/syntax/ast_util.rs +++ b/src/comp/syntax/ast_util.rs @@ -305,10 +305,42 @@ fn lit_to_const(lit: @lit) -> const_val { fn compare_const_vals(a: const_val, b: const_val) -> int { alt (a, b) { - (const_int(a), const_int(b)) { a == b ? 0 : a < b ? -1 : 1 } - (const_uint(a), const_uint(b)) { a == b ? 0 : a < b ? -1 : 1 } - (const_float(a), const_float(b)) { a == b ? 0 : a < b ? -1 : 1 } - (const_str(a), const_str(b)) { a == b ? 0 : a < b ? -1 : 1 } + (const_int(a), const_int(b)) { + if a == b { + 0 + } else if a < b { + -1 + } else { + 1 + } + } + (const_uint(a), const_uint(b)) { + if a == b { + 0 + } else if a < b { + -1 + } else { + 1 + } + } + (const_float(a), const_float(b)) { + if a == b { + 0 + } else if a < b { + -1 + } else { + 1 + } + } + (const_str(a), const_str(b)) { + if a == b { + 0 + } else if a < b { + -1 + } else { + 1 + } + } } } diff --git a/src/comp/syntax/parse/lexer.rs b/src/comp/syntax/parse/lexer.rs index d2fbe02d63ad3..c7c0f32cff928 100644 --- a/src/comp/syntax/parse/lexer.rs +++ b/src/comp/syntax/parse/lexer.rs @@ -197,31 +197,31 @@ fn scan_number(c: char, rdr: reader) -> token::token { c = rdr.curr; n = rdr.next(); if c == 'u' || c == 'i' { - let signed = c == 'i', tp = signed ? either::left(ast::ty_i) - : either::right(ast::ty_u); + let signed = c == 'i', tp = if signed { either::left(ast::ty_i) } + else { either::right(ast::ty_u) }; rdr.bump(); c = rdr.curr; if c == '8' { rdr.bump(); - tp = signed ? either::left(ast::ty_i8) - : either::right(ast::ty_u8); + tp = if signed { either::left(ast::ty_i8) } + else { either::right(ast::ty_u8) }; } n = rdr.next(); if c == '1' && n == '6' { rdr.bump(); rdr.bump(); - tp = signed ? either::left(ast::ty_i16) - : either::right(ast::ty_u16); + tp = if signed { either::left(ast::ty_i16) } + else { either::right(ast::ty_u16) }; } else if c == '3' && n == '2' { rdr.bump(); rdr.bump(); - tp = signed ? either::left(ast::ty_i32) - : either::right(ast::ty_u32); + tp = if signed { either::left(ast::ty_i32) } + else { either::right(ast::ty_u32) }; } else if c == '6' && n == '4' { rdr.bump(); rdr.bump(); - tp = signed ? either::left(ast::ty_i64) - : either::right(ast::ty_u64); + tp = if signed { either::left(ast::ty_i64) } + else { either::right(ast::ty_u64) }; } let parsed = u64::from_str(num_str, base as u64); alt tp { diff --git a/src/comp/syntax/parse/parser.rs b/src/comp/syntax/parse/parser.rs index a7bbddfee3941..86e682ddacb10 100644 --- a/src/comp/syntax/parse/parser.rs +++ b/src/comp/syntax/parse/parser.rs @@ -538,8 +538,11 @@ fn parse_arg(p: parser) -> ast::arg { fn parse_fn_block_arg(p: parser) -> ast::arg { let m = parse_arg_mode(p); let i = parse_value_ident(p); - let t = eat(p, token::COLON) ? parse_ty(p, false) : - @spanned(p.span.lo, p.span.hi, ast::ty_infer); + let t = if eat(p, token::COLON) { + parse_ty(p, false) + } else { + @spanned(p.span.lo, p.span.hi, ast::ty_infer) + }; ret {mode: m, ty: t, ident: i, id: p.get_id()}; } @@ -676,7 +679,12 @@ fn parse_path(p: parser) -> @ast::path { fn parse_path_and_ty_param_substs(p: parser, colons: bool) -> @ast::path { let lo = p.span.lo; let path = parse_path(p); - if colons ? eat(p, token::MOD_SEP) : p.token == token::LT { + let b = if colons { + eat(p, token::MOD_SEP) + } else { + p.token == token::LT + }; + if b { let seq = parse_seq_lt_gt(some(token::COMMA), {|p| parse_ty(p, false)}, p); @spanned(lo, seq.span.hi, {types: seq.node with path.node}) @@ -1504,7 +1512,11 @@ fn parse_pat(p: parser) -> @ast::pat { _ { true } } { let name = parse_path(p); - let sub = eat(p, token::AT) ? some(parse_pat(p)) : none; + let sub = if eat(p, token::AT) { + some(parse_pat(p)) + } else { + none + }; pat = ast::pat_ident(name, sub); } else { let enum_path = parse_path_and_ty_param_substs(p, true); @@ -1546,7 +1558,11 @@ fn parse_local(p: parser, allow_init: bool) -> @ast::local { fn parse_let(p: parser) -> @ast::decl { fn parse_let_style(p: parser) -> ast::let_style { - eat(p, token::BINOP(token::AND)) ? ast::let_ref : ast::let_copy + if eat(p, token::BINOP(token::AND)) { + ast::let_ref + } else { + ast::let_copy + } } let lo = p.span.lo; let locals = [(parse_let_style(p), parse_local(p, true))]; @@ -1786,11 +1802,19 @@ fn parse_fn_decl(p: parser, purity: ast::purity) } fn parse_fn_block_decl(p: parser) -> ast::fn_decl { - let inputs = eat(p, token::OROR) ? [] : - parse_seq(token::BINOP(token::OR), token::BINOP(token::OR), - seq_sep(token::COMMA), parse_fn_block_arg, p).node; - let output = eat(p, token::RARROW) ? parse_ty(p, false) : - @spanned(p.span.lo, p.span.hi, ast::ty_infer); + let inputs = if eat(p, token::OROR) { + [] + } else { + parse_seq(token::BINOP(token::OR), + token::BINOP(token::OR), + seq_sep(token::COMMA), + parse_fn_block_arg, p).node + }; + let output = if eat(p, token::RARROW) { + parse_ty(p, false) + } else { + @spanned(p.span.lo, p.span.hi, ast::ty_infer) + }; ret {inputs: inputs, output: output, purity: ast::impure_fn, diff --git a/src/comp/util/ppaux.rs b/src/comp/util/ppaux.rs index 2ae8a860a2709..dd56304829354 100644 --- a/src/comp/util/ppaux.rs +++ b/src/comp/util/ppaux.rs @@ -24,10 +24,10 @@ fn ty_to_str(cx: ctxt, typ: t) -> str { str { let modestr = alt input.mode { ast::by_ref { - ty::type_is_immediate(cx, input.ty) ? "&&" : "" + if ty::type_is_immediate(cx, input.ty) { "&&" } else { "" } } ast::by_val { - ty::type_is_immediate(cx, input.ty) ? "" : "++" + if ty::type_is_immediate(cx, input.ty) { "" } else { "++" } } _ { mode_str(input.mode) } }; diff --git a/src/libcore/float.rs b/src/libcore/float.rs index 4023c65b118d9..ffa56129d4f5a 100644 --- a/src/libcore/float.rs +++ b/src/libcore/float.rs @@ -46,7 +46,7 @@ exact - Whether to enforce the exact number of significant digits */ fn to_str_common(num: float, digits: uint, exact: bool) -> str { if is_NaN(num) { ret "NaN"; } - let (num, accum) = num < 0.0 ? (-num, "-") : (num, ""); + let (num, accum) = if num < 0.0 { (-num, "-") } else { (num, "") }; let trunc = num as uint; let frac = num - (trunc as float); accum += uint::str(trunc); diff --git a/src/libcore/math.rs b/src/libcore/math.rs index c2982cf918a80..2552d58b4a2d6 100644 --- a/src/libcore/math.rs +++ b/src/libcore/math.rs @@ -7,14 +7,14 @@ Function: min Returns the minimum of two values */ -pure fn min(x: T, y: T) -> T { x < y ? x : y } +pure fn min(x: T, y: T) -> T { if x < y { x } else { y} } /* Function: max Returns the maximum of two values */ -pure fn max(x: T, y: T) -> T { x < y ? y : x } +pure fn max(x: T, y: T) -> T { if x < y { y } else { x } } #[test] fn test_max_min() { @@ -310,4 +310,4 @@ fn test_log_functions() { assert ln1p(float::infinity) == float::infinity; } -*/ \ No newline at end of file +*/ diff --git a/src/libstd/md4.rs b/src/libstd/md4.rs index 7b5320a5dfc29..1d6540f04e88a 100644 --- a/src/libstd/md4.rs +++ b/src/libstd/md4.rs @@ -65,7 +65,7 @@ fn md4(msg: [u8]) -> {a: u32, b: u32, c: u32, d: u32} { let j = 0u, q = 0x6ed9eba1u32; while j < 8u { - let jj = j > 2u ? j - 3u : j; + let jj = if j > 2u { j - 3u } else { j }; a = rot(3, a + (b ^ c ^ d) + x[jj] + q); d = rot(9, d + (a ^ b ^ c) + x[jj + 8u] + q); c = rot(11, c + (d ^ a ^ b) + x[jj + 4u] + q); diff --git a/src/test/pretty/block-disambig.rs b/src/test/pretty/block-disambig.rs index 545fe2c12ff7b..d1a7a9b85acfc 100644 --- a/src/test/pretty/block-disambig.rs +++ b/src/test/pretty/block-disambig.rs @@ -24,7 +24,17 @@ fn test7() -> uint { (*regs < 2) as uint } -fn test8() -> int { let val = @0; alt true { true { } } if *val < 1 { 0 } else { 1 } } +fn test8() -> int { + let val = @0; + alt true { + true { } + } + if *val < 1 { + 0 + } else { + 1 + } +} fn test9() { let regs = @mutable 0; alt true { true { } } *regs += 1; } From 3b30b7aa25d44b817c5136251fd9d7f8e0023bf9 Mon Sep 17 00:00:00 2001 From: Paul Woolcock Date: Sun, 29 Jan 2012 22:58:16 -0500 Subject: [PATCH 3/4] Fix last failing test All tests now pass, without the ternary operator. --- src/test/run-pass/weird-exprs.rs | 10 +++++++++- 1 file changed, 9 insertions(+), 1 deletion(-) diff --git a/src/test/run-pass/weird-exprs.rs b/src/test/run-pass/weird-exprs.rs index a373c3baf0ae2..4093a311b0974 100644 --- a/src/test/run-pass/weird-exprs.rs +++ b/src/test/run-pass/weird-exprs.rs @@ -19,7 +19,15 @@ fn zombiejesus() { do { while (ret) { if (ret) { - alt (ret) { _ { if ret { ret } else { ret } } }; + alt (ret) { + _ { + if (ret) { + ret + } else { + ret + } + } + }; } else if (ret) { ret; } From 7d7c0bd09479d6381b3cb56f4197fbd94773a967 Mon Sep 17 00:00:00 2001 From: Paul Woolcock Date: Mon, 30 Jan 2012 11:40:54 -0500 Subject: [PATCH 4/4] Remove ternary operator `expr_ternary`, `ternary_to_if`, and all parses & lexer definitions have been removed. --- doc/tutorial.md | 7 ------- src/comp/middle/kind.rs | 1 - src/comp/middle/last_use.rs | 3 --- src/comp/middle/trans/base.rs | 3 --- src/comp/middle/tstate/pre_post_conditions.rs | 1 - src/comp/middle/tstate/states.rs | 3 --- src/comp/middle/typeck.rs | 3 --- src/comp/syntax/ast.rs | 1 - src/comp/syntax/ast_util.rs | 17 ----------------- src/comp/syntax/fold.rs | 4 ---- src/comp/syntax/parse/lexer.rs | 4 ---- src/comp/syntax/parse/parser.rs | 15 +-------------- src/comp/syntax/parse/token.rs | 2 -- src/comp/syntax/print/pprust.rs | 18 ++++-------------- src/comp/syntax/visit.rs | 5 ----- 15 files changed, 5 insertions(+), 82 deletions(-) diff --git a/doc/tutorial.md b/doc/tutorial.md index 9a955f8a8b835..1c36bfee610e9 100644 --- a/doc/tutorial.md +++ b/doc/tutorial.md @@ -473,13 +473,6 @@ The comparison operators are the traditional `==`, `!=`, `<`, `>`, `<=`, and `>=`. Short-circuiting (lazy) boolean operators are written `&&` (and) and `||` (or). -Rust has a ternary conditional operator `?:`, as in: - -~~~~ -let badness = 12; -let message = badness < 10 ? "error" : "FATAL ERROR"; -~~~~ - For type casting, Rust uses the binary `as` operator, which has a precedence between the bitwise combination operators (`&`, `|`, `^`) and the comparison operators. It takes an expression on the left side, diff --git a/src/comp/middle/kind.rs b/src/comp/middle/kind.rs index db35362f3ea08..f3eee04b49208 100644 --- a/src/comp/middle/kind.rs +++ b/src/comp/middle/kind.rs @@ -189,7 +189,6 @@ fn check_expr(e: @expr, cx: ctx, v: visit::vt) { none {} } } - expr_ternary(_, a, b) { maybe_copy(cx, a); maybe_copy(cx, b); } expr_fn(_, _, _, cap_clause) { check_fn_cap_clause(cx, e.id, *cap_clause); } diff --git a/src/comp/middle/last_use.rs b/src/comp/middle/last_use.rs index af078afe53f20..88e60afb456c1 100644 --- a/src/comp/middle/last_use.rs +++ b/src/comp/middle/last_use.rs @@ -88,9 +88,6 @@ fn visit_expr(ex: @expr, cx: ctx, v: visit::vt) { v.visit_expr(coll, cx, v); visit_block(loop, cx) {|| visit::visit_block(blk, cx, v);} } - expr_ternary(_, _, _) { - v.visit_expr(ast_util::ternary_to_if(ex), cx, v); - } expr_alt(input, arms) { v.visit_expr(input, cx, v); let before = cx.current, sets = []; diff --git a/src/comp/middle/trans/base.rs b/src/comp/middle/trans/base.rs index 02c7147582682..94f3e8297190f 100644 --- a/src/comp/middle/trans/base.rs +++ b/src/comp/middle/trans/base.rs @@ -3474,9 +3474,6 @@ fn trans_expr(bcx: @block_ctxt, e: @ast::expr, dest: dest) -> @block_ctxt { ast::expr_if(cond, thn, els) | ast::expr_if_check(cond, thn, els) { ret trans_if(bcx, cond, thn, els, dest); } - ast::expr_ternary(_, _, _) { - ret trans_expr(bcx, ast_util::ternary_to_if(e), dest); - } ast::expr_alt(expr, arms) { // tcx.sess.span_note(e.span, "about to call trans_alt"); ret alt::trans_alt(bcx, expr, arms, dest); diff --git a/src/comp/middle/tstate/pre_post_conditions.rs b/src/comp/middle/tstate/pre_post_conditions.rs index 99bb750f3b768..987bbb4d81d14 100644 --- a/src/comp/middle/tstate/pre_post_conditions.rs +++ b/src/comp/middle/tstate/pre_post_conditions.rs @@ -415,7 +415,6 @@ fn find_pre_post_expr(fcx: fn_ctxt, e: @expr) { expr_if(antec, conseq, maybe_alt) { join_then_else(fcx, antec, conseq, maybe_alt, e.id, plain_if); } - expr_ternary(_, _, _) { find_pre_post_expr(fcx, ternary_to_if(e)); } expr_binary(bop, l, r) { if lazy_binop(bop) { find_pre_post_expr(fcx, l); diff --git a/src/comp/middle/tstate/states.rs b/src/comp/middle/tstate/states.rs index 2a976d0469f99..a125c00d63bff 100644 --- a/src/comp/middle/tstate/states.rs +++ b/src/comp/middle/tstate/states.rs @@ -466,9 +466,6 @@ fn find_pre_post_state_expr(fcx: fn_ctxt, pres: prestate, e: @expr) -> bool { ret join_then_else(fcx, antec, conseq, maybe_alt, e.id, plain_if, pres); } - expr_ternary(_, _, _) { - ret find_pre_post_state_expr(fcx, pres, ternary_to_if(e)); - } expr_binary(bop, l, r) { if lazy_binop(bop) { let changed = find_pre_post_state_expr(fcx, pres, l); diff --git a/src/comp/middle/typeck.rs b/src/comp/middle/typeck.rs index 3a656ca8829af..5badb9bc0fad4 100644 --- a/src/comp/middle/typeck.rs +++ b/src/comp/middle/typeck.rs @@ -1980,9 +1980,6 @@ fn check_expr_with_unifier(fcx: @fn_ctxt, expr: @ast::expr, unify: unifier, check_pred_expr(fcx, cond) | check_then_else(fcx, thn, elsopt, id, expr.span); } - ast::expr_ternary(_, _, _) { - bot = check_expr(fcx, ast_util::ternary_to_if(expr)); - } ast::expr_assert(e) { bot = check_expr_with(fcx, e, ty::mk_bool(tcx)); write::nil_ty(tcx, id); diff --git a/src/comp/syntax/ast.rs b/src/comp/syntax/ast.rs index 4ff96c17daadd..ee93a3e0e2958 100644 --- a/src/comp/syntax/ast.rs +++ b/src/comp/syntax/ast.rs @@ -213,7 +213,6 @@ enum expr_ { expr_lit(@lit), expr_cast(@expr, @ty), expr_if(@expr, blk, option::t<@expr>), - expr_ternary(@expr, @expr, @expr), expr_while(@expr, blk), expr_for(@local, @expr, blk), expr_do_while(blk, @expr), diff --git a/src/comp/syntax/ast_util.rs b/src/comp/syntax/ast_util.rs index 32df1e95fdd62..68b157cecb8da 100644 --- a/src/comp/syntax/ast_util.rs +++ b/src/comp/syntax/ast_util.rs @@ -205,23 +205,6 @@ fn default_block(stmts1: [@stmt], expr1: option::t<@expr>, id1: node_id) -> {view_items: [], stmts: stmts1, expr: expr1, id: id1, rules: default_blk} } -// This is a convenience function to transfor ternary expressions to if -// expressions so that they can be treated the same -fn ternary_to_if(e: @expr) -> @expr { - alt e.node { - expr_ternary(cond, then, els) { - let then_blk = block_from_expr(then); - let els_blk = block_from_expr(els); - let els_expr = - @{id: els.id, node: expr_block(els_blk), span: els.span}; - ret @{id: e.id, - node: expr_if(cond, then_blk, option::some(els_expr)), - span: e.span}; - } - _ { fail; } - } -} - // FIXME this doesn't handle big integer/float literals correctly (nor does // the rest of our literal handling) enum const_val { diff --git a/src/comp/syntax/fold.rs b/src/comp/syntax/fold.rs index b24f3aae47376..a6e10d183c36f 100644 --- a/src/comp/syntax/fold.rs +++ b/src/comp/syntax/fold.rs @@ -352,10 +352,6 @@ fn noop_fold_expr(e: expr_, fld: ast_fold) -> expr_ { expr_if(fld.fold_expr(cond), fld.fold_block(tr), option::map(fl, fld.fold_expr)) } - expr_ternary(cond, tr, fl) { - expr_ternary(fld.fold_expr(cond), fld.fold_expr(tr), - fld.fold_expr(fl)) - } expr_while(cond, body) { expr_while(fld.fold_expr(cond), fld.fold_block(body)) } diff --git a/src/comp/syntax/parse/lexer.rs b/src/comp/syntax/parse/lexer.rs index c7c0f32cff928..ae31f1b3434ea 100644 --- a/src/comp/syntax/parse/lexer.rs +++ b/src/comp/syntax/parse/lexer.rs @@ -328,10 +328,6 @@ fn next_token_inner(rdr: reader) -> token::token { // One-byte tokens. - '?' { - rdr.bump(); - ret token::QUES; - } ';' { rdr.bump(); ret token::SEMI; } ',' { rdr.bump(); ret token::COMMA; } '.' { diff --git a/src/comp/syntax/parse/parser.rs b/src/comp/syntax/parse/parser.rs index 86e682ddacb10..b50c3e3834db6 100644 --- a/src/comp/syntax/parse/parser.rs +++ b/src/comp/syntax/parse/parser.rs @@ -1097,18 +1097,6 @@ fn parse_prefix_expr(p: parser) -> pexpr { ret mk_pexpr(p, lo, hi, ex); } -fn parse_ternary(p: parser) -> @ast::expr { - let cond_expr = parse_binops(p); - if p.token == token::QUES { - p.bump(); - let then_expr = parse_expr(p); - expect(p, token::COLON); - let else_expr = parse_expr(p); - ret mk_expr(p, cond_expr.span.lo, else_expr.span.hi, - ast::expr_ternary(cond_expr, then_expr, else_expr)); - } else { ret cond_expr; } -} - type op_spec = {tok: token::token, op: ast::binop, prec: int}; @@ -1143,7 +1131,6 @@ fn parse_binops(p: parser) -> @ast::expr { const unop_prec: int = 100; const as_prec: int = 5; -const ternary_prec: int = 0; fn parse_more_binops(p: parser, plhs: pexpr, min_prec: int) -> @ast::expr { @@ -1174,7 +1161,7 @@ fn parse_more_binops(p: parser, plhs: pexpr, min_prec: int) -> fn parse_assign_expr(p: parser) -> @ast::expr { let lo = p.span.lo; - let lhs = parse_ternary(p); + let lhs = parse_binops(p); alt p.token { token::EQ { p.bump(); diff --git a/src/comp/syntax/parse/token.rs b/src/comp/syntax/parse/token.rs index 0965697f8c8b3..3b38f314ecf33 100644 --- a/src/comp/syntax/parse/token.rs +++ b/src/comp/syntax/parse/token.rs @@ -43,7 +43,6 @@ enum token { SEMI, COLON, MOD_SEP, - QUES, RARROW, LARROW, DARROW, @@ -114,7 +113,6 @@ fn to_str(r: reader, t: token) -> str { SEMI { ret ";"; } COLON { ret ":"; } MOD_SEP { ret "::"; } - QUES { ret "?"; } RARROW { ret "->"; } LARROW { ret "<-"; } DARROW { ret "<->"; } diff --git a/src/comp/syntax/print/pprust.rs b/src/comp/syntax/print/pprust.rs index b8d42aa4ade77..86203c4c7e8cb 100644 --- a/src/comp/syntax/print/pprust.rs +++ b/src/comp/syntax/print/pprust.rs @@ -856,15 +856,6 @@ fn print_expr(s: ps, &&expr: @ast::expr) { ast::expr_if_check(test, blk, elseopt) { print_if(s, test, blk, elseopt, true); } - ast::expr_ternary(test, then, els) { - print_expr(s, test); - space(s.s); - word_space(s, "?"); - print_expr(s, then); - space(s.s); - word_space(s, ":"); - print_expr(s, els); - } ast::expr_while(test, blk) { head(s, "while"); print_maybe_parens_discrim(s, test); @@ -1045,8 +1036,8 @@ fn print_expr_parens_if_not_bot(s: ps, ex: @ast::expr) { let parens = alt ex.node { ast::expr_fail(_) | ast::expr_ret(_) | ast::expr_binary(_, _, _) | ast::expr_unary(_, _) | - ast::expr_ternary(_, _, _) | ast::expr_move(_, _) | - ast::expr_copy(_) | ast::expr_assign(_, _) | ast::expr_be(_) | + ast::expr_move(_, _) | ast::expr_copy(_) | + ast::expr_assign(_, _) | ast::expr_be(_) | ast::expr_assign_op(_, _, _) | ast::expr_swap(_, _) | ast::expr_log(_, _, _) | ast::expr_assert(_) | ast::expr_call(_, _, true) | @@ -1396,7 +1387,6 @@ fn need_parens(expr: @ast::expr, outer_prec: int) -> bool { alt expr.node { ast::expr_binary(op, _, _) { operator_prec(op) < outer_prec } ast::expr_cast(_, _) { parse::parser::as_prec < outer_prec } - ast::expr_ternary(_, _, _) { parse::parser::ternary_prec < outer_prec } // This may be too conservative in some cases ast::expr_assign(_, _) { true } ast::expr_move(_, _) { true } @@ -1758,8 +1748,8 @@ fn ends_in_lit_int(ex: @ast::expr) -> bool { alt ex.node { ast::expr_lit(@{node: ast::lit_int(_, ast::ty_i), _}) { true } ast::expr_binary(_, _, sub) | ast::expr_unary(_, sub) | - ast::expr_ternary(_, _, sub) | ast::expr_move(_, sub) | - ast::expr_copy(sub) | ast::expr_assign(_, sub) | ast::expr_be(sub) | + ast::expr_move(_, sub) | ast::expr_copy(sub) | + ast::expr_assign(_, sub) | ast::expr_be(sub) | ast::expr_assign_op(_, _, sub) | ast::expr_swap(_, sub) | ast::expr_log(_, _, sub) | ast::expr_assert(sub) | ast::expr_check(_, sub) { ends_in_lit_int(sub) } diff --git a/src/comp/syntax/visit.rs b/src/comp/syntax/visit.rs index ba99519285954..1fb6991256e10 100644 --- a/src/comp/syntax/visit.rs +++ b/src/comp/syntax/visit.rs @@ -312,11 +312,6 @@ fn visit_expr(ex: @expr, e: E, v: vt) { v.visit_block(b, e, v); visit_expr_opt(eo, e, v); } - expr_ternary(c, t, el) { - v.visit_expr(c, e, v); - v.visit_expr(t, e, v); - v.visit_expr(el, e, v); - } expr_while(x, b) { v.visit_expr(x, e, v); v.visit_block(b, e, v); } expr_for(dcl, x, b) { v.visit_local(dcl, e, v);