auto merge of #15242 : pcwalton/rust/self-in-trait-methods, r=alexcrichton
I can't believe this worked! I believe that the way the ABI and immediates work mean that this Just Works. Closes #10672. r? @alexcrichton
This commit is contained in:
bors
commit
5cef1243a2
|
|
@ -1220,7 +1220,7 @@ pub fn init_function<'a>(fcx: &'a FunctionContext<'a>,
|
|||
// - new_fn_ctxt
|
||||
// - trans_args
|
||||
|
||||
fn arg_kind(cx: &FunctionContext, t: ty::t) -> datum::Rvalue {
|
||||
pub fn arg_kind(cx: &FunctionContext, t: ty::t) -> datum::Rvalue {
|
||||
use middle::trans::datum::{ByRef, ByValue};
|
||||
|
||||
datum::Rvalue {
|
||||
|
|
|
|||
|
|
@ -159,6 +159,14 @@ impl<'a> Builder<'a> {
|
|||
attributes: &[(uint, u64)])
|
||||
-> ValueRef {
|
||||
self.count_insn("invoke");
|
||||
|
||||
debug!("Invoke {} with args ({})",
|
||||
self.ccx.tn.val_to_str(llfn),
|
||||
args.iter()
|
||||
.map(|&v| self.ccx.tn.val_to_str(v))
|
||||
.collect::<Vec<String>>()
|
||||
.connect(", "));
|
||||
|
||||
unsafe {
|
||||
let v = llvm::LLVMBuildInvoke(self.llbuilder,
|
||||
llfn,
|
||||
|
|
|
|||
|
|
@ -16,7 +16,9 @@
|
|||
* closure.
|
||||
*/
|
||||
|
||||
use arena::TypedArena;
|
||||
use back::abi;
|
||||
use back::link;
|
||||
use driver::session;
|
||||
use lib::llvm::ValueRef;
|
||||
use lib::llvm::llvm;
|
||||
|
|
@ -33,28 +35,26 @@ use middle::trans::cleanup::CleanupMethods;
|
|||
use middle::trans::common;
|
||||
use middle::trans::common::*;
|
||||
use middle::trans::datum::*;
|
||||
use middle::trans::datum::Datum;
|
||||
use middle::trans::datum::{Datum, KindOps};
|
||||
use middle::trans::expr;
|
||||
use middle::trans::glue;
|
||||
use middle::trans::inline;
|
||||
use middle::trans::foreign;
|
||||
use middle::trans::meth;
|
||||
use middle::trans::monomorphize;
|
||||
use middle::trans::type_::Type;
|
||||
use middle::trans::type_of;
|
||||
use middle::trans::foreign;
|
||||
use middle::ty;
|
||||
use middle::typeck;
|
||||
use middle::typeck::coherence::make_substs_for_receiver_types;
|
||||
use middle::typeck::MethodCall;
|
||||
use util::ppaux::Repr;
|
||||
|
||||
use middle::trans::type_::Type;
|
||||
|
||||
use std::gc::Gc;
|
||||
use syntax::ast;
|
||||
use synabi = syntax::abi;
|
||||
use syntax::ast_map;
|
||||
|
||||
use std::gc::Gc;
|
||||
|
||||
pub struct MethodData {
|
||||
pub llfn: ValueRef,
|
||||
pub llself: ValueRef,
|
||||
|
|
@ -224,6 +224,134 @@ fn resolve_default_method_vtables(bcx: &Block,
|
|||
param_vtables
|
||||
}
|
||||
|
||||
/// Translates the adapter that deconstructs a `Box<Trait>` object into
|
||||
/// `Trait` so that a by-value self method can be called.
|
||||
pub fn trans_unboxing_shim(bcx: &Block,
|
||||
llshimmedfn: ValueRef,
|
||||
method: &ty::Method,
|
||||
method_id: ast::DefId,
|
||||
substs: subst::Substs)
|
||||
-> ValueRef {
|
||||
let _icx = push_ctxt("trans_unboxing_shim");
|
||||
let ccx = bcx.ccx();
|
||||
let tcx = bcx.tcx();
|
||||
|
||||
// Transform the self type to `Box<self_type>`.
|
||||
let self_type = *method.fty.sig.inputs.get(0);
|
||||
let boxed_self_type = ty::mk_uniq(tcx, self_type);
|
||||
let boxed_function_type = ty::FnSig {
|
||||
binder_id: method.fty.sig.binder_id,
|
||||
inputs: method.fty.sig.inputs.iter().enumerate().map(|(i, typ)| {
|
||||
if i == 0 {
|
||||
boxed_self_type
|
||||
} else {
|
||||
*typ
|
||||
}
|
||||
}).collect(),
|
||||
output: method.fty.sig.output,
|
||||
variadic: false,
|
||||
};
|
||||
let boxed_function_type = ty::BareFnTy {
|
||||
fn_style: method.fty.fn_style,
|
||||
abi: method.fty.abi,
|
||||
sig: boxed_function_type,
|
||||
};
|
||||
let boxed_function_type =
|
||||
ty::mk_bare_fn(tcx, boxed_function_type).subst(tcx, &substs);
|
||||
let function_type =
|
||||
ty::mk_bare_fn(tcx, method.fty.clone()).subst(tcx, &substs);
|
||||
|
||||
let function_name = tcx.map.with_path(method_id.node, |path| {
|
||||
link::mangle_internal_name_by_path_and_seq(path, "unboxing_shim")
|
||||
});
|
||||
let llfn = decl_internal_rust_fn(ccx,
|
||||
boxed_function_type,
|
||||
function_name.as_slice());
|
||||
|
||||
let block_arena = TypedArena::new();
|
||||
let empty_param_substs = param_substs::empty();
|
||||
let return_type = ty::ty_fn_ret(boxed_function_type);
|
||||
let fcx = new_fn_ctxt(ccx,
|
||||
llfn,
|
||||
-1,
|
||||
false,
|
||||
return_type,
|
||||
&empty_param_substs,
|
||||
None,
|
||||
&block_arena);
|
||||
init_function(&fcx, false, return_type);
|
||||
|
||||
// Create the substituted versions of the self type.
|
||||
let mut bcx = fcx.entry_bcx.borrow().clone().unwrap();
|
||||
let arg_scope = fcx.push_custom_cleanup_scope();
|
||||
let arg_scope_id = cleanup::CustomScope(arg_scope);
|
||||
let boxed_arg_types = ty::ty_fn_args(boxed_function_type);
|
||||
let boxed_self_type = *boxed_arg_types.get(0);
|
||||
let arg_types = ty::ty_fn_args(function_type);
|
||||
let self_type = *arg_types.get(0);
|
||||
let boxed_self_kind = arg_kind(&fcx, boxed_self_type);
|
||||
|
||||
// Create a datum for self.
|
||||
let llboxedself = unsafe {
|
||||
llvm::LLVMGetParam(fcx.llfn, fcx.arg_pos(0) as u32)
|
||||
};
|
||||
let llboxedself = Datum::new(llboxedself,
|
||||
boxed_self_type,
|
||||
boxed_self_kind);
|
||||
let boxed_self =
|
||||
unpack_datum!(bcx,
|
||||
llboxedself.to_lvalue_datum_in_scope(bcx,
|
||||
"boxedself",
|
||||
arg_scope_id));
|
||||
|
||||
// This `Load` is needed because lvalue data are always by-ref.
|
||||
let llboxedself = Load(bcx, boxed_self.val);
|
||||
|
||||
let llself = if type_is_immediate(ccx, self_type) {
|
||||
let llboxedself = Load(bcx, llboxedself);
|
||||
immediate_rvalue(llboxedself, self_type)
|
||||
} else {
|
||||
let llself = rvalue_scratch_datum(bcx, self_type, "self");
|
||||
memcpy_ty(bcx, llself.val, llboxedself, self_type);
|
||||
llself
|
||||
};
|
||||
|
||||
// Make sure we don't free the box twice!
|
||||
boxed_self.kind.post_store(bcx, boxed_self.val, boxed_self_type);
|
||||
|
||||
// Schedule a cleanup to free the box.
|
||||
fcx.schedule_free_value(arg_scope_id,
|
||||
llboxedself,
|
||||
cleanup::HeapExchange,
|
||||
self_type);
|
||||
|
||||
// Now call the function.
|
||||
let mut llshimmedargs = vec!(llself.val);
|
||||
for i in range(1, arg_types.len()) {
|
||||
llshimmedargs.push(unsafe {
|
||||
llvm::LLVMGetParam(fcx.llfn, fcx.arg_pos(i) as u32)
|
||||
});
|
||||
}
|
||||
bcx = trans_call_inner(bcx,
|
||||
None,
|
||||
function_type,
|
||||
|bcx, _| {
|
||||
Callee {
|
||||
bcx: bcx,
|
||||
data: Fn(llshimmedfn),
|
||||
}
|
||||
},
|
||||
ArgVals(llshimmedargs.as_slice()),
|
||||
match fcx.llretptr.get() {
|
||||
None => None,
|
||||
Some(llretptr) => Some(expr::SaveIn(llretptr)),
|
||||
}).bcx;
|
||||
|
||||
bcx = fcx.pop_and_trans_custom_cleanup_scope(bcx, arg_scope);
|
||||
finish_fn(&fcx, bcx);
|
||||
|
||||
llfn
|
||||
}
|
||||
|
||||
pub fn trans_fn_ref_with_vtables(
|
||||
bcx: &Block, //
|
||||
|
|
|
|||
|
|
@ -492,14 +492,24 @@ fn emit_vtable_methods(bcx: &Block,
|
|||
m.repr(tcx),
|
||||
substs.repr(tcx));
|
||||
if m.generics.has_type_params(subst::FnSpace) ||
|
||||
ty::type_has_self(ty::mk_bare_fn(tcx, m.fty.clone()))
|
||||
{
|
||||
ty::type_has_self(ty::mk_bare_fn(tcx, m.fty.clone())) {
|
||||
debug!("(making impl vtable) method has self or type params: {}",
|
||||
token::get_ident(ident));
|
||||
C_null(Type::nil(ccx).ptr_to())
|
||||
} else {
|
||||
trans_fn_ref_with_vtables(bcx, m_id, ExprId(0),
|
||||
substs.clone(), vtables.clone())
|
||||
let mut fn_ref = trans_fn_ref_with_vtables(bcx,
|
||||
m_id,
|
||||
ExprId(0),
|
||||
substs.clone(),
|
||||
vtables.clone());
|
||||
if m.explicit_self == ast::SelfValue {
|
||||
fn_ref = trans_unboxing_shim(bcx,
|
||||
fn_ref,
|
||||
&*m,
|
||||
m_id,
|
||||
substs.clone());
|
||||
}
|
||||
fn_ref
|
||||
}
|
||||
}).collect()
|
||||
}
|
||||
|
|
|
|||
|
|
@ -271,7 +271,9 @@ fn construct_transformed_self_ty_for_object(
|
|||
tcx.sess.span_bug(span, "static method for object type receiver");
|
||||
}
|
||||
ast::SelfValue => {
|
||||
ty::mk_err() // error reported in `enforce_object_limitations()`
|
||||
let tr = ty::mk_trait(tcx, trait_def_id, obj_substs,
|
||||
ty::empty_builtin_bounds());
|
||||
ty::mk_uniq(tcx, tr)
|
||||
}
|
||||
ast::SelfRegion(..) | ast::SelfUniq => {
|
||||
let transformed_self_ty = *method_ty.fty.sig.inputs.get(0);
|
||||
|
|
@ -1225,14 +1227,7 @@ impl<'a> LookupContext<'a> {
|
|||
through an object");
|
||||
}
|
||||
|
||||
ast::SelfValue => { // reason (a) above
|
||||
self.tcx().sess.span_err(
|
||||
self.span,
|
||||
"cannot call a method with a by-value receiver \
|
||||
through an object");
|
||||
}
|
||||
|
||||
ast::SelfRegion(..) | ast::SelfUniq => {}
|
||||
ast::SelfValue | ast::SelfRegion(..) | ast::SelfUniq => {}
|
||||
}
|
||||
|
||||
// reason (a) above
|
||||
|
|
@ -1302,7 +1297,26 @@ impl<'a> LookupContext<'a> {
|
|||
}
|
||||
|
||||
SelfValue => {
|
||||
rcvr_matches_ty(self.fcx, rcvr_ty, candidate)
|
||||
debug!("(is relevant?) explicit self is by-value");
|
||||
match ty::get(rcvr_ty).sty {
|
||||
ty::ty_uniq(typ) => {
|
||||
match ty::get(typ).sty {
|
||||
ty::ty_trait(box ty::TyTrait {
|
||||
def_id: self_did,
|
||||
..
|
||||
}) => {
|
||||
rcvr_matches_object(self_did, candidate) ||
|
||||
rcvr_matches_ty(self.fcx,
|
||||
rcvr_ty,
|
||||
candidate)
|
||||
}
|
||||
_ => {
|
||||
rcvr_matches_ty(self.fcx, rcvr_ty, candidate)
|
||||
}
|
||||
}
|
||||
}
|
||||
_ => rcvr_matches_ty(self.fcx, rcvr_ty, candidate)
|
||||
}
|
||||
}
|
||||
|
||||
SelfRegion(_, m) => {
|
||||
|
|
|
|||
|
|
@ -0,0 +1,51 @@
|
|||
// 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.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
|
||||
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
||||
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
|
||||
// option. This file may not be copied, modified, or distributed
|
||||
// except according to those terms.
|
||||
|
||||
// error-pattern:explicit failure
|
||||
|
||||
trait Foo {
|
||||
fn foo(self, x: int);
|
||||
}
|
||||
|
||||
struct S {
|
||||
x: int,
|
||||
y: int,
|
||||
z: int,
|
||||
s: String,
|
||||
}
|
||||
|
||||
impl Foo for S {
|
||||
fn foo(self, x: int) {
|
||||
fail!()
|
||||
}
|
||||
}
|
||||
|
||||
impl Drop for S {
|
||||
fn drop(&mut self) {
|
||||
println!("bye 1!");
|
||||
}
|
||||
}
|
||||
|
||||
fn f() {
|
||||
let s = S {
|
||||
x: 2,
|
||||
y: 3,
|
||||
z: 4,
|
||||
s: "hello".to_string(),
|
||||
};
|
||||
let st = box s as Box<Foo>;
|
||||
st.foo(5);
|
||||
}
|
||||
|
||||
fn main() {
|
||||
f();
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -0,0 +1,77 @@
|
|||
// 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.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
|
||||
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
||||
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
|
||||
// option. This file may not be copied, modified, or distributed
|
||||
// except according to those terms.
|
||||
|
||||
static mut destructor_count: uint = 0;
|
||||
|
||||
trait Foo {
|
||||
fn foo(self, x: int);
|
||||
}
|
||||
|
||||
struct S {
|
||||
x: int,
|
||||
y: int,
|
||||
z: int,
|
||||
s: String,
|
||||
}
|
||||
|
||||
impl Foo for S {
|
||||
fn foo(self, x: int) {
|
||||
assert!(self.x == 2);
|
||||
assert!(self.y == 3);
|
||||
assert!(self.z == 4);
|
||||
assert!(self.s.as_slice() == "hello");
|
||||
assert!(x == 5);
|
||||
}
|
||||
}
|
||||
|
||||
impl Drop for S {
|
||||
fn drop(&mut self) {
|
||||
println!("bye 1!");
|
||||
unsafe {
|
||||
destructor_count += 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl Foo for int {
|
||||
fn foo(self, x: int) {
|
||||
println!("{}", x * x);
|
||||
}
|
||||
}
|
||||
|
||||
fn f() {
|
||||
let s = S {
|
||||
x: 2,
|
||||
y: 3,
|
||||
z: 4,
|
||||
s: "hello".to_string(),
|
||||
};
|
||||
let st = box s as Box<Foo>;
|
||||
st.foo(5);
|
||||
println!("bye 2!");
|
||||
}
|
||||
|
||||
fn g() {
|
||||
let s = 2i;
|
||||
let st = box s as Box<Foo>;
|
||||
st.foo(3);
|
||||
println!("bye 3!");
|
||||
}
|
||||
|
||||
fn main() {
|
||||
f();
|
||||
|
||||
unsafe {
|
||||
assert!(destructor_count == 1);
|
||||
}
|
||||
|
||||
g();
|
||||
}
|
||||
|
||||
Loading…
Reference in New Issue