squiid/rust
1
0
Fork 0
Code Issues Pull requests Projects Activity

Move various data structures out of typeck and into ty.

Browse source
This commit is contained in:
Niko Matsakis 2014-11-25 14:21:20 -05:00
parent 6d965cc2c9
commit 7c44561ad6
29 changed files with 331 additions and 344 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

12
src/librustc/lint/builtin.rs
View file

@ -30,7 +30,7 @@ use metadata::csearch;
use middle::def::*; use middle::def::*;
use middle::ty::{mod, Ty}; use middle::ty::{mod, Ty};
use middle::typeck::astconv::ast_ty_to_ty; use middle::typeck::astconv::ast_ty_to_ty;
use middle::typeck::{mod, infer}; use middle::typeck::infer;
use middle::{def, pat_util, stability}; use middle::{def, pat_util, stability};
use middle::const_eval::{eval_const_expr_partial, const_int, const_uint}; use middle::const_eval::{eval_const_expr_partial, const_int, const_uint};
use util::ppaux::{ty_to_string}; use util::ppaux::{ty_to_string};
@ -1589,22 +1589,22 @@ impl LintPass for Stability {
} }
ast::ExprMethodCall(i, _, _) => { ast::ExprMethodCall(i, _, _) => {
span = i.span; span = i.span;
let method_call = typeck::MethodCall::expr(e.id); let method_call = ty::MethodCall::expr(e.id);
match cx.tcx.method_map.borrow().get(&method_call) { match cx.tcx.method_map.borrow().get(&method_call) {
Some(method) => { Some(method) => {
match method.origin { match method.origin {
typeck::MethodStatic(def_id) => { ty::MethodStatic(def_id) => {
def_id def_id
} }
typeck::MethodStaticUnboxedClosure(def_id) => { ty::MethodStaticUnboxedClosure(def_id) => {
def_id def_id
} }
typeck::MethodTypeParam(typeck::MethodParam { ty::MethodTypeParam(ty::MethodParam {
ref trait_ref, ref trait_ref,
method_num: index, method_num: index,
.. ..
}) | }) |
typeck::MethodTraitObject(typeck::MethodObject { ty::MethodTraitObject(ty::MethodObject {
ref trait_ref, ref trait_ref,
method_num: index, method_num: index,
.. ..

3
src/librustc/metadata/csearch.rs
View file

@ -21,7 +21,6 @@ use middle::def;
use middle::lang_items; use middle::lang_items;
use middle::resolve; use middle::resolve;
use middle::ty; use middle::ty;
use middle::typeck;
use middle::subst::VecPerParamSpace; use middle::subst::VecPerParamSpace;
use rbml; use rbml;
@ -268,7 +267,7 @@ pub fn get_impl_trait<'tcx>(tcx: &ty::ctxt<'tcx>,
// Given a def_id for an impl, return information about its vtables // Given a def_id for an impl, return information about its vtables
pub fn get_impl_vtables<'tcx>(tcx: &ty::ctxt<'tcx>, pub fn get_impl_vtables<'tcx>(tcx: &ty::ctxt<'tcx>,
def: ast::DefId) def: ast::DefId)
-> typeck::vtable_res<'tcx> { -> ty::vtable_res<'tcx> {
let cstore = &tcx.sess.cstore; let cstore = &tcx.sess.cstore;
let cdata = cstore.get_crate_data(def.krate); let cdata = cstore.get_crate_data(def.krate);
decoder::get_impl_vtables(&*cdata, def.node, tcx) decoder::get_impl_vtables(&*cdata, def.node, tcx)

3
src/librustc/metadata/decoder.rs
View file

@ -30,7 +30,6 @@ use middle::resolve::{TraitItemKind, TypeTraitItemKind};
use middle::subst; use middle::subst;
use middle::ty::{ImplContainer, TraitContainer}; use middle::ty::{ImplContainer, TraitContainer};
use middle::ty::{mod, Ty}; use middle::ty::{mod, Ty};
use middle::typeck;
use middle::astencode::vtable_decoder_helpers; use middle::astencode::vtable_decoder_helpers;
use std::hash::Hash; use std::hash::Hash;
@ -422,7 +421,7 @@ pub fn get_impl_trait<'tcx>(cdata: Cmd,
pub fn get_impl_vtables<'tcx>(cdata: Cmd, pub fn get_impl_vtables<'tcx>(cdata: Cmd,
id: ast::NodeId, id: ast::NodeId,
tcx: &ty::ctxt<'tcx>) tcx: &ty::ctxt<'tcx>)
-> typeck::vtable_res<'tcx> -> ty::vtable_res<'tcx>
{ {
let item_doc = lookup_item(id, cdata.data()); let item_doc = lookup_item(id, cdata.data());
let vtables_doc = reader::get_doc(item_doc, tag_item_impl_vtables); let vtables_doc = reader::get_doc(item_doc, tag_item_impl_vtables);

79
src/librustc/middle/astencode.rs
View file

@ -26,8 +26,7 @@ use metadata::tyencode;
use middle::mem_categorization::Typer; use middle::mem_categorization::Typer;
use middle::subst; use middle::subst;
use middle::subst::VecPerParamSpace; use middle::subst::VecPerParamSpace;
use middle::typeck::{mod, MethodCall, MethodCallee, MethodOrigin}; use middle::ty::{mod, Ty, MethodCall, MethodCallee, MethodOrigin};
use middle::ty::{mod, Ty};
use util::ppaux::ty_to_string; use util::ppaux::ty_to_string;
use syntax::{ast, ast_map, ast_util, codemap, fold}; use syntax::{ast, ast_map, ast_util, codemap, fold};
@ -576,12 +575,12 @@ impl tr for ty::UpvarBorrow {
trait read_method_callee_helper<'tcx> { trait read_method_callee_helper<'tcx> {
fn read_method_callee<'a, 'b>(&mut self, dcx: &DecodeContext<'a, 'b, 'tcx>) fn read_method_callee<'a, 'b>(&mut self, dcx: &DecodeContext<'a, 'b, 'tcx>)
-> (typeck::ExprAdjustment, MethodCallee<'tcx>); -> (ty::ExprAdjustment, MethodCallee<'tcx>);
} }
fn encode_method_callee<'a, 'tcx>(ecx: &e::EncodeContext<'a, 'tcx>, fn encode_method_callee<'a, 'tcx>(ecx: &e::EncodeContext<'a, 'tcx>,
rbml_w: &mut Encoder, rbml_w: &mut Encoder,
adjustment: typeck::ExprAdjustment, adjustment: ty::ExprAdjustment,
method: &MethodCallee<'tcx>) { method: &MethodCallee<'tcx>) {
use serialize::Encoder; use serialize::Encoder;
@ -603,7 +602,7 @@ fn encode_method_callee<'a, 'tcx>(ecx: &e::EncodeContext<'a, 'tcx>,
impl<'a, 'tcx> read_method_callee_helper<'tcx> for reader::Decoder<'a> { impl<'a, 'tcx> read_method_callee_helper<'tcx> for reader::Decoder<'a> {
fn read_method_callee<'a, 'b>(&mut self, dcx: &DecodeContext<'a, 'b, 'tcx>) fn read_method_callee<'a, 'b>(&mut self, dcx: &DecodeContext<'a, 'b, 'tcx>)
-> (typeck::ExprAdjustment, MethodCallee<'tcx>) { -> (ty::ExprAdjustment, MethodCallee<'tcx>) {
self.read_struct("MethodCallee", 4, |this| { self.read_struct("MethodCallee", 4, |this| {
let adjustment = this.read_struct_field("adjustment", 0, |this| { let adjustment = this.read_struct_field("adjustment", 0, |this| {
@ -627,22 +626,22 @@ impl<'a, 'tcx> read_method_callee_helper<'tcx> for reader::Decoder<'a> {
impl<'tcx> tr for MethodOrigin<'tcx> { impl<'tcx> tr for MethodOrigin<'tcx> {
fn tr(&self, dcx: &DecodeContext) -> MethodOrigin<'tcx> { fn tr(&self, dcx: &DecodeContext) -> MethodOrigin<'tcx> {
match *self { match *self {
typeck::MethodStatic(did) => typeck::MethodStatic(did.tr(dcx)), ty::MethodStatic(did) => ty::MethodStatic(did.tr(dcx)),
typeck::MethodStaticUnboxedClosure(did) => { ty::MethodStaticUnboxedClosure(did) => {
typeck::MethodStaticUnboxedClosure(did.tr(dcx)) ty::MethodStaticUnboxedClosure(did.tr(dcx))
} }
typeck::MethodTypeParam(ref mp) => { ty::MethodTypeParam(ref mp) => {
typeck::MethodTypeParam( ty::MethodTypeParam(
typeck::MethodParam { ty::MethodParam {
// def-id is already translated when we read it out // def-id is already translated when we read it out
trait_ref: mp.trait_ref.clone(), trait_ref: mp.trait_ref.clone(),
method_num: mp.method_num, method_num: mp.method_num,
} }
) )
} }
typeck::MethodTraitObject(ref mo) => { ty::MethodTraitObject(ref mo) => {
typeck::MethodTraitObject( ty::MethodTraitObject(
typeck::MethodObject { ty::MethodObject {
trait_ref: mo.trait_ref.clone(), trait_ref: mo.trait_ref.clone(),
.. *mo .. *mo
} }
@ -687,16 +686,16 @@ pub trait vtable_decoder_helpers<'tcx> {
fn read_vtable_res_with_key(&mut self, fn read_vtable_res_with_key(&mut self,
tcx: &ty::ctxt<'tcx>, tcx: &ty::ctxt<'tcx>,
cdata: &cstore::crate_metadata) cdata: &cstore::crate_metadata)
-> (typeck::ExprAdjustment, typeck::vtable_res<'tcx>); -> (ty::ExprAdjustment, ty::vtable_res<'tcx>);
fn read_vtable_res(&mut self, fn read_vtable_res(&mut self,
tcx: &ty::ctxt<'tcx>, cdata: &cstore::crate_metadata) tcx: &ty::ctxt<'tcx>, cdata: &cstore::crate_metadata)
-> typeck::vtable_res<'tcx>; -> ty::vtable_res<'tcx>;
fn read_vtable_param_res(&mut self, fn read_vtable_param_res(&mut self,
tcx: &ty::ctxt<'tcx>, cdata: &cstore::crate_metadata) tcx: &ty::ctxt<'tcx>, cdata: &cstore::crate_metadata)
-> typeck::vtable_param_res<'tcx>; -> ty::vtable_param_res<'tcx>;
fn read_vtable_origin(&mut self, fn read_vtable_origin(&mut self,
tcx: &ty::ctxt<'tcx>, cdata: &cstore::crate_metadata) tcx: &ty::ctxt<'tcx>, cdata: &cstore::crate_metadata)
-> typeck::vtable_origin<'tcx>; -> ty::vtable_origin<'tcx>;
} }
impl<'tcx, 'a> vtable_decoder_helpers<'tcx> for reader::Decoder<'a> { impl<'tcx, 'a> vtable_decoder_helpers<'tcx> for reader::Decoder<'a> {
@ -714,7 +713,7 @@ impl<'tcx, 'a> vtable_decoder_helpers<'tcx> for reader::Decoder<'a> {
fn read_vtable_res_with_key(&mut self, fn read_vtable_res_with_key(&mut self,
tcx: &ty::ctxt<'tcx>, tcx: &ty::ctxt<'tcx>,
cdata: &cstore::crate_metadata) cdata: &cstore::crate_metadata)
-> (typeck::ExprAdjustment, typeck::vtable_res<'tcx>) { -> (ty::ExprAdjustment, ty::vtable_res<'tcx>) {
self.read_struct("VtableWithKey", 2, |this| { self.read_struct("VtableWithKey", 2, |this| {
let adjustment = this.read_struct_field("adjustment", 0, |this| { let adjustment = this.read_struct_field("adjustment", 0, |this| {
Decodable::decode(this) Decodable::decode(this)
@ -728,7 +727,7 @@ impl<'tcx, 'a> vtable_decoder_helpers<'tcx> for reader::Decoder<'a> {
fn read_vtable_res(&mut self, fn read_vtable_res(&mut self,
tcx: &ty::ctxt<'tcx>, tcx: &ty::ctxt<'tcx>,
cdata: &cstore::crate_metadata) cdata: &cstore::crate_metadata)
-> typeck::vtable_res<'tcx> -> ty::vtable_res<'tcx>
{ {
self.read_vec_per_param_space( self.read_vec_per_param_space(
|this| this.read_vtable_param_res(tcx, cdata)) |this| this.read_vtable_param_res(tcx, cdata))
@ -736,14 +735,14 @@ impl<'tcx, 'a> vtable_decoder_helpers<'tcx> for reader::Decoder<'a> {
fn read_vtable_param_res(&mut self, fn read_vtable_param_res(&mut self,
tcx: &ty::ctxt<'tcx>, cdata: &cstore::crate_metadata) tcx: &ty::ctxt<'tcx>, cdata: &cstore::crate_metadata)
-> typeck::vtable_param_res<'tcx> { -> ty::vtable_param_res<'tcx> {
self.read_to_vec(|this| Ok(this.read_vtable_origin(tcx, cdata))) self.read_to_vec(|this| Ok(this.read_vtable_origin(tcx, cdata)))
.unwrap().into_iter().collect() .unwrap().into_iter().collect()
} }
fn read_vtable_origin(&mut self, fn read_vtable_origin(&mut self,
tcx: &ty::ctxt<'tcx>, cdata: &cstore::crate_metadata) tcx: &ty::ctxt<'tcx>, cdata: &cstore::crate_metadata)
-> typeck::vtable_origin<'tcx> { -> ty::vtable_origin<'tcx> {
self.read_enum("vtable_origin", |this| { self.read_enum("vtable_origin", |this| {
this.read_enum_variant(&["vtable_static", this.read_enum_variant(&["vtable_static",
"vtable_param", "vtable_param",
@ -752,7 +751,7 @@ impl<'tcx, 'a> vtable_decoder_helpers<'tcx> for reader::Decoder<'a> {
|this, i| { |this, i| {
Ok(match i { Ok(match i {
0 => { 0 => {
typeck::vtable_static( ty::vtable_static(
this.read_enum_variant_arg(0u, |this| { this.read_enum_variant_arg(0u, |this| {
Ok(this.read_def_id_nodcx(cdata)) Ok(this.read_def_id_nodcx(cdata))
}).unwrap(), }).unwrap(),
@ -765,7 +764,7 @@ impl<'tcx, 'a> vtable_decoder_helpers<'tcx> for reader::Decoder<'a> {
) )
} }
1 => { 1 => {
typeck::vtable_param( ty::vtable_param(
this.read_enum_variant_arg(0u, |this| { this.read_enum_variant_arg(0u, |this| {
Decodable::decode(this) Decodable::decode(this)
}).unwrap(), }).unwrap(),
@ -775,14 +774,14 @@ impl<'tcx, 'a> vtable_decoder_helpers<'tcx> for reader::Decoder<'a> {
) )
} }
2 => { 2 => {
typeck::vtable_unboxed_closure( ty::vtable_unboxed_closure(
this.read_enum_variant_arg(0u, |this| { this.read_enum_variant_arg(0u, |this| {
Ok(this.read_def_id_nodcx(cdata)) Ok(this.read_def_id_nodcx(cdata))
}).unwrap() }).unwrap()
) )
} }
3 => { 3 => {
typeck::vtable_error ty::vtable_error
} }
_ => panic!("bad enum variant") _ => panic!("bad enum variant")
}) })
@ -826,7 +825,7 @@ trait rbml_writer_helpers<'tcx> {
closure_type: &ty::ClosureTy<'tcx>); closure_type: &ty::ClosureTy<'tcx>);
fn emit_method_origin<'a>(&mut self, fn emit_method_origin<'a>(&mut self,
ecx: &e::EncodeContext<'a, 'tcx>, ecx: &e::EncodeContext<'a, 'tcx>,
method_origin: &typeck::MethodOrigin<'tcx>); method_origin: &ty::MethodOrigin<'tcx>);
fn emit_ty<'a>(&mut self, ecx: &e::EncodeContext<'a, 'tcx>, ty: Ty<'tcx>); fn emit_ty<'a>(&mut self, ecx: &e::EncodeContext<'a, 'tcx>, ty: Ty<'tcx>);
fn emit_tys<'a>(&mut self, ecx: &e::EncodeContext<'a, 'tcx>, tys: &[Ty<'tcx>]); fn emit_tys<'a>(&mut self, ecx: &e::EncodeContext<'a, 'tcx>, tys: &[Ty<'tcx>]);
fn emit_type_param_def<'a>(&mut self, ecx: &e::EncodeContext<'a, 'tcx>, fn emit_type_param_def<'a>(&mut self, ecx: &e::EncodeContext<'a, 'tcx>,
@ -860,25 +859,25 @@ impl<'a, 'tcx> rbml_writer_helpers<'tcx> for Encoder<'a> {
fn emit_method_origin<'a>(&mut self, fn emit_method_origin<'a>(&mut self,
ecx: &e::EncodeContext<'a, 'tcx>, ecx: &e::EncodeContext<'a, 'tcx>,
method_origin: &typeck::MethodOrigin<'tcx>) method_origin: &ty::MethodOrigin<'tcx>)
{ {
use serialize::Encoder; use serialize::Encoder;
self.emit_enum("MethodOrigin", |this| { self.emit_enum("MethodOrigin", |this| {
match *method_origin { match *method_origin {
typeck::MethodStatic(def_id) => { ty::MethodStatic(def_id) => {
this.emit_enum_variant("MethodStatic", 0, 1, |this| { this.emit_enum_variant("MethodStatic", 0, 1, |this| {
Ok(this.emit_def_id(def_id)) Ok(this.emit_def_id(def_id))
}) })
} }
typeck::MethodStaticUnboxedClosure(def_id) => { ty::MethodStaticUnboxedClosure(def_id) => {
this.emit_enum_variant("MethodStaticUnboxedClosure", 1, 1, |this| { this.emit_enum_variant("MethodStaticUnboxedClosure", 1, 1, |this| {
Ok(this.emit_def_id(def_id)) Ok(this.emit_def_id(def_id))
}) })
} }
typeck::MethodTypeParam(ref p) => { ty::MethodTypeParam(ref p) => {
this.emit_enum_variant("MethodTypeParam", 2, 1, |this| { this.emit_enum_variant("MethodTypeParam", 2, 1, |this| {
this.emit_struct("MethodParam", 2, |this| { this.emit_struct("MethodParam", 2, |this| {
try!(this.emit_struct_field("trait_ref", 0, |this| { try!(this.emit_struct_field("trait_ref", 0, |this| {
@ -892,7 +891,7 @@ impl<'a, 'tcx> rbml_writer_helpers<'tcx> for Encoder<'a> {
}) })
} }
typeck::MethodTraitObject(ref o) => { ty::MethodTraitObject(ref o) => {
this.emit_enum_variant("MethodTraitObject", 3, 1, |this| { this.emit_enum_variant("MethodTraitObject", 3, 1, |this| {
this.emit_struct("MethodObject", 2, |this| { this.emit_struct("MethodObject", 2, |this| {
try!(this.emit_struct_field("trait_ref", 0, |this| { try!(this.emit_struct_field("trait_ref", 0, |this| {
@ -1330,7 +1329,7 @@ impl<'a> doc_decoder_helpers for rbml::Doc<'a> {
trait rbml_decoder_decoder_helpers<'tcx> { trait rbml_decoder_decoder_helpers<'tcx> {
fn read_method_origin<'a, 'b>(&mut self, dcx: &DecodeContext<'a, 'b, 'tcx>) fn read_method_origin<'a, 'b>(&mut self, dcx: &DecodeContext<'a, 'b, 'tcx>)
-> typeck::MethodOrigin<'tcx>; -> ty::MethodOrigin<'tcx>;
fn read_ty<'a, 'b>(&mut self, dcx: &DecodeContext<'a, 'b, 'tcx>) -> Ty<'tcx>; fn read_ty<'a, 'b>(&mut self, dcx: &DecodeContext<'a, 'b, 'tcx>) -> Ty<'tcx>;
fn read_tys<'a, 'b>(&mut self, dcx: &DecodeContext<'a, 'b, 'tcx>) -> Vec<Ty<'tcx>>; fn read_tys<'a, 'b>(&mut self, dcx: &DecodeContext<'a, 'b, 'tcx>) -> Vec<Ty<'tcx>>;
fn read_trait_ref<'a, 'b>(&mut self, dcx: &DecodeContext<'a, 'b, 'tcx>) fn read_trait_ref<'a, 'b>(&mut self, dcx: &DecodeContext<'a, 'b, 'tcx>)
@ -1409,7 +1408,7 @@ impl<'a, 'tcx> rbml_decoder_decoder_helpers<'tcx> for reader::Decoder<'a> {
} }
fn read_method_origin<'a, 'b>(&mut self, dcx: &DecodeContext<'a, 'b, 'tcx>) fn read_method_origin<'a, 'b>(&mut self, dcx: &DecodeContext<'a, 'b, 'tcx>)
-> typeck::MethodOrigin<'tcx> -> ty::MethodOrigin<'tcx>
{ {
self.read_enum("MethodOrigin", |this| { self.read_enum("MethodOrigin", |this| {
let variants = &["MethodStatic", "MethodStaticUnboxedClosure", let variants = &["MethodStatic", "MethodStaticUnboxedClosure",
@ -1418,18 +1417,18 @@ impl<'a, 'tcx> rbml_decoder_decoder_helpers<'tcx> for reader::Decoder<'a> {
Ok(match i { Ok(match i {
0 => { 0 => {
let def_id = this.read_def_id(dcx); let def_id = this.read_def_id(dcx);
typeck::MethodStatic(def_id) ty::MethodStatic(def_id)
} }
1 => { 1 => {
let def_id = this.read_def_id(dcx); let def_id = this.read_def_id(dcx);
typeck::MethodStaticUnboxedClosure(def_id) ty::MethodStaticUnboxedClosure(def_id)
} }
2 => { 2 => {
this.read_struct("MethodTypeParam", 2, |this| { this.read_struct("MethodTypeParam", 2, |this| {
Ok(typeck::MethodTypeParam( Ok(ty::MethodTypeParam(
typeck::MethodParam { ty::MethodParam {
trait_ref: { trait_ref: {
this.read_struct_field("trait_ref", 0, |this| { this.read_struct_field("trait_ref", 0, |this| {
Ok(this.read_trait_ref(dcx)) Ok(this.read_trait_ref(dcx))
@ -1446,8 +1445,8 @@ impl<'a, 'tcx> rbml_decoder_decoder_helpers<'tcx> for reader::Decoder<'a> {
3 => { 3 => {
this.read_struct("MethodTraitObject", 2, |this| { this.read_struct("MethodTraitObject", 2, |this| {
Ok(typeck::MethodTraitObject( Ok(ty::MethodTraitObject(
typeck::MethodObject { ty::MethodObject {
trait_ref: { trait_ref: {
this.read_struct_field("trait_ref", 0, |this| { this.read_struct_field("trait_ref", 0, |this| {
Ok(this.read_trait_ref(dcx)) Ok(this.read_trait_ref(dcx))

5
src/librustc/middle/cfg/construct.rs
View file

@ -12,7 +12,6 @@ use middle::cfg::*;
use middle::def; use middle::def;
use middle::graph; use middle::graph;
use middle::region::CodeExtent; use middle::region::CodeExtent;
use middle::typeck;
use middle::ty; use middle::ty;
use syntax::ast; use syntax::ast;
use syntax::ast_util; use syntax::ast_util;
@ -510,7 +509,7 @@ impl<'a, 'tcx> CFGBuilder<'a, 'tcx> {
pred: CFGIndex, pred: CFGIndex,
func_or_rcvr: &ast::Expr, func_or_rcvr: &ast::Expr,
args: I) -> CFGIndex { args: I) -> CFGIndex {
let method_call = typeck::MethodCall::expr(call_expr.id); let method_call = ty::MethodCall::expr(call_expr.id);
let return_ty = ty::ty_fn_ret(match self.tcx.method_map.borrow().get(&method_call) { let return_ty = ty::ty_fn_ret(match self.tcx.method_map.borrow().get(&method_call) {
Some(method) => method.ty, Some(method) => method.ty,
None => ty::expr_ty(self.tcx, func_or_rcvr) None => ty::expr_ty(self.tcx, func_or_rcvr)
@ -635,7 +634,7 @@ impl<'a, 'tcx> CFGBuilder<'a, 'tcx> {
} }
fn is_method_call(&self, expr: &ast::Expr) -> bool { fn is_method_call(&self, expr: &ast::Expr) -> bool {
let method_call = typeck::MethodCall::expr(expr.id); let method_call = ty::MethodCall::expr(expr.id);
self.tcx.method_map.borrow().contains_key(&method_call) self.tcx.method_map.borrow().contains_key(&method_call)
} }
} }

3
src/librustc/middle/check_const.rs
View file

@ -11,7 +11,6 @@
use middle::def::*; use middle::def::*;
use middle::ty; use middle::ty;
use middle::typeck;
use util::ppaux; use util::ppaux;
use syntax::ast; use syntax::ast;
@ -111,7 +110,7 @@ fn check_expr(v: &mut CheckCrateVisitor, e: &ast::Expr) -> bool {
} }
ast::ExprLit(ref lit) if ast_util::lit_is_str(&**lit) => {} ast::ExprLit(ref lit) if ast_util::lit_is_str(&**lit) => {}
ast::ExprBinary(..) | ast::ExprUnary(..) => { ast::ExprBinary(..) | ast::ExprUnary(..) => {
let method_call = typeck::MethodCall::expr(e.id); let method_call = ty::MethodCall::expr(e.id);
if v.tcx.method_map.borrow().contains_key(&method_call) { if v.tcx.method_map.borrow().contains_key(&method_call) {
span_err!(v.tcx.sess, e.span, E0011, span_err!(v.tcx.sess, e.span, E0011,
"user-defined operators are not allowed in constant \ "user-defined operators are not allowed in constant \

12
src/librustc/middle/dead.rs
View file

@ -12,7 +12,7 @@
// closely. The idea is that all reachable symbols are live, codes called // closely. The idea is that all reachable symbols are live, codes called
// from live codes are live, and everything else is dead. // from live codes are live, and everything else is dead.
use middle::{def, pat_util, privacy, ty, typeck}; use middle::{def, pat_util, privacy, ty};
use lint; use lint;
use util::nodemap::NodeSet; use util::nodemap::NodeSet;
@ -90,23 +90,23 @@ impl<'a, 'tcx> MarkSymbolVisitor<'a, 'tcx> {
fn lookup_and_handle_method(&mut self, id: ast::NodeId, fn lookup_and_handle_method(&mut self, id: ast::NodeId,
span: codemap::Span) { span: codemap::Span) {
let method_call = typeck::MethodCall::expr(id); let method_call = ty::MethodCall::expr(id);
match self.tcx.method_map.borrow().get(&method_call) { match self.tcx.method_map.borrow().get(&method_call) {
Some(method) => { Some(method) => {
match method.origin { match method.origin {
typeck::MethodStatic(def_id) => { ty::MethodStatic(def_id) => {
match ty::provided_source(self.tcx, def_id) { match ty::provided_source(self.tcx, def_id) {
Some(p_did) => self.check_def_id(p_did), Some(p_did) => self.check_def_id(p_did),
None => self.check_def_id(def_id) None => self.check_def_id(def_id)
} }
} }
typeck::MethodStaticUnboxedClosure(_) => {} ty::MethodStaticUnboxedClosure(_) => {}
typeck::MethodTypeParam(typeck::MethodParam { ty::MethodTypeParam(ty::MethodParam {
ref trait_ref, ref trait_ref,
method_num: index, method_num: index,
.. ..
}) | }) |
typeck::MethodTraitObject(typeck::MethodObject { ty::MethodTraitObject(ty::MethodObject {
ref trait_ref, ref trait_ref,
method_num: index, method_num: index,
.. ..

2
src/librustc/middle/effect.rs
View file

@ -14,7 +14,7 @@ use self::UnsafeContext::*;
use middle::def; use middle::def;
use middle::ty::{mod, Ty}; use middle::ty::{mod, Ty};
use middle::typeck::MethodCall; use middle::ty::MethodCall;
use util::ppaux; use util::ppaux;
use syntax::ast; use syntax::ast;

9
src/librustc/middle/expr_use_visitor.rs
View file

@ -24,10 +24,9 @@ use middle::{def, region, pat_util};
use middle::mem_categorization as mc; use middle::mem_categorization as mc;
use middle::mem_categorization::Typer; use middle::mem_categorization::Typer;
use middle::ty::{mod, Ty}; use middle::ty::{mod, Ty};
use middle::typeck::{MethodCall, MethodObject, MethodTraitObject}; use middle::ty::{MethodCall, MethodObject, MethodTraitObject};
use middle::typeck::{MethodOrigin, MethodParam, MethodTypeParam}; use middle::ty::{MethodOrigin, MethodParam, MethodTypeParam};
use middle::typeck::{MethodStatic, MethodStaticUnboxedClosure}; use middle::ty::{MethodStatic, MethodStaticUnboxedClosure};
use middle::typeck;
use util::ppaux::Repr; use util::ppaux::Repr;
use syntax::ast; use syntax::ast;
@ -825,7 +824,7 @@ impl<'d,'t,'tcx,TYPER:mc::Typer<'tcx>> ExprUseVisitor<'d,'t,'tcx,TYPER> {
debug!("walk_autoderefs expr={} autoderefs={}", expr.repr(self.tcx()), autoderefs); debug!("walk_autoderefs expr={} autoderefs={}", expr.repr(self.tcx()), autoderefs);
for i in range(0, autoderefs) { for i in range(0, autoderefs) {
let deref_id = typeck::MethodCall::autoderef(expr.id, i); let deref_id = ty::MethodCall::autoderef(expr.id, i);
match self.typer.node_method_ty(deref_id) { match self.typer.node_method_ty(deref_id) {
None => {} None => {}
Some(method_ty) => { Some(method_ty) => {

4
src/librustc/middle/liveness.rs
View file

@ -111,7 +111,7 @@ use self::VarKind::*;
use middle::def::*; use middle::def::*;
use middle::mem_categorization::Typer; use middle::mem_categorization::Typer;
use middle::{pat_util, typeck, ty}; use middle::{pat_util, ty};
use lint; use lint;
use util::nodemap::NodeMap; use util::nodemap::NodeMap;
@ -1156,7 +1156,7 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> {
} }
ast::ExprMethodCall(_, _, ref args) => { ast::ExprMethodCall(_, _, ref args) => {
let method_call = typeck::MethodCall::expr(expr.id); let method_call = ty::MethodCall::expr(expr.id);
let method_ty = self.ir.tcx.method_map.borrow().get(&method_call).unwrap().ty; let method_ty = self.ir.tcx.method_map.borrow().get(&method_call).unwrap().ty;
let diverges = ty::ty_fn_ret(method_ty) == ty::FnDiverging; let diverges = ty::ty_fn_ret(method_ty) == ty::FnDiverging;
let succ = if diverges { let succ = if diverges {

15
src/librustc/middle/mem_categorization.rs
View file

@ -74,7 +74,6 @@ pub use self::categorization::*;
use middle::def; use middle::def;
use middle::region; use middle::region;
use middle::ty::{mod, Ty}; use middle::ty::{mod, Ty};
use middle::typeck;
use util::nodemap::{DefIdMap, NodeMap}; use util::nodemap::{DefIdMap, NodeMap};
use util::ppaux::{ty_to_string, Repr}; use util::ppaux::{ty_to_string, Repr};
@ -283,7 +282,7 @@ pub type McResult<T> = Result<T, ()>;
pub trait Typer<'tcx> { pub trait Typer<'tcx> {
fn tcx<'a>(&'a self) -> &'a ty::ctxt<'tcx>; fn tcx<'a>(&'a self) -> &'a ty::ctxt<'tcx>;
fn node_ty(&self, id: ast::NodeId) -> McResult<Ty<'tcx>>; fn node_ty(&self, id: ast::NodeId) -> McResult<Ty<'tcx>>;
fn node_method_ty(&self, method_call: typeck::MethodCall) -> Option<Ty<'tcx>>; fn node_method_ty(&self, method_call: ty::MethodCall) -> Option<Ty<'tcx>>;
fn adjustments<'a>(&'a self) -> &'a RefCell<NodeMap<ty::AutoAdjustment<'tcx>>>; fn adjustments<'a>(&'a self) -> &'a RefCell<NodeMap<ty::AutoAdjustment<'tcx>>>;
fn is_method_call(&self, id: ast::NodeId) -> bool; fn is_method_call(&self, id: ast::NodeId) -> bool;
fn temporary_scope(&self, rvalue_id: ast::NodeId) -> Option<region::CodeExtent>; fn temporary_scope(&self, rvalue_id: ast::NodeId) -> Option<region::CodeExtent>;
@ -509,7 +508,7 @@ impl<'t,'tcx,TYPER:Typer<'tcx>> MemCategorizationContext<'t,TYPER> {
} }
ast::ExprIndex(ref base, _) => { ast::ExprIndex(ref base, _) => {
let method_call = typeck::MethodCall::expr(expr.id()); let method_call = ty::MethodCall::expr(expr.id());
match self.typer.node_method_ty(method_call) { match self.typer.node_method_ty(method_call) {
Some(method_ty) => { Some(method_ty) => {
// If this is an index implemented by a method call, then it will // If this is an index implemented by a method call, then it will
@ -890,12 +889,12 @@ impl<'t,'tcx,TYPER:Typer<'tcx>> MemCategorizationContext<'t,TYPER> {
implicit: bool) implicit: bool)
-> cmt<'tcx> { -> cmt<'tcx> {
let adjustment = match self.typer.adjustments().borrow().get(&node.id()) { let adjustment = match self.typer.adjustments().borrow().get(&node.id()) {
Some(adj) if ty::adjust_is_object(adj) => typeck::AutoObject, Some(adj) if ty::adjust_is_object(adj) => ty::AutoObject,
_ if deref_cnt != 0 => typeck::AutoDeref(deref_cnt), _ if deref_cnt != 0 => ty::AutoDeref(deref_cnt),
_ => typeck::NoAdjustment _ => ty::NoAdjustment
}; };
let method_call = typeck::MethodCall { let method_call = ty::MethodCall {
expr_id: node.id(), expr_id: node.id(),
adjustment: adjustment adjustment: adjustment
}; };
@ -980,7 +979,7 @@ impl<'t,'tcx,TYPER:Typer<'tcx>> MemCategorizationContext<'t,TYPER> {
//! - `elt`: the AST node being indexed //! - `elt`: the AST node being indexed
//! - `base_cmt`: the cmt of `elt` //! - `base_cmt`: the cmt of `elt`
let method_call = typeck::MethodCall::expr(elt.id()); let method_call = ty::MethodCall::expr(elt.id());
let method_ty = self.typer.node_method_ty(method_call); let method_ty = self.typer.node_method_ty(method_call);
let element_ty = match method_ty { let element_ty = match method_ty {

4
src/librustc/middle/privacy.rs
View file

@ -19,8 +19,8 @@ use std::mem::replace;
use metadata::csearch; use metadata::csearch;
use middle::{def, resolve}; use middle::{def, resolve};
use middle::ty::{mod, Ty}; use middle::ty::{mod, Ty};
use middle::typeck::{MethodCall, MethodMap, MethodOrigin, MethodParam, MethodTypeParam}; use middle::ty::{MethodCall, MethodMap, MethodOrigin, MethodParam, MethodTypeParam};
use middle::typeck::{MethodStatic, MethodStaticUnboxedClosure, MethodObject, MethodTraitObject}; use middle::ty::{MethodStatic, MethodStaticUnboxedClosure, MethodObject, MethodTraitObject};
use util::nodemap::{NodeMap, NodeSet}; use util::nodemap::{NodeMap, NodeSet};
use syntax::{ast, ast_map}; use syntax::{ast, ast_map};

5
src/librustc/middle/reachable.rs
View file

@ -17,7 +17,6 @@
use middle::def; use middle::def;
use middle::ty; use middle::ty;
use middle::typeck;
use middle::privacy; use middle::privacy;
use session::config; use session::config;
use util::nodemap::NodeSet; use util::nodemap::NodeSet;
@ -137,9 +136,9 @@ impl<'a, 'tcx, 'v> Visitor<'v> for ReachableContext<'a, 'tcx> {
} }
} }
ast::ExprMethodCall(..) => { ast::ExprMethodCall(..) => {
let method_call = typeck::MethodCall::expr(expr.id); let method_call = ty::MethodCall::expr(expr.id);
match (*self.tcx.method_map.borrow())[method_call].origin { match (*self.tcx.method_map.borrow())[method_call].origin {
typeck::MethodStatic(def_id) => { ty::MethodStatic(def_id) => {
if is_local(def_id) { if is_local(def_id) {
if self.def_id_represents_local_inlined_item(def_id) { if self.def_id_represents_local_inlined_item(def_id) {
self.worklist.push(def_id.node) self.worklist.push(def_id.node)

198
src/librustc/middle/ty.rs
View file

@ -35,6 +35,9 @@ pub use self::ImplOrTraitItem::*;
pub use self::BoundRegion::*; pub use self::BoundRegion::*;
pub use self::sty::*; pub use self::sty::*;
pub use self::IntVarValue::*; pub use self::IntVarValue::*;
pub use self::ExprAdjustment::*;
pub use self::vtable_origin::*;
pub use self::MethodOrigin::*;
use back::svh::Svh; use back::svh::Svh;
use session::Session; use session::Session;
@ -53,7 +56,6 @@ use middle::stability;
use middle::subst::{mod, Subst, Substs, VecPerParamSpace}; use middle::subst::{mod, Subst, Substs, VecPerParamSpace};
use middle::traits; use middle::traits;
use middle::ty; use middle::ty;
use middle::typeck;
use middle::ty_fold::{mod, TypeFoldable, TypeFolder, HigherRankedFoldable}; use middle::ty_fold::{mod, TypeFoldable, TypeFolder, HigherRankedFoldable};
use middle; use middle;
use util::ppaux::{note_and_explain_region, bound_region_ptr_to_string}; use util::ppaux::{note_and_explain_region, bound_region_ptr_to_string};
@ -412,7 +414,161 @@ pub fn type_of_adjust<'tcx>(cx: &ctxt<'tcx>, adj: &AutoAdjustment<'tcx>) -> Opti
} }
} }
#[deriving(Clone, Encodable, Decodable, PartialEq, PartialOrd, Show)]
pub struct param_index {
pub space: subst::ParamSpace,
pub index: uint
}
#[deriving(Clone, Show)]
pub enum MethodOrigin<'tcx> {
// fully statically resolved method
MethodStatic(ast::DefId),
// fully statically resolved unboxed closure invocation
MethodStaticUnboxedClosure(ast::DefId),
// method invoked on a type parameter with a bounded trait
MethodTypeParam(MethodParam<'tcx>),
// method invoked on a trait instance
MethodTraitObject(MethodObject<'tcx>),
}
// details for a method invoked with a receiver whose type is a type parameter
// with a bounded trait.
#[deriving(Clone, Show)]
pub struct MethodParam<'tcx> {
// the precise trait reference that occurs as a bound -- this may
// be a supertrait of what the user actually typed.
pub trait_ref: Rc<ty::TraitRef<'tcx>>,
// index of uint in the list of methods for the trait
pub method_num: uint,
}
// details for a method invoked with a receiver whose type is an object
#[deriving(Clone, Show)]
pub struct MethodObject<'tcx> {
// the (super)trait containing the method to be invoked
pub trait_ref: Rc<ty::TraitRef<'tcx>>,
// the actual base trait id of the object
pub object_trait_id: ast::DefId,
// index of the method to be invoked amongst the trait's methods
pub method_num: uint,
// index into the actual runtime vtable.
// the vtable is formed by concatenating together the method lists of
// the base object trait and all supertraits; this is the index into
// that vtable
pub real_index: uint,
}
#[deriving(Clone)]
pub struct MethodCallee<'tcx> {
pub origin: MethodOrigin<'tcx>,
pub ty: Ty<'tcx>,
pub substs: subst::Substs<'tcx>
}
/// With method calls, we store some extra information in
/// side tables (i.e method_map). We use
/// MethodCall as a key to index into these tables instead of
/// just directly using the expression's NodeId. The reason
/// for this being that we may apply adjustments (coercions)
/// with the resulting expression also needing to use the
/// side tables. The problem with this is that we don't
/// assign a separate NodeId to this new expression
/// and so it would clash with the base expression if both
/// needed to add to the side tables. Thus to disambiguate
/// we also keep track of whether there's an adjustment in
/// our key.
#[deriving(Clone, PartialEq, Eq, Hash, Show)]
pub struct MethodCall {
pub expr_id: ast::NodeId,
pub adjustment: ExprAdjustment
}
#[deriving(Clone, PartialEq, Eq, Hash, Show, Encodable, Decodable)]
pub enum ExprAdjustment {
NoAdjustment,
AutoDeref(uint),
AutoObject
}
impl MethodCall {
pub fn expr(id: ast::NodeId) -> MethodCall {
MethodCall {
expr_id: id,
adjustment: NoAdjustment
}
}
pub fn autoobject(id: ast::NodeId) -> MethodCall {
MethodCall {
expr_id: id,
adjustment: AutoObject
}
}
pub fn autoderef(expr_id: ast::NodeId, autoderef: uint) -> MethodCall {
MethodCall {
expr_id: expr_id,
adjustment: AutoDeref(1 + autoderef)
}
}
}
// maps from an expression id that corresponds to a method call to the details
// of the method to be invoked
pub type MethodMap<'tcx> = RefCell<FnvHashMap<MethodCall, MethodCallee<'tcx>>>;
pub type vtable_param_res<'tcx> = Vec<vtable_origin<'tcx>>;
// Resolutions for bounds of all parameters, left to right, for a given path.
pub type vtable_res<'tcx> = VecPerParamSpace<vtable_param_res<'tcx>>;
#[deriving(Clone)]
pub enum vtable_origin<'tcx> {
/*
Statically known vtable. def_id gives the impl item
from whence comes the vtable, and tys are the type substs.
vtable_res is the vtable itself.
*/
vtable_static(ast::DefId, subst::Substs<'tcx>, vtable_res<'tcx>),
/*
Dynamic vtable, comes from a parameter that has a bound on it:
fn foo<T:quux,baz,bar>(a: T) -- a's vtable would have a
vtable_param origin
The first argument is the param index (identifying T in the example),
and the second is the bound number (identifying baz)
*/
vtable_param(param_index, uint),
/*
Vtable automatically generated for an unboxed closure. The def ID is the
ID of the closure expression.
*/
vtable_unboxed_closure(ast::DefId),
/*
Asked to determine the vtable for ty_err. This is the value used
for the vtables of `Self` in a virtual call like `foo.bar()`
where `foo` is of object type. The same value is also used when
type errors occur.
*/
vtable_error,
}
// For every explicit cast into an object type, maps from the cast
// expr to the associated trait ref.
pub type ObjectCastMap<'tcx> = RefCell<NodeMap<Rc<ty::TraitRef<'tcx>>>>;
/// A restriction that certain types must be the same size. The use of /// A restriction that certain types must be the same size. The use of
/// `transmute` gives rise to these restrictions. /// `transmute` gives rise to these restrictions.
@ -473,7 +629,7 @@ pub struct ctxt<'tcx> {
/// Maps from node-id of a trait object cast (like `foo as /// Maps from node-id of a trait object cast (like `foo as
/// Box<Trait>`) to the trait reference. /// Box<Trait>`) to the trait reference.
pub object_cast_map: typeck::ObjectCastMap<'tcx>, pub object_cast_map: ObjectCastMap<'tcx>,
pub map: ast_map::Map<'tcx>, pub map: ast_map::Map<'tcx>,
pub intrinsic_defs: RefCell<DefIdMap<Ty<'tcx>>>, pub intrinsic_defs: RefCell<DefIdMap<Ty<'tcx>>>,
@ -548,7 +704,7 @@ pub struct ctxt<'tcx> {
pub extern_const_statics: RefCell<DefIdMap<ast::NodeId>>, pub extern_const_statics: RefCell<DefIdMap<ast::NodeId>>,
pub extern_const_variants: RefCell<DefIdMap<ast::NodeId>>, pub extern_const_variants: RefCell<DefIdMap<ast::NodeId>>,
pub method_map: typeck::MethodMap<'tcx>, pub method_map: MethodMap<'tcx>,
pub dependency_formats: RefCell<dependency_format::Dependencies>, pub dependency_formats: RefCell<dependency_format::Dependencies>,
@ -3658,7 +3814,7 @@ pub fn adjust_ty<'tcx>(cx: &ctxt<'tcx>,
expr_id: ast::NodeId, expr_id: ast::NodeId,
unadjusted_ty: Ty<'tcx>, unadjusted_ty: Ty<'tcx>,
adjustment: Option<&AutoAdjustment<'tcx>>, adjustment: Option<&AutoAdjustment<'tcx>>,
method_type: |typeck::MethodCall| -> Option<Ty<'tcx>>) method_type: |MethodCall| -> Option<Ty<'tcx>>)
-> Ty<'tcx> { -> Ty<'tcx> {
if let ty_err = unadjusted_ty.sty { if let ty_err = unadjusted_ty.sty {
@ -3699,7 +3855,7 @@ pub fn adjust_ty<'tcx>(cx: &ctxt<'tcx>,
if !ty::type_is_error(adjusted_ty) { if !ty::type_is_error(adjusted_ty) {
for i in range(0, adj.autoderefs) { for i in range(0, adj.autoderefs) {
let method_call = typeck::MethodCall::autoderef(expr_id, i); let method_call = MethodCall::autoderef(expr_id, i);
match method_type(method_call) { match method_type(method_call) {
Some(method_ty) => { Some(method_ty) => {
if let ty::FnConverging(result_type) = ty_fn_ret(method_ty) { if let ty::FnConverging(result_type) = ty_fn_ret(method_ty) {
@ -3830,7 +3986,7 @@ pub enum ExprKind {
} }
pub fn expr_kind(tcx: &ctxt, expr: &ast::Expr) -> ExprKind { pub fn expr_kind(tcx: &ctxt, expr: &ast::Expr) -> ExprKind {
if tcx.method_map.borrow().contains_key(&typeck::MethodCall::expr(expr.id)) { if tcx.method_map.borrow().contains_key(&MethodCall::expr(expr.id)) {
// Overloaded operations are generally calls, and hence they are // Overloaded operations are generally calls, and hence they are
// generated via DPS, but there are a few exceptions: // generated via DPS, but there are a few exceptions:
return match expr.node { return match expr.node {
@ -5747,7 +5903,7 @@ impl<'tcx> mc::Typer<'tcx> for ty::ctxt<'tcx> {
Ok(ty::node_id_to_type(self, id)) Ok(ty::node_id_to_type(self, id))
} }
fn node_method_ty(&self, method_call: typeck::MethodCall) -> Option<Ty<'tcx>> { fn node_method_ty(&self, method_call: MethodCall) -> Option<Ty<'tcx>> {
self.method_map.borrow().get(&method_call).map(|method| method.ty) self.method_map.borrow().get(&method_call).map(|method| method.ty)
} }
@ -5756,7 +5912,7 @@ impl<'tcx> mc::Typer<'tcx> for ty::ctxt<'tcx> {
} }
fn is_method_call(&self, id: ast::NodeId) -> bool { fn is_method_call(&self, id: ast::NodeId) -> bool {
self.method_map.borrow().contains_key(&typeck::MethodCall::expr(id)) self.method_map.borrow().contains_key(&MethodCall::expr(id))
} }
fn temporary_scope(&self, rvalue_id: ast::NodeId) -> Option<region::CodeExtent> { fn temporary_scope(&self, rvalue_id: ast::NodeId) -> Option<region::CodeExtent> {
@ -6010,3 +6166,29 @@ impl<'tcx> Repr<'tcx> for TyTrait<'tcx> {
self.bounds.repr(tcx)) self.bounds.repr(tcx))
} }
} }
impl<'tcx> Repr<'tcx> for vtable_origin<'tcx> {
fn repr(&self, tcx: &ty::ctxt<'tcx>) -> String {
match *self {
vtable_static(def_id, ref tys, ref vtable_res) => {
format!("vtable_static({}:{}, {}, {})",
def_id,
ty::item_path_str(tcx, def_id),
tys.repr(tcx),
vtable_res.repr(tcx))
}
vtable_param(x, y) => {
format!("vtable_param({}, {})", x, y)
}
vtable_unboxed_closure(def_id) => {
format!("vtable_unboxed_closure({})", def_id)
}
vtable_error => {
format!("vtable_error")
}
}
}
}

41
src/librustc/middle/ty_fold.rs
View file

@ -38,7 +38,6 @@ use middle::subst;
use middle::subst::VecPerParamSpace; use middle::subst::VecPerParamSpace;
use middle::ty::{mod, Ty}; use middle::ty::{mod, Ty};
use middle::traits; use middle::traits;
use middle::typeck;
use std::rc::Rc; use std::rc::Rc;
use syntax::owned_slice::OwnedSlice; use syntax::owned_slice::OwnedSlice;
use util::ppaux::Repr; use util::ppaux::Repr;
@ -304,23 +303,23 @@ impl<'tcx> TypeFoldable<'tcx> for ty::AutoRef<'tcx> {
} }
} }
impl<'tcx> TypeFoldable<'tcx> for typeck::MethodOrigin<'tcx> { impl<'tcx> TypeFoldable<'tcx> for ty::MethodOrigin<'tcx> {
fn fold_with<F: TypeFolder<'tcx>>(&self, folder: &mut F) -> typeck::MethodOrigin<'tcx> { fn fold_with<F: TypeFolder<'tcx>>(&self, folder: &mut F) -> ty::MethodOrigin<'tcx> {
match *self { match *self {
typeck::MethodStatic(def_id) => { ty::MethodStatic(def_id) => {
typeck::MethodStatic(def_id) ty::MethodStatic(def_id)
} }
typeck::MethodStaticUnboxedClosure(def_id) => { ty::MethodStaticUnboxedClosure(def_id) => {
typeck::MethodStaticUnboxedClosure(def_id) ty::MethodStaticUnboxedClosure(def_id)
} }
typeck::MethodTypeParam(ref param) => { ty::MethodTypeParam(ref param) => {
typeck::MethodTypeParam(typeck::MethodParam { ty::MethodTypeParam(ty::MethodParam {
trait_ref: param.trait_ref.fold_with(folder), trait_ref: param.trait_ref.fold_with(folder),
method_num: param.method_num method_num: param.method_num
}) })
} }
typeck::MethodTraitObject(ref object) => { ty::MethodTraitObject(ref object) => {
typeck::MethodTraitObject(typeck::MethodObject { ty::MethodTraitObject(ty::MethodObject {
trait_ref: object.trait_ref.fold_with(folder), trait_ref: object.trait_ref.fold_with(folder),
object_trait_id: object.object_trait_id, object_trait_id: object.object_trait_id,
method_num: object.method_num, method_num: object.method_num,
@ -331,22 +330,22 @@ impl<'tcx> TypeFoldable<'tcx> for typeck::MethodOrigin<'tcx> {
} }
} }
impl<'tcx> TypeFoldable<'tcx> for typeck::vtable_origin<'tcx> { impl<'tcx> TypeFoldable<'tcx> for ty::vtable_origin<'tcx> {
fn fold_with<F: TypeFolder<'tcx>>(&self, folder: &mut F) -> typeck::vtable_origin<'tcx> { fn fold_with<F: TypeFolder<'tcx>>(&self, folder: &mut F) -> ty::vtable_origin<'tcx> {
match *self { match *self {
typeck::vtable_static(def_id, ref substs, ref origins) => { ty::vtable_static(def_id, ref substs, ref origins) => {
let r_substs = substs.fold_with(folder); let r_substs = substs.fold_with(folder);
let r_origins = origins.fold_with(folder); let r_origins = origins.fold_with(folder);
typeck::vtable_static(def_id, r_substs, r_origins) ty::vtable_static(def_id, r_substs, r_origins)
} }
typeck::vtable_param(n, b) => { ty::vtable_param(n, b) => {
typeck::vtable_param(n, b) ty::vtable_param(n, b)
} }
typeck::vtable_unboxed_closure(def_id) => { ty::vtable_unboxed_closure(def_id) => {
typeck::vtable_unboxed_closure(def_id) ty::vtable_unboxed_closure(def_id)
} }
typeck::vtable_error => { ty::vtable_error => {
typeck::vtable_error ty::vtable_error
} }
} }
} }

4
src/librustc/middle/typeck/check/method/confirm.rs
View file

@ -13,9 +13,9 @@ use super::probe;
use middle::subst::{mod, Subst}; use middle::subst::{mod, Subst};
use middle::traits; use middle::traits;
use middle::ty::{mod, Ty}; use middle::ty::{mod, Ty};
use middle::typeck::check::{mod, FnCtxt, NoPreference, PreferMutLvalue}; use middle::ty::{MethodCall, MethodCallee, MethodObject, MethodOrigin,
use middle::typeck::{MethodCall, MethodCallee, MethodObject, MethodOrigin,
MethodParam, MethodStatic, MethodTraitObject, MethodTypeParam}; MethodParam, MethodStatic, MethodTraitObject, MethodTypeParam};
use middle::typeck::check::{mod, FnCtxt, NoPreference, PreferMutLvalue};
use middle::typeck::infer::{mod, InferCtxt}; use middle::typeck::infer::{mod, InferCtxt};
use middle::ty_fold::HigherRankedFoldable; use middle::ty_fold::HigherRankedFoldable;
use syntax::ast; use syntax::ast;

2
src/librustc/middle/typeck/check/method/mod.rs
View file

@ -21,8 +21,6 @@ use middle::typeck::check::{impl_self_ty};
use middle::typeck::check::vtable; use middle::typeck::check::vtable;
use middle::typeck::check::vtable::select_new_fcx_obligations; use middle::typeck::check::vtable::select_new_fcx_obligations;
use middle::typeck::infer; use middle::typeck::infer;
use middle::typeck::{MethodCallee};
use middle::typeck::{MethodParam, MethodTypeParam};
use util::ppaux::{Repr, UserString}; use util::ppaux::{Repr, UserString};
use std::rc::Rc; use std::rc::Rc;

2
src/librustc/middle/typeck/check/method/probe.rs
View file

@ -17,10 +17,10 @@ use middle::subst;
use middle::subst::Subst; use middle::subst::Subst;
use middle::traits; use middle::traits;
use middle::ty::{mod, Ty}; use middle::ty::{mod, Ty};
use middle::ty::{MethodObject};
use middle::ty_fold::HigherRankedFoldable; use middle::ty_fold::HigherRankedFoldable;
use middle::typeck::check; use middle::typeck::check;
use middle::typeck::check::{FnCtxt, NoPreference}; use middle::typeck::check::{FnCtxt, NoPreference};
use middle::typeck::{MethodObject};
use middle::typeck::infer; use middle::typeck::infer;
use middle::typeck::infer::InferCtxt; use middle::typeck::infer::InferCtxt;
use syntax::ast; use syntax::ast;

11
src/librustc/middle/typeck/check/mod.rs
View file

@ -93,12 +93,13 @@ use middle::ty::{FnSig, VariantInfo, Polytype};
use middle::ty::{Disr, ParamTy, ParameterEnvironment}; use middle::ty::{Disr, ParamTy, ParameterEnvironment};
use middle::ty::{mod, Ty}; use middle::ty::{mod, Ty};
use middle::ty::liberate_late_bound_regions; use middle::ty::liberate_late_bound_regions;
use middle::ty::{MethodCall, MethodCallee, MethodMap, ObjectCastMap};
use middle::ty_fold::TypeFolder; use middle::ty_fold::TypeFolder;
use middle::typeck::astconv::{mod, ast_region_to_region, ast_ty_to_ty, AstConv}; use middle::typeck::astconv::{mod, ast_region_to_region, ast_ty_to_ty, AstConv};
use middle::typeck::check::_match::pat_ctxt; use middle::typeck::check::_match::pat_ctxt;
use middle::typeck::rscope::RegionScope; use middle::typeck::rscope::RegionScope;
use middle::typeck::{mod, CrateCtxt, infer, lookup_def_ccx, no_params, require_same_types}; use middle::typeck::{CrateCtxt, infer, lookup_def_ccx, no_params, require_same_types};
use middle::typeck::{MethodCall, MethodCallee, MethodMap, ObjectCastMap, TypeAndSubsts}; use middle::typeck::TypeAndSubsts;
use middle::lang_items::TypeIdLangItem; use middle::lang_items::TypeIdLangItem;
use lint; use lint;
use util::common::{block_query, indenter, loop_query}; use util::common::{block_query, indenter, loop_query};
@ -279,7 +280,7 @@ impl<'a, 'tcx> mem_categorization::Typer<'tcx> for FnCtxt<'a, 'tcx> {
fn node_ty(&self, id: ast::NodeId) -> McResult<Ty<'tcx>> { fn node_ty(&self, id: ast::NodeId) -> McResult<Ty<'tcx>> {
Ok(self.node_ty(id)) Ok(self.node_ty(id))
} }
fn node_method_ty(&self, method_call: typeck::MethodCall) fn node_method_ty(&self, method_call: ty::MethodCall)
-> Option<Ty<'tcx>> { -> Option<Ty<'tcx>> {
self.inh.method_map.borrow().get(&method_call).map(|m| m.ty) self.inh.method_map.borrow().get(&method_call).map(|m| m.ty)
} }
@ -287,7 +288,7 @@ impl<'a, 'tcx> mem_categorization::Typer<'tcx> for FnCtxt<'a, 'tcx> {
&self.inh.adjustments &self.inh.adjustments
} }
fn is_method_call(&self, id: ast::NodeId) -> bool { fn is_method_call(&self, id: ast::NodeId) -> bool {
self.inh.method_map.borrow().contains_key(&typeck::MethodCall::expr(id)) self.inh.method_map.borrow().contains_key(&ty::MethodCall::expr(id))
} }
fn temporary_scope(&self, rvalue_id: ast::NodeId) -> Option<CodeExtent> { fn temporary_scope(&self, rvalue_id: ast::NodeId) -> Option<CodeExtent> {
self.tcx().temporary_scope(rvalue_id) self.tcx().temporary_scope(rvalue_id)
@ -3260,7 +3261,7 @@ fn check_expr_with_unifier<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>,
Some(method) => { Some(method) => {
let method_ty = method.ty; let method_ty = method.ty;
// HACK(eddyb) Fully qualified path to work around a resolve bug. // HACK(eddyb) Fully qualified path to work around a resolve bug.
let method_call = ::middle::typeck::MethodCall::expr(op_ex.id); let method_call = ::middle::ty::MethodCall::expr(op_ex.id);
fcx.inh.method_map.borrow_mut().insert(method_call, method); fcx.inh.method_map.borrow_mut().insert(method_call, method);
match check_method_argument_types(fcx, match check_method_argument_types(fcx,
op_ex.span, op_ex.span,

3
src/librustc/middle/typeck/check/regionck.rs
View file

@ -119,7 +119,7 @@ use middle::mem_categorization as mc;
use middle::region::CodeExtent; use middle::region::CodeExtent;
use middle::traits; use middle::traits;
use middle::ty::{ReScope}; use middle::ty::{ReScope};
use middle::ty::{mod, Ty}; use middle::ty::{mod, Ty, MethodCall};
use middle::typeck::astconv::AstConv; use middle::typeck::astconv::AstConv;
use middle::typeck::check::FnCtxt; use middle::typeck::check::FnCtxt;
use middle::typeck::check::regionmanip; use middle::typeck::check::regionmanip;
@ -127,7 +127,6 @@ use middle::typeck::check::vtable;
use middle::typeck::infer::resolve_and_force_all_but_regions; use middle::typeck::infer::resolve_and_force_all_but_regions;
use middle::typeck::infer::resolve_type; use middle::typeck::infer::resolve_type;
use middle::typeck::infer; use middle::typeck::infer;
use middle::typeck::MethodCall;
use middle::pat_util; use middle::pat_util;
use util::nodemap::{DefIdMap, NodeMap, FnvHashMap}; use util::nodemap::{DefIdMap, NodeMap, FnvHashMap};
use util::ppaux::{ty_to_string, Repr}; use util::ppaux::{ty_to_string, Repr};

3
src/librustc/middle/typeck/check/writeback.rs
View file

@ -15,14 +15,13 @@ use self::ResolveReason::*;
use middle::def; use middle::def;
use middle::pat_util; use middle::pat_util;
use middle::ty::{mod, Ty}; use middle::ty::{mod, Ty, MethodCall, MethodCallee};
use middle::ty_fold::{TypeFolder,TypeFoldable}; use middle::ty_fold::{TypeFolder,TypeFoldable};
use middle::typeck::astconv::AstConv; use middle::typeck::astconv::AstConv;
use middle::typeck::check::FnCtxt; use middle::typeck::check::FnCtxt;
use middle::typeck::infer::{force_all, resolve_all, resolve_region}; use middle::typeck::infer::{force_all, resolve_all, resolve_region};
use middle::typeck::infer::resolve_type; use middle::typeck::infer::resolve_type;
use middle::typeck::infer; use middle::typeck::infer;
use middle::typeck::{MethodCall, MethodCallee};
use middle::typeck::write_substs_to_tcx; use middle::typeck::write_substs_to_tcx;
use middle::typeck::write_ty_to_tcx; use middle::typeck::write_ty_to_tcx;
use util::ppaux::Repr; use util::ppaux::Repr;

188
src/librustc/middle/typeck/mod.rs
View file

@ -61,10 +61,6 @@ independently:
#![allow(non_camel_case_types)] #![allow(non_camel_case_types)]
pub use self::ExprAdjustment::*;
pub use self::vtable_origin::*;
pub use self::MethodOrigin::*;
use middle::def; use middle::def;
use middle::resolve; use middle::resolve;
use middle::subst; use middle::subst;
@ -74,10 +70,7 @@ use session::config;
use util::common::time; use util::common::time;
use util::ppaux::Repr; use util::ppaux::Repr;
use util::ppaux; use util::ppaux;
use util::nodemap::{NodeMap, FnvHashMap};
use std::cell::RefCell;
use std::rc::Rc;
use syntax::codemap::Span; use syntax::codemap::Span;
use syntax::print::pprust::*; use syntax::print::pprust::*;
use syntax::{ast, ast_map, abi}; use syntax::{ast, ast_map, abi};
@ -90,192 +83,11 @@ pub mod collect;
pub mod coherence; pub mod coherence;
pub mod variance; pub mod variance;
#[deriving(Clone, Encodable, Decodable, PartialEq, PartialOrd, Show)]
pub struct param_index {
pub space: subst::ParamSpace,
pub index: uint
}
#[deriving(Clone, Show)]
pub enum MethodOrigin<'tcx> {
// fully statically resolved method
MethodStatic(ast::DefId),
// fully statically resolved unboxed closure invocation
MethodStaticUnboxedClosure(ast::DefId),
// method invoked on a type parameter with a bounded trait
MethodTypeParam(MethodParam<'tcx>),
// method invoked on a trait instance
MethodTraitObject(MethodObject<'tcx>),
}
// details for a method invoked with a receiver whose type is a type parameter
// with a bounded trait.
#[deriving(Clone, Show)]
pub struct MethodParam<'tcx> {
// the precise trait reference that occurs as a bound -- this may
// be a supertrait of what the user actually typed.
pub trait_ref: Rc<ty::TraitRef<'tcx>>,
// index of uint in the list of methods for the trait
pub method_num: uint,
}
// details for a method invoked with a receiver whose type is an object
#[deriving(Clone, Show)]
pub struct MethodObject<'tcx> {
// the (super)trait containing the method to be invoked
pub trait_ref: Rc<ty::TraitRef<'tcx>>,
// the actual base trait id of the object
pub object_trait_id: ast::DefId,
// index of the method to be invoked amongst the trait's methods
pub method_num: uint,
// index into the actual runtime vtable.
// the vtable is formed by concatenating together the method lists of
// the base object trait and all supertraits; this is the index into
// that vtable
pub real_index: uint,
}
#[deriving(Clone)]
pub struct MethodCallee<'tcx> {
pub origin: MethodOrigin<'tcx>,
pub ty: Ty<'tcx>,
pub substs: subst::Substs<'tcx>
}
/// With method calls, we store some extra information in
/// side tables (i.e method_map). We use
/// MethodCall as a key to index into these tables instead of
/// just directly using the expression's NodeId. The reason
/// for this being that we may apply adjustments (coercions)
/// with the resulting expression also needing to use the
/// side tables. The problem with this is that we don't
/// assign a separate NodeId to this new expression
/// and so it would clash with the base expression if both
/// needed to add to the side tables. Thus to disambiguate
/// we also keep track of whether there's an adjustment in
/// our key.
#[deriving(Clone, PartialEq, Eq, Hash, Show)]
pub struct MethodCall {
pub expr_id: ast::NodeId,
pub adjustment: ExprAdjustment
}
#[deriving(Clone, PartialEq, Eq, Hash, Show, Encodable, Decodable)]
pub enum ExprAdjustment {
NoAdjustment,
AutoDeref(uint),
AutoObject
}
pub struct TypeAndSubsts<'tcx> { pub struct TypeAndSubsts<'tcx> {
pub substs: subst::Substs<'tcx>, pub substs: subst::Substs<'tcx>,
pub ty: Ty<'tcx>, pub ty: Ty<'tcx>,
} }
impl MethodCall {
pub fn expr(id: ast::NodeId) -> MethodCall {
MethodCall {
expr_id: id,
adjustment: NoAdjustment
}
}
pub fn autoobject(id: ast::NodeId) -> MethodCall {
MethodCall {
expr_id: id,
adjustment: AutoObject
}
}
pub fn autoderef(expr_id: ast::NodeId, autoderef: uint) -> MethodCall {
MethodCall {
expr_id: expr_id,
adjustment: AutoDeref(1 + autoderef)
}
}
}
// maps from an expression id that corresponds to a method call to the details
// of the method to be invoked
pub type MethodMap<'tcx> = RefCell<FnvHashMap<MethodCall, MethodCallee<'tcx>>>;
pub type vtable_param_res<'tcx> = Vec<vtable_origin<'tcx>>;
// Resolutions for bounds of all parameters, left to right, for a given path.
pub type vtable_res<'tcx> = VecPerParamSpace<vtable_param_res<'tcx>>;
#[deriving(Clone)]
pub enum vtable_origin<'tcx> {
/*
Statically known vtable. def_id gives the impl item
from whence comes the vtable, and tys are the type substs.
vtable_res is the vtable itself.
*/
vtable_static(ast::DefId, subst::Substs<'tcx>, vtable_res<'tcx>),
/*
Dynamic vtable, comes from a parameter that has a bound on it:
fn foo<T:quux,baz,bar>(a: T) -- a's vtable would have a
vtable_param origin
The first argument is the param index (identifying T in the example),
and the second is the bound number (identifying baz)
*/
vtable_param(param_index, uint),
/*
Vtable automatically generated for an unboxed closure. The def ID is the
ID of the closure expression.
*/
vtable_unboxed_closure(ast::DefId),
/*
Asked to determine the vtable for ty_err. This is the value used
for the vtables of `Self` in a virtual call like `foo.bar()`
where `foo` is of object type. The same value is also used when
type errors occur.
*/
vtable_error,
}
impl<'tcx> Repr<'tcx> for vtable_origin<'tcx> {
fn repr(&self, tcx: &ty::ctxt<'tcx>) -> String {
match *self {
vtable_static(def_id, ref tys, ref vtable_res) => {
format!("vtable_static({}:{}, {}, {})",
def_id,
ty::item_path_str(tcx, def_id),
tys.repr(tcx),
vtable_res.repr(tcx))
}
vtable_param(x, y) => {
format!("vtable_param({}, {})", x, y)
}
vtable_unboxed_closure(def_id) => {
format!("vtable_unboxed_closure({})", def_id)
}
vtable_error => {
format!("vtable_error")
}
}
}
}
// For every explicit cast into an object type, maps from the cast
// expr to the associated trait ref.
pub type ObjectCastMap<'tcx> = RefCell<NodeMap<Rc<ty::TraitRef<'tcx>>>>;
pub struct CrateCtxt<'a, 'tcx: 'a> { pub struct CrateCtxt<'a, 'tcx: 'a> {
// A mapping from method call sites to traits that have that method. // A mapping from method call sites to traits that have that method.
trait_map: resolve::TraitMap, trait_map: resolve::TraitMap,

18
src/librustc/util/ppaux.rs
View file

@ -23,7 +23,6 @@ use middle::ty::{ty_param, ty_ptr, ty_rptr, ty_tup, ty_open};
use middle::ty::{ty_unboxed_closure}; use middle::ty::{ty_unboxed_closure};
use middle::ty::{ty_uniq, ty_trait, ty_int, ty_uint, ty_infer}; use middle::ty::{ty_uniq, ty_trait, ty_int, ty_uint, ty_infer};
use middle::ty; use middle::ty;
use middle::typeck;
use middle::typeck::check::regionmanip; use middle::typeck::check::regionmanip;
use std::rc::Rc; use std::rc::Rc;
@ -1018,7 +1017,7 @@ impl<'tcx> Repr<'tcx> for ty::FnOutput<'tcx> {
} }
} }
impl<'tcx> Repr<'tcx> for typeck::MethodCallee<'tcx> { impl<'tcx> Repr<'tcx> for ty::MethodCallee<'tcx> {
fn repr(&self, tcx: &ctxt<'tcx>) -> String { fn repr(&self, tcx: &ctxt<'tcx>) -> String {
format!("MethodCallee {{origin: {}, ty: {}, {}}}", format!("MethodCallee {{origin: {}, ty: {}, {}}}",
self.origin.repr(tcx), self.origin.repr(tcx),
@ -1027,26 +1026,26 @@ impl<'tcx> Repr<'tcx> for typeck::MethodCallee<'tcx> {
} }
} }
impl<'tcx> Repr<'tcx> for typeck::MethodOrigin<'tcx> { impl<'tcx> Repr<'tcx> for ty::MethodOrigin<'tcx> {
fn repr(&self, tcx: &ctxt<'tcx>) -> String { fn repr(&self, tcx: &ctxt<'tcx>) -> String {
match self { match self {
&typeck::MethodStatic(def_id) => { &ty::MethodStatic(def_id) => {
format!("MethodStatic({})", def_id.repr(tcx)) format!("MethodStatic({})", def_id.repr(tcx))
} }
&typeck::MethodStaticUnboxedClosure(def_id) => { &ty::MethodStaticUnboxedClosure(def_id) => {
format!("MethodStaticUnboxedClosure({})", def_id.repr(tcx)) format!("MethodStaticUnboxedClosure({})", def_id.repr(tcx))
} }
&typeck::MethodTypeParam(ref p) => { &ty::MethodTypeParam(ref p) => {
p.repr(tcx) p.repr(tcx)
} }
&typeck::MethodTraitObject(ref p) => { &ty::MethodTraitObject(ref p) => {
p.repr(tcx) p.repr(tcx)
} }
} }
} }
} }
impl<'tcx> Repr<'tcx> for typeck::MethodParam<'tcx> { impl<'tcx> Repr<'tcx> for ty::MethodParam<'tcx> {
fn repr(&self, tcx: &ctxt<'tcx>) -> String { fn repr(&self, tcx: &ctxt<'tcx>) -> String {
format!("MethodParam({},{})", format!("MethodParam({},{})",
self.trait_ref.repr(tcx), self.trait_ref.repr(tcx),
@ -1054,7 +1053,7 @@ impl<'tcx> Repr<'tcx> for typeck::MethodParam<'tcx> {
} }
} }
impl<'tcx> Repr<'tcx> for typeck::MethodObject<'tcx> { impl<'tcx> Repr<'tcx> for ty::MethodObject<'tcx> {
fn repr(&self, tcx: &ctxt<'tcx>) -> String { fn repr(&self, tcx: &ctxt<'tcx>) -> String {
format!("MethodObject({},{},{})", format!("MethodObject({},{},{})",
self.trait_ref.repr(tcx), self.trait_ref.repr(tcx),
@ -1293,7 +1292,6 @@ impl<'tcx> Repr<'tcx> for ty::ExplicitSelfCategory {
} }
} }
impl<'tcx> Repr<'tcx> for regionmanip::WfConstraint<'tcx> { impl<'tcx> Repr<'tcx> for regionmanip::WfConstraint<'tcx> {
fn repr(&self, tcx: &ctxt) -> String { fn repr(&self, tcx: &ctxt) -> String {
match *self { match *self {

10
src/librustc_trans/save/mod.rs
View file

@ -912,10 +912,10 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> {
ex: &ast::Expr, ex: &ast::Expr,
args: &Vec<P<ast::Expr>>) { args: &Vec<P<ast::Expr>>) {
let method_map = self.analysis.ty_cx.method_map.borrow(); let method_map = self.analysis.ty_cx.method_map.borrow();
let method_callee = &(*method_map)[typeck::MethodCall::expr(ex.id)]; let method_callee = &(*method_map)[ty::MethodCall::expr(ex.id)];
let (def_id, decl_id) = match method_callee.origin { let (def_id, decl_id) = match method_callee.origin {
typeck::MethodStatic(def_id) | ty::MethodStatic(def_id) |
typeck::MethodStaticUnboxedClosure(def_id) => { ty::MethodStaticUnboxedClosure(def_id) => {
// method invoked on an object with a concrete type (not a static method) // method invoked on an object with a concrete type (not a static method)
let decl_id = let decl_id =
match ty::trait_item_of_item(&self.analysis.ty_cx, match ty::trait_item_of_item(&self.analysis.ty_cx,
@ -936,14 +936,14 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> {
}; };
(Some(def_id), decl_id) (Some(def_id), decl_id)
} }
typeck::MethodTypeParam(ref mp) => { ty::MethodTypeParam(ref mp) => {
// method invoked on a type parameter // method invoked on a type parameter
let trait_item = ty::trait_item(&self.analysis.ty_cx, let trait_item = ty::trait_item(&self.analysis.ty_cx,
mp.trait_ref.def_id, mp.trait_ref.def_id,
mp.method_num); mp.method_num);
(None, Some(trait_item.def_id())) (None, Some(trait_item.def_id()))
} }
typeck::MethodTraitObject(ref mo) => { ty::MethodTraitObject(ref mo) => {
// method invoked on a trait instance // method invoked on a trait instance
let trait_item = ty::trait_item(&self.analysis.ty_cx, let trait_item = ty::trait_item(&self.analysis.ty_cx,
mo.trait_ref.def_id, mo.trait_ref.def_id,

2
src/librustc_trans/trans/callee.rs
View file

@ -49,8 +49,8 @@ use trans::monomorphize;
use trans::type_::Type; use trans::type_::Type;
use trans::type_of; use trans::type_of;
use middle::ty::{mod, Ty}; use middle::ty::{mod, Ty};
use middle::ty::MethodCall;
use middle::typeck::coherence::make_substs_for_receiver_types; use middle::typeck::coherence::make_substs_for_receiver_types;
use middle::typeck::MethodCall;
use util::ppaux::Repr; use util::ppaux::Repr;
use util::ppaux::ty_to_string; use util::ppaux::ty_to_string;

7
src/librustc_trans/trans/common.rs
View file

@ -36,7 +36,6 @@ use middle::traits;
use middle::ty::{mod, Ty}; use middle::ty::{mod, Ty};
use middle::ty_fold; use middle::ty_fold;
use middle::ty_fold::TypeFoldable; use middle::ty_fold::TypeFoldable;
use middle::typeck;
use middle::typeck::infer; use middle::typeck::infer;
use util::ppaux::Repr; use util::ppaux::Repr;
use util::nodemap::{DefIdMap, FnvHashMap, NodeMap}; use util::nodemap::{DefIdMap, FnvHashMap, NodeMap};
@ -468,7 +467,7 @@ impl<'blk, 'tcx> mc::Typer<'tcx> for BlockS<'blk, 'tcx> {
Ok(node_id_type(self, id)) Ok(node_id_type(self, id))
} }
fn node_method_ty(&self, method_call: typeck::MethodCall) -> Option<Ty<'tcx>> { fn node_method_ty(&self, method_call: ty::MethodCall) -> Option<Ty<'tcx>> {
self.tcx() self.tcx()
.method_map .method_map
.borrow() .borrow()
@ -481,7 +480,7 @@ impl<'blk, 'tcx> mc::Typer<'tcx> for BlockS<'blk, 'tcx> {
} }
fn is_method_call(&self, id: ast::NodeId) -> bool { fn is_method_call(&self, id: ast::NodeId) -> bool {
self.tcx().method_map.borrow().contains_key(&typeck::MethodCall::expr(id)) self.tcx().method_map.borrow().contains_key(&ty::MethodCall::expr(id))
} }
fn temporary_scope(&self, rvalue_id: ast::NodeId) -> Option<region::CodeExtent> { fn temporary_scope(&self, rvalue_id: ast::NodeId) -> Option<region::CodeExtent> {
@ -870,7 +869,7 @@ pub enum ExprOrMethodCall {
ExprId(ast::NodeId), ExprId(ast::NodeId),
// Type parameters for a method call like `a.foo::<int>()` // Type parameters for a method call like `a.foo::<int>()`
MethodCall(typeck::MethodCall) MethodCall(ty::MethodCall)
} }
pub fn node_id_substs<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, pub fn node_id_substs<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,

2
src/librustc_trans/trans/controlflow.rs
View file

@ -27,7 +27,7 @@ use trans::meth;
use trans::type_::Type; use trans::type_::Type;
use trans; use trans;
use middle::ty; use middle::ty;
use middle::typeck::MethodCall; use middle::ty::MethodCall;
use session::config::FullDebugInfo; use session::config::FullDebugInfo;
use util::ppaux::Repr; use util::ppaux::Repr;
use util::ppaux; use util::ppaux;

17
src/librustc_trans/trans/expr.rs
View file

@ -47,9 +47,18 @@ use trans::build::*;
use trans::cleanup::{mod, CleanupMethods}; use trans::cleanup::{mod, CleanupMethods};
use trans::common::*; use trans::common::*;
use trans::datum::*; use trans::datum::*;
use middle::ty::{mod, struct_fields, tup_fields}; use trans::debuginfo;
use middle::ty::{AdjustDerefRef, AdjustAddEnv, AutoUnsafe, AutoPtr, Ty}; use trans::glue;
use middle::typeck::{mod, MethodCall}; use trans::machine;
use trans::meth;
use trans::inline;
use trans::tvec;
use trans::type_of;
use middle::ty::{struct_fields, tup_fields};
use middle::ty::{AdjustDerefRef, AdjustAddEnv, AutoUnsafe};
use middle::ty::{AutoPtr};
use middle::ty::{mod, Ty};
use middle::ty::MethodCall;
use util::common::indenter; use util::common::indenter;
use util::ppaux::Repr; use util::ppaux::Repr;
use trans::machine::{llsize_of, llsize_of_alloc}; use trans::machine::{llsize_of, llsize_of_alloc};
@ -2091,7 +2100,7 @@ fn deref_once<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
// path (below) to dereference that `&T`. // path (below) to dereference that `&T`.
let datum = match method_call.adjustment { let datum = match method_call.adjustment {
// Always perform an AutoPtr when applying an overloaded auto-deref // Always perform an AutoPtr when applying an overloaded auto-deref
typeck::AutoDeref(_) => unpack_datum!(bcx, auto_ref(bcx, datum, expr)), ty::AutoDeref(_) => unpack_datum!(bcx, auto_ref(bcx, datum, expr)),
_ => datum _ => datum
}; };

11
src/librustc_trans/trans/meth.rs
View file

@ -31,8 +31,7 @@ use trans::machine;
use trans::type_::Type; use trans::type_::Type;
use trans::type_of::*; use trans::type_of::*;
use middle::ty::{mod, Ty}; use middle::ty::{mod, Ty};
use middle::typeck; use middle::ty::MethodCall;
use middle::typeck::MethodCall;
use util::ppaux::Repr; use util::ppaux::Repr;
use std::c_str::ToCStr; use std::c_str::ToCStr;
@ -119,8 +118,8 @@ pub fn trans_method_callee<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
.unwrap(); .unwrap();
match origin { match origin {
typeck::MethodStatic(did) | ty::MethodStatic(did) |
typeck::MethodStaticUnboxedClosure(did) => { ty::MethodStaticUnboxedClosure(did) => {
Callee { Callee {
bcx: bcx, bcx: bcx,
data: Fn(callee::trans_fn_ref(bcx, data: Fn(callee::trans_fn_ref(bcx,
@ -129,7 +128,7 @@ pub fn trans_method_callee<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
} }
} }
typeck::MethodTypeParam(typeck::MethodParam { ty::MethodTypeParam(ty::MethodParam {
ref trait_ref, ref trait_ref,
method_num method_num
}) => { }) => {
@ -147,7 +146,7 @@ pub fn trans_method_callee<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
method_num, origin) method_num, origin)
} }
typeck::MethodTraitObject(ref mt) => { ty::MethodTraitObject(ref mt) => {
let self_expr = match self_expr { let self_expr = match self_expr {
Some(self_expr) => self_expr, Some(self_expr) => self_expr,
None => { None => {