From cf50e1d147738865b2ee196a07df9b8fb24c9583 Mon Sep 17 00:00:00 2001 From: Tim Chevalier Date: Sat, 27 Oct 2012 17:14:09 -0700 Subject: [PATCH 1/2] Preserve parenthesization in the AST for better pretty-printing, as per #1458 --- src/libsyntax/ast.rs | 5 +- src/libsyntax/fold.rs | 3 +- src/libsyntax/parse/classify.rs | 36 ----- src/libsyntax/parse/parser.rs | 129 +++++++----------- src/libsyntax/print/pprust.rs | 83 +++-------- src/libsyntax/visit.rs | 1 + src/rustc/middle/check_const.rs | 2 + src/rustc/middle/const_eval.rs | 4 +- src/rustc/middle/liveness.rs | 7 +- src/rustc/middle/mem_categorization.rs | 2 + src/rustc/middle/trans/consts.rs | 1 + src/rustc/middle/trans/expr.rs | 13 +- src/rustc/middle/trans/type_use.rs | 1 + src/rustc/middle/ty.rs | 20 +-- src/rustc/middle/typeck/check.rs | 28 ++-- src/rustc/middle/typeck/check/alt.rs | 8 +- src/rustc/middle/typeck/check/vtable.rs | 5 + src/test/compile-fail/trait-cast.rs | 3 + src/test/run-fail/zip-different-lengths.rs | 8 +- .../run-pass/syntax-extension-source-utils.rs | 6 +- 20 files changed, 148 insertions(+), 217 deletions(-) diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs index 60f22f1b844e1..a3e57716d173f 100644 --- a/src/libsyntax/ast.rs +++ b/src/libsyntax/ast.rs @@ -744,7 +744,10 @@ enum expr_ { expr_struct(@path, ~[field], Option<@expr>), // A vector literal constructed from one repeated element. - expr_repeat(@expr /* element */, @expr /* count */, mutability) + expr_repeat(@expr /* element */, @expr /* count */, mutability), + + // No-op: used solely so we can pretty-print faithfully + expr_paren(@expr) } #[auto_serialize] diff --git a/src/libsyntax/fold.rs b/src/libsyntax/fold.rs index e2b6e6daa2fa2..5fe3c8feea690 100644 --- a/src/libsyntax/fold.rs +++ b/src/libsyntax/fold.rs @@ -494,7 +494,8 @@ fn noop_fold_expr(e: expr_, fld: ast_fold) -> expr_ { expr_struct(fld.fold_path(path), vec::map(fields, |x| fold_field(*x)), option::map(&maybe_expr, |x| fld.fold_expr(*x))) - } + }, + expr_paren(ex) => expr_paren(fld.fold_expr(ex)) } } diff --git a/src/libsyntax/parse/classify.rs b/src/libsyntax/parse/classify.rs index ff3abb5379e0a..2f3e29bd90ff3 100644 --- a/src/libsyntax/parse/classify.rs +++ b/src/libsyntax/parse/classify.rs @@ -36,39 +36,3 @@ fn stmt_ends_with_semi(stmt: ast::stmt) -> bool { } } } - -fn need_parens(expr: @ast::expr, outer_prec: uint) -> bool { - match expr.node { - ast::expr_binary(op, _, _) => operator_prec(op) < outer_prec, - ast::expr_cast(_, _) => parse::prec::as_prec < outer_prec, - // This may be too conservative in some cases - ast::expr_assign(_, _) => true, - ast::expr_swap(_, _) => true, - ast::expr_assign_op(_, _, _) => true, - ast::expr_ret(_) => true, - ast::expr_assert(_) => true, - ast::expr_log(_, _, _) => true, - _ => !parse::classify::expr_requires_semi_to_be_stmt(expr) - } -} - -fn ends_in_lit_int(ex: @ast::expr) -> bool { - match ex.node { - ast::expr_lit(node) => match node { - @{node: ast::lit_int(_, ast::ty_i), _} - | @{node: ast::lit_int_unsuffixed(_), _} => true, - _ => false - }, - ast::expr_binary(_, _, sub) | ast::expr_unary(_, sub) | - ast::expr_copy(sub) | ast::expr_assign(_, sub) | - ast::expr_assign_op(_, _, sub) | ast::expr_swap(_, sub) | - ast::expr_log(_, _, sub) | ast::expr_assert(sub) => { - ends_in_lit_int(sub) - } - ast::expr_fail(osub) | ast::expr_ret(osub) => match osub { - Some(ex) => ends_in_lit_int(ex), - _ => false - }, - _ => false - } -} diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs index b9a7166701225..a5bc5013c1759 100644 --- a/src/libsyntax/parse/parser.rs +++ b/src/libsyntax/parse/parser.rs @@ -36,11 +36,11 @@ use ast::{_mod, add, arg, arm, attribute, expr_call, expr_cast, expr_copy, expr_do_body, expr_fail, expr_field, expr_fn, expr_fn_block, expr_if, expr_index, expr_lit, expr_log, expr_loop, expr_loop_body, expr_mac, - expr_path, expr_rec, expr_repeat, expr_ret, expr_swap, - expr_struct, expr_tup, expr_unary, expr_unary_move, expr_vec, - expr_vstore, expr_while, extern_fn, field, fn_decl, foreign_item, - foreign_item_const, foreign_item_fn, foreign_mod, ident, - impure_fn, infer, inherited, + expr_paren, expr_path, expr_rec, expr_repeat, expr_ret, + expr_swap, expr_struct, expr_tup, expr_unary, expr_unary_move, + expr_vec, expr_vstore, expr_while, extern_fn, field, fn_decl, + foreign_item, foreign_item_const, foreign_item_fn, foreign_mod, + ident, impure_fn, infer, inherited, item, item_, item_class, item_const, item_enum, item_fn, item_foreign_mod, item_impl, item_mac, item_mod, item_trait, item_ty, lit, lit_, lit_bool, lit_float, lit_int, @@ -94,18 +94,6 @@ enum restriction { enum file_type { CRATE_FILE, SOURCE_FILE, } - -// We don't allow single-entry tuples in the true AST; that indicates a -// parenthesized expression. However, we preserve them temporarily while -// parsing because `(while{...})+3` parses differently from `while{...}+3`. -// -// To reflect the fact that the @expr is not a true expr that should be -// part of the AST, we wrap such expressions in the pexpr enum. They -// can then be converted to true expressions by a call to `to_expr()`. -enum pexpr { - pexpr(@expr), -} - enum class_member { field_member(@struct_field), method_member(@method) @@ -141,11 +129,11 @@ macro_rules! maybe_whole_expr ( ($p:expr) => { match copy $p.token { INTERPOLATED(token::nt_expr(e)) => { $p.bump(); - return pexpr(e); + return e; } INTERPOLATED(token::nt_path(pt)) => { $p.bump(); - return $p.mk_pexpr($p.span.lo, $p.span.lo, + return $p.mk_expr($p.span.lo, $p.span.lo, expr_path(pt)); } _ => () @@ -850,18 +838,7 @@ impl Parser { node: expr_lit(lv_lit), span: span}; } - fn mk_pexpr(lo: uint, hi: uint, node: expr_) -> pexpr { - return pexpr(self.mk_expr(lo, hi, node)); - } - - fn to_expr(e: pexpr) -> @expr { - match e.node { - expr_tup(es) if vec::len(es) == 1u => es[0u], - _ => *e - } - } - - fn parse_bottom_expr() -> pexpr { + fn parse_bottom_expr() -> @expr { maybe_whole_expr!(self); let lo = self.span.lo; let mut hi = self.span.hi; @@ -869,7 +846,7 @@ impl Parser { let mut ex: expr_; match self.maybe_parse_dollar_mac() { - Some(x) => return pexpr(self.mk_mac_expr(lo, self.span.hi, x)), + Some(x) => return self.mk_mac_expr(lo, self.span.hi, x), _ => () } @@ -879,7 +856,7 @@ impl Parser { hi = self.span.hi; self.bump(); let lit = @spanned(lo, hi, lit_nil); - return self.mk_pexpr(lo, hi, expr_lit(lit)); + return self.mk_expr(lo, hi, expr_lit(lit)); } let mut es = ~[self.parse_expr()]; while self.token == token::COMMA { @@ -888,12 +865,12 @@ impl Parser { hi = self.span.hi; self.expect(token::RPAREN); - // Note: we retain the expr_tup() even for simple - // parenthesized expressions, but only for a "little while". - // This is so that wrappers around parse_bottom_expr() - // can tell whether the expression was parenthesized or not, - // which affects expr_is_complete(). - return self.mk_pexpr(lo, hi, expr_tup(es)); + return if es.len() == 1 { + self.mk_expr(lo, self.span.hi, expr_paren(es[0])) + } + else { + self.mk_expr(lo, hi, expr_tup(es)) + } } else if self.token == token::LBRACE { if self.looking_at_record_literal() { ex = self.parse_record_literal(); @@ -901,32 +878,32 @@ impl Parser { } else { self.bump(); let blk = self.parse_block_tail(lo, default_blk); - return self.mk_pexpr(blk.span.lo, blk.span.hi, + return self.mk_expr(blk.span.lo, blk.span.hi, expr_block(blk)); } } else if token::is_bar(self.token) { - return pexpr(self.parse_lambda_expr()); + return self.parse_lambda_expr(); } else if self.eat_keyword(~"if") { - return pexpr(self.parse_if_expr()); + return self.parse_if_expr(); } else if self.eat_keyword(~"for") { - return pexpr(self.parse_sugary_call_expr(~"for", expr_loop_body)); + return self.parse_sugary_call_expr(~"for", expr_loop_body); } else if self.eat_keyword(~"do") { - return pexpr(self.parse_sugary_call_expr(~"do", expr_do_body)); + return self.parse_sugary_call_expr(~"do", expr_do_body); } else if self.eat_keyword(~"while") { - return pexpr(self.parse_while_expr()); + return self.parse_while_expr(); } else if self.eat_keyword(~"loop") { - return pexpr(self.parse_loop_expr()); + return self.parse_loop_expr(); } else if self.eat_keyword(~"match") { - return pexpr(self.parse_alt_expr()); + return self.parse_alt_expr(); } else if self.eat_keyword(~"fn") { let proto = self.parse_fn_ty_proto(); match proto { proto_bare => self.fatal(~"fn expr are deprecated, use fn@"), _ => { /* fallthrough */ } } - return pexpr(self.parse_fn_expr(proto)); + return self.parse_fn_expr(proto); } else if self.eat_keyword(~"unsafe") { - return pexpr(self.parse_block_expr(lo, unsafe_blk)); + return self.parse_block_expr(lo, unsafe_blk); } else if self.token == token::LBRACKET { self.bump(); let mutbl = self.parse_mutability(); @@ -962,7 +939,7 @@ impl Parser { hi = self.span.hi; } else if self.token == token::ELLIPSIS { self.bump(); - return pexpr(self.mk_mac_expr(lo, self.span.hi, mac_ellipsis)); + return self.mk_mac_expr(lo, self.span.hi, mac_ellipsis); } else if self.token == token::POUND { let ex_ext = self.parse_syntax_ext(); hi = ex_ext.span.hi; @@ -1020,8 +997,8 @@ impl Parser { let hi = self.span.hi; - return pexpr(self.mk_mac_expr( - lo, hi, mac_invoc_tt(pth, tts))); + return self.mk_mac_expr( + lo, hi, mac_invoc_tt(pth, tts)); } else if self.token == token::LBRACE { // This might be a struct literal. if self.looking_at_record_literal() { @@ -1053,7 +1030,7 @@ impl Parser { hi = pth.span.hi; self.expect(token::RBRACE); ex = expr_struct(pth, fields, base); - return self.mk_pexpr(lo, hi, ex); + return self.mk_expr(lo, hi, ex); } } @@ -1068,7 +1045,7 @@ impl Parser { let (hi, ex) = self.try_convert_expr_to_obsolete_fixed_length_vstore(lo, hi, ex); - return self.mk_pexpr(lo, hi, ex); + return self.mk_expr(lo, hi, ex); } fn parse_block_expr(lo: uint, blk_mode: blk_check_mode) -> @expr { @@ -1125,7 +1102,7 @@ impl Parser { return self.mk_mac_expr(lo, self.span.hi, mac_invoc(pth, e, b)); } - fn parse_dot_or_call_expr() -> pexpr { + fn parse_dot_or_call_expr() -> @expr { let b = self.parse_bottom_expr(); self.parse_dot_or_call_expr_with(b) } @@ -1134,7 +1111,7 @@ impl Parser { return self.restriction != RESTRICT_NO_CALL_EXPRS; } - fn parse_dot_or_call_expr_with(e0: pexpr) -> pexpr { + fn parse_dot_or_call_expr_with(e0: @expr) -> @expr { let mut e = e0; let lo = e.span.lo; let mut hi; @@ -1150,8 +1127,7 @@ impl Parser { self.parse_seq_to_gt(Some(token::COMMA), |p| p.parse_ty(false)) } else { ~[] }; - e = self.mk_pexpr(lo, hi, expr_field(self.to_expr(e), i, - tys)); + e = self.mk_expr(lo, hi, expr_field(e, i, tys)); } _ => self.unexpected() } @@ -1167,8 +1143,8 @@ impl Parser { |p| p.parse_expr()); hi = self.span.hi; - let nd = expr_call(self.to_expr(e), es, false); - e = self.mk_pexpr(lo, hi, nd); + let nd = expr_call(e, es, false); + e = self.mk_expr(lo, hi, nd); } // expr[...] @@ -1177,7 +1153,7 @@ impl Parser { let ix = self.parse_expr(); hi = ix.span.hi; self.expect(token::RBRACKET); - e = self.mk_pexpr(lo, hi, expr_index(self.to_expr(e), ix)); + e = self.mk_expr(lo, hi, expr_index(e, ix)); } _ => return e @@ -1326,7 +1302,7 @@ impl Parser { } - fn parse_prefix_expr() -> pexpr { + fn parse_prefix_expr() -> @expr { let lo = self.span.lo; let mut hi; @@ -1334,7 +1310,7 @@ impl Parser { match copy self.token { token::NOT => { self.bump(); - let e = self.to_expr(self.parse_prefix_expr()); + let e = self.parse_prefix_expr(); hi = e.span.hi; self.get_id(); // see ast_util::op_expr_callee_id ex = expr_unary(not, e); @@ -1343,21 +1319,21 @@ impl Parser { match b { token::MINUS => { self.bump(); - let e = self.to_expr(self.parse_prefix_expr()); + let e = self.parse_prefix_expr(); hi = e.span.hi; self.get_id(); // see ast_util::op_expr_callee_id ex = expr_unary(neg, e); } token::STAR => { self.bump(); - let e = self.to_expr(self.parse_prefix_expr()); + let e = self.parse_prefix_expr(); hi = e.span.hi; ex = expr_unary(deref, e); } token::AND => { self.bump(); let m = self.parse_mutability(); - let e = self.to_expr(self.parse_prefix_expr()); + let e = self.parse_prefix_expr(); hi = e.span.hi; // HACK: turn &[...] into a &-evec ex = match e.node { @@ -1374,7 +1350,7 @@ impl Parser { token::AT => { self.bump(); let m = self.parse_mutability(); - let e = self.to_expr(self.parse_prefix_expr()); + let e = self.parse_prefix_expr(); hi = e.span.hi; // HACK: turn @[...] into a @-evec ex = match e.node { @@ -1386,7 +1362,7 @@ impl Parser { token::TILDE => { self.bump(); let m = self.parse_mutability(); - let e = self.to_expr(self.parse_prefix_expr()); + let e = self.parse_prefix_expr(); hi = e.span.hi; // HACK: turn ~[...] into a ~-evec ex = match e.node { @@ -1397,18 +1373,17 @@ impl Parser { } _ => return self.parse_dot_or_call_expr() } - return self.mk_pexpr(lo, hi, ex); + return self.mk_expr(lo, hi, ex); } fn parse_binops() -> @expr { - return self.parse_more_binops(self.parse_prefix_expr(), 0u); + return self.parse_more_binops(self.parse_prefix_expr(), 0); } - fn parse_more_binops(plhs: pexpr, min_prec: uint) -> + fn parse_more_binops(lhs: @expr, min_prec: uint) -> @expr { - let lhs = self.to_expr(plhs); - if self.expr_is_complete(plhs) { return lhs; } + if self.expr_is_complete(lhs) { return lhs; } let peeked = self.token; if peeked == token::BINOP(token::OR) && (self.restriction == RESTRICT_NO_BAR_OP || @@ -1428,7 +1403,7 @@ impl Parser { let expr = self.parse_prefix_expr(); let rhs = self.parse_more_binops(expr, cur_prec); self.get_id(); // see ast_util::op_expr_callee_id - let bin = self.mk_pexpr(lhs.span.lo, rhs.span.hi, + let bin = self.mk_expr(lhs.span.lo, rhs.span.hi, expr_binary(cur_op, lhs, rhs)); return self.parse_more_binops(bin, min_prec); } @@ -1438,7 +1413,7 @@ impl Parser { if as_prec > min_prec && self.eat_keyword(~"as") { let rhs = self.parse_ty(true); let _as = - self.mk_pexpr(lhs.span.lo, rhs.span.hi, expr_cast(lhs, rhs)); + self.mk_expr(lhs.span.lo, rhs.span.hi, expr_cast(lhs, rhs)); return self.parse_more_binops(_as, min_prec); } return lhs; @@ -2173,9 +2148,9 @@ impl Parser { } } - fn expr_is_complete(e: pexpr) -> bool { + fn expr_is_complete(e: @expr) -> bool { return self.restriction == RESTRICT_STMT_EXPR && - !classify::expr_requires_semi_to_be_stmt(*e); + !classify::expr_requires_semi_to_be_stmt(e); } fn parse_block() -> blk { diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs index 82db3aaa4b3a2..3836c21ff2449 100644 --- a/src/libsyntax/print/pprust.rs +++ b/src/libsyntax/print/pprust.rs @@ -773,7 +773,7 @@ fn print_variant(s: ps, v: ast::variant) { match v.node.kind { ast::tuple_variant_kind(args) => { print_ident(s, v.node.name); - if vec::len(args) > 0u { + if args.is_not_empty() { popen(s); fn print_variant_arg(s: ps, arg: ast::variant_arg) { print_type(s, arg.ty); @@ -951,25 +951,11 @@ fn print_possibly_embedded_block_(s: ps, blk: ast::blk, embedded: embed_type, s.ann.post(ann_node); } -// return and fail, without arguments cannot appear is the discriminant of if, -// alt, do, & while unambiguously without being parenthesized -fn print_maybe_parens_discrim(s: ps, e: @ast::expr) { - let disambig = match e.node { - ast::expr_ret(None) - | ast::expr_fail(None) - | ast::expr_again(*) => true, - _ => false - }; - if disambig { popen(s); } - print_expr(s, e); - if disambig { pclose(s); } -} - fn print_if(s: ps, test: @ast::expr, blk: ast::blk, elseopt: Option<@ast::expr>, chk: bool) { head(s, ~"if"); if chk { word_nbsp(s, ~"check"); } - print_maybe_parens_discrim(s, test); + print_expr(s, test); space(s.s); print_block(s, blk); fn do_else(s: ps, els: Option<@ast::expr>) { @@ -981,7 +967,7 @@ fn print_if(s: ps, test: @ast::expr, blk: ast::blk, cbox(s, indent_unit - 1u); ibox(s, 0u); word(s.s, ~" else if "); - print_maybe_parens_discrim(s, i); + print_expr(s, i); space(s.s); print_block(s, t); do_else(s, e); @@ -1154,8 +1140,8 @@ fn print_expr(s: ps, &&expr: @ast::expr) { } Some(blk_arg) } else { None }; - print_expr_parens_if_not_bot(s, func); - if !has_block || vec::len(base_args) > 0u { + print_expr(s, func); + if !has_block || base_args.is_not_empty() { popen(s); commasep_exprs(s, inconsistent, base_args); pclose(s); @@ -1178,15 +1164,14 @@ fn print_expr(s: ps, &&expr: @ast::expr) { } } ast::expr_binary(op, lhs, rhs) => { - let prec = operator_prec(op); - print_op_maybe_parens(s, lhs, prec); + print_expr(s, lhs); space(s.s); word_space(s, ast_util::binop_to_str(op)); - print_op_maybe_parens(s, rhs, prec + 1u); + print_expr(s, rhs); } ast::expr_unary(op, expr) => { word(s.s, ast_util::unop_to_str(op)); - print_op_maybe_parens(s, expr, parse::prec::unop_prec); + print_expr(s, expr); } ast::expr_addr_of(m, expr) => { word(s.s, ~"&"); @@ -1195,7 +1180,7 @@ fn print_expr(s: ps, &&expr: @ast::expr) { } ast::expr_lit(lit) => print_literal(s, lit), ast::expr_cast(expr, ty) => { - print_op_maybe_parens(s, expr, parse::prec::as_prec); + print_expr(s, expr); space(s.s); word_space(s, ~"as"); print_type_ex(s, ty, true); @@ -1205,7 +1190,7 @@ fn print_expr(s: ps, &&expr: @ast::expr) { } ast::expr_while(test, blk) => { head(s, ~"while"); - print_maybe_parens_discrim(s, test); + print_expr(s, test); space(s.s); print_block(s, blk); } @@ -1220,9 +1205,9 @@ fn print_expr(s: ps, &&expr: @ast::expr) { } ast::expr_match(expr, arms) => { cbox(s, alt_indent_unit); - ibox(s, 4u); + ibox(s, 4); word_nbsp(s, ~"match"); - print_maybe_parens_discrim(s, expr); + print_expr(s, expr); space(s.s); bopen(s); let len = arms.len(); @@ -1335,12 +1320,9 @@ fn print_expr(s: ps, &&expr: @ast::expr) { print_block(s, blk); } ast::expr_copy(e) => { word_space(s, ~"copy"); print_expr(s, e); } - // shouldn't parenthesize unless it's needed ast::expr_unary_move(e) => { - popen(s); word_space(s, ~"move"); print_expr(s, e); - pclose(s); } ast::expr_assign(lhs, rhs) => { print_expr(s, lhs); @@ -1362,12 +1344,7 @@ fn print_expr(s: ps, &&expr: @ast::expr) { print_expr(s, rhs); } ast::expr_field(expr, id, tys) => { - // Deal with '10.x' - if ends_in_lit_int(expr) { - popen(s); print_expr(s, expr); pclose(s); - } else { - print_expr_parens_if_not_bot(s, expr); - } + print_expr(s, expr); word(s.s, ~"."); print_ident(s, id); if vec::len(tys) > 0u { @@ -1377,7 +1354,7 @@ fn print_expr(s: ps, &&expr: @ast::expr) { } } ast::expr_index(expr, index) => { - print_expr_parens_if_not_bot(s, expr); + print_expr(s, expr); word(s.s, ~"["); print_expr(s, index); word(s.s, ~"]"); @@ -1427,27 +1404,16 @@ fn print_expr(s: ps, &&expr: @ast::expr) { print_expr(s, expr); } ast::expr_mac(m) => print_mac(s, m), + ast::expr_paren(e) => { + popen(s); + print_expr(s, e); + pclose(s); + } } s.ann.post(ann_node); end(s); } -fn print_expr_parens_if_not_bot(s: ps, ex: @ast::expr) { - let parens = match ex.node { - ast::expr_fail(_) | ast::expr_ret(_) | - ast::expr_binary(_, _, _) | ast::expr_unary(_, _) | - ast::expr_copy(_) | ast::expr_assign(_, _) | - ast::expr_assign_op(_, _, _) | ast::expr_swap(_, _) | - ast::expr_log(_, _, _) | ast::expr_assert(_) | - ast::expr_call(_, _, true) | - ast::expr_vstore(_, _) => true, - _ => false - }; - if parens { popen(s); } - print_expr(s, ex); - if parens { pclose(s); } -} - fn print_local_decl(s: ps, loc: @ast::local) { print_pat(s, loc.node.pat); match loc.node.ty.node { @@ -1557,7 +1523,7 @@ fn print_pat(s: ps, &&pat: @ast::pat) { match args_ { None => word(s.s, ~"(*)"), Some(args) => { - if vec::len(args) > 0u { + if args.is_not_empty() { popen(s); commasep(s, inconsistent, args, print_pat); pclose(s); @@ -1813,7 +1779,7 @@ fn print_view_item(s: ps, item: @ast::view_item) { ast::view_item_use(id, mta, _) => { head(s, ~"extern mod"); print_ident(s, id); - if vec::len(mta) > 0u { + if mta.is_not_empty() { popen(s); commasep(s, consistent, mta, print_meta_item); pclose(s); @@ -1835,13 +1801,6 @@ fn print_view_item(s: ps, item: @ast::view_item) { end(s); // end outer head-block } -fn print_op_maybe_parens(s: ps, expr: @ast::expr, outer_prec: uint) { - let add_them = need_parens(expr, outer_prec); - if add_them { popen(s); } - print_expr(s, expr); - if add_them { pclose(s); } -} - fn print_mutability(s: ps, mutbl: ast::mutability) { match mutbl { ast::m_mutbl => word_nbsp(s, ~"mut"), diff --git a/src/libsyntax/visit.rs b/src/libsyntax/visit.rs index e4eabfabf2f2e..2dbe2b16044ef 100644 --- a/src/libsyntax/visit.rs +++ b/src/libsyntax/visit.rs @@ -462,6 +462,7 @@ fn visit_expr(ex: @expr, e: E, v: vt) { v.visit_expr(x, e, v); } expr_mac(mac) => visit_mac(mac, e, v), + expr_paren(x) => v.visit_expr(x, e, v), } v.visit_expr_post(ex, e, v); } diff --git a/src/rustc/middle/check_const.rs b/src/rustc/middle/check_const.rs index bdc042fb764e9..482ab3041f44c 100644 --- a/src/rustc/middle/check_const.rs +++ b/src/rustc/middle/check_const.rs @@ -98,6 +98,8 @@ fn check_expr(sess: Session, def_map: resolve::DefMap, } } } + expr_paren(e) => { check_expr(sess, def_map, method_map, + tcx, e, is_const, v); } expr_vstore(_, expr_vstore_slice) | expr_vstore(_, expr_vstore_fixed(_)) | expr_vec(_, m_imm) | diff --git a/src/rustc/middle/const_eval.rs b/src/rustc/middle/const_eval.rs index d0296ebd2e544..3e30bf50e023d 100644 --- a/src/rustc/middle/const_eval.rs +++ b/src/rustc/middle/const_eval.rs @@ -72,7 +72,8 @@ fn classify(e: @expr, } ast::expr_copy(inner) | - ast::expr_unary(_, inner) => { + ast::expr_unary(_, inner) | + ast::expr_paren(inner) => { classify(inner, def_map, tcx) } @@ -376,6 +377,7 @@ fn eval_const_expr_partial(tcx: middle::ty::ctxt, e: @expr) expr_lit(lit) => Ok(lit_to_const(lit)), // If we have a vstore, just keep going; it has to be a string expr_vstore(e, _) => eval_const_expr_partial(tcx, e), + expr_paren(e) => eval_const_expr_partial(tcx, e), _ => Err(~"Unsupported constant expr") } } diff --git a/src/rustc/middle/liveness.rs b/src/rustc/middle/liveness.rs index c438474130f26..baf083b191ba0 100644 --- a/src/rustc/middle/liveness.rs +++ b/src/rustc/middle/liveness.rs @@ -554,7 +554,7 @@ fn visit_expr(expr: @expr, &&self: @IrMaps, vt: vt<@IrMaps>) { expr_break(_) | expr_again(_) | expr_lit(_) | expr_ret(*) | expr_block(*) | expr_unary_move(*) | expr_assign(*) | expr_swap(*) | expr_assign_op(*) | expr_mac(*) | expr_struct(*) | - expr_repeat(*) => { + expr_repeat(*) | expr_paren(*) => { visit::visit_expr(expr, self, vt); } } @@ -1253,7 +1253,8 @@ impl Liveness { expr_loop_body(e) | expr_do_body(e) | expr_cast(e, _) | - expr_unary(_, e) => { + expr_unary(_, e) | + expr_paren(e) => { self.propagate_through_expr(e, succ) } @@ -1550,7 +1551,7 @@ fn check_expr(expr: @expr, &&self: @Liveness, vt: vt<@Liveness>) { expr_cast(*) | expr_unary(*) | expr_fail(*) | expr_ret(*) | expr_break(*) | expr_again(*) | expr_lit(_) | expr_block(*) | expr_swap(*) | expr_mac(*) | expr_addr_of(*) | - expr_struct(*) | expr_repeat(*) => { + expr_struct(*) | expr_repeat(*) | expr_paren(*) => { visit::visit_expr(expr, self, vt); } } diff --git a/src/rustc/middle/mem_categorization.rs b/src/rustc/middle/mem_categorization.rs index 8ee9adc4e2f3b..83eddc1c21b72 100644 --- a/src/rustc/middle/mem_categorization.rs +++ b/src/rustc/middle/mem_categorization.rs @@ -481,6 +481,8 @@ impl &mem_categorization_ctxt { self.cat_def(expr.id, expr.span, expr_ty, def) } + ast::expr_paren(e) => self.cat_expr_unadjusted(e), + ast::expr_addr_of(*) | ast::expr_call(*) | ast::expr_swap(*) | ast::expr_assign(*) | ast::expr_assign_op(*) | ast::expr_fn(*) | ast::expr_fn_block(*) | diff --git a/src/rustc/middle/trans/consts.rs b/src/rustc/middle/trans/consts.rs index 98ff7329b0f5c..54eec8c6de073 100644 --- a/src/rustc/middle/trans/consts.rs +++ b/src/rustc/middle/trans/consts.rs @@ -361,6 +361,7 @@ fn const_expr(cx: @crate_ctxt, e: @ast::expr) -> ValueRef { _ => cx.sess.span_bug(e.span, ~"expected to find a const def") } } + ast::expr_paren(e) => { return const_expr(cx, e); } _ => cx.sess.span_bug(e.span, ~"bad constant expression type in consts::const_expr") }; diff --git a/src/rustc/middle/trans/expr.rs b/src/rustc/middle/trans/expr.rs index dee553536048a..3aabef8794c4f 100644 --- a/src/rustc/middle/trans/expr.rs +++ b/src/rustc/middle/trans/expr.rs @@ -161,7 +161,6 @@ impl Dest : cmp::Eq { fn trans_to_datum(bcx: block, expr: @ast::expr) -> DatumBlock { debug!("trans_to_datum(expr=%s)", bcx.expr_to_str(expr)); - return match bcx.tcx().adjustments.find(expr.id) { None => { trans_to_datum_unadjusted(bcx, expr) @@ -392,6 +391,9 @@ fn trans_rvalue_datum_unadjusted(bcx: block, expr: @ast::expr) -> DatumBlock { ast::expr_cast(val, _) => { return trans_imm_cast(bcx, val, expr.id); } + ast::expr_paren(e) => { + return trans_rvalue_datum_unadjusted(bcx, e); + } _ => { bcx.tcx().sess.span_bug( expr.span, @@ -450,6 +452,9 @@ fn trans_rvalue_stmt_unadjusted(bcx: block, expr: @ast::expr) -> block { ast::expr_assign_op(op, dst, src) => { return trans_assign_op(bcx, expr, op, dst, src); } + ast::expr_paren(a) => { + return trans_rvalue_stmt_unadjusted(bcx, a); + } _ => { bcx.tcx().sess.span_bug( expr.span, @@ -469,6 +474,9 @@ fn trans_rvalue_dps_unadjusted(bcx: block, expr: @ast::expr, trace_span!(bcx, expr.span, shorten(bcx.expr_to_str(expr))); match expr.node { + ast::expr_paren(e) => { + return trans_rvalue_dps_unadjusted(bcx, e, dest); + } ast::expr_path(_) => { return trans_def_dps_unadjusted(bcx, expr, bcx.def(expr.id), dest); @@ -690,6 +698,9 @@ fn trans_lvalue_unadjusted(bcx: block, expr: @ast::expr) -> DatumBlock { let mut bcx = bcx; match expr.node { + ast::expr_paren(e) => { + return unrooted(bcx, e); + } ast::expr_path(_) => { return trans_def_lvalue(bcx, expr, bcx.def(expr.id)); } diff --git a/src/rustc/middle/trans/type_use.rs b/src/rustc/middle/trans/type_use.rs index 78fbb7f47bed2..b8a7580e03cc9 100644 --- a/src/rustc/middle/trans/type_use.rs +++ b/src/rustc/middle/trans/type_use.rs @@ -267,6 +267,7 @@ fn mark_for_expr(cx: ctx, e: @expr) { } } } + expr_paren(e) => mark_for_expr(cx, e), expr_match(*) | expr_block(_) | expr_if(*) | expr_while(*) | expr_fail(_) | expr_break(_) | expr_again(_) | expr_unary(_, _) | expr_lit(_) | expr_assert(_) | diff --git a/src/rustc/middle/ty.rs b/src/rustc/middle/ty.rs index f44f6a3ce628d..1402d1c93243d 100644 --- a/src/rustc/middle/ty.rs +++ b/src/rustc/middle/ty.rs @@ -2872,24 +2872,6 @@ fn is_pred_ty(fty: t) -> bool { is_fn_ty(fty) && type_is_bool(ty_fn_ret(fty)) } -/* -fn ty_var_id(typ: t) -> TyVid { - match get(typ).sty { - ty_infer(TyVar(vid)) => return vid, - _ => { error!("ty_var_id called on non-var ty"); fail; } - } -} - -fn int_var_id(typ: t) -> IntVid { - match get(typ).sty { - ty_infer(IntVar(vid)) => return vid, - _ => { error!("ty_var_integral_id called on ty other than \ - ty_var_integral"); - fail; } - } -} -*/ - // Type accessors for AST nodes fn block_ty(cx: ctxt, b: &ast::blk) -> t { return node_id_to_type(cx, b.node.id); @@ -3094,6 +3076,8 @@ fn expr_kind(tcx: ctxt, RvalueDatumExpr } + ast::expr_paren(e) => expr_kind(tcx, method_map, e), + ast::expr_mac(*) => { tcx.sess.span_bug( expr.span, diff --git a/src/rustc/middle/typeck/check.rs b/src/rustc/middle/typeck/check.rs index 339a035b35cfa..5fc92b2d0d0ae 100644 --- a/src/rustc/middle/typeck/check.rs +++ b/src/rustc/middle/typeck/check.rs @@ -990,11 +990,11 @@ fn check_expr_with_unifier(fcx: @fn_ctxt, debug!("check_call_inner: after universal quant., fty=%s", fcx.infcx().ty_to_str(fty)); - let supplied_arg_count = vec::len(args); + let supplied_arg_count = args.len(); // Grab the argument types, supplying fresh type variables // if the wrong number of arguments were supplied - let expected_arg_count = vec::len(fn_ty.sig.inputs); + let expected_arg_count = fn_ty.sig.inputs.len(); let formal_tys = if expected_arg_count == supplied_arg_count { fn_ty.sig.inputs.map(|a| a.ty) } else { @@ -1058,8 +1058,11 @@ fn check_expr_with_unifier(fcx: @fn_ctxt, bot |= check_expr_with_unifier( fcx, *arg, Some(formal_ty), - || demand::assign(fcx, arg.span, formal_ty, *arg) + || demand::assign(fcx, arg.span, + formal_ty, *arg) ); + fcx.write_ty(arg.id, fcx.expr_ty(*arg)); + } } } @@ -1369,12 +1372,13 @@ fn check_expr_with_unifier(fcx: @fn_ctxt, let expr_t = structurally_resolved_type(fcx, expr.span, fcx.expr_ty(base)); let (base_t, derefs) = do_autoderef(fcx, expr.span, expr_t); - let n_tys = vec::len(tys); + let n_tys = tys.len(); + match structure_of(fcx, expr.span, base_t) { ty::ty_rec(fields) => { match ty::field_idx(field, fields) { Some(ix) => { - if n_tys > 0u { + if n_tys > 0 { tcx.sess.span_err( expr.span, ~"can't provide type parameters \ @@ -1680,7 +1684,7 @@ fn check_expr_with_unifier(fcx: @fn_ctxt, ty::mk_estr(tcx, tt) } ast::expr_vec(args, mutbl) => { - let tt = ast_expr_vstore_to_vstore(fcx, ev, vec::len(args), vst); + let tt = ast_expr_vstore_to_vstore(fcx, ev, args.len(), vst); let t: ty::t = fcx.infcx().next_ty_var(); for args.each |e| { bot |= check_expr_with(fcx, *e, t); } ty::mk_evec(tcx, {ty: t, mutbl: mutbl}, tt) @@ -1871,6 +1875,14 @@ fn check_expr_with_unifier(fcx: @fn_ctxt, bot = check_expr(fcx, a, expected); fcx.write_ty(id, fcx.expr_ty(a)); } + ast::expr_paren(a) => { + bot = check_expr_with_unifier(fcx, a, expected, || ()); + fcx.write_ty(id, fcx.expr_ty(a)); + do expected.iter |i| { + demand::assign(fcx, expr.span, *i, expr); + demand::assign(fcx, a.span, *i, a); + }; + } ast::expr_assign(lhs, rhs) => { bot = check_assignment(fcx, expr.span, lhs, rhs, id); } @@ -2583,9 +2595,9 @@ fn instantiate_path(fcx: @fn_ctxt, // determine values for type parameters, using the values given by // the user (if any) and otherwise using fresh type variables - let tps = if ty_substs_len == 0u { + let tps = if ty_substs_len == 0 { fcx.infcx().next_ty_vars(ty_param_count) - } else if ty_param_count == 0u { + } else if ty_param_count == 0 { fcx.ccx.tcx.sess.span_err (span, ~"this item does not take type parameters"); fcx.infcx().next_ty_vars(ty_param_count) diff --git a/src/rustc/middle/typeck/check/alt.rs b/src/rustc/middle/typeck/check/alt.rs index a8308bb1b3c24..dc1b14e4beb24 100644 --- a/src/rustc/middle/typeck/check/alt.rs +++ b/src/rustc/middle/typeck/check/alt.rs @@ -132,6 +132,10 @@ fn check_pat_variant(pcx: pat_ctxt, pat: @ast::pat, path: @ast::path, instantiate_path(pcx.fcx, path, enum_tpt, pat.span, pat.id, pcx.block_region); + // structure_of requires type variables to be resolved. + // So when we pass in , it's an error if it + // contains type variables. + // Take the enum type params out of `expected`. match structure_of(pcx.fcx, pat.span, expected) { ty::ty_enum(_, ref expected_substs) => { @@ -151,7 +155,7 @@ fn check_pat_variant(pcx: pat_ctxt, pat: @ast::pat, path: @ast::path, None => arg_len, Some(ps) => ps.len() }; - if arg_len > 0u { + if arg_len > 0 { // N-ary variant. if arg_len != subpats_len { let s = fmt!("this pattern has %u field%s, but the \ @@ -168,7 +172,7 @@ fn check_pat_variant(pcx: pat_ctxt, pat: @ast::pat, path: @ast::path, check_pat(pcx, *subpat, *arg_ty); } }; - } else if subpats_len > 0u { + } else if subpats_len > 0 { tcx.sess.span_fatal (pat.span, fmt!("this pattern has %u field%s, \ but the corresponding variant has no fields", diff --git a/src/rustc/middle/typeck/check/vtable.rs b/src/rustc/middle/typeck/check/vtable.rs index 345b8246b4278..85a65d7432fd8 100644 --- a/src/rustc/middle/typeck/check/vtable.rs +++ b/src/rustc/middle/typeck/check/vtable.rs @@ -486,6 +486,11 @@ fn early_resolve_expr(ex: @ast::expr, &&fcx: @fn_ctxt, is_early: bool) { _ => () } } + + ast::expr_paren(e) => { + early_resolve_expr(e, fcx, is_early); + } + // Must resolve bounds on methods with bounded params ast::expr_field(*) | ast::expr_binary(*) | ast::expr_unary(*) | ast::expr_assign_op(*) | diff --git a/src/test/compile-fail/trait-cast.rs b/src/test/compile-fail/trait-cast.rs index 9e15a31d95aa0..43c16984bb667 100644 --- a/src/test/compile-fail/trait-cast.rs +++ b/src/test/compile-fail/trait-cast.rs @@ -3,6 +3,9 @@ trait foo { } fn bar(x: foo) -> foo { return (x as foo::); //~^ ERROR mismatched types: expected `@foo` but found `@foo` + //~^^ ERROR mismatched types: expected `@foo` but found `@foo` + // This is unfortunate -- new handling of parens means the error message + // gets printed twice } fn main() {} diff --git a/src/test/run-fail/zip-different-lengths.rs b/src/test/run-fail/zip-different-lengths.rs index c6239c1f657c9..fa91049e3aea1 100644 --- a/src/test/run-fail/zip-different-lengths.rs +++ b/src/test/run-fail/zip-different-lengths.rs @@ -8,7 +8,7 @@ fn enum_chars(start: u8, end: u8) -> ~[char] { assert start < end; let mut i = start; let mut r = ~[]; - while i <= end { r.push(i as char); i += 1u as u8; } + while i <= end { r.push(i as char); i += 1 as u8; } return r; } @@ -16,16 +16,16 @@ fn enum_uints(start: uint, end: uint) -> ~[uint] { assert start < end; let mut i = start; let mut r = ~[]; - while i <= end { r.push(i); i += 1u; } + while i <= end { r.push(i); i += 1; } return r; } fn main() { - let a = 'a' as u8, j = 'j' as u8, k = 1u, l = 9u; + let a = 'a' as u8, j = 'j' as u8, k = 1, l = 9; let chars = enum_chars(a, j); let ints = enum_uints(k, l); - assert (same_length(chars, ints)); + assert same_length(chars, ints); let ps = zip(chars, ints); fail ~"the impossible happened"; } diff --git a/src/test/run-pass/syntax-extension-source-utils.rs b/src/test/run-pass/syntax-extension-source-utils.rs index 1704047a48f29..7afb74fa12172 100644 --- a/src/test/run-pass/syntax-extension-source-utils.rs +++ b/src/test/run-pass/syntax-extension-source-utils.rs @@ -11,10 +11,10 @@ mod m1 { } fn main() { - assert(line!() == 14u); - assert(col!() == 11u); + assert(line!() == 14); + assert(col!() == 11); assert(file!().ends_with(~"syntax-extension-source-utils.rs")); - assert(stringify!((2*3) + 5) == ~"2 * 3 + 5"); + assert(stringify!((2*3) + 5) == ~"(2 * 3) + 5"); assert(include!("syntax-extension-source-utils-files/includeme.fragment") == ~"victory robot 6"); From 19f8025a3ad66968837b5a5b2daaad6c2826c85e Mon Sep 17 00:00:00 2001 From: Tim Chevalier Date: Sat, 27 Oct 2012 17:18:15 -0700 Subject: [PATCH 2/2] Remove xfail-pretty from tests that pretty-print correctly now --- src/test/bench/core-std.rs | 1 - src/test/bench/msgsend-pipes-shared.rs | 2 -- src/test/bench/msgsend-pipes.rs | 2 -- src/test/bench/msgsend-ring-mutex-arcs.rs | 2 -- src/test/bench/msgsend-ring-pipes.rs | 2 -- src/test/bench/msgsend-ring-rw-arcs.rs | 2 -- src/test/bench/pingpong.rs | 2 -- src/test/bench/shootout-pfib.rs | 1 - src/test/compile-fail/qquote-1.rs | 1 - src/test/compile-fail/qquote-2.rs | 1 - src/test/run-pass/fat-arrow-alt.rs | 1 - src/test/run-pass/html-literals.rs | 1 - src/test/run-pass/issue-2718.rs | 1 - src/test/run-pass/pipe-bank-proto.rs | 1 - src/test/run-pass/pipe-detect-term.rs | 1 - src/test/run-pass/pipe-peek.rs | 1 - src/test/run-pass/pipe-pingpong-bounded.rs | 1 - src/test/run-pass/pipe-pingpong-proto.rs | 1 - src/test/run-pass/pipe-presentation-examples.rs | 1 - src/test/run-pass/pipe-sleep.rs | 1 - src/test/run-pass/rec-align-u32.rs | 1 - src/test/run-pass/rec-align-u64.rs | 1 - src/test/run-pass/reexport-star.rs | 1 - src/test/run-pass/test-ignore-cfg.rs | 1 - src/test/run-pass/unreachable-code-1.rs | 1 - src/test/run-pass/unreachable-code.rs | 1 - 26 files changed, 32 deletions(-) diff --git a/src/test/bench/core-std.rs b/src/test/bench/core-std.rs index 550da39cb11ea..6f90a2c99e810 100644 --- a/src/test/bench/core-std.rs +++ b/src/test/bench/core-std.rs @@ -1,4 +1,3 @@ -// xfail-pretty // Microbenchmarks for various functions in core and std extern mod std; diff --git a/src/test/bench/msgsend-pipes-shared.rs b/src/test/bench/msgsend-pipes-shared.rs index 55afa0490918c..397b17be7c0f2 100644 --- a/src/test/bench/msgsend-pipes-shared.rs +++ b/src/test/bench/msgsend-pipes-shared.rs @@ -8,8 +8,6 @@ // different scalability characteristics compared to the select // version. -// xfail-pretty - #[legacy_modes]; extern mod std; diff --git a/src/test/bench/msgsend-pipes.rs b/src/test/bench/msgsend-pipes.rs index f0fc1dd5f001b..12e0035afe8c1 100644 --- a/src/test/bench/msgsend-pipes.rs +++ b/src/test/bench/msgsend-pipes.rs @@ -4,8 +4,6 @@ // // I *think* it's the same, more or less. -// xfail-pretty - #[legacy_modes]; extern mod std; diff --git a/src/test/bench/msgsend-ring-mutex-arcs.rs b/src/test/bench/msgsend-ring-mutex-arcs.rs index 82b8e2410a964..ac2fc1f5258a0 100644 --- a/src/test/bench/msgsend-ring-mutex-arcs.rs +++ b/src/test/bench/msgsend-ring-mutex-arcs.rs @@ -5,8 +5,6 @@ // This also serves as a pipes test, because ARCs are implemented with pipes. -// xfail-pretty - extern mod std; use std::time; use std::arc; diff --git a/src/test/bench/msgsend-ring-pipes.rs b/src/test/bench/msgsend-ring-pipes.rs index de4332b692a1a..636fef53732db 100644 --- a/src/test/bench/msgsend-ring-pipes.rs +++ b/src/test/bench/msgsend-ring-pipes.rs @@ -6,8 +6,6 @@ // This version uses automatically compiled channel contracts. -// xfail-pretty - extern mod std; use std::time; use std::future; diff --git a/src/test/bench/msgsend-ring-rw-arcs.rs b/src/test/bench/msgsend-ring-rw-arcs.rs index 375ff8f50d866..ae0099b232743 100644 --- a/src/test/bench/msgsend-ring-rw-arcs.rs +++ b/src/test/bench/msgsend-ring-rw-arcs.rs @@ -5,8 +5,6 @@ // This also serves as a pipes test, because ARCs are implemented with pipes. -// xfail-pretty - extern mod std; use std::time; use std::arc; diff --git a/src/test/bench/pingpong.rs b/src/test/bench/pingpong.rs index fc2025511947b..17987fba2f825 100644 --- a/src/test/bench/pingpong.rs +++ b/src/test/bench/pingpong.rs @@ -1,7 +1,5 @@ // Compare bounded and unbounded protocol performance. -// xfail-pretty - extern mod std; use pipes::{spawn_service, recv}; diff --git a/src/test/bench/shootout-pfib.rs b/src/test/bench/shootout-pfib.rs index e70b796298be8..dbb445c89e4b6 100644 --- a/src/test/bench/shootout-pfib.rs +++ b/src/test/bench/shootout-pfib.rs @@ -1,5 +1,4 @@ // -*- rust -*- -// xfail-pretty /* A parallel version of fibonacci numbers. diff --git a/src/test/compile-fail/qquote-1.rs b/src/test/compile-fail/qquote-1.rs index 344c87538819f..c7911c76218e5 100644 --- a/src/test/compile-fail/qquote-1.rs +++ b/src/test/compile-fail/qquote-1.rs @@ -1,4 +1,3 @@ -// xfail-pretty extern mod std; extern mod syntax; diff --git a/src/test/compile-fail/qquote-2.rs b/src/test/compile-fail/qquote-2.rs index 656d75c5a40d1..2c34943ac577a 100644 --- a/src/test/compile-fail/qquote-2.rs +++ b/src/test/compile-fail/qquote-2.rs @@ -1,4 +1,3 @@ -// xfail-pretty extern mod std; use syntax; diff --git a/src/test/run-pass/fat-arrow-alt.rs b/src/test/run-pass/fat-arrow-alt.rs index 5c80ebfae234e..935d962d2bb76 100644 --- a/src/test/run-pass/fat-arrow-alt.rs +++ b/src/test/run-pass/fat-arrow-alt.rs @@ -1,5 +1,4 @@ // -*- rust -*- -// xfail-pretty enum color { red, diff --git a/src/test/run-pass/html-literals.rs b/src/test/run-pass/html-literals.rs index dc8abc532979c..e2c1b9fbdfb3f 100644 --- a/src/test/run-pass/html-literals.rs +++ b/src/test/run-pass/html-literals.rs @@ -1,6 +1,5 @@ // A test of the macro system. Can we do HTML literals? -// xfail-pretty /* diff --git a/src/test/run-pass/issue-2718.rs b/src/test/run-pass/issue-2718.rs index 7b8ff9b86b028..ebc601245963d 100644 --- a/src/test/run-pass/issue-2718.rs +++ b/src/test/run-pass/issue-2718.rs @@ -1,5 +1,4 @@ // tjc: I don't know why -// xfail-pretty mod pipes { #[legacy_exports]; use cast::{forget, transmute}; diff --git a/src/test/run-pass/pipe-bank-proto.rs b/src/test/run-pass/pipe-bank-proto.rs index 7d7de6d120dce..affa7d54ac72a 100644 --- a/src/test/run-pass/pipe-bank-proto.rs +++ b/src/test/run-pass/pipe-bank-proto.rs @@ -1,4 +1,3 @@ -// xfail-pretty // An example of the bank protocol from eholk's blog post. // diff --git a/src/test/run-pass/pipe-detect-term.rs b/src/test/run-pass/pipe-detect-term.rs index 524541780c074..cc5463bd33900 100644 --- a/src/test/run-pass/pipe-detect-term.rs +++ b/src/test/run-pass/pipe-detect-term.rs @@ -1,6 +1,5 @@ // Make sure that we can detect when one end of the pipe is closed. -// xfail-pretty // xfail-win32 extern mod std; diff --git a/src/test/run-pass/pipe-peek.rs b/src/test/run-pass/pipe-peek.rs index e3a2d29747b63..2f26ecff91d01 100644 --- a/src/test/run-pass/pipe-peek.rs +++ b/src/test/run-pass/pipe-peek.rs @@ -1,4 +1,3 @@ -// xfail-pretty extern mod std; use std::timer::sleep; diff --git a/src/test/run-pass/pipe-pingpong-bounded.rs b/src/test/run-pass/pipe-pingpong-bounded.rs index 0db7d6cf123a6..f00668e4ba453 100644 --- a/src/test/run-pass/pipe-pingpong-bounded.rs +++ b/src/test/run-pass/pipe-pingpong-bounded.rs @@ -2,7 +2,6 @@ // experiment with what code the compiler should generate for bounded // protocols. -// xfail-pretty // This was generated initially by the pipe compiler, but it's been // modified in hopefully straightforward ways. diff --git a/src/test/run-pass/pipe-pingpong-proto.rs b/src/test/run-pass/pipe-pingpong-proto.rs index c1c74aefa9c8c..5a782dbada879 100644 --- a/src/test/run-pass/pipe-pingpong-proto.rs +++ b/src/test/run-pass/pipe-pingpong-proto.rs @@ -1,6 +1,5 @@ // An example to make sure the protocol parsing syntax extension works. -// xfail-pretty proto! pingpong ( ping:send { diff --git a/src/test/run-pass/pipe-presentation-examples.rs b/src/test/run-pass/pipe-presentation-examples.rs index 853aba53eda47..cd5fcaabf5cb4 100644 --- a/src/test/run-pass/pipe-presentation-examples.rs +++ b/src/test/run-pass/pipe-presentation-examples.rs @@ -3,7 +3,6 @@ // Code is easier to write in emacs, and it's good to be sure all the // code samples compile (or not) as they should. -// xfail-pretty use double_buffer::client::*; use double_buffer::give_buffer; diff --git a/src/test/run-pass/pipe-sleep.rs b/src/test/run-pass/pipe-sleep.rs index c9975bec9469e..57eafb2018d77 100644 --- a/src/test/run-pass/pipe-sleep.rs +++ b/src/test/run-pass/pipe-sleep.rs @@ -1,4 +1,3 @@ -// xfail-pretty extern mod std; use std::timer::sleep; diff --git a/src/test/run-pass/rec-align-u32.rs b/src/test/run-pass/rec-align-u32.rs index 93ef8e755f4fd..c5ef4d76f95db 100644 --- a/src/test/run-pass/rec-align-u32.rs +++ b/src/test/run-pass/rec-align-u32.rs @@ -1,4 +1,3 @@ -// xfail-pretty // Issue #2303 #[abi = "rust-intrinsic"] diff --git a/src/test/run-pass/rec-align-u64.rs b/src/test/run-pass/rec-align-u64.rs index 24400b8d34080..6ad737b0b3f38 100644 --- a/src/test/run-pass/rec-align-u64.rs +++ b/src/test/run-pass/rec-align-u64.rs @@ -1,4 +1,3 @@ -// xfail-pretty // Issue #2303 #[abi = "rust-intrinsic"] diff --git a/src/test/run-pass/reexport-star.rs b/src/test/run-pass/reexport-star.rs index daa8d9d67964f..f3e8d993943cc 100644 --- a/src/test/run-pass/reexport-star.rs +++ b/src/test/run-pass/reexport-star.rs @@ -1,4 +1,3 @@ -// xfail-pretty // FIXME #3654 mod a { diff --git a/src/test/run-pass/test-ignore-cfg.rs b/src/test/run-pass/test-ignore-cfg.rs index 0baabecb0ab91..e6cd3631e55ad 100644 --- a/src/test/run-pass/test-ignore-cfg.rs +++ b/src/test/run-pass/test-ignore-cfg.rs @@ -1,6 +1,5 @@ // compile-flags: --test --cfg ignorecfg // xfail-fast -// xfail-pretty extern mod std; diff --git a/src/test/run-pass/unreachable-code-1.rs b/src/test/run-pass/unreachable-code-1.rs index 11cf1fe85f9de..fb35463f0532d 100644 --- a/src/test/run-pass/unreachable-code-1.rs +++ b/src/test/run-pass/unreachable-code-1.rs @@ -1,4 +1,3 @@ -// xfail-pretty fn id(x: bool) -> bool { x } diff --git a/src/test/run-pass/unreachable-code.rs b/src/test/run-pass/unreachable-code.rs index 9d34e7a8dc68a..4b847c5d83eee 100644 --- a/src/test/run-pass/unreachable-code.rs +++ b/src/test/run-pass/unreachable-code.rs @@ -1,4 +1,3 @@ -// xfail-pretty fn id(x: bool) -> bool { x }