diff --git a/src/librustc/middle/typeck/check/regionck.rs b/src/librustc/middle/typeck/check/regionck.rs index d034277d44a..21cabb5a745 100644 --- a/src/librustc/middle/typeck/check/regionck.rs +++ b/src/librustc/middle/typeck/check/regionck.rs @@ -391,7 +391,7 @@ fn visit_expr(expr: @ast::expr, (rcx, v): (@mut Rcx, rvt)) { let target_ty = rcx.resolve_node_type(expr.id); match ty::get(target_ty).sty { ty::ty_trait(_, _, ty::RegionTraitStore(trait_region), _, _) => { - let source_ty = rcx.fcx.expr_ty(source); + let source_ty = rcx.resolve_expr_type_adjusted(source); constrain_regions_in_type( rcx, trait_region, @@ -1153,17 +1153,20 @@ pub mod guarantor { match ty::get(ty).sty { ty::ty_rptr(r, _) | ty::ty_evec(_, ty::vstore_slice(r)) | + ty::ty_trait(_, _, ty::RegionTraitStore(r), _, _) | ty::ty_estr(ty::vstore_slice(r)) => { BorrowedPointer(r) } ty::ty_uniq(*) | ty::ty_estr(ty::vstore_uniq) | + ty::ty_trait(_, _, ty::UniqTraitStore, _, _) | ty::ty_evec(_, ty::vstore_uniq) => { OwnedPointer } ty::ty_box(*) | ty::ty_ptr(*) | ty::ty_evec(_, ty::vstore_box) | + ty::ty_trait(_, _, ty::BoxTraitStore, _, _) | ty::ty_estr(ty::vstore_box) => { OtherPointer } diff --git a/src/librustc/middle/typeck/infer/coercion.rs b/src/librustc/middle/typeck/infer/coercion.rs index f2bde146ea7..7736dbbb99d 100644 --- a/src/librustc/middle/typeck/infer/coercion.rs +++ b/src/librustc/middle/typeck/infer/coercion.rs @@ -121,9 +121,9 @@ impl Coerce { }; } - ty::ty_trait(_, _, ty::RegionTraitStore(*), _, _) => { + ty::ty_trait(_, _, ty::RegionTraitStore(*), m, _) => { return do self.unpack_actual_value(a) |sty_a| { - self.coerce_borrowed_object(a, sty_a, b) + self.coerce_borrowed_object(a, sty_a, b, m) }; } @@ -274,7 +274,8 @@ impl Coerce { fn coerce_borrowed_object(&self, a: ty::t, sty_a: &ty::sty, - b: ty::t) -> CoerceResult + b: ty::t, + b_mutbl: ast::mutability) -> CoerceResult { debug!("coerce_borrowed_object(a=%s, sty_a=%?, b=%s)", a.inf_str(self.infcx), sty_a, @@ -282,26 +283,21 @@ impl Coerce { let tcx = self.infcx.tcx; let r_a = self.infcx.next_region_var(Coercion(self.trace)); - let trt_mut; let a_borrowed = match *sty_a { - ty::ty_trait(_, _, ty::RegionTraitStore(_), _, _) => { - return self.subtype(a, b); - } - ty::ty_trait(did, ref substs, _, m, b) => { - trt_mut = m; + ty::ty_trait(did, ref substs, _, _, b) => { ty::mk_trait(tcx, did, substs.clone(), - ty::RegionTraitStore(r_a), m, b) + ty::RegionTraitStore(r_a), b_mutbl, b) } _ => { return self.subtype(a, b); } }; - if_ok!(self.tys(a_borrowed, b)); + if_ok!(self.subtype(a_borrowed, b)); Ok(Some(@AutoDerefRef(AutoDerefRef { autoderefs: 0, - autoref: Some(AutoBorrowObj(r_a, trt_mut)) + autoref: Some(AutoBorrowObj(r_a, b_mutbl)) }))) } diff --git a/src/test/run-fail/borrowck-wg-fail-object-arg.rs b/src/test/run-fail/borrowck-wg-fail-object-arg.rs new file mode 100644 index 00000000000..c70d752ef30 --- /dev/null +++ b/src/test/run-fail/borrowck-wg-fail-object-arg.rs @@ -0,0 +1,22 @@ +// error-pattern:borrowed + +trait Foo { + fn foo(&self, @mut int); +} + +impl Foo for int { + fn foo(&self, x: @mut int) { + *x += *self; + } +} + +fn it_takes_two(f: &Foo, g: &mut Foo) { +} + +fn main() { + let x = @mut 3_i; + let y = x as @mut Foo; + let z = y; + + it_takes_two(y, z); +} diff --git a/src/test/run-pass/objects-coerce-freeze-borrored.rs b/src/test/run-pass/objects-coerce-freeze-borrored.rs new file mode 100644 index 00000000000..4dda5ca556e --- /dev/null +++ b/src/test/run-pass/objects-coerce-freeze-borrored.rs @@ -0,0 +1,48 @@ +// Copyright 2012 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. + +// Test that we can coerce an `@Object` to an `&Object` + +trait Foo { + fn foo(&self) -> uint; + fn bar(&mut self) -> uint; +} + +impl Foo for uint { + fn foo(&self) -> uint { + *self + } + + fn bar(&mut self) -> uint { + *self += 1; + *self + } +} + +fn do_it_mut(obj: &mut Foo) { + let x = obj.bar(); + let y = obj.foo(); + assert_eq!(x, y); + + do_it_imm(obj, y); +} + +fn do_it_imm(obj: &Foo, v: uint) { + let y = obj.foo(); + assert_eq!(v, y); +} + +fn main() { + let mut x = 22_u; + let obj = &mut x as &mut Foo; + do_it_mut(obj); + do_it_imm(obj, 23u); + do_it_mut(obj); +} diff --git a/src/test/run-pass/objects-coerce-from-managed-to-borrowed.rs b/src/test/run-pass/objects-coerce-from-managed-to-borrowed.rs new file mode 100644 index 00000000000..fe4eb2ea48e --- /dev/null +++ b/src/test/run-pass/objects-coerce-from-managed-to-borrowed.rs @@ -0,0 +1,44 @@ +// Copyright 2012 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. + +// Test that we can coerce an `@Object` to an `&Object` + +trait Foo { + fn foo(&self) -> uint; + fn bar(&mut self) -> uint; +} + +impl Foo for uint { + fn foo(&self) -> uint { + *self + } + + fn bar(&mut self) -> uint { + *self += 1; + *self + } +} + +fn do_it_mut(obj: &mut Foo) { + let x = obj.bar(); + let y = obj.foo(); + assert_eq!(x, y); +} + +fn do_it_imm(obj: &Foo, v: uint) { + let y = obj.foo(); + assert_eq!(v, y); +} + +fn main() { + let x = @mut 22u as @mut Foo; + do_it_mut(x); + do_it_imm(x, 23u); +}