464 lines
18 KiB
Rust
464 lines
18 KiB
Rust
// Translation of automatically-derived trait implementations. This handles
|
|
// enums and structs only; other types cannot be automatically derived.
|
|
|
|
use lib::llvm::llvm::{LLVMCountParams, LLVMGetParam};
|
|
use middle::trans::base::{GEP_enum, finish_fn, get_insn_ctxt, get_item_val};
|
|
use middle::trans::base::{new_fn_ctxt, sub_block, top_scope_block};
|
|
use middle::trans::base;
|
|
use middle::trans::build::{AddCase, Br, CondBr, GEPi, Load, PointerCast};
|
|
use middle::trans::build::{Store, Switch, Unreachable, ValueRef};
|
|
use middle::trans::callee;
|
|
use middle::trans::callee::{ArgVals, Callee, DontAutorefArg, Method};
|
|
use middle::trans::callee::{MethodData};
|
|
use middle::trans::common;
|
|
use middle::trans::common::{C_bool, C_int, T_ptr, block, crate_ctxt};
|
|
use middle::trans::common::{fn_ctxt};
|
|
use middle::trans::expr::SaveIn;
|
|
use middle::trans::type_of::type_of;
|
|
use middle::ty::{DerivedFieldInfo, re_static};
|
|
use middle::typeck::check::method;
|
|
use middle::typeck::method_static;
|
|
use syntax::ast;
|
|
use syntax::ast::{def_id, ident, node_id, ty_param};
|
|
use syntax::ast_map::path;
|
|
use syntax::ast_util;
|
|
use syntax::ast_util::local_def;
|
|
|
|
use core::dvec::DVec;
|
|
use core::dvec;
|
|
use core::libc::c_uint;
|
|
|
|
/// The kind of deriving method this is.
|
|
enum DerivingKind {
|
|
BoolKind, // fn f(&self, other: &other) -> bool
|
|
UnitKind, // fn f(&self) -> ()
|
|
}
|
|
|
|
impl DerivingKind {
|
|
static fn of_item(ccx: @crate_ctxt, method_did: ast::def_id)
|
|
-> DerivingKind {
|
|
let item_type = ty::lookup_item_type(ccx.tcx, method_did).ty;
|
|
match ty::get(item_type).sty {
|
|
ty::ty_fn(ref f) => {
|
|
match ty::get(f.sig.output).sty {
|
|
ty::ty_bool => BoolKind,
|
|
ty::ty_nil => UnitKind,
|
|
_ => {
|
|
// FIXME (#3957): Report this earlier.
|
|
ccx.tcx.sess.fatal(~"attempt to automatically derive \
|
|
derive an implementation of a \
|
|
function returning something \
|
|
other than bool or ()");
|
|
}
|
|
}
|
|
}
|
|
_ => {
|
|
ccx.tcx.sess.bug(~"DerivingKind::of_item(): method def ID \
|
|
didn't have a function type");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// The main "translation" pass for the automatically-derived methods in
|
|
/// an impl. Generates code for monomorphic methods only. Other methods will
|
|
/// be generated when they are invoked with specific type parameters; see
|
|
/// `trans::base::lval_static_fn()` or `trans::base::monomorphic_fn()`.
|
|
pub fn trans_deriving_impl(ccx: @crate_ctxt,
|
|
_path: path,
|
|
_name: ident,
|
|
tps: ~[ty_param],
|
|
id: node_id) {
|
|
let _icx = ccx.insn_ctxt("deriving::trans_deriving_impl");
|
|
if tps.len() > 0 { return; }
|
|
|
|
let impl_def_id = local_def(id);
|
|
let self_ty = ty::lookup_item_type(ccx.tcx, impl_def_id);
|
|
|
|
match ccx.tcx.automatically_derived_methods_for_impl.find(impl_def_id) {
|
|
Some(copy method_dids) => {
|
|
for method_dids.each |method_did| {
|
|
let kind = DerivingKind::of_item(ccx, *method_did);
|
|
let llfn = get_item_val(ccx, method_did.node);
|
|
|
|
// Transform the self type as appropriate.
|
|
let derived_method_info =
|
|
ccx.tcx.automatically_derived_methods.get(*method_did);
|
|
let transformed_self_ty =
|
|
method::transform_self_type_for_method(
|
|
ccx.tcx,
|
|
Some(re_static),
|
|
self_ty.ty,
|
|
derived_method_info.method_info.self_type);
|
|
|
|
match ty::get(self_ty.ty).sty {
|
|
ty::ty_class(*) => {
|
|
trans_deriving_struct_method(ccx,
|
|
llfn,
|
|
impl_def_id,
|
|
self_ty.ty,
|
|
transformed_self_ty,
|
|
kind);
|
|
}
|
|
ty::ty_enum(*) => {
|
|
trans_deriving_enum_method(ccx,
|
|
llfn,
|
|
impl_def_id,
|
|
self_ty.ty,
|
|
transformed_self_ty,
|
|
kind);
|
|
}
|
|
_ => {
|
|
ccx.tcx.sess.bug(~"translation of non-struct \
|
|
deriving method");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
None => {} // Nothing to do.
|
|
}
|
|
}
|
|
|
|
fn get_extra_params(llfn: ValueRef, kind: DerivingKind) -> ~[ValueRef] {
|
|
let n_params = LLVMCountParams(llfn) as uint;
|
|
|
|
let initial_extra_param;
|
|
match kind {
|
|
BoolKind => initial_extra_param = 3,
|
|
UnitKind => initial_extra_param = 2,
|
|
}
|
|
|
|
let extra_params = DVec();
|
|
for uint::range(initial_extra_param, n_params) |i| {
|
|
extra_params.push(LLVMGetParam(llfn, i as c_uint));
|
|
}
|
|
|
|
return dvec::unwrap(move extra_params);
|
|
}
|
|
|
|
fn trans_deriving_struct_method(ccx: @crate_ctxt,
|
|
llfn: ValueRef,
|
|
impl_did: def_id,
|
|
self_ty: ty::t,
|
|
transformed_self_ty: ty::t,
|
|
kind: DerivingKind) {
|
|
let _icx = ccx.insn_ctxt("trans_deriving_struct_method");
|
|
let fcx = new_fn_ctxt(ccx, ~[], llfn, None);
|
|
let top_bcx = top_scope_block(fcx, None);
|
|
let lltop = top_bcx.llbb;
|
|
let mut bcx = top_bcx;
|
|
|
|
let llextraparams = get_extra_params(llfn, kind);
|
|
|
|
let lltransformedselfty = type_of(ccx, transformed_self_ty);
|
|
let lltransformedselfval =
|
|
PointerCast(bcx, fcx.llenv, T_ptr(lltransformedselfty));
|
|
let llselfval = Load(bcx, lltransformedselfval);
|
|
|
|
// If there is an "other" value, then get it. The "other" value is the
|
|
// value we're comparing against in the case of Eq and Ord.
|
|
let llotherval_opt;
|
|
match kind {
|
|
BoolKind => llotherval_opt = Some(LLVMGetParam(llfn, 2)),
|
|
UnitKind => llotherval_opt = None
|
|
}
|
|
|
|
let struct_field_tys;
|
|
match ty::get(self_ty).sty {
|
|
ty::ty_class(struct_id, ref struct_substs) => {
|
|
struct_field_tys = ty::class_items_as_fields(
|
|
ccx.tcx, struct_id, struct_substs);
|
|
}
|
|
_ => {
|
|
ccx.tcx.sess.bug(~"passed non-struct to \
|
|
trans_deriving_struct_method");
|
|
}
|
|
}
|
|
|
|
// Iterate over every element of the struct.
|
|
for ccx.tcx.deriving_struct_methods.get(impl_did).eachi
|
|
|i, derived_method_info| {
|
|
let llselfval = GEPi(bcx, llselfval, [0, 0, i]);
|
|
let llselfallocaty = common::val_ty(llselfval);
|
|
let llselfalloca = base::alloca(bcx, llselfallocaty);
|
|
Store(bcx, llselfval, llselfalloca);
|
|
|
|
let llotherval_opt = llotherval_opt.map(
|
|
|llotherval| GEPi(bcx, *llotherval, [0, 0, i]));
|
|
|
|
let self_ty = struct_field_tys[i].mt.ty;
|
|
bcx = call_substructure_method(bcx,
|
|
derived_method_info,
|
|
self_ty,
|
|
llselfalloca,
|
|
llotherval_opt,
|
|
llextraparams);
|
|
|
|
// If this derived method is of boolean kind, return immediately if
|
|
// the call to the substructure method returned false.
|
|
match kind {
|
|
BoolKind => {
|
|
let next_block = sub_block(top_bcx, ~"next");
|
|
let llcond = Load(bcx, fcx.llretptr);
|
|
CondBr(bcx, llcond, next_block.llbb, fcx.llreturn);
|
|
bcx = next_block;
|
|
}
|
|
UnitKind => {} // Unconditionally continue.
|
|
}
|
|
}
|
|
|
|
// Store true if necessary.
|
|
match kind {
|
|
BoolKind => Store(bcx, C_bool(true), fcx.llretptr),
|
|
UnitKind => {}
|
|
}
|
|
|
|
Br(bcx, fcx.llreturn);
|
|
|
|
finish_fn(fcx, lltop);
|
|
}
|
|
|
|
// This could have been combined with trans_deriving_struct_method, but it
|
|
// would probably be too big and hard to understand.
|
|
fn trans_deriving_enum_method(ccx: @crate_ctxt,
|
|
llfn: ValueRef,
|
|
impl_did: def_id,
|
|
self_ty: ty::t,
|
|
transformed_self_ty: ty::t,
|
|
kind: DerivingKind) {
|
|
let _icx = ccx.insn_ctxt("trans_deriving_enum_method");
|
|
let fcx = new_fn_ctxt(ccx, ~[], llfn, None);
|
|
let top_bcx = top_scope_block(fcx, None);
|
|
let lltop = top_bcx.llbb;
|
|
let mut bcx = top_bcx;
|
|
|
|
let llextraparams = get_extra_params(llfn, kind);
|
|
|
|
let lltransformedselfty = type_of(ccx, transformed_self_ty);
|
|
let lltransformedselfval =
|
|
PointerCast(bcx, fcx.llenv, T_ptr(lltransformedselfty));
|
|
let llselfval = Load(bcx, lltransformedselfval);
|
|
|
|
let llotherval_opt;
|
|
match kind {
|
|
UnitKind => llotherval_opt = None,
|
|
BoolKind => llotherval_opt = Some(LLVMGetParam(llfn, 2))
|
|
}
|
|
|
|
let enum_id, enum_substs, enum_variant_infos;
|
|
match ty::get(self_ty).sty {
|
|
ty::ty_enum(found_enum_id, ref found_enum_substs) => {
|
|
enum_id = found_enum_id;
|
|
enum_substs = copy *found_enum_substs;
|
|
enum_variant_infos = ty::substd_enum_variants(
|
|
ccx.tcx, enum_id, &enum_substs);
|
|
}
|
|
_ => {
|
|
ccx.tcx.sess.bug(~"passed non-enum to \
|
|
trans_deriving_enum_method");
|
|
}
|
|
}
|
|
|
|
// Create the "no match" basic block, if necessary. This is a basic block
|
|
// that does nothing more than return false.
|
|
let nomatch_bcx_opt;
|
|
match kind {
|
|
BoolKind => {
|
|
let nomatch_bcx = sub_block(top_bcx, ~"no_match");
|
|
Store(nomatch_bcx, C_bool(false), fcx.llretptr);
|
|
Br(nomatch_bcx, fcx.llreturn);
|
|
nomatch_bcx_opt = Some(nomatch_bcx);
|
|
}
|
|
UnitKind => nomatch_bcx_opt = None
|
|
}
|
|
|
|
// Create the "unreachable" basic block.
|
|
let unreachable_bcx = sub_block(top_bcx, ~"unreachable");
|
|
Unreachable(unreachable_bcx);
|
|
|
|
// Get the deriving enum method info.
|
|
let deriving_enum_methods = ccx.tcx.deriving_enum_methods.get(impl_did);
|
|
let n_variants = deriving_enum_methods.len();
|
|
|
|
if n_variants != 1 {
|
|
// Grab the two discriminants.
|
|
let llselfdiscrim = Load(bcx, GEPi(bcx, llselfval, [0, 0]));
|
|
let llotherdiscrim_opt = llotherval_opt.map(
|
|
|llotherval| Load(bcx, GEPi(bcx, *llotherval, [0, 0])));
|
|
|
|
// Skip over the discriminants and compute the address of the payload.
|
|
let llselfpayload = GEPi(bcx, llselfval, [0, 1]);
|
|
let llotherpayload_opt = llotherval_opt.map(
|
|
|llotherval| GEPi(bcx, *llotherval, [0, 1]));
|
|
|
|
// Create basic blocks for the outer switch.
|
|
let outer_bcxs = vec::from_fn(
|
|
deriving_enum_methods.len(),
|
|
|i| sub_block(top_bcx, fmt!("outer_%u", i)));
|
|
|
|
// For each basic block in the outer switch...
|
|
for outer_bcxs.eachi |self_variant_index, bcx| {
|
|
// Create the matching basic block for the inner switch.
|
|
let top_match_bcx = sub_block(top_bcx, fmt!("maybe_match_%u",
|
|
self_variant_index));
|
|
let mut match_bcx = top_match_bcx;
|
|
|
|
// Compare each variant.
|
|
for deriving_enum_methods[self_variant_index].eachi
|
|
|i, derived_method_info| {
|
|
let variant_def_id =
|
|
enum_variant_infos[self_variant_index].id;
|
|
let llselfval = GEP_enum(match_bcx, llselfpayload, enum_id,
|
|
variant_def_id, enum_substs.tps, i);
|
|
let llselfallocaty = common::val_ty(llselfval);
|
|
let llselfalloca = base::alloca(match_bcx, llselfallocaty);
|
|
Store(match_bcx, llselfval, llselfalloca);
|
|
|
|
let llotherval_opt = llotherpayload_opt.map(|llotherpayload|
|
|
GEP_enum(match_bcx, *llotherpayload, enum_id,
|
|
variant_def_id, enum_substs.tps, i));
|
|
|
|
let self_ty = enum_variant_infos[self_variant_index].args[i];
|
|
match_bcx = call_substructure_method(match_bcx,
|
|
derived_method_info,
|
|
self_ty,
|
|
llselfalloca,
|
|
llotherval_opt,
|
|
llextraparams);
|
|
|
|
// If this is a boolean-kind deriving method, then return
|
|
// immediately if the call to the substructure returned false.
|
|
match kind {
|
|
BoolKind => {
|
|
let next_bcx = sub_block(top_bcx,
|
|
fmt!("next_%u_%u",
|
|
self_variant_index,
|
|
i));
|
|
let llcond = Load(match_bcx, fcx.llretptr);
|
|
CondBr(match_bcx,
|
|
llcond,
|
|
next_bcx.llbb,
|
|
fcx.llreturn);
|
|
match_bcx = next_bcx;
|
|
}
|
|
UnitKind => {}
|
|
}
|
|
}
|
|
|
|
// Store true in the return pointer if this is a boolean-kind
|
|
// deriving method.
|
|
match kind {
|
|
BoolKind => Store(match_bcx, C_bool(true), fcx.llretptr),
|
|
UnitKind => {}
|
|
}
|
|
|
|
// Finish up the matching block.
|
|
Br(match_bcx, fcx.llreturn);
|
|
|
|
// If this is a boolean-kind derived method, build the inner
|
|
// switch. Otherwise, just jump to the matching case.
|
|
match llotherdiscrim_opt {
|
|
None => Br(*bcx, top_match_bcx.llbb),
|
|
Some(copy llotherdiscrim) => {
|
|
let llswitch = Switch(*bcx,
|
|
llotherdiscrim,
|
|
unreachable_bcx.llbb,
|
|
n_variants);
|
|
for uint::range(0, n_variants) |other_variant_index| {
|
|
let discriminant =
|
|
enum_variant_infos[other_variant_index].disr_val;
|
|
if self_variant_index == other_variant_index {
|
|
// This is the potentially-matching case.
|
|
AddCase(llswitch,
|
|
C_int(ccx, discriminant),
|
|
top_match_bcx.llbb);
|
|
} else {
|
|
// This is always a non-matching case.
|
|
AddCase(llswitch,
|
|
C_int(ccx, discriminant),
|
|
nomatch_bcx_opt.get().llbb);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Now build the outer switch.
|
|
let llswitch = Switch(top_bcx, llselfdiscrim, unreachable_bcx.llbb,
|
|
n_variants);
|
|
for outer_bcxs.eachi |self_variant_index, outer_bcx| {
|
|
let discriminant =
|
|
enum_variant_infos[self_variant_index].disr_val;
|
|
AddCase(llswitch, C_int(ccx, discriminant), outer_bcx.llbb);
|
|
}
|
|
} else {
|
|
ccx.tcx.sess.unimpl(~"degenerate enum deriving");
|
|
}
|
|
|
|
// Finish up the function.
|
|
finish_fn(fcx, lltop);
|
|
}
|
|
|
|
fn call_substructure_method(bcx: block,
|
|
derived_field_info: &DerivedFieldInfo,
|
|
self_ty: ty::t,
|
|
llselfval: ValueRef,
|
|
llotherval_opt: Option<ValueRef>,
|
|
llextraparams: &[ValueRef]) -> block {
|
|
let fcx = bcx.fcx;
|
|
let ccx = fcx.ccx;
|
|
|
|
let target_method_def_id;
|
|
match derived_field_info.method_origin {
|
|
method_static(did) => target_method_def_id = did,
|
|
_ => fail ~"derived method didn't resolve to a static method"
|
|
}
|
|
|
|
let fn_expr_tpbt = ty::lookup_item_type(ccx.tcx, target_method_def_id);
|
|
debug!("(calling substructure method) substructure method has %u \
|
|
parameter(s), vtable result is %?",
|
|
fn_expr_tpbt.bounds.len(),
|
|
derived_field_info.vtable_result);
|
|
|
|
// Get the substructure method we need to call. This may involve
|
|
// code generation in the case of generics, default methods, or cross-
|
|
// crate inlining.
|
|
let fn_data = callee::trans_fn_ref_with_vtables(bcx,
|
|
target_method_def_id,
|
|
0, // ref id
|
|
*derived_field_info.
|
|
type_parameter_substitutions,
|
|
derived_field_info.
|
|
vtable_result);
|
|
let llfn = fn_data.llfn;
|
|
|
|
// Create the callee.
|
|
let cb: &fn(block) -> Callee = |bloc| {
|
|
Callee {
|
|
bcx: bloc,
|
|
data: Method(MethodData {
|
|
llfn: llfn,
|
|
llself: llselfval,
|
|
self_ty: self_ty,
|
|
self_mode: ast::by_copy
|
|
})
|
|
}
|
|
};
|
|
|
|
// Build up the argument list.
|
|
let llargvals = DVec();
|
|
for llotherval_opt.each |llotherval| { llargvals.push(*llotherval); }
|
|
for llextraparams.each |llextraparam| { llargvals.push(*llextraparam); }
|
|
|
|
// And perform the call.
|
|
callee::trans_call_inner(bcx,
|
|
None,
|
|
fn_expr_tpbt.ty,
|
|
ty::mk_bool(ccx.tcx),
|
|
cb,
|
|
ArgVals(dvec::unwrap(move llargvals)),
|
|
SaveIn(fcx.llretptr),
|
|
DontAutorefArg)
|
|
}
|
|
|