From de70d76373e05fcf0f421cedb185b08de10a714c Mon Sep 17 00:00:00 2001 From: Patrick Walton Date: Mon, 7 Jul 2014 16:35:15 -0700 Subject: [PATCH] librustc: Remove cross-borrowing of `Box` to `&T` from the language, except where trait objects are involved. Part of issue #15349, though I'm leaving it open for trait objects. Cross borrowing for trait objects remains because it is needed until we have DST. This will break code like: fn foo(x: &int) { ... } let a = box 3i; foo(a); Change this code to: fn foo(x: &int) { ... } let a = box 3i; foo(&*a); [breaking-change] --- src/doc/guide-lifetimes.md | 9 +++--- src/doc/guide-pointers.md | 2 +- src/doc/rust.md | 2 +- src/doc/tutorial.md | 10 +++--- src/liballoc/boxed.rs | 6 ++-- src/libcollections/treemap.rs | 2 +- src/libregex_macros/lib.rs | 4 +-- src/librustc/driver/driver.rs | 2 +- src/librustc/metadata/encoder.rs | 2 +- src/librustc/metadata/tyencode.rs | 2 +- src/librustc/middle/astencode.rs | 5 +-- src/librustc/middle/borrowck/mod.rs | 9 ++++-- src/librustc/middle/check_match.rs | 4 ++- src/librustc/middle/dead.rs | 6 ++-- src/librustc/middle/reachable.rs | 4 +-- src/librustc/middle/resolve.rs | 4 +-- src/librustc/middle/save/mod.rs | 5 +-- src/librustc/middle/trans/_match.rs | 8 +++-- src/librustc/middle/trans/meth.rs | 9 ++++-- src/librustc/middle/ty.rs | 2 +- src/librustc/middle/typeck/astconv.rs | 2 +- src/librustc/middle/typeck/check/mod.rs | 26 ++++++++++------ src/librustc/middle/typeck/collect.rs | 16 +++++++--- src/librustc/middle/typeck/infer/coercion.rs | 31 ++++--------------- src/librustc/middle/typeck/infer/combine.rs | 2 +- src/librustc/middle/typeck/infer/mod.rs | 4 +-- src/librustc/middle/typeck/infer/test.rs | 2 +- src/librustc/util/ppaux.rs | 2 +- src/libsyntax/ext/deriving/generic/mod.rs | 4 ++- src/libsyntax/ext/expand.rs | 26 +++++++++------- src/libsyntax/fold.rs | 6 ++-- src/libsyntax/parse/parser.rs | 4 ++- src/libsyntax/print/pprust.rs | 2 +- src/libsyntax/visit.rs | 6 ++-- src/libterm/terminfo/searcher.rs | 2 +- .../borrowck-bad-nested-calls-free.rs | 2 +- .../borrowck-bad-nested-calls-move.rs | 2 +- .../borrowck-closures-use-after-free.rs | 2 +- .../compile-fail/borrowck-lend-flow-loop.rs | 6 ++-- .../borrowck-loan-blocks-mut-uniq.rs | 2 +- .../borrowck-preserve-box-in-field.rs | 2 +- .../borrowck-preserve-box-in-uniq.rs | 2 +- .../compile-fail/borrowck-preserve-box.rs | 2 +- .../borrowck-preserve-expl-deref.rs | 2 +- .../compile-fail/borrowck-uniq-via-lend.rs | 14 ++++----- src/test/compile-fail/issue-11192.rs | 2 +- src/test/compile-fail/isuue-12470.rs | 2 +- src/test/compile-fail/lint-allocation.rs | 17 ---------- .../regions-infer-borrow-scope-too-big.rs | 2 +- .../regions-infer-borrow-scope-within-loop.rs | 2 +- .../compile-fail/regions-trait-variance.rs | 2 +- .../struct-field-assignability.rs | 4 ++- src/test/debuginfo/borrowed-managed-basic.rs | 28 ++++++++--------- src/test/debuginfo/borrowed-struct.rs | 4 +-- src/test/debuginfo/borrowed-tuple.rs | 4 +-- src/test/debuginfo/borrowed-unique-basic.rs | 28 ++++++++--------- .../var-captured-in-sendable-closure.rs | 2 +- src/test/run-pass/bitv-perf-test.rs | 2 +- src/test/run-pass/borrowck-lend-args.rs | 6 ++-- src/test/run-pass/borrowck-mut-uniq.rs | 2 +- src/test/run-pass/borrowck-root-while-cond.rs | 2 +- src/test/run-pass/borrowck-uniq-via-ref.rs | 12 +++---- src/test/run-pass/cci_borrow.rs | 2 +- src/test/run-pass/issue-3794.rs | 3 +- src/test/run-pass/issue-5884.rs | 2 +- src/test/run-pass/let-assignability.rs | 2 +- src/test/run-pass/new-box.rs | 2 +- src/test/run-pass/regions-borrow-at.rs | 2 +- src/test/run-pass/regions-borrow-uniq.rs | 2 +- .../run-pass/regions-escape-into-other-fn.rs | 2 +- ...gions-infer-borrow-scope-within-loop-ok.rs | 2 +- .../run-pass/regions-infer-borrow-scope.rs | 2 +- 72 files changed, 206 insertions(+), 204 deletions(-) delete mode 100644 src/test/compile-fail/lint-allocation.rs diff --git a/src/doc/guide-lifetimes.md b/src/doc/guide-lifetimes.md index 1f44b77d56abb..a6cc9cd0bc281 100644 --- a/src/doc/guide-lifetimes.md +++ b/src/doc/guide-lifetimes.md @@ -67,7 +67,7 @@ Now we can call `compute_distance()`: # let on_the_stack : Point = Point{x: 3.0, y: 4.0}; # let on_the_heap : Box = box Point{x: 7.0, y: 9.0}; # fn compute_distance(p1: &Point, p2: &Point) -> f64 { 0.0 } -compute_distance(&on_the_stack, on_the_heap); +compute_distance(&on_the_stack, &*on_the_heap); ~~~ Here, the `&` operator takes the address of the variable @@ -77,10 +77,9 @@ value. We also call this _borrowing_ the local variable `on_the_stack`, because we have created an alias: that is, another name for the same data. -In the case of `on_the_heap`, however, no explicit action is necessary. -The compiler will automatically convert a box point to a reference like &point. -This is another form of borrowing; in this case, the contents of the owned box -are being lent out. +Likewise, in the case of `owned_box`, +the `&` operator is used in conjunction with the `*` operator +to take a reference to the contents of the box. Whenever a caller lends data to a callee, there are some limitations on what the caller can do with the original. For example, if the contents of a diff --git a/src/doc/guide-pointers.md b/src/doc/guide-pointers.md index 0865282209773..17a1114be55f6 100644 --- a/src/doc/guide-pointers.md +++ b/src/doc/guide-pointers.md @@ -279,7 +279,7 @@ fn main() { let origin = &Point { x: 0.0, y: 0.0 }; let p1 = box Point { x: 5.0, y: 3.0 }; - println!("{}", compute_distance(origin, p1)); + println!("{}", compute_distance(origin, &*p1)); } ~~~ diff --git a/src/doc/rust.md b/src/doc/rust.md index 9d5a6fa42a830..9fe61eb3fe3b0 100644 --- a/src/doc/rust.md +++ b/src/doc/rust.md @@ -3243,7 +3243,7 @@ enum List { Nil, Cons(uint, Box) } fn is_sorted(list: &List) -> bool { match *list { Nil | Cons(_, box Nil) => true, - Cons(x, ref r @ box Cons(y, _)) => (x <= y) && is_sorted(*r) + Cons(x, ref r @ box Cons(y, _)) => (x <= y) && is_sorted(&**r) } } diff --git a/src/doc/tutorial.md b/src/doc/tutorial.md index e0f0bbd6c9f2b..4c90e564b584e 100644 --- a/src/doc/tutorial.md +++ b/src/doc/tutorial.md @@ -1470,7 +1470,7 @@ Now we can call `compute_distance()` in various ways: # let on_the_stack : Point = Point { x: 3.0, y: 4.0 }; # let on_the_heap : Box = box Point { x: 7.0, y: 9.0 }; # fn compute_distance(p1: &Point, p2: &Point) -> f64 { 0.0 } -compute_distance(&on_the_stack, on_the_heap); +compute_distance(&on_the_stack, &*on_the_heap); ~~~ Here the `&` operator is used to take the address of the variable @@ -1480,11 +1480,9 @@ reference. We also call this _borrowing_ the local variable `on_the_stack`, because we are creating an alias: that is, another route to the same data. -In the case of `owned_box`, however, no -explicit action is necessary. The compiler will automatically convert -a box `box point` to a reference like -`&point`. This is another form of borrowing; in this case, the -contents of the owned box are being lent out. +Likewise, in the case of `owned_box`, +the `&` operator is used in conjunction with the `*` operator +to take a reference to the contents of the box. Whenever a value is borrowed, there are some limitations on what you can do with the original. For example, if the contents of a variable diff --git a/src/liballoc/boxed.rs b/src/liballoc/boxed.rs index 56506d798d9df..89f6e934ad259 100644 --- a/src/liballoc/boxed.rs +++ b/src/liballoc/boxed.rs @@ -67,7 +67,7 @@ impl PartialEq for Box { impl PartialOrd for Box { #[inline] fn partial_cmp(&self, other: &Box) -> Option { - (**self).partial_cmp(*other) + (**self).partial_cmp(&**other) } #[inline] fn lt(&self, other: &Box) -> bool { *(*self) < *(*other) } @@ -80,7 +80,9 @@ impl PartialOrd for Box { } impl Ord for Box { #[inline] - fn cmp(&self, other: &Box) -> Ordering { (**self).cmp(*other) } + fn cmp(&self, other: &Box) -> Ordering { + (**self).cmp(&**other) + } } impl Eq for Box {} diff --git a/src/libcollections/treemap.rs b/src/libcollections/treemap.rs index c2211d08bfab7..ad5ad13167c0e 100644 --- a/src/libcollections/treemap.rs +++ b/src/libcollections/treemap.rs @@ -516,7 +516,7 @@ define_iterator! { fn deref<'a, K, V>(node: &'a Option>>) -> *const TreeNode { match *node { Some(ref n) => { - let n: &TreeNode = *n; + let n: &TreeNode = &**n; n as *const TreeNode } None => ptr::null() diff --git a/src/libregex_macros/lib.rs b/src/libregex_macros/lib.rs index 6545163fdbb68..7163dfa3b16ab 100644 --- a/src/libregex_macros/lib.rs +++ b/src/libregex_macros/lib.rs @@ -623,7 +623,7 @@ fn parse(cx: &mut ExtCtxt, tts: &[ast::TokenTree]) -> Option { _ => { cx.span_err(entry.span, format!( "expected string literal but got `{}`", - pprust::lit_to_string(lit)).as_slice()); + pprust::lit_to_string(&*lit)).as_slice()); return None } } @@ -631,7 +631,7 @@ fn parse(cx: &mut ExtCtxt, tts: &[ast::TokenTree]) -> Option { _ => { cx.span_err(entry.span, format!( "expected string literal but got `{}`", - pprust::expr_to_string(entry)).as_slice()); + pprust::expr_to_string(&*entry)).as_slice()); return None } }; diff --git a/src/librustc/driver/driver.rs b/src/librustc/driver/driver.rs index 87693658afd03..43aa3f9041fd9 100644 --- a/src/librustc/driver/driver.rs +++ b/src/librustc/driver/driver.rs @@ -799,7 +799,7 @@ fn print_flowgraph(variants: Vec, let ty_cx = &analysis.ty_cx; let cfg = match code { blocks::BlockCode(block) => cfg::CFG::new(ty_cx, &*block), - blocks::FnLikeCode(fn_like) => cfg::CFG::new(ty_cx, fn_like.body()), + blocks::FnLikeCode(fn_like) => cfg::CFG::new(ty_cx, &*fn_like.body()), }; debug!("cfg: {:?}", cfg); diff --git a/src/librustc/metadata/encoder.rs b/src/librustc/metadata/encoder.rs index 3c9f32dcd2f85..a3389ef86e551 100644 --- a/src/librustc/metadata/encoder.rs +++ b/src/librustc/metadata/encoder.rs @@ -1248,7 +1248,7 @@ fn encode_info_for_item(ecx: &EncodeContext, encode_method_sort(ebml_w, 'p'); encode_inlined_item(ecx, ebml_w, IIMethodRef(def_id, true, &*m)); - encode_method_argument_names(ebml_w, m.pe_fn_decl()); + encode_method_argument_names(ebml_w, &*m.pe_fn_decl()); } } diff --git a/src/librustc/metadata/tyencode.rs b/src/librustc/metadata/tyencode.rs index b207543398aaa..bcd6f3ac91abc 100644 --- a/src/librustc/metadata/tyencode.rs +++ b/src/librustc/metadata/tyencode.rs @@ -267,7 +267,7 @@ fn enc_sty(w: &mut MemWriter, cx: &ctxt, st: &ty::sty) { } ty::ty_closure(ref f) => { mywrite!(w, "f"); - enc_closure_ty(w, cx, *f); + enc_closure_ty(w, cx, &**f); } ty::ty_bare_fn(ref f) => { mywrite!(w, "F"); diff --git a/src/librustc/middle/astencode.rs b/src/librustc/middle/astencode.rs index 9240547874fd8..fd10fd3c35aae 100644 --- a/src/librustc/middle/astencode.rs +++ b/src/librustc/middle/astencode.rs @@ -1557,7 +1557,7 @@ fn test_simplification() { return alist {eq_fn: eq_int, data: Vec::new()}; } ).unwrap(); - let item_in = e::IIItemRef(item); + let item_in = e::IIItemRef(&*item); let item_out = simplify_ast(item_in); let item_exp = ast::IIItem(quote_item!(cx, fn new_int_alist() -> alist { @@ -1566,7 +1566,8 @@ fn test_simplification() { ).unwrap()); match (item_out, item_exp) { (ast::IIItem(item_out), ast::IIItem(item_exp)) => { - assert!(pprust::item_to_string(item_out) == pprust::item_to_string(item_exp)); + assert!(pprust::item_to_string(&*item_out) == + pprust::item_to_string(&*item_exp)); } _ => fail!() } diff --git a/src/librustc/middle/borrowck/mod.rs b/src/librustc/middle/borrowck/mod.rs index 77b3cfafa63af..5604d33496d9d 100644 --- a/src/librustc/middle/borrowck/mod.rs +++ b/src/librustc/middle/borrowck/mod.rs @@ -216,8 +216,13 @@ pub fn build_borrowck_dataflow_data_for_fn<'a>( let p = input.fn_parts; - let dataflow_data = build_borrowck_dataflow_data( - &mut bccx, &p.kind, p.decl, input.cfg, p.body, p.span, p.id); + let dataflow_data = build_borrowck_dataflow_data(&mut bccx, + &p.kind, + &*p.decl, + input.cfg, + &*p.body, + p.span, + p.id); (bccx, dataflow_data) } diff --git a/src/librustc/middle/check_match.rs b/src/librustc/middle/check_match.rs index 832b222ef1641..066837afac94a 100644 --- a/src/librustc/middle/check_match.rs +++ b/src/librustc/middle/check_match.rs @@ -47,7 +47,9 @@ impl fmt::Show for Matrix { let &Matrix(ref m) = self; let pretty_printed_matrix: Vec> = m.iter().map(|row| { - row.iter().map(|&pat| pat_to_string(pat)).collect::>() + row.iter() + .map(|&pat| pat_to_string(&*pat)) + .collect::>() }).collect(); let column_count = m.iter().map(|row| row.len()).max().unwrap_or(0u); diff --git a/src/librustc/middle/dead.rs b/src/librustc/middle/dead.rs index 8f01ee0564d19..33e7554084ac6 100644 --- a/src/librustc/middle/dead.rs +++ b/src/librustc/middle/dead.rs @@ -212,7 +212,7 @@ impl<'a> MarkSymbolVisitor<'a> { visit::walk_trait_method(self, &*trait_method, ctxt); } ast_map::NodeMethod(method) => { - visit::walk_block(self, method.pe_body(), ctxt); + visit::walk_block(self, &*method.pe_body(), ctxt); } ast_map::NodeForeignItem(foreign_item) => { visit::walk_foreign_item(self, &*foreign_item, ctxt); @@ -520,7 +520,9 @@ impl<'a> Visitor<()> for DeadVisitor<'a> { // Overwrite so that we don't warn the trait method itself. fn visit_trait_method(&mut self, trait_method: &ast::TraitMethod, _: ()) { match *trait_method { - ast::Provided(ref method) => visit::walk_block(self, method.pe_body(), ()), + ast::Provided(ref method) => { + visit::walk_block(self, &*method.pe_body(), ()) + } ast::Required(_) => () } } diff --git a/src/librustc/middle/reachable.rs b/src/librustc/middle/reachable.rs index b228a82bdf7b1..e404ce8566375 100644 --- a/src/librustc/middle/reachable.rs +++ b/src/librustc/middle/reachable.rs @@ -316,14 +316,14 @@ impl<'a> ReachableContext<'a> { // Keep going, nothing to get exported } ast::Provided(ref method) => { - visit::walk_block(self, method.pe_body(), ()) + visit::walk_block(self, &*method.pe_body(), ()) } } } ast_map::NodeMethod(method) => { let did = self.tcx.map.get_parent_did(search_item); if method_might_be_inlined(self.tcx, &*method, did) { - visit::walk_block(self, method.pe_body(), ()) + visit::walk_block(self, &*method.pe_body(), ()) } } // Nothing to recurse on for these diff --git a/src/librustc/middle/resolve.rs b/src/librustc/middle/resolve.rs index f00d7c36f5333..5bea24dfa90f6 100644 --- a/src/librustc/middle/resolve.rs +++ b/src/librustc/middle/resolve.rs @@ -3707,7 +3707,7 @@ impl<'a> Resolver<'a> { match ty_m.explicit_self.node { SelfExplicit(ref typ, _) => { - this.resolve_type(*typ) + this.resolve_type(&**typ) } _ => {} } @@ -4044,7 +4044,7 @@ impl<'a> Resolver<'a> { rib_kind); match method.pe_explicit_self().node { - SelfExplicit(ref typ, _) => self.resolve_type(*typ), + SelfExplicit(ref typ, _) => self.resolve_type(&**typ), _ => {} } diff --git a/src/librustc/middle/save/mod.rs b/src/librustc/middle/save/mod.rs index 9ae2a4c62cd54..0aeb90df11a26 100644 --- a/src/librustc/middle/save/mod.rs +++ b/src/librustc/middle/save/mod.rs @@ -356,9 +356,10 @@ impl <'l> DxrVisitor<'l> { for arg in method.pe_fn_decl().inputs.iter() { self.visit_ty(&*arg.ty, e); } - self.visit_ty(method.pe_fn_decl().output, e); + self.visit_ty(&*method.pe_fn_decl().output, e); // walk the fn body - self.visit_block(method.pe_body(), DxrVisitorEnv::new_nested(method.id)); + self.visit_block(&*method.pe_body(), + DxrVisitorEnv::new_nested(method.id)); self.process_generic_params(method.pe_generics(), method.span, diff --git a/src/librustc/middle/trans/_match.rs b/src/librustc/middle/trans/_match.rs index 958d2cd377431..75224883cf37f 100644 --- a/src/librustc/middle/trans/_match.rs +++ b/src/librustc/middle/trans/_match.rs @@ -491,7 +491,7 @@ fn enter_default<'a, 'b>( // Collect all of the matches that can match against anything. enter_match(bcx, dm, m, col, val, |pats| { - if pat_is_binding_or_wild(dm, pats[col]) { + if pat_is_binding_or_wild(dm, &*pats[col]) { Some(Vec::from_slice(pats.slice_to(col)).append(pats.slice_from(col + 1))) } else { None @@ -546,8 +546,10 @@ fn enter_opt<'a, 'b>( let _indenter = indenter(); let ctor = match opt { - &lit(x) => check_match::ConstantValue(const_eval::eval_const_expr( - bcx.tcx(), lit_to_expr(bcx.tcx(), &x))), + &lit(x) => { + check_match::ConstantValue(const_eval::eval_const_expr( + bcx.tcx(), &*lit_to_expr(bcx.tcx(), &x))) + } &range(ref lo, ref hi) => check_match::ConstantRange( const_eval::eval_const_expr(bcx.tcx(), &**lo), const_eval::eval_const_expr(bcx.tcx(), &**hi) diff --git a/src/librustc/middle/trans/meth.rs b/src/librustc/middle/trans/meth.rs index 53f0645cb8702..ba44314d962ac 100644 --- a/src/librustc/middle/trans/meth.rs +++ b/src/librustc/middle/trans/meth.rs @@ -68,8 +68,13 @@ pub fn trans_impl(ccx: &CrateContext, for method in methods.iter() { if method.pe_generics().ty_params.len() == 0u { let llfn = get_item_val(ccx, method.id); - trans_fn(ccx, method.pe_fn_decl(), method.pe_body(), - llfn, ¶m_substs::empty(), method.id, []); + trans_fn(ccx, + &*method.pe_fn_decl(), + &*method.pe_body(), + llfn, + ¶m_substs::empty(), + method.id, + []); } else { let mut v = TransItemVisitor{ ccx: ccx }; visit::walk_method_helper(&mut v, &**method, ()); diff --git a/src/librustc/middle/ty.rs b/src/librustc/middle/ty.rs index cfafe99090d58..95ec43738308e 100644 --- a/src/librustc/middle/ty.rs +++ b/src/librustc/middle/ty.rs @@ -2038,7 +2038,7 @@ pub fn type_contents(cx: &ctxt, ty: t) -> TypeContents { } ty_closure(ref c) => { - closure_contents(cx, *c) + closure_contents(cx, &**c) } ty_box(typ) => { diff --git a/src/librustc/middle/typeck/astconv.rs b/src/librustc/middle/typeck/astconv.rs index 09557c94aa62a..6d215282cc45d 100644 --- a/src/librustc/middle/typeck/astconv.rs +++ b/src/librustc/middle/typeck/astconv.rs @@ -1018,7 +1018,7 @@ fn determine_explicit_self_category ty::ByBoxExplicitSelfCategory, ast::SelfExplicit(ast_type, _) => { - let explicit_type = ast_ty_to_ty(this, rscope, ast_type); + let explicit_type = ast_ty_to_ty(this, rscope, &*ast_type); { let inference_context = infer::new_infer_ctxt(this.tcx()); diff --git a/src/librustc/middle/typeck/check/mod.rs b/src/librustc/middle/typeck/check/mod.rs index 4f07f1121b7ce..3b860be0f0134 100644 --- a/src/librustc/middle/typeck/check/mod.rs +++ b/src/librustc/middle/typeck/check/mod.rs @@ -764,7 +764,12 @@ fn check_method_body(ccx: &CrateCtxt, let fty = ty::node_id_to_type(ccx.tcx, method.id); - check_bare_fn(ccx, method.pe_fn_decl(), method.pe_body(), method.id, fty, param_env); + check_bare_fn(ccx, + &*method.pe_fn_decl(), + &*method.pe_body(), + method.id, + fty, + param_env); } fn check_impl_methods_against_trait(ccx: &CrateCtxt, @@ -2370,7 +2375,7 @@ fn check_expr_with_unifier(fcx: &FnCtxt, if ty::type_is_integral(lhs_t) && ast_util::is_shift_binop(op) { // Shift is a special case: rhs must be uint, no matter what lhs is - check_expr_has_type(fcx, rhs, ty::mk_uint()); + check_expr_has_type(fcx, &*rhs, ty::mk_uint()); fcx.write_ty(expr.id, lhs_t); return; } @@ -2957,7 +2962,7 @@ fn check_expr_with_unifier(fcx: &FnCtxt, } ast::ExprLit(lit) => { - let typ = check_lit(fcx, lit, expected); + let typ = check_lit(fcx, &*lit, expected); fcx.write_ty(id, typ); } ast::ExprBinary(op, ref lhs, ref rhs) => { @@ -3164,8 +3169,11 @@ fn check_expr_with_unifier(fcx: &FnCtxt, fcx.write_bot(id); } ast::ExprParen(a) => { - check_expr_with_expectation_and_lvalue_pref(fcx, a, expected, lvalue_pref); - fcx.write_ty(id, fcx.expr_ty(a)); + check_expr_with_expectation_and_lvalue_pref(fcx, + &*a, + expected, + lvalue_pref); + fcx.write_ty(id, fcx.expr_ty(&*a)); } ast::ExprAssign(ref lhs, ref rhs) => { check_expr_with_lvalue_pref(fcx, &**lhs, PreferMutLvalue); @@ -3326,8 +3334,8 @@ fn check_expr_with_unifier(fcx: &FnCtxt, Some(ref fs) if i < fs.len() => ExpectHasType(*fs.get(i)), _ => NoExpectation }; - check_expr_with_expectation(fcx, *e, opt_hint); - let t = fcx.expr_ty(*e); + check_expr_with_expectation(fcx, &**e, opt_hint); + let t = fcx.expr_ty(&**e); err_field = err_field || ty::type_is_error(t); bot_field = bot_field || ty::type_is_bot(t); t @@ -3674,8 +3682,8 @@ fn check_block_with_expected(fcx: &FnCtxt, e.span, "unreachable expression".to_string()); } - check_expr_with_expectation(fcx, e, expected); - let ety = fcx.expr_ty(e); + check_expr_with_expectation(fcx, &*e, expected); + let ety = fcx.expr_ty(&*e); fcx.write_ty(blk.id, ety); if any_err { fcx.write_error(blk.id); diff --git a/src/librustc/middle/typeck/collect.rs b/src/librustc/middle/typeck/collect.rs index eea26fbcfc73f..906cc1e0255aa 100644 --- a/src/librustc/middle/typeck/collect.rs +++ b/src/librustc/middle/typeck/collect.rs @@ -215,9 +215,15 @@ pub fn ensure_trait_methods(ccx: &CrateCtxt, &ast::Provided(ref m) => { ty_method_of_trait_method( - ccx, trait_id, &trait_def.generics, - &m.id, &m.pe_ident(), m.pe_explicit_self(), - m.pe_generics(), &m.pe_fn_style(), m.pe_fn_decl()) + ccx, + trait_id, + &trait_def.generics, + &m.id, + &m.pe_ident(), + m.pe_explicit_self(), + m.pe_generics(), + &m.pe_fn_style(), + &*m.pe_fn_decl()) } }); @@ -383,7 +389,7 @@ fn convert_methods(ccx: &CrateCtxt, m.pe_fn_style(), untransformed_rcvr_ty, *m.pe_explicit_self(), - m.pe_fn_decl()); + &*m.pe_fn_decl()); // if the method specifies a visibility, use that, otherwise // inherit the visibility from the impl (so `foo` in `pub impl @@ -1295,7 +1301,7 @@ fn check_method_self_type( explicit_self: &ast::ExplicitSelf) { match explicit_self.node { ast::SelfExplicit(ref ast_type, _) => { - let typ = crate_context.to_ty(rs, *ast_type); + let typ = crate_context.to_ty(rs, &**ast_type); let base_type = match ty::get(typ).sty { ty::ty_rptr(_, tm) => tm.ty, ty::ty_uniq(typ) => typ, diff --git a/src/librustc/middle/typeck/infer/coercion.rs b/src/librustc/middle/typeck/infer/coercion.rs index f8efb3c38c200..03890250f7701 100644 --- a/src/librustc/middle/typeck/infer/coercion.rs +++ b/src/librustc/middle/typeck/infer/coercion.rs @@ -76,7 +76,6 @@ use util::common::indenter; use util::ppaux::Repr; use syntax::abi; -use syntax::ast::MutImmutable; use syntax::ast; // Note: Coerce is not actually a combiner, in that it does not @@ -248,12 +247,7 @@ impl<'f> Coerce<'f> { let r_borrow = self.get_ref().infcx.next_region_var(coercion); let inner_ty = match *sty_a { - ty::ty_box(typ) | ty::ty_uniq(typ) => { - if mt_b.mutbl == ast::MutMutable { - return Err(ty::terr_mutability) - } - typ - } + ty::ty_box(_) | ty::ty_uniq(_) => return Err(ty::terr_mismatch), ty::ty_rptr(_, mt_a) => mt_a.ty, _ => { return self.subtype(a, b); @@ -280,23 +274,9 @@ impl<'f> Coerce<'f> { b.repr(self.get_ref().infcx.tcx)); match *sty_a { - ty::ty_uniq(t) => match ty::get(t).sty { - ty::ty_str => {} - _ => return self.subtype(a, b), - }, - _ => { - return self.subtype(a, b); - } - }; - - let coercion = Coercion(self.get_ref().trace.clone()); - let r_a = self.get_ref().infcx.next_region_var(coercion); - let a_borrowed = ty::mk_str_slice(self.get_ref().infcx.tcx, r_a, ast::MutImmutable); - if_ok!(self.subtype(a_borrowed, b)); - Ok(Some(AutoDerefRef(AutoDerefRef { - autoderefs: 0, - autoref: Some(AutoBorrowVec(r_a, MutImmutable)) - }))) + ty::ty_uniq(_) => return Err(ty::terr_mismatch), + _ => return self.subtype(a, b), + } } pub fn coerce_borrowed_vector(&self, @@ -313,7 +293,8 @@ impl<'f> Coerce<'f> { let coercion = Coercion(self.get_ref().trace.clone()); let r_borrow = self.get_ref().infcx.next_region_var(coercion); let ty_inner = match *sty_a { - ty::ty_uniq(t) | ty::ty_ptr(ty::mt{ty: t, ..}) | + ty::ty_uniq(_) => return Err(ty::terr_mismatch), + ty::ty_ptr(ty::mt{ty: t, ..}) | ty::ty_rptr(_, ty::mt{ty: t, ..}) => match ty::get(t).sty { ty::ty_vec(mt, None) => mt.ty, _ => { diff --git a/src/librustc/middle/typeck/infer/combine.rs b/src/librustc/middle/typeck/infer/combine.rs index c3de120a0c393..d82e6e74778e5 100644 --- a/src/librustc/middle/typeck/infer/combine.rs +++ b/src/librustc/middle/typeck/infer/combine.rs @@ -552,7 +552,7 @@ pub fn super_tys(this: &C, a: ty::t, b: ty::t) -> cres { } (&ty::ty_closure(ref a_fty), &ty::ty_closure(ref b_fty)) => { - this.closure_tys(*a_fty, *b_fty).and_then(|fty| { + this.closure_tys(&**a_fty, &**b_fty).and_then(|fty| { Ok(ty::mk_closure(tcx, fty)) }) } diff --git a/src/librustc/middle/typeck/infer/mod.rs b/src/librustc/middle/typeck/infer/mod.rs index 16e758df9dbbd..30fffc42a3f97 100644 --- a/src/librustc/middle/typeck/infer/mod.rs +++ b/src/librustc/middle/typeck/infer/mod.rs @@ -30,8 +30,8 @@ use middle::ty_fold::TypeFolder; use middle::typeck::check::regionmanip::replace_late_bound_regions_in_fn_sig; use middle::typeck::infer::coercion::Coerce; use middle::typeck::infer::combine::{Combine, CombineFields, eq_tys}; -use middle::typeck::infer::region_inference::{RegionVarBindings, - RegionSnapshot}; +use middle::typeck::infer::region_inference::{RegionSnapshot}; +use middle::typeck::infer::region_inference::{RegionVarBindings}; use middle::typeck::infer::resolve::{resolver}; use middle::typeck::infer::sub::Sub; use middle::typeck::infer::lub::Lub; diff --git a/src/librustc/middle/typeck/infer/test.rs b/src/librustc/middle/typeck/infer/test.rs index c06e40fce14f9..54ea826f10920 100644 --- a/src/librustc/middle/typeck/infer/test.rs +++ b/src/librustc/middle/typeck/infer/test.rs @@ -174,7 +174,7 @@ impl<'a> Env<'a> { assert!(idx < names.len()); for item in m.items.iter() { if item.ident.user_string(this.tcx) == names[idx] { - return search(this, *item, idx+1, names); + return search(this, &**item, idx+1, names); } } return None; diff --git a/src/librustc/util/ppaux.rs b/src/librustc/util/ppaux.rs index e37bef98e4404..8b8e37fe280d9 100644 --- a/src/librustc/util/ppaux.rs +++ b/src/librustc/util/ppaux.rs @@ -374,7 +374,7 @@ pub fn ty_to_string(cx: &ctxt, typ: t) -> String { format!("({})", strs.connect(",")) } ty_closure(ref f) => { - closure_to_string(cx, *f) + closure_to_string(cx, &**f) } ty_bare_fn(ref f) => { bare_fn_to_string(cx, f.fn_style, f.abi, None, &f.sig) diff --git a/src/libsyntax/ext/deriving/generic/mod.rs b/src/libsyntax/ext/deriving/generic/mod.rs index 46efdccadec80..f1c1784146a84 100644 --- a/src/libsyntax/ext/deriving/generic/mod.rs +++ b/src/libsyntax/ext/deriving/generic/mod.rs @@ -954,7 +954,9 @@ impl<'a> MethodDef<'a> { // expressions for referencing every field of every // Self arg, assuming all are instances of VariantK. // Build up code associated with such a case. - let substructure = EnumMatching(index, variant, field_tuples); + let substructure = EnumMatching(index, + &*variant, + field_tuples); let arm_expr = self.call_substructure_method( cx, trait_, type_ident, self_args, nonself_args, &substructure); diff --git a/src/libsyntax/ext/expand.rs b/src/libsyntax/ext/expand.rs index 58689389769c9..a098139b36dcb 100644 --- a/src/libsyntax/ext/expand.rs +++ b/src/libsyntax/ext/expand.rs @@ -166,14 +166,14 @@ pub fn expand_expr(e: Gc, fld: &mut MacroExpander) -> Gc { ast::ExprFnBlock(fn_decl, block) => { let (rewritten_fn_decl, rewritten_block) - = expand_and_rename_fn_decl_and_block(fn_decl, block, fld); + = expand_and_rename_fn_decl_and_block(&*fn_decl, block, fld); let new_node = ast::ExprFnBlock(rewritten_fn_decl, rewritten_block); box(GC) ast::Expr{id:e.id, node: new_node, span: fld.new_span(e.span)} } ast::ExprProc(fn_decl, block) => { let (rewritten_fn_decl, rewritten_block) - = expand_and_rename_fn_decl_and_block(fn_decl, block, fld); + = expand_and_rename_fn_decl_and_block(&*fn_decl, block, fld); let new_node = ast::ExprProc(rewritten_fn_decl, rewritten_block); box(GC) ast::Expr{id:e.id, node: new_node, span: fld.new_span(e.span)} } @@ -422,7 +422,7 @@ fn expand_item_underscore(item: &ast::Item_, fld: &mut MacroExpander) -> ast::It match *item { ast::ItemFn(decl, fn_style, abi, ref generics, body) => { let (rewritten_fn_decl, rewritten_body) - = expand_and_rename_fn_decl_and_block(decl,body,fld); + = expand_and_rename_fn_decl_and_block(&*decl, body, fld); let expanded_generics = fold::fold_generics(generics,fld); ast::ItemFn(rewritten_fn_decl, fn_style, abi, expanded_generics, rewritten_body) } @@ -572,7 +572,9 @@ fn expand_stmt(s: &Stmt, fld: &mut MacroExpander) -> SmallVector> { }; let expanded_stmt = match expand_mac_invoc(mac,&s.span, |r|{r.make_stmt()}, - |sts,mrk|{mark_stmt(sts,mrk)}, + |sts,mrk| { + mark_stmt(&*sts,mrk) + }, fld) { Some(stmt) => stmt, None => { @@ -628,7 +630,7 @@ fn expand_non_macro_stmt(s: &Stmt, fld: &mut MacroExpander) // names, as well... but that should be okay, as long as // the new names are gensyms for the old ones. // generate fresh names, push them to a new pending list - let idents = pattern_bindings(expanded_pat); + let idents = pattern_bindings(&*expanded_pat); let mut new_pending_renames = idents.iter().map(|ident| (*ident, fresh_name(ident))).collect(); // rewrite the pattern using the new names (the old @@ -677,7 +679,7 @@ fn expand_arm(arm: &ast::Arm, fld: &mut MacroExpander) -> ast::Arm { // all of the pats must have the same set of bindings, so use the // first one to extract them and generate new names: let first_pat = expanded_pats.get(0); - let idents = pattern_bindings(*first_pat); + let idents = pattern_bindings(&**first_pat); let new_renames = idents.iter().map(|id| (*id,fresh_name(id))).collect(); // apply the renaming, but only to the PatIdents: @@ -732,7 +734,7 @@ fn pattern_bindings(pat : &ast::Pat) -> Vec { fn fn_decl_arg_bindings(fn_decl: &ast::FnDecl) -> Vec { let mut pat_idents = PatIdentFinder{ident_accumulator:Vec::new()}; for arg in fn_decl.inputs.iter() { - pat_idents.visit_pat(arg.pat,()); + pat_idents.visit_pat(&*arg.pat, ()); } pat_idents.ident_accumulator } @@ -910,7 +912,7 @@ fn expand_method(m: &ast::Method, fld: &mut MacroExpander) -> SmallVector { let (rewritten_fn_decl, rewritten_body) - = expand_and_rename_fn_decl_and_block(decl,body,fld); + = expand_and_rename_fn_decl_and_block(&*decl,body,fld); SmallVector::one(box(GC) ast::Method { attrs: m.attrs.iter().map(|a| fld.fold_attribute(*a)).collect(), id: id, @@ -951,12 +953,12 @@ fn expand_and_rename_fn_decl_and_block(fn_decl: &ast::FnDecl, block: Gc (Gc, Gc) { let expanded_decl = fld.fold_fn_decl(fn_decl); - let idents = fn_decl_arg_bindings(expanded_decl); + let idents = fn_decl_arg_bindings(&*expanded_decl); let renames = idents.iter().map(|id : &ast::Ident| (*id,fresh_name(id))).collect(); // first, a renamer for the PatIdents, for the fn_decl: let mut rename_pat_fld = PatIdentRenamer{renames: &renames}; - let rewritten_fn_decl = rename_pat_fld.fold_fn_decl(expanded_decl); + let rewritten_fn_decl = rename_pat_fld.fold_fn_decl(&*expanded_decl); // now, a renamer for *all* idents, for the body: let mut rename_fld = IdentRenamer{renames: &renames}; let rewritten_body = fld.fold_block(rename_fld.fold_block(block)); @@ -999,7 +1001,7 @@ impl<'a, 'b> Folder for MacroExpander<'a, 'b> { } fn fold_method(&mut self, method: Gc) -> SmallVector> { - expand_method(method, self) + expand_method(&*method, self) } fn new_span(&mut self, span: Span) -> Span { @@ -1660,7 +1662,7 @@ foo_module!() fn pat_idents(){ let pat = string_to_pat( "(a,Foo{x:c @ (b,9),y:Bar(4,d)})".to_string()); - let idents = pattern_bindings(pat); + let idents = pattern_bindings(&*pat); assert_eq!(idents, strs_to_idents(vec!("a","c","b","d"))); } diff --git a/src/libsyntax/fold.rs b/src/libsyntax/fold.rs index 87c762af2e5bd..5467afab9f515 100644 --- a/src/libsyntax/fold.rs +++ b/src/libsyntax/fold.rs @@ -472,7 +472,7 @@ fn fold_interpolated(nt : &token::Nonterminal, fld: &mut T) -> token: .expect_one("expected fold to produce exactly one item")), token::NtBlock(block) => token::NtBlock(fld.fold_block(block)), token::NtStmt(stmt) => - token::NtStmt(fld.fold_stmt(stmt) + token::NtStmt(fld.fold_stmt(&*stmt) // this is probably okay, because the only folds likely // to peek inside interpolated nodes will be renamings/markings, // which map single items to single items @@ -483,8 +483,8 @@ fn fold_interpolated(nt : &token::Nonterminal, fld: &mut T) -> token: token::NtIdent(ref id, is_mod_name) => token::NtIdent(box fld.fold_ident(**id),is_mod_name), token::NtMeta(meta_item) => token::NtMeta(fold_meta_item_(meta_item,fld)), - token::NtPath(ref path) => token::NtPath(box fld.fold_path(*path)), - token::NtTT(tt) => token::NtTT(box (GC) fold_tt(tt,fld)), + token::NtPath(ref path) => token::NtPath(box fld.fold_path(&**path)), + token::NtTT(tt) => token::NtTT(box (GC) fold_tt(&*tt,fld)), // it looks to me like we can leave out the matchers: token::NtMatchers(matchers) _ => (*nt).clone() } diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs index bdfd928cfbcd8..a77f24f98f818 100644 --- a/src/libsyntax/parse/parser.rs +++ b/src/libsyntax/parse/parser.rs @@ -502,7 +502,9 @@ impl<'a> Parser<'a> { inedible: &[token::Token]) { debug!("commit_stmt {:?}", s); let _s = s; // unused, but future checks might want to inspect `s`. - if self.last_token.as_ref().map_or(false, |t| is_ident_or_path(*t)) { + if self.last_token + .as_ref() + .map_or(false, |t| is_ident_or_path(&**t)) { let expected = edible.iter().map(|x| (*x).clone()).collect::>() .append(inedible.as_slice()); self.check_for_erroneous_unit_struct_expecting( diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs index 428a15cb8cf74..10caaea86cf4b 100644 --- a/src/libsyntax/print/pprust.rs +++ b/src/libsyntax/print/pprust.rs @@ -1862,7 +1862,7 @@ impl<'a> State<'a> { ast::SelfExplicit(ref typ, _) => { try!(word(&mut self.s, "self")); try!(self.word_space(":")); - try!(self.print_type(*typ)); + try!(self.print_type(&**typ)); } } return Ok(true); diff --git a/src/libsyntax/visit.rs b/src/libsyntax/visit.rs index 6760d7a393205..cd953607ea22b 100644 --- a/src/libsyntax/visit.rs +++ b/src/libsyntax/visit.rs @@ -215,7 +215,7 @@ pub fn walk_explicit_self>(visitor: &mut V, SelfRegion(ref lifetime, _, _) => { visitor.visit_opt_lifetime_ref(explicit_self.span, lifetime, env) } - SelfExplicit(ref typ, _) => visitor.visit_ty(*typ, env.clone()), + SelfExplicit(ref typ, _) => visitor.visit_ty(&**typ, env.clone()), } } @@ -565,8 +565,8 @@ pub fn walk_method_helper>(visitor: &mut V, MethDecl(ident, ref generics, _, _, decl, body, _) => { visitor.visit_ident(method.span, ident, env.clone()); visitor.visit_fn(&FkMethod(ident, generics, method), - decl, - body, + &*decl, + &*body, method.span, method.id, env.clone()); diff --git a/src/libterm/terminfo/searcher.rs b/src/libterm/terminfo/searcher.rs index 7ad14d7975493..ebec59924e8f3 100644 --- a/src/libterm/terminfo/searcher.rs +++ b/src/libterm/terminfo/searcher.rs @@ -79,7 +79,7 @@ pub fn get_dbpath_for_term(term: &str) -> Option> { pub fn open(term: &str) -> Result { match get_dbpath_for_term(term) { Some(x) => { - match File::open(x) { + match File::open(&*x) { Ok(file) => Ok(file), Err(e) => Err(format!("error opening file: {}", e)), } diff --git a/src/test/compile-fail/borrowck-bad-nested-calls-free.rs b/src/test/compile-fail/borrowck-bad-nested-calls-free.rs index fd96b750fc16c..ab2fc6c67b401 100644 --- a/src/test/compile-fail/borrowck-bad-nested-calls-free.rs +++ b/src/test/compile-fail/borrowck-bad-nested-calls-free.rs @@ -30,7 +30,7 @@ fn implicit() { // evaluated, but it gets freed when evaluating the second // argument! add( - a, + &*a, rewrite(&mut a)); //~ ERROR cannot borrow } diff --git a/src/test/compile-fail/borrowck-bad-nested-calls-move.rs b/src/test/compile-fail/borrowck-bad-nested-calls-move.rs index d1ab70e4aedcc..708eed0d113bd 100644 --- a/src/test/compile-fail/borrowck-bad-nested-calls-move.rs +++ b/src/test/compile-fail/borrowck-bad-nested-calls-move.rs @@ -30,7 +30,7 @@ fn implicit() { // evaluated, but it gets moved when evaluating the second // argument! add( - a, + &*a, a); //~ ERROR cannot move } diff --git a/src/test/compile-fail/borrowck-closures-use-after-free.rs b/src/test/compile-fail/borrowck-closures-use-after-free.rs index ec31160f0d535..735d9ece9b1a5 100644 --- a/src/test/compile-fail/borrowck-closures-use-after-free.rs +++ b/src/test/compile-fail/borrowck-closures-use-after-free.rs @@ -28,5 +28,5 @@ fn main() { let test = |foo: &Foo| { ptr = box Foo { x: ptr.x + 1 }; }; - test(ptr); //~ ERROR cannot borrow `*ptr` + test(&*ptr); //~ ERROR cannot borrow `*ptr` } diff --git a/src/test/compile-fail/borrowck-lend-flow-loop.rs b/src/test/compile-fail/borrowck-lend-flow-loop.rs index 561d8c679a1a4..12e1240d10d63 100644 --- a/src/test/compile-fail/borrowck-lend-flow-loop.rs +++ b/src/test/compile-fail/borrowck-lend-flow-loop.rs @@ -31,7 +31,7 @@ fn loop_overarching_alias_mut() { let mut x = &mut v; **x += 1; loop { - borrow(v); //~ ERROR cannot borrow + borrow(&*v); //~ ERROR cannot borrow } } @@ -41,7 +41,7 @@ fn block_overarching_alias_mut() { let mut v = box 3; let mut x = &mut v; for _ in range(0i, 3) { - borrow(v); //~ ERROR cannot borrow + borrow(&*v); //~ ERROR cannot borrow } *x = box 5; } @@ -105,7 +105,7 @@ fn while_aliased_mut_cond(cond: bool, cond2: bool) { let mut x = &mut w; while cond { **x += 1; - borrow(v); //~ ERROR cannot borrow + borrow(&*v); //~ ERROR cannot borrow if cond2 { x = &mut v; //~ ERROR cannot borrow } diff --git a/src/test/compile-fail/borrowck-loan-blocks-mut-uniq.rs b/src/test/compile-fail/borrowck-loan-blocks-mut-uniq.rs index c11a08b254f1c..bfa890ada9f19 100644 --- a/src/test/compile-fail/borrowck-loan-blocks-mut-uniq.rs +++ b/src/test/compile-fail/borrowck-loan-blocks-mut-uniq.rs @@ -14,7 +14,7 @@ fn borrow(v: &int, f: |x: &int|) { fn box_imm() { let mut v = box 3; - borrow(v, + borrow(&*v, |w| { //~ ERROR cannot borrow `v` as mutable v = box 4; assert_eq!(*v, 3); diff --git a/src/test/compile-fail/borrowck-preserve-box-in-field.rs b/src/test/compile-fail/borrowck-preserve-box-in-field.rs index 1ea4a98c45bee..b9dc795358083 100644 --- a/src/test/compile-fail/borrowck-preserve-box-in-field.rs +++ b/src/test/compile-fail/borrowck-preserve-box-in-field.rs @@ -25,7 +25,7 @@ struct F { f: Box } pub fn main() { let mut x = box(GC) F {f: box 3}; - borrow(x.f, |b_x| { + borrow(&*x.f, |b_x| { //~^ ERROR cannot borrow `x` as mutable because `*x.f` is also borrowed as immutable assert_eq!(*b_x, 3); assert_eq!(&(*x.f) as *const int, &(*b_x) as *const int); diff --git a/src/test/compile-fail/borrowck-preserve-box-in-uniq.rs b/src/test/compile-fail/borrowck-preserve-box-in-uniq.rs index 979791ad763f5..38c80f293ef24 100644 --- a/src/test/compile-fail/borrowck-preserve-box-in-uniq.rs +++ b/src/test/compile-fail/borrowck-preserve-box-in-uniq.rs @@ -25,7 +25,7 @@ struct F { f: Box } pub fn main() { let mut x = box box(GC) F{f: box 3}; - borrow(x.f, |b_x| { + borrow(&*x.f, |b_x| { //~^ ERROR cannot borrow `x` as mutable because `*x.f` is also borrowed as immutable assert_eq!(*b_x, 3); assert_eq!(&(*x.f) as *const int, &(*b_x) as *const int); diff --git a/src/test/compile-fail/borrowck-preserve-box.rs b/src/test/compile-fail/borrowck-preserve-box.rs index 9eadb62c3a059..d838851e922ca 100644 --- a/src/test/compile-fail/borrowck-preserve-box.rs +++ b/src/test/compile-fail/borrowck-preserve-box.rs @@ -23,7 +23,7 @@ fn borrow(x: &int, f: |x: &int|) { pub fn main() { let mut x = box(GC) 3; - borrow(x, |b_x| { + borrow(&*x, |b_x| { //~^ ERROR cannot borrow `x` as mutable because `*x` is also borrowed as immutable assert_eq!(*b_x, 3); assert_eq!(&(*x) as *const int, &(*b_x) as *const int); diff --git a/src/test/compile-fail/borrowck-preserve-expl-deref.rs b/src/test/compile-fail/borrowck-preserve-expl-deref.rs index 066bb53cdc4d3..d00bded2d79ca 100644 --- a/src/test/compile-fail/borrowck-preserve-expl-deref.rs +++ b/src/test/compile-fail/borrowck-preserve-expl-deref.rs @@ -25,7 +25,7 @@ struct F { f: Box } pub fn main() { let mut x = box(GC) F {f: box 3}; - borrow((*x).f, |b_x| { + borrow(&*(*x).f, |b_x| { //~^ ERROR cannot borrow `x` as mutable because `*x.f` is also borrowed as immutable assert_eq!(*b_x, 3); assert_eq!(&(*x.f) as *const int, &(*b_x) as *const int); diff --git a/src/test/compile-fail/borrowck-uniq-via-lend.rs b/src/test/compile-fail/borrowck-uniq-via-lend.rs index 5a129956487c9..9785b6a8f69a3 100644 --- a/src/test/compile-fail/borrowck-uniq-via-lend.rs +++ b/src/test/compile-fail/borrowck-uniq-via-lend.rs @@ -13,13 +13,13 @@ fn borrow(_v: &int) {} fn local() { let mut v = box 3i; - borrow(v); + borrow(&*v); } fn local_rec() { struct F { f: Box } let mut v = F {f: box 3}; - borrow(v.f); + borrow(&*v.f); } fn local_recs() { @@ -27,26 +27,26 @@ fn local_recs() { struct G { g: H } struct H { h: Box } let mut v = F {f: G {g: H {h: box 3}}}; - borrow(v.f.g.h); + borrow(&*v.f.g.h); } fn aliased_imm() { let mut v = box 3i; let _w = &v; - borrow(v); + borrow(&*v); } fn aliased_mut() { let mut v = box 3i; let _w = &mut v; - borrow(v); //~ ERROR cannot borrow `*v` + borrow(&*v); //~ ERROR cannot borrow `*v` } fn aliased_other() { let mut v = box 3i; let mut w = box 4i; let _x = &mut w; - borrow(v); + borrow(&*v); } fn aliased_other_reassign() { @@ -54,7 +54,7 @@ fn aliased_other_reassign() { let mut w = box 4i; let mut _x = &mut w; _x = &mut v; - borrow(v); //~ ERROR cannot borrow `*v` + borrow(&*v); //~ ERROR cannot borrow `*v` } fn main() { diff --git a/src/test/compile-fail/issue-11192.rs b/src/test/compile-fail/issue-11192.rs index e7fa8300bcb69..18a00d15eafe3 100644 --- a/src/test/compile-fail/issue-11192.rs +++ b/src/test/compile-fail/issue-11192.rs @@ -25,7 +25,7 @@ fn main() { ptr = box Foo { x: ptr.x + 1 }; println!("access {}", foo.x); }; - test(ptr); + test(&*ptr); //~^ ERROR: cannot borrow `*ptr` as immutable } diff --git a/src/test/compile-fail/isuue-12470.rs b/src/test/compile-fail/isuue-12470.rs index 18bfb7abe6c86..d4073a5e98479 100644 --- a/src/test/compile-fail/isuue-12470.rs +++ b/src/test/compile-fail/isuue-12470.rs @@ -33,7 +33,7 @@ fn make_a<'a>(p: &'a X) -> A<'a> { fn make_make_a() -> A { let b: Box = box B {i:1}; - let bb: &B = b; //~ ERROR does not live long enough + let bb: &B = &*b; //~ ERROR does not live long enough make_a(bb) } diff --git a/src/test/compile-fail/lint-allocation.rs b/src/test/compile-fail/lint-allocation.rs deleted file mode 100644 index 1600043acbfbb..0000000000000 --- a/src/test/compile-fail/lint-allocation.rs +++ /dev/null @@ -1,17 +0,0 @@ -// Copyright 2013 The Rust Project Developers. See the COPYRIGHT -// file at the top-level directory of this distribution and at -// http://rust-lang.org/COPYRIGHT. -// -// Licensed under the Apache License, Version 2.0 or the MIT license -// , at your -// option. This file may not be copied, modified, or distributed -// except according to those terms. - -#![deny(unnecessary_allocation)] - -fn f(_: &int) {} - -fn main() { - f(box 1); //~ ERROR unnecessary allocation, use & instead -} diff --git a/src/test/compile-fail/regions-infer-borrow-scope-too-big.rs b/src/test/compile-fail/regions-infer-borrow-scope-too-big.rs index 77988d1867952..028988dbd4fa5 100644 --- a/src/test/compile-fail/regions-infer-borrow-scope-too-big.rs +++ b/src/test/compile-fail/regions-infer-borrow-scope-too-big.rs @@ -22,7 +22,7 @@ fn x_coord<'r>(p: &'r point) -> &'r int { } fn foo(p: Gc) -> &int { - let xc = x_coord(p); //~ ERROR `*p` does not live long enough + let xc = x_coord(&*p); //~ ERROR `*p` does not live long enough assert_eq!(*xc, 3); return xc; } diff --git a/src/test/compile-fail/regions-infer-borrow-scope-within-loop.rs b/src/test/compile-fail/regions-infer-borrow-scope-within-loop.rs index 0aff58c34cc23..bb021d4135a16 100644 --- a/src/test/compile-fail/regions-infer-borrow-scope-within-loop.rs +++ b/src/test/compile-fail/regions-infer-borrow-scope-within-loop.rs @@ -21,7 +21,7 @@ fn foo(cond: || -> bool, make_box: || -> Gc) { // Here we complain because the resulting region // of this borrow is the fn body as a whole. - y = borrow(x); //~ ERROR `*x` does not live long enough + y = borrow(&*x); //~ ERROR `*x` does not live long enough assert_eq!(*x, *y); if cond() { break; } diff --git a/src/test/compile-fail/regions-trait-variance.rs b/src/test/compile-fail/regions-trait-variance.rs index 62e6a404838c2..24dcfb87ad884 100644 --- a/src/test/compile-fail/regions-trait-variance.rs +++ b/src/test/compile-fail/regions-trait-variance.rs @@ -42,7 +42,7 @@ fn make_make_a() -> A { let b: Box = box B { i: 1, }; - let bb: &B = b; //~ ERROR `*b` does not live long enough + let bb: &B = &*b; //~ ERROR `*b` does not live long enough make_a(bb) } diff --git a/src/test/compile-fail/struct-field-assignability.rs b/src/test/compile-fail/struct-field-assignability.rs index b6ce848a7d8fb..bfa8f402a82db 100644 --- a/src/test/compile-fail/struct-field-assignability.rs +++ b/src/test/compile-fail/struct-field-assignability.rs @@ -1,3 +1,5 @@ +// ignore-test + // Copyright 2014 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. @@ -17,6 +19,6 @@ struct Foo<'a> { } pub fn main() { - let f = Foo { x: box(GC) 3 }; //~ ERROR borrowed value does not live long enough + let f = Foo { x: &*(box(GC) 3) }; //~ ERROR borrowed value does not live long enough assert_eq!(*f.x, 3); } diff --git a/src/test/debuginfo/borrowed-managed-basic.rs b/src/test/debuginfo/borrowed-managed-basic.rs index 82e44b46d3c8c..8e924a46d9aaa 100644 --- a/src/test/debuginfo/borrowed-managed-basic.rs +++ b/src/test/debuginfo/borrowed-managed-basic.rs @@ -120,46 +120,46 @@ use std::gc::{Gc, GC}; fn main() { let bool_box: Gc = box(GC) true; - let bool_ref: &bool = bool_box; + let bool_ref: &bool = &*bool_box; let int_box: Gc = box(GC) -1; - let int_ref: &int = int_box; + let int_ref: &int = &*int_box; let char_box: Gc = box(GC) 'a'; - let char_ref: &char = char_box; + let char_ref: &char = &*char_box; let i8_box: Gc = box(GC) 68; - let i8_ref: &i8 = i8_box; + let i8_ref: &i8 = &*i8_box; let i16_box: Gc = box(GC) -16; - let i16_ref: &i16 = i16_box; + let i16_ref: &i16 = &*i16_box; let i32_box: Gc = box(GC) -32; - let i32_ref: &i32 = i32_box; + let i32_ref: &i32 = &*i32_box; let i64_box: Gc = box(GC) -64; - let i64_ref: &i64 = i64_box; + let i64_ref: &i64 = &*i64_box; let uint_box: Gc = box(GC) 1; - let uint_ref: &uint = uint_box; + let uint_ref: &uint = &*uint_box; let u8_box: Gc = box(GC) 100; - let u8_ref: &u8 = u8_box; + let u8_ref: &u8 = &*u8_box; let u16_box: Gc = box(GC) 16; - let u16_ref: &u16 = u16_box; + let u16_ref: &u16 = &*u16_box; let u32_box: Gc = box(GC) 32; - let u32_ref: &u32 = u32_box; + let u32_ref: &u32 = &*u32_box; let u64_box: Gc = box(GC) 64; - let u64_ref: &u64 = u64_box; + let u64_ref: &u64 = &*u64_box; let f32_box: Gc = box(GC) 2.5; - let f32_ref: &f32 = f32_box; + let f32_ref: &f32 = &*f32_box; let f64_box: Gc = box(GC) 3.5; - let f64_ref: &f64 = f64_box; + let f64_ref: &f64 = &*f64_box; zzz(); // #break } diff --git a/src/test/debuginfo/borrowed-struct.rs b/src/test/debuginfo/borrowed-struct.rs index 5ad0fe89d2cdf..ed56c19869f22 100644 --- a/src/test/debuginfo/borrowed-struct.rs +++ b/src/test/debuginfo/borrowed-struct.rs @@ -100,12 +100,12 @@ fn main() { let ref_to_unnamed: &SomeStruct = &SomeStruct { x: 11, y: 24.5 }; let managed_val = box(GC) SomeStruct { x: 12, y: 25.5 }; - let managed_val_ref: &SomeStruct = managed_val; + let managed_val_ref: &SomeStruct = &*managed_val; let managed_val_interior_ref_1: &int = &managed_val.x; let managed_val_interior_ref_2: &f64 = &managed_val.y; let unique_val = box SomeStruct { x: 13, y: 26.5 }; - let unique_val_ref: &SomeStruct = unique_val; + let unique_val_ref: &SomeStruct = &*unique_val; let unique_val_interior_ref_1: &int = &unique_val.x; let unique_val_interior_ref_2: &f64 = &unique_val.y; diff --git a/src/test/debuginfo/borrowed-tuple.rs b/src/test/debuginfo/borrowed-tuple.rs index 5c20c7471ec26..583906b7b3070 100644 --- a/src/test/debuginfo/borrowed-tuple.rs +++ b/src/test/debuginfo/borrowed-tuple.rs @@ -60,10 +60,10 @@ fn main() { let ref_to_unnamed: &(i16, f32) = &(-15, -20f32); let managed_val: Gc<(i16, f32)> = box(GC) (-16, -21f32); - let managed_val_ref: &(i16, f32) = managed_val; + let managed_val_ref: &(i16, f32) = &*managed_val; let unique_val: Box<(i16, f32)> = box() (-17, -22f32); - let unique_val_ref: &(i16, f32) = unique_val; + let unique_val_ref: &(i16, f32) = &*unique_val; zzz(); // #break } diff --git a/src/test/debuginfo/borrowed-unique-basic.rs b/src/test/debuginfo/borrowed-unique-basic.rs index 821c85fdcf3a0..4a5df78b5c61e 100644 --- a/src/test/debuginfo/borrowed-unique-basic.rs +++ b/src/test/debuginfo/borrowed-unique-basic.rs @@ -116,46 +116,46 @@ fn main() { let bool_box: Box = box true; - let bool_ref: &bool = bool_box; + let bool_ref: &bool = &*bool_box; let int_box: Box = box -1; - let int_ref: &int = int_box; + let int_ref: &int = &*int_box; let char_box: Box = box 'a'; - let char_ref: &char = char_box; + let char_ref: &char = &*char_box; let i8_box: Box = box 68; - let i8_ref: &i8 = i8_box; + let i8_ref: &i8 = &*i8_box; let i16_box: Box = box -16; - let i16_ref: &i16 = i16_box; + let i16_ref: &i16 = &*i16_box; let i32_box: Box = box -32; - let i32_ref: &i32 = i32_box; + let i32_ref: &i32 = &*i32_box; let i64_box: Box = box -64; - let i64_ref: &i64 = i64_box; + let i64_ref: &i64 = &*i64_box; let uint_box: Box = box 1; - let uint_ref: &uint = uint_box; + let uint_ref: &uint = &*uint_box; let u8_box: Box = box 100; - let u8_ref: &u8 = u8_box; + let u8_ref: &u8 = &*u8_box; let u16_box: Box = box 16; - let u16_ref: &u16 = u16_box; + let u16_ref: &u16 = &*u16_box; let u32_box: Box = box 32; - let u32_ref: &u32 = u32_box; + let u32_ref: &u32 = &*u32_box; let u64_box: Box = box 64; - let u64_ref: &u64 = u64_box; + let u64_ref: &u64 = &*u64_box; let f32_box: Box = box 2.5; - let f32_ref: &f32 = f32_box; + let f32_ref: &f32 = &*f32_box; let f64_box: Box = box 3.5; - let f64_ref: &f64 = f64_box; + let f64_ref: &f64 = &*f64_box; zzz(); // #break } diff --git a/src/test/debuginfo/var-captured-in-sendable-closure.rs b/src/test/debuginfo/var-captured-in-sendable-closure.rs index cd100415cbec6..e87c23b96e276 100644 --- a/src/test/debuginfo/var-captured-in-sendable-closure.rs +++ b/src/test/debuginfo/var-captured-in-sendable-closure.rs @@ -58,7 +58,7 @@ fn main() { let closure: proc() = proc() { zzz(); // #break - do_something(&constant, &a_struct.a, owned); + do_something(&constant, &a_struct.a, &*owned); }; closure(); diff --git a/src/test/run-pass/bitv-perf-test.rs b/src/test/run-pass/bitv-perf-test.rs index 3823a7033f5a6..281167ff46c86 100644 --- a/src/test/run-pass/bitv-perf-test.rs +++ b/src/test/run-pass/bitv-perf-test.rs @@ -15,7 +15,7 @@ use std::collections::Bitv; fn bitv_test() { let mut v1 = box Bitv::with_capacity(31, false); let v2 = box Bitv::with_capacity(31, true); - v1.union(v2); + v1.union(&*v2); } pub fn main() { diff --git a/src/test/run-pass/borrowck-lend-args.rs b/src/test/run-pass/borrowck-lend-args.rs index 68d1b74e2019b..9b8fa8f9f79b2 100644 --- a/src/test/run-pass/borrowck-lend-args.rs +++ b/src/test/run-pass/borrowck-lend-args.rs @@ -12,15 +12,15 @@ fn borrow(_v: &int) {} fn borrow_from_arg_imm_ref(v: Box) { - borrow(v); + borrow(&*v); } fn borrow_from_arg_mut_ref(v: &mut Box) { - borrow(*v); + borrow(&**v); } fn borrow_from_arg_copy(v: Box) { - borrow(v); + borrow(&*v); } pub fn main() { diff --git a/src/test/run-pass/borrowck-mut-uniq.rs b/src/test/run-pass/borrowck-mut-uniq.rs index c0be4abafbe9a..993ce37a1eca7 100644 --- a/src/test/run-pass/borrowck-mut-uniq.rs +++ b/src/test/run-pass/borrowck-mut-uniq.rs @@ -32,7 +32,7 @@ pub fn main() { add_int(&mut *ints, 22); add_int(&mut *ints, 44); - iter_ints(ints, |i| { + iter_ints(&*ints, |i| { println!("int = {}", *i); true }); diff --git a/src/test/run-pass/borrowck-root-while-cond.rs b/src/test/run-pass/borrowck-root-while-cond.rs index eda8637adc4cf..35cdfb41abca0 100644 --- a/src/test/run-pass/borrowck-root-while-cond.rs +++ b/src/test/run-pass/borrowck-root-while-cond.rs @@ -18,5 +18,5 @@ struct Rec { f: Gc } pub fn main() { let rec = box(GC) Rec {f: box(GC) 22}; - while *borrow(rec.f) == 23 {} + while *borrow(&*rec.f) == 23 {} } diff --git a/src/test/run-pass/borrowck-uniq-via-ref.rs b/src/test/run-pass/borrowck-uniq-via-ref.rs index 451f9ccf5bd6d..84bd70c78d487 100644 --- a/src/test/run-pass/borrowck-uniq-via-ref.rs +++ b/src/test/run-pass/borrowck-uniq-via-ref.rs @@ -28,27 +28,27 @@ struct Innermost { fn borrow(_v: &int) {} fn box_mut(v: &mut Box) { - borrow(*v); // OK: &mut -> &imm + borrow(&**v); // OK: &mut -> &imm } fn box_mut_rec(v: &mut Rec) { - borrow(v.f); // OK: &mut -> &imm + borrow(&*v.f); // OK: &mut -> &imm } fn box_mut_recs(v: &mut Outer) { - borrow(v.f.g.h); // OK: &mut -> &imm + borrow(&*v.f.g.h); // OK: &mut -> &imm } fn box_imm(v: &Box) { - borrow(*v); // OK + borrow(&**v); // OK } fn box_imm_rec(v: &Rec) { - borrow(v.f); // OK + borrow(&*v.f); // OK } fn box_imm_recs(v: &Outer) { - borrow(v.f.g.h); // OK + borrow(&*v.f.g.h); // OK } pub fn main() { diff --git a/src/test/run-pass/cci_borrow.rs b/src/test/run-pass/cci_borrow.rs index 324fb428df019..32b4065439f93 100644 --- a/src/test/run-pass/cci_borrow.rs +++ b/src/test/run-pass/cci_borrow.rs @@ -18,7 +18,7 @@ use std::gc::GC; pub fn main() { let p = box(GC) 22u; - let r = foo(p); + let r = foo(&*p); println!("r={}", r); assert_eq!(r, 22u); } diff --git a/src/test/run-pass/issue-3794.rs b/src/test/run-pass/issue-3794.rs index 00878189627ae..9414a6f2302df 100644 --- a/src/test/run-pass/issue-3794.rs +++ b/src/test/run-pass/issue-3794.rs @@ -34,8 +34,7 @@ fn print_s(s: &S) { pub fn main() { let s: Box = box S { s: 5 }; - print_s(s); + print_s(&*s); let t: Box = s as Box; print_t(t); - } diff --git a/src/test/run-pass/issue-5884.rs b/src/test/run-pass/issue-5884.rs index c99fb7765fb23..2d8f966caf1bf 100644 --- a/src/test/run-pass/issue-5884.rs +++ b/src/test/run-pass/issue-5884.rs @@ -22,7 +22,7 @@ struct Bar<'a> { } fn check(a: Gc) { - let _ic = Bar{ b: a, a: box None }; + let _ic = Bar{ b: &*a, a: box None }; } pub fn main(){} diff --git a/src/test/run-pass/let-assignability.rs b/src/test/run-pass/let-assignability.rs index 477f3b2acafda..6bea1aebc4588 100644 --- a/src/test/run-pass/let-assignability.rs +++ b/src/test/run-pass/let-assignability.rs @@ -10,7 +10,7 @@ fn f() { let a = box 1; - let b: &int = a; + let b: &int = &*a; println!("{}", b); } diff --git a/src/test/run-pass/new-box.rs b/src/test/run-pass/new-box.rs index d41896ffb41d0..38f552e9a9846 100644 --- a/src/test/run-pass/new-box.rs +++ b/src/test/run-pass/new-box.rs @@ -10,7 +10,7 @@ fn f(x: Box) { - let y: &int = x; + let y: &int = &*x; println!("{}", *x); println!("{}", *y); } diff --git a/src/test/run-pass/regions-borrow-at.rs b/src/test/run-pass/regions-borrow-at.rs index c6dfbabd448db..74990432d03e0 100644 --- a/src/test/run-pass/regions-borrow-at.rs +++ b/src/test/run-pass/regions-borrow-at.rs @@ -18,7 +18,7 @@ fn foo(x: &uint) -> uint { pub fn main() { let p = box(GC) 22u; - let r = foo(p); + let r = foo(&*p); println!("r={}", r); assert_eq!(r, 22u); } diff --git a/src/test/run-pass/regions-borrow-uniq.rs b/src/test/run-pass/regions-borrow-uniq.rs index 6b35c0768d79a..36f7d88f7d797 100644 --- a/src/test/run-pass/regions-borrow-uniq.rs +++ b/src/test/run-pass/regions-borrow-uniq.rs @@ -14,6 +14,6 @@ fn foo(x: &uint) -> uint { pub fn main() { let p = box 3u; - let r = foo(p); + let r = foo(&*p); assert_eq!(r, 3u); } diff --git a/src/test/run-pass/regions-escape-into-other-fn.rs b/src/test/run-pass/regions-escape-into-other-fn.rs index 695a1b110da4e..5e2893c49809e 100644 --- a/src/test/run-pass/regions-escape-into-other-fn.rs +++ b/src/test/run-pass/regions-escape-into-other-fn.rs @@ -17,5 +17,5 @@ fn bar(x: &uint) -> uint { *x } pub fn main() { let p = box(GC) 3u; - assert_eq!(bar(foo(p)), 3); + assert_eq!(bar(foo(&*p)), 3); } diff --git a/src/test/run-pass/regions-infer-borrow-scope-within-loop-ok.rs b/src/test/run-pass/regions-infer-borrow-scope-within-loop-ok.rs index 8f05531853390..0b42f71fccb05 100644 --- a/src/test/run-pass/regions-infer-borrow-scope-within-loop-ok.rs +++ b/src/test/run-pass/regions-infer-borrow-scope-within-loop-ok.rs @@ -15,7 +15,7 @@ fn borrow<'r, T>(x: &'r T) -> &'r T {x} pub fn main() { let x = box(GC) 3i; loop { - let y = borrow(x); + let y = borrow(&*x); assert_eq!(*x, *y); break; } diff --git a/src/test/run-pass/regions-infer-borrow-scope.rs b/src/test/run-pass/regions-infer-borrow-scope.rs index c757762245325..abbbb51580fb7 100644 --- a/src/test/run-pass/regions-infer-borrow-scope.rs +++ b/src/test/run-pass/regions-infer-borrow-scope.rs @@ -20,6 +20,6 @@ fn x_coord<'r>(p: &'r Point) -> &'r int { pub fn main() { let p = box(GC) Point {x: 3, y: 4}; - let xc = x_coord(p); + let xc = x_coord(&*p); assert_eq!(*xc, 3); }