From ad66c215aa2b20cf42968915571886e6ce8e9dd4 Mon Sep 17 00:00:00 2001 From: Eduard Burtescu Date: Thu, 25 Jun 2015 23:42:17 +0300 Subject: [PATCH] rustc: switch most remaining middle::ty functions to methods. --- src/librustc/metadata/encoder.rs | 51 +- src/librustc/middle/cfg/construct.rs | 2 +- src/librustc/middle/check_const.rs | 24 +- src/librustc/middle/check_match.rs | 34 +- src/librustc/middle/check_rvalues.rs | 2 +- src/librustc/middle/const_eval.rs | 18 +- src/librustc/middle/dead.rs | 23 +- src/librustc/middle/effect.rs | 8 +- src/librustc/middle/expr_use_visitor.rs | 37 +- src/librustc/middle/implicator.rs | 16 +- src/librustc/middle/infer/bivariate.rs | 4 +- src/librustc/middle/infer/error_reporting.rs | 337 +- src/librustc/middle/infer/mod.rs | 2 +- src/librustc/middle/intrinsicck.rs | 12 +- src/librustc/middle/liveness.rs | 11 +- src/librustc/middle/mem_categorization.rs | 20 +- src/librustc/middle/pat_util.rs | 2 +- src/librustc/middle/stability.rs | 28 +- src/librustc/middle/traits/coherence.rs | 14 +- src/librustc/middle/traits/error_reporting.rs | 12 +- src/librustc/middle/traits/fulfill.rs | 2 +- src/librustc/middle/traits/object_safety.rs | 16 +- src/librustc/middle/traits/project.rs | 4 +- src/librustc/middle/traits/select.rs | 36 +- src/librustc/middle/traits/util.rs | 20 +- src/librustc/middle/ty.rs | 5324 ++++++++--------- src/librustc/middle/ty_relate/mod.rs | 2 +- src/librustc/util/ppaux.rs | 12 +- src/librustc_borrowck/borrowck/check_loans.rs | 2 +- src/librustc_borrowck/borrowck/fragments.rs | 8 +- .../borrowck/gather_loans/gather_moves.rs | 4 +- .../borrowck/gather_loans/mod.rs | 2 +- .../borrowck/gather_loans/move_error.rs | 2 +- src/librustc_borrowck/borrowck/mod.rs | 32 +- src/librustc_driver/driver.rs | 20 +- src/librustc_driver/pretty.rs | 2 +- src/librustc_driver/test.rs | 20 +- src/librustc_lint/builtin.rs | 74 +- src/librustc_privacy/lib.rs | 34 +- src/librustc_trans/save/dump_csv.rs | 46 +- src/librustc_trans/save/mod.rs | 8 +- src/librustc_trans/trans/_match.rs | 27 +- src/librustc_trans/trans/adt.rs | 27 +- src/librustc_trans/trans/attributes.rs | 4 +- src/librustc_trans/trans/base.rs | 34 +- src/librustc_trans/trans/callee.rs | 34 +- src/librustc_trans/trans/closure.rs | 8 +- src/librustc_trans/trans/common.rs | 35 +- src/librustc_trans/trans/consts.rs | 26 +- src/librustc_trans/trans/datum.rs | 8 +- .../trans/debuginfo/metadata.rs | 16 +- src/librustc_trans/trans/debuginfo/mod.rs | 6 +- .../trans/debuginfo/namespace.rs | 4 +- .../trans/debuginfo/type_names.rs | 6 +- src/librustc_trans/trans/declare.rs | 2 +- src/librustc_trans/trans/expr.rs | 38 +- src/librustc_trans/trans/foreign.rs | 16 +- src/librustc_trans/trans/glue.rs | 6 +- src/librustc_trans/trans/inline.rs | 11 +- src/librustc_trans/trans/intrinsic.rs | 8 +- src/librustc_trans/trans/meth.rs | 26 +- src/librustc_trans/trans/monomorphize.rs | 8 +- src/librustc_trans/trans/tvec.rs | 4 +- src/librustc_trans/trans/type_of.rs | 6 +- src/librustc_typeck/astconv.rs | 15 +- src/librustc_typeck/check/_match.rs | 26 +- src/librustc_typeck/check/callee.rs | 5 +- src/librustc_typeck/check/cast.rs | 2 +- src/librustc_typeck/check/closure.rs | 6 +- src/librustc_typeck/check/coercion.rs | 2 +- src/librustc_typeck/check/compare_method.rs | 2 +- src/librustc_typeck/check/dropck.rs | 36 +- src/librustc_typeck/check/method/confirm.rs | 10 +- src/librustc_typeck/check/method/mod.rs | 6 +- src/librustc_typeck/check/method/probe.rs | 29 +- src/librustc_typeck/check/method/suggest.rs | 21 +- src/librustc_typeck/check/mod.rs | 146 +- src/librustc_typeck/check/op.rs | 4 +- src/librustc_typeck/check/regionck.rs | 30 +- src/librustc_typeck/check/upvar.rs | 2 +- src/librustc_typeck/check/wf.rs | 61 +- src/librustc_typeck/check/writeback.rs | 8 +- src/librustc_typeck/coherence/mod.rs | 51 +- src/librustc_typeck/coherence/orphan.rs | 14 +- src/librustc_typeck/coherence/overlap.rs | 14 +- src/librustc_typeck/coherence/unsafety.rs | 4 +- src/librustc_typeck/collect.rs | 48 +- src/librustc_typeck/lib.rs | 6 +- src/librustc_typeck/variance.rs | 22 +- src/librustdoc/clean/inline.rs | 36 +- src/librustdoc/clean/mod.rs | 8 +- src/librustdoc/clean/simplify.rs | 5 +- 92 files changed, 3516 insertions(+), 3790 deletions(-) diff --git a/src/librustc/metadata/encoder.rs b/src/librustc/metadata/encoder.rs index b217eabec6e6a..b844717e61388 100644 --- a/src/librustc/metadata/encoder.rs +++ b/src/librustc/metadata/encoder.rs @@ -23,7 +23,6 @@ use metadata::cstore; use metadata::decoder; use metadata::tyencode; use middle::def; -use middle::ty::lookup_item_type; use middle::ty::{self, Ty}; use middle::stability; use util::nodemap::{FnvHashMap, NodeMap, NodeSet}; @@ -133,7 +132,7 @@ pub fn def_to_string(did: DefId) -> String { fn encode_item_variances(rbml_w: &mut Encoder, ecx: &EncodeContext, id: NodeId) { - let v = ty::item_variances(ecx.tcx, ast_util::local_def(id)); + let v = ecx.tcx.item_variances(ast_util::local_def(id)); rbml_w.start_tag(tag_item_variances); v.encode(rbml_w); rbml_w.end_tag(); @@ -144,8 +143,8 @@ fn encode_bounds_and_type_for_item<'a, 'tcx>(rbml_w: &mut Encoder, id: ast::NodeId) { encode_bounds_and_type(rbml_w, ecx, - &ty::lookup_item_type(ecx.tcx, local_def(id)), - &ty::lookup_predicates(ecx.tcx, local_def(id))); + &ecx.tcx.lookup_item_type(local_def(id)), + &ecx.tcx.lookup_predicates(local_def(id))); } fn encode_bounds_and_type<'a, 'tcx>(rbml_w: &mut Encoder, @@ -293,8 +292,7 @@ fn encode_enum_variant_info(ecx: &EncodeContext, let mut disr_val = 0; let mut i = 0; - let vi = ty::enum_variants(ecx.tcx, - DefId { krate: ast::LOCAL_CRATE, node: id }); + let vi = ecx.tcx.enum_variants(local_def(id)); for variant in variants { let def_id = local_def(variant.node.id); index.push(entry { @@ -319,7 +317,7 @@ fn encode_enum_variant_info(ecx: &EncodeContext, match variant.node.kind { ast::TupleVariantKind(_) => {}, ast::StructVariantKind(_) => { - let fields = ty::lookup_struct_fields(ecx.tcx, def_id); + let fields = ecx.tcx.lookup_struct_fields(def_id); let idx = encode_info_for_struct(ecx, rbml_w, &fields[..], @@ -328,9 +326,10 @@ fn encode_enum_variant_info(ecx: &EncodeContext, encode_index(rbml_w, idx, write_i64); } } - if (*vi)[i].disr_val != disr_val { - encode_disr_val(ecx, rbml_w, (*vi)[i].disr_val); - disr_val = (*vi)[i].disr_val; + let specified_disr_val = vi[i].disr_val; + if specified_disr_val != disr_val { + encode_disr_val(ecx, rbml_w, specified_disr_val); + disr_val = specified_disr_val; } encode_bounds_and_type_for_item(rbml_w, ecx, def_id.local_id()); @@ -379,9 +378,7 @@ fn encode_reexported_static_base_methods(ecx: &EncodeContext, Some(implementations) => { for base_impl_did in implementations.iter() { for &method_did in impl_items.get(base_impl_did).unwrap() { - let impl_item = ty::impl_or_trait_item( - ecx.tcx, - method_did.def_id()); + let impl_item = ecx.tcx.impl_or_trait_item(method_did.def_id()); if let ty::MethodTraitItem(ref m) = impl_item { encode_reexported_static_method(rbml_w, exp, @@ -875,7 +872,7 @@ fn encode_info_for_method<'a, 'tcx>(ecx: &EncodeContext<'a, 'tcx>, if let Some(impl_item) = impl_item_opt { if let ast::MethodImplItem(ref sig, _) = impl_item.node { encode_attributes(rbml_w, &impl_item.attrs); - let scheme = ty::lookup_item_type(ecx.tcx, m.def_id); + let scheme = ecx.tcx.lookup_item_type(m.def_id); let any_types = !scheme.generics.types.is_empty(); let needs_inline = any_types || is_default_impl || attr::requests_inline(&impl_item.attrs); @@ -923,7 +920,7 @@ fn encode_info_for_associated_type<'a, 'tcx>(ecx: &EncodeContext<'a, 'tcx>, encode_attributes(rbml_w, &ii.attrs); } else { encode_predicates(rbml_w, ecx, - &ty::lookup_predicates(ecx.tcx, associated_type.def_id), + &ecx.tcx.lookup_predicates(associated_type.def_id), tag_item_generics); } @@ -995,7 +992,7 @@ fn encode_extension_implementations(ecx: &EncodeContext, rbml_w: &mut Encoder, trait_def_id: DefId) { assert!(ast_util::is_local(trait_def_id)); - let def = ty::lookup_trait_def(ecx.tcx, trait_def_id); + let def = ecx.tcx.lookup_trait_def(trait_def_id); def.for_each_impl(ecx.tcx, |impl_def_id| { rbml_w.start_tag(tag_items_data_item_extension_impl); @@ -1161,7 +1158,7 @@ fn encode_info_for_item(ecx: &EncodeContext, index); } ast::ItemStruct(ref struct_def, _) => { - let fields = ty::lookup_struct_fields(tcx, def_id); + let fields = tcx.lookup_struct_fields(def_id); /* First, encode the fields These come first because we need to write them to make @@ -1220,7 +1217,7 @@ fn encode_info_for_item(ecx: &EncodeContext, encode_name(rbml_w, item.ident.name); encode_unsafety(rbml_w, unsafety); - let trait_ref = ty::impl_trait_ref(tcx, local_def(item.id)).unwrap(); + let trait_ref = tcx.impl_trait_ref(local_def(item.id)).unwrap(); encode_trait_ref(rbml_w, ecx, trait_ref, tag_item_trait_ref); rbml_w.end_tag(); } @@ -1274,7 +1271,7 @@ fn encode_info_for_item(ecx: &EncodeContext, } rbml_w.end_tag(); } - if let Some(trait_ref) = ty::impl_trait_ref(tcx, local_def(item.id)) { + if let Some(trait_ref) = tcx.impl_trait_ref(local_def(item.id)) { encode_trait_ref(rbml_w, ecx, trait_ref, tag_item_trait_ref); } encode_path(rbml_w, path.clone()); @@ -1298,7 +1295,7 @@ fn encode_info_for_item(ecx: &EncodeContext, pos: rbml_w.mark_stable_position(), }); - match ty::impl_or_trait_item(tcx, trait_item_def_id.def_id()) { + match tcx.impl_or_trait_item(trait_item_def_id.def_id()) { ty::ConstTraitItem(ref associated_const) => { encode_info_for_associated_const(ecx, rbml_w, @@ -1333,22 +1330,22 @@ fn encode_info_for_item(ecx: &EncodeContext, encode_def_id(rbml_w, def_id); encode_family(rbml_w, 'I'); encode_item_variances(rbml_w, ecx, item.id); - let trait_def = ty::lookup_trait_def(tcx, def_id); - let trait_predicates = ty::lookup_predicates(tcx, def_id); + let trait_def = tcx.lookup_trait_def(def_id); + let trait_predicates = tcx.lookup_predicates(def_id); encode_unsafety(rbml_w, trait_def.unsafety); encode_paren_sugar(rbml_w, trait_def.paren_sugar); - encode_defaulted(rbml_w, ty::trait_has_default_impl(tcx, def_id)); + encode_defaulted(rbml_w, tcx.trait_has_default_impl(def_id)); encode_associated_type_names(rbml_w, &trait_def.associated_type_names); encode_generics(rbml_w, ecx, &trait_def.generics, &trait_predicates, tag_item_generics); - encode_predicates(rbml_w, ecx, &ty::lookup_super_predicates(tcx, def_id), + encode_predicates(rbml_w, ecx, &tcx.lookup_super_predicates(def_id), tag_item_super_predicates); encode_trait_ref(rbml_w, ecx, trait_def.trait_ref, tag_item_trait_ref); encode_name(rbml_w, item.ident.name); encode_attributes(rbml_w, &item.attrs); encode_visibility(rbml_w, vis); encode_stability(rbml_w, stab); - for &method_def_id in ty::trait_item_def_ids(tcx, def_id).iter() { + for &method_def_id in tcx.trait_item_def_ids(def_id).iter() { rbml_w.start_tag(tag_item_trait_item); match method_def_id { ty::ConstTraitItemId(const_def_id) => { @@ -1380,7 +1377,7 @@ fn encode_info_for_item(ecx: &EncodeContext, rbml_w.end_tag(); // Now output the trait item info for each trait item. - let r = ty::trait_item_def_ids(tcx, def_id); + let r = tcx.trait_item_def_ids(def_id); for (i, &item_def_id) in r.iter().enumerate() { assert_eq!(item_def_id.def_id().krate, ast::LOCAL_CRATE); @@ -1397,7 +1394,7 @@ fn encode_info_for_item(ecx: &EncodeContext, encode_stability(rbml_w, stab); let trait_item_type = - ty::impl_or_trait_item(tcx, item_def_id.def_id()); + tcx.impl_or_trait_item(item_def_id.def_id()); let is_nonstatic_method; match trait_item_type { ty::ConstTraitItem(associated_const) => { diff --git a/src/librustc/middle/cfg/construct.rs b/src/librustc/middle/cfg/construct.rs index 71c3ffb862840..801b3a721e40d 100644 --- a/src/librustc/middle/cfg/construct.rs +++ b/src/librustc/middle/cfg/construct.rs @@ -413,7 +413,7 @@ impl<'a, 'tcx> CFGBuilder<'a, 'tcx> { let method_call = ty::MethodCall::expr(call_expr.id); let fn_ty = match self.tcx.method_map.borrow().get(&method_call) { Some(method) => method.ty, - None => ty::expr_ty_adjusted(self.tcx, func_or_rcvr) + None => self.tcx.expr_ty_adjusted(func_or_rcvr) }; let func_or_rcvr_exit = self.expr(func_or_rcvr, pred); diff --git a/src/librustc/middle/check_const.rs b/src/librustc/middle/check_const.rs index 8af6946d3c3b1..62bf1648725cd 100644 --- a/src/librustc/middle/check_const.rs +++ b/src/librustc/middle/check_const.rs @@ -115,7 +115,7 @@ impl<'a, 'tcx> CheckCrateVisitor<'a, 'tcx> { { let param_env = match item_id { Some(item_id) => ty::ParameterEnvironment::for_item(self.tcx, item_id), - None => ty::empty_parameter_environment(self.tcx) + None => self.tcx.empty_parameter_environment() }; f(&mut euv::ExprUseVisitor::new(self, ¶m_env)) } @@ -231,7 +231,7 @@ impl<'a, 'tcx> CheckCrateVisitor<'a, 'tcx> { fn_like.id()); self.add_qualif(qualif); - if ty::type_contents(self.tcx, ret_ty).interior_unsafe() { + if ret_ty.type_contents(self.tcx).interior_unsafe() { self.add_qualif(ConstQualif::MUTABLE_MEM); } @@ -266,8 +266,8 @@ impl<'a, 'tcx> CheckCrateVisitor<'a, 'tcx> { } fn check_static_mut_type(&self, e: &ast::Expr) { - let node_ty = ty::node_id_to_type(self.tcx, e.id); - let tcontents = ty::type_contents(self.tcx, node_ty); + let node_ty = self.tcx.node_id_to_type(e.id); + let tcontents = node_ty.type_contents(self.tcx); let suffix = if tcontents.has_dtor() { "destructors" @@ -282,12 +282,12 @@ impl<'a, 'tcx> CheckCrateVisitor<'a, 'tcx> { } fn check_static_type(&self, e: &ast::Expr) { - let ty = ty::node_id_to_type(self.tcx, e.id); + let ty = self.tcx.node_id_to_type(e.id); let infcx = infer::new_infer_ctxt(self.tcx); let mut fulfill_cx = traits::FulfillmentContext::new(false); let cause = traits::ObligationCause::new(e.span, e.id, traits::SharedStatic); fulfill_cx.register_builtin_bound(&infcx, ty, ty::BoundSync, cause); - let env = ty::empty_parameter_environment(self.tcx); + let env = self.tcx.empty_parameter_environment(); match fulfill_cx.select_all_or_error(&infcx, &env) { Ok(()) => { }, Err(ref errors) => { @@ -402,7 +402,7 @@ impl<'a, 'tcx, 'v> Visitor<'v> for CheckCrateVisitor<'a, 'tcx> { let mut outer = self.qualif; self.qualif = ConstQualif::empty(); - let node_ty = ty::node_id_to_type(self.tcx, ex.id); + let node_ty = self.tcx.node_id_to_type(ex.id); check_expr(self, ex, node_ty); // Special-case some expressions to avoid certain flags bubbling up. @@ -479,7 +479,7 @@ impl<'a, 'tcx, 'v> Visitor<'v> for CheckCrateVisitor<'a, 'tcx> { // initializer values (very bad). // If the type doesn't have interior mutability, then `ConstQualif::MUTABLE_MEM` has // propagated from another error, so erroring again would be just noise. - let tc = ty::type_contents(self.tcx, node_ty); + let tc = node_ty.type_contents(self.tcx); if self.qualif.intersects(ConstQualif::MUTABLE_MEM) && tc.interior_unsafe() { outer = outer | ConstQualif::NOT_CONST; if self.mode != Mode::Var { @@ -529,7 +529,7 @@ fn check_expr<'a, 'tcx>(v: &mut CheckCrateVisitor<'a, 'tcx>, e: &ast::Expr, node_ty: Ty<'tcx>) { match node_ty.sty { ty::TyStruct(did, _) | - ty::TyEnum(did, _) if ty::has_dtor(v.tcx, did) => { + ty::TyEnum(did, _) if v.tcx.has_dtor(did) => { v.add_qualif(ConstQualif::NEEDS_DROP); if v.mode != Mode::Var { v.tcx.sess.span_err(e.span, @@ -560,7 +560,7 @@ fn check_expr<'a, 'tcx>(v: &mut CheckCrateVisitor<'a, 'tcx>, } } ast::ExprUnary(op, ref inner) => { - match ty::node_id_to_type(v.tcx, inner.id).sty { + match v.tcx.node_id_to_type(inner.id).sty { ty::TyRawPtr(_) => { assert!(op == ast::UnDeref); @@ -574,7 +574,7 @@ fn check_expr<'a, 'tcx>(v: &mut CheckCrateVisitor<'a, 'tcx>, } } ast::ExprBinary(op, ref lhs, _) => { - match ty::node_id_to_type(v.tcx, lhs.id).sty { + match v.tcx.node_id_to_type(lhs.id).sty { ty::TyRawPtr(_) => { assert!(op.node == ast::BiEq || op.node == ast::BiNe || op.node == ast::BiLe || op.node == ast::BiLt || @@ -731,7 +731,7 @@ fn check_expr<'a, 'tcx>(v: &mut CheckCrateVisitor<'a, 'tcx>, ast::ExprClosure(..) => { // Paths in constant contexts cannot refer to local variables, // as there are none, and thus closures can't have upvars there. - if ty::with_freevars(v.tcx, e.id, |fv| !fv.is_empty()) { + if v.tcx.with_freevars(e.id, |fv| !fv.is_empty()) { assert!(v.mode == Mode::Var, "global closures can't capture anything"); v.add_qualif(ConstQualif::NOT_CONST); diff --git a/src/librustc/middle/check_match.rs b/src/librustc/middle/check_match.rs index dd708cf8f3ae6..d2b3b83e4f42f 100644 --- a/src/librustc/middle/check_match.rs +++ b/src/librustc/middle/check_match.rs @@ -20,7 +20,7 @@ use middle::expr_use_visitor::{ConsumeMode, Delegate, ExprUseVisitor, Init}; use middle::expr_use_visitor::{JustWrite, LoanCause, MutateMode}; use middle::expr_use_visitor::WriteAndRead; use middle::expr_use_visitor as euv; -use middle::mem_categorization::cmt; +use middle::mem_categorization::{cmt, Typer}; use middle::pat_util::*; use middle::ty::*; use middle::ty; @@ -149,7 +149,7 @@ impl<'a, 'tcx, 'v> Visitor<'v> for MatchCheckCtxt<'a, 'tcx> { pub fn check_crate(tcx: &ty::ctxt) { visit::walk_crate(&mut MatchCheckCtxt { tcx: tcx, - param_env: ty::empty_parameter_environment(tcx), + param_env: tcx.empty_parameter_environment(), }, tcx.map.krate()); tcx.sess.abort_if_errors(); } @@ -203,9 +203,9 @@ fn check_expr(cx: &mut MatchCheckCtxt, ex: &ast::Expr) { // Finally, check if the whole match expression is exhaustive. // Check for empty enum, because is_useful only works on inhabited types. - let pat_ty = node_id_to_type(cx.tcx, scrut.id); + let pat_ty = cx.tcx.node_id_to_type(scrut.id); if inlined_arms.is_empty() { - if !type_is_empty(cx.tcx, pat_ty) { + if !pat_ty.is_empty(cx.tcx) { // We know the type is inhabited, so this must be wrong span_err!(cx.tcx.sess, ex.span, E0002, "non-exhaustive patterns: type {} is non-empty", @@ -231,11 +231,11 @@ fn check_for_bindings_named_the_same_as_variants(cx: &MatchCheckCtxt, pat: &Pat) ast_util::walk_pat(pat, |p| { match p.node { ast::PatIdent(ast::BindByValue(ast::MutImmutable), ident, None) => { - let pat_ty = ty::pat_ty(cx.tcx, p); + let pat_ty = cx.tcx.pat_ty(p); if let ty::TyEnum(def_id, _) = pat_ty.sty { let def = cx.tcx.def_map.borrow().get(&p.id).map(|d| d.full_def()); if let Some(DefLocal(_)) = def { - if ty::enum_variants(cx.tcx, def_id).iter().any(|variant| + if cx.tcx.enum_variants(def_id).iter().any(|variant| token::get_name(variant.name) == token::get_name(ident.node.name) && variant.args.is_empty() ) { @@ -509,12 +509,12 @@ fn construct_witness(cx: &MatchCheckCtxt, ctor: &Constructor, ty::TyEnum(cid, _) | ty::TyStruct(cid, _) => { let (vid, is_structure) = match ctor { &Variant(vid) => - (vid, ty::enum_variant_with_id(cx.tcx, cid, vid).arg_names.is_some()), + (vid, cx.tcx.enum_variant_with_id(cid, vid).arg_names.is_some()), _ => - (cid, !ty::is_tuple_struct(cx.tcx, cid)) + (cid, !cx.tcx.is_tuple_struct(cid)) }; if is_structure { - let fields = ty::lookup_struct_fields(cx.tcx, vid); + let fields = cx.tcx.lookup_struct_fields(vid); let field_pats: Vec<_> = fields.into_iter() .zip(pats) .filter(|&(_, ref pat)| pat.node != ast::PatWild(ast::PatWildSingle)) @@ -605,7 +605,7 @@ fn all_constructors(cx: &MatchCheckCtxt, left_ty: Ty, }, ty::TyEnum(eid, _) => - ty::enum_variants(cx.tcx, eid) + cx.tcx.enum_variants(eid) .iter() .map(|va| Variant(va.id)) .collect(), @@ -653,7 +653,7 @@ fn is_useful(cx: &MatchCheckCtxt, let left_ty = if real_pat.id == DUMMY_NODE_ID { cx.tcx.mk_nil() } else { - let left_ty = ty::pat_ty(cx.tcx, &*real_pat); + let left_ty = cx.tcx.pat_ty(&*real_pat); match real_pat.node { ast::PatIdent(ast::BindByRef(..), _, _) => { @@ -817,11 +817,11 @@ pub fn constructor_arity(cx: &MatchCheckCtxt, ctor: &Constructor, ty: Ty) -> usi }, ty::TyEnum(eid, _) => { match *ctor { - Variant(id) => enum_variant_with_id(cx.tcx, eid, id).args.len(), + Variant(id) => cx.tcx.enum_variant_with_id(eid, id).args.len(), _ => unreachable!() } } - ty::TyStruct(cid, _) => ty::lookup_struct_fields(cx.tcx, cid).len(), + ty::TyStruct(cid, _) => cx.tcx.lookup_struct_fields(cid).len(), ty::TyArray(_, n) => n, _ => 0 } @@ -913,7 +913,7 @@ pub fn specialize<'a>(cx: &MatchCheckCtxt, r: &[&'a Pat], }, _ => { // Assume this is a struct. - match ty::ty_to_def_id(node_id_to_type(cx.tcx, pat_id)) { + match cx.tcx.node_id_to_type(pat_id).ty_to_def_id() { None => { cx.tcx.sess.span_bug(pat_span, "struct pattern wasn't of a \ @@ -924,7 +924,7 @@ pub fn specialize<'a>(cx: &MatchCheckCtxt, r: &[&'a Pat], } }; class_id.map(|variant_id| { - let struct_fields = ty::lookup_struct_fields(cx.tcx, variant_id); + let struct_fields = cx.tcx.lookup_struct_fields(variant_id); let args = struct_fields.iter().map(|sf| { match pattern_fields.iter().find(|f| f.node.ident.name == sf.name) { Some(ref f) => &*f.node.pat, @@ -1109,8 +1109,8 @@ fn check_legality_of_move_bindings(cx: &MatchCheckCtxt, if pat_is_binding(def_map, &*p) { match p.node { ast::PatIdent(ast::BindByValue(_), _, ref sub) => { - let pat_ty = ty::node_id_to_type(tcx, p.id); - if ty::type_moves_by_default(&cx.param_env, pat.span, pat_ty) { + let pat_ty = tcx.node_id_to_type(p.id); + if cx.param_env.type_moves_by_default(pat_ty, pat.span) { check_move(p, sub.as_ref().map(|p| &**p)); } } diff --git a/src/librustc/middle/check_rvalues.rs b/src/librustc/middle/check_rvalues.rs index f5934751c58b2..1489e946fe2ce 100644 --- a/src/librustc/middle/check_rvalues.rs +++ b/src/librustc/middle/check_rvalues.rs @@ -59,7 +59,7 @@ impl<'a, 'tcx> euv::Delegate<'tcx> for RvalueContextDelegate<'a, 'tcx> { cmt: mc::cmt<'tcx>, _: euv::ConsumeMode) { debug!("consume; cmt: {:?}; type: {:?}", *cmt, cmt.ty); - if !ty::type_is_sized(Some(self.param_env), self.tcx, span, cmt.ty) { + if !cmt.ty.is_sized(self.param_env, span) { span_err!(self.tcx.sess, span, E0161, "cannot move a value of type {0}: the size of {0} cannot be statically determined", cmt.ty); diff --git a/src/librustc/middle/const_eval.rs b/src/librustc/middle/const_eval.rs index ed06ccf1ec649..1b1725dd15c85 100644 --- a/src/librustc/middle/const_eval.rs +++ b/src/librustc/middle/const_eval.rs @@ -126,9 +126,9 @@ pub fn lookup_const_by_id<'a, 'tcx: 'a>(tcx: &'a ty::ctxt<'tcx>, // `resolve_trait_associated_const` will select an impl // or the default. Some(ref_id) => { - let trait_id = ty::trait_of_item(tcx, def_id) + let trait_id = tcx.trait_of_item(def_id) .unwrap(); - let substs = ty::node_id_item_substs(tcx, ref_id) + let substs = tcx.node_id_item_substs(ref_id) .substs; resolve_trait_associated_const(tcx, ti, trait_id, substs) @@ -176,7 +176,7 @@ pub fn lookup_const_by_id<'a, 'tcx: 'a>(tcx: &'a ty::ctxt<'tcx>, // a trait-associated const if the caller gives us // the expression that refers to it. Some(ref_id) => { - let substs = ty::node_id_item_substs(tcx, ref_id) + let substs = tcx.node_id_item_substs(ref_id) .substs; resolve_trait_associated_const(tcx, ti, trait_id, substs).map(|e| e.id) @@ -714,7 +714,7 @@ pub fn eval_const_expr_partial<'tcx>(tcx: &ty::ctxt<'tcx>, e: &Expr, ty_hint: Option>) -> EvalResult { eval_const_expr_with_substs(tcx, e, ty_hint, |id| { - ty::node_id_item_substs(tcx, id).substs + tcx.node_id_item_substs(id).substs }) } @@ -725,7 +725,7 @@ pub fn eval_const_expr_with_substs<'tcx, S>(tcx: &ty::ctxt<'tcx>, where S: Fn(ast::NodeId) -> subst::Substs<'tcx> { fn fromb(b: bool) -> ConstVal { Int(b as i64) } - let ety = ty_hint.or_else(|| ty::expr_ty_opt(tcx, e)); + let ety = ty_hint.or_else(|| tcx.expr_ty_opt(e)); // If type of expression itself is int or uint, normalize in these // bindings so that isize/usize is mapped to a type with an @@ -882,7 +882,7 @@ pub fn eval_const_expr_with_substs<'tcx, S>(tcx: &ty::ctxt<'tcx>, // FIXME (#23833): the type-hint can cause problems, // e.g. `(i8::MAX + 1_i8) as u32` feeds in `u32` as result // type to the sum, and thus no overflow is signaled. - let base_hint = ty::expr_ty_opt(tcx, &**base).unwrap_or(ety); + let base_hint = tcx.expr_ty_opt(&**base).unwrap_or(ety); let val = try!(eval_const_expr_partial(tcx, &**base, Some(base_hint))); match cast_const(tcx, val, ety) { Ok(val) => val, @@ -1030,10 +1030,10 @@ fn resolve_trait_associated_const<'a, 'tcx: 'a>(tcx: &'a ty::ctxt<'tcx>, let trait_ref = ty::Binder(ty::TraitRef { def_id: trait_id, substs: trait_substs }); - ty::populate_implementations_for_trait_if_necessary(tcx, trait_ref.def_id()); + tcx.populate_implementations_for_trait_if_necessary(trait_ref.def_id()); let infcx = infer::new_infer_ctxt(tcx); - let param_env = ty::empty_parameter_environment(tcx); + let param_env = tcx.empty_parameter_environment(); let mut selcx = traits::SelectionContext::new(&infcx, ¶m_env); let obligation = traits::Obligation::new(traits::ObligationCause::dummy(), trait_ref.to_poly_trait_predicate()); @@ -1056,7 +1056,7 @@ fn resolve_trait_associated_const<'a, 'tcx: 'a>(tcx: &'a ty::ctxt<'tcx>, match selection { traits::VtableImpl(ref impl_data) => { - match ty::associated_consts(tcx, impl_data.impl_def_id) + match tcx.associated_consts(impl_data.impl_def_id) .iter().find(|ic| ic.name == ti.ident.name) { Some(ic) => lookup_const_by_id(tcx, ic.def_id, None), None => match ti.node { diff --git a/src/librustc/middle/dead.rs b/src/librustc/middle/dead.rs index fd810429c86e0..bd8b8afbdfe88 100644 --- a/src/librustc/middle/dead.rs +++ b/src/librustc/middle/dead.rs @@ -100,7 +100,7 @@ impl<'a, 'tcx> MarkSymbolVisitor<'a, 'tcx> { Some(method) => { match method.origin { ty::MethodStatic(def_id) => { - match ty::provided_source(self.tcx, def_id) { + match self.tcx.provided_source(def_id) { Some(p_did) => self.check_def_id(p_did), None => self.check_def_id(def_id) } @@ -116,9 +116,7 @@ impl<'a, 'tcx> MarkSymbolVisitor<'a, 'tcx> { method_num: index, .. }) => { - let trait_item = ty::trait_item(self.tcx, - trait_ref.def_id, - index); + let trait_item = self.tcx.trait_item(trait_ref.def_id, index); self.check_def_id(trait_item.def_id()); } } @@ -132,9 +130,9 @@ impl<'a, 'tcx> MarkSymbolVisitor<'a, 'tcx> { } fn handle_field_access(&mut self, lhs: &ast::Expr, name: ast::Name) { - match ty::expr_ty_adjusted(self.tcx, lhs).sty { + match self.tcx.expr_ty_adjusted(lhs).sty { ty::TyStruct(id, _) => { - let fields = ty::lookup_struct_fields(self.tcx, id); + let fields = self.tcx.lookup_struct_fields(id); let field_id = fields.iter() .find(|field| field.name == name).unwrap().id; self.live_symbols.insert(field_id.node); @@ -144,9 +142,9 @@ impl<'a, 'tcx> MarkSymbolVisitor<'a, 'tcx> { } fn handle_tup_field_access(&mut self, lhs: &ast::Expr, idx: usize) { - match ty::expr_ty_adjusted(self.tcx, lhs).sty { + match self.tcx.expr_ty_adjusted(lhs).sty { ty::TyStruct(id, _) => { - let fields = ty::lookup_struct_fields(self.tcx, id); + let fields = self.tcx.lookup_struct_fields(id); let field_id = fields[idx].id; self.live_symbols.insert(field_id.node); }, @@ -159,8 +157,7 @@ impl<'a, 'tcx> MarkSymbolVisitor<'a, 'tcx> { let id = match self.tcx.def_map.borrow().get(&lhs.id).unwrap().full_def() { def::DefVariant(_, id, _) => id, _ => { - match ty::ty_to_def_id(ty::node_id_to_type(self.tcx, - lhs.id)) { + match self.tcx.node_id_to_type(lhs.id).ty_to_def_id() { None => { self.tcx.sess.span_bug(lhs.span, "struct pattern wasn't of a \ @@ -170,7 +167,7 @@ impl<'a, 'tcx> MarkSymbolVisitor<'a, 'tcx> { } } }; - let fields = ty::lookup_struct_fields(self.tcx, id); + let fields = self.tcx.lookup_struct_fields(id); for pat in pats { if let ast::PatWild(ast::PatWildSingle) = pat.node.pat.node { continue; @@ -480,8 +477,8 @@ impl<'a, 'tcx> DeadVisitor<'a, 'tcx> { fn should_warn_about_field(&mut self, node: &ast::StructField_) -> bool { let is_named = node.ident().is_some(); - let field_type = ty::node_id_to_type(self.tcx, node.id); - let is_marker_field = match ty::ty_to_def_id(field_type) { + let field_type = self.tcx.node_id_to_type(node.id); + let is_marker_field = match field_type.ty_to_def_id() { Some(def_id) => self.tcx.lang_items.items().any(|(_, item)| *item == Some(def_id)), _ => false }; diff --git a/src/librustc/middle/effect.rs b/src/librustc/middle/effect.rs index bb63ec42d8c0c..c48d5d5da4020 100644 --- a/src/librustc/middle/effect.rs +++ b/src/librustc/middle/effect.rs @@ -62,7 +62,7 @@ impl<'a, 'tcx> EffectCheckVisitor<'a, 'tcx> { fn check_str_index(&mut self, e: &ast::Expr) { let base_type = match e.node { - ast::ExprIndex(ref base, _) => ty::node_id_to_type(self.tcx, base.id), + ast::ExprIndex(ref base, _) => self.tcx.node_id_to_type(base.id), _ => return }; debug!("effect: checking index with base type {:?}", @@ -149,7 +149,7 @@ impl<'a, 'tcx, 'v> Visitor<'v> for EffectCheckVisitor<'a, 'tcx> { } } ast::ExprCall(ref base, _) => { - let base_type = ty::node_id_to_type(self.tcx, base.id); + let base_type = self.tcx.node_id_to_type(base.id); debug!("effect: call case, base type is {:?}", base_type); if type_is_unsafe_function(base_type) { @@ -157,7 +157,7 @@ impl<'a, 'tcx, 'v> Visitor<'v> for EffectCheckVisitor<'a, 'tcx> { } } ast::ExprUnary(ast::UnDeref, ref base) => { - let base_type = ty::node_id_to_type(self.tcx, base.id); + let base_type = self.tcx.node_id_to_type(base.id); debug!("effect: unary case, base type is {:?}", base_type); if let ty::TyRawPtr(_) = base_type.sty { @@ -174,7 +174,7 @@ impl<'a, 'tcx, 'v> Visitor<'v> for EffectCheckVisitor<'a, 'tcx> { self.require_unsafe(expr.span, "use of inline assembly"); } ast::ExprPath(..) => { - if let def::DefStatic(_, true) = ty::resolve_expr(self.tcx, expr) { + if let def::DefStatic(_, true) = self.tcx.resolve_expr(expr) { self.require_unsafe(expr.span, "use of mutable static"); } } diff --git a/src/librustc/middle/expr_use_visitor.rs b/src/librustc/middle/expr_use_visitor.rs index 2b685f801d7f7..a15d02ea29605 100644 --- a/src/librustc/middle/expr_use_visitor.rs +++ b/src/librustc/middle/expr_use_visitor.rs @@ -229,7 +229,7 @@ impl OverloadedCallType { fn from_method_id(tcx: &ty::ctxt, method_id: ast::DefId) -> OverloadedCallType { - let method_descriptor = match ty::impl_or_trait_item(tcx, method_id) { + let method_descriptor = match tcx.impl_or_trait_item(method_id) { ty::MethodTraitItem(ref method_descriptor) => { (*method_descriptor).clone() } @@ -244,7 +244,7 @@ impl OverloadedCallType { } ty::ImplContainer(impl_id) => impl_id, }; - let trait_ref = match ty::impl_trait_ref(tcx, impl_id) { + let trait_ref = match tcx.impl_trait_ref(impl_id) { None => { tcx.sess.bug("statically resolved overloaded call impl \ didn't implement a trait?!") @@ -502,9 +502,10 @@ impl<'d,'t,'tcx,TYPER:mc::Typer<'tcx>> ExprUseVisitor<'d,'t,'tcx,TYPER> { // make sure that the thing we are pointing out stays valid // for the lifetime `scope_r` of the resulting ptr: let expr_ty = return_if_err!(self.typer.node_ty(expr.id)); - let r = ty::ty_region(self.tcx(), expr.span, expr_ty); - let bk = ty::BorrowKind::from_mutbl(m); - self.borrow_expr(&**base, r, bk, AddrOf); + if let ty::TyRef(&r, _) = expr_ty.sty { + let bk = ty::BorrowKind::from_mutbl(m); + self.borrow_expr(&**base, r, bk, AddrOf); + } } ast::ExprInlineAsm(ref ia) => { @@ -740,7 +741,7 @@ impl<'d,'t,'tcx,TYPER:mc::Typer<'tcx>> ExprUseVisitor<'d,'t,'tcx,TYPER> { // expression that will actually be used let with_fields = match with_cmt.ty.sty { ty::TyStruct(did, substs) => { - ty::struct_fields(self.tcx(), did, substs) + self.tcx().struct_fields(did, substs) } _ => { // the base expression should always evaluate to a @@ -822,7 +823,7 @@ impl<'d,'t,'tcx,TYPER:mc::Typer<'tcx>> ExprUseVisitor<'d,'t,'tcx,TYPER> { // the method call infrastructure should have // replaced all late-bound regions with variables: let self_ty = method_ty.fn_sig().input(0); - let self_ty = ty::no_late_bound_regions(self.tcx(), &self_ty).unwrap(); + let self_ty = self.tcx().no_late_bound_regions(&self_ty).unwrap(); let (m, r) = match self_ty.sty { ty::TyRef(r, ref m) => (m.mutbl, r), @@ -922,10 +923,7 @@ impl<'d,'t,'tcx,TYPER:mc::Typer<'tcx>> ExprUseVisitor<'d,'t,'tcx,TYPER> { // This is always an rvalue, since we are producing a new // (temporary) indirection. - let adj_ty = - ty::adjust_ty_for_autoref(self.tcx(), - cmt_base_ty, - opt_autoref); + let adj_ty = cmt_base_ty.adjust_for_autoref(self.tcx(), opt_autoref); self.mc.cat_rvalue_node(expr.id, expr.span, adj_ty) } @@ -1074,12 +1072,11 @@ impl<'d,'t,'tcx,TYPER:mc::Typer<'tcx>> ExprUseVisitor<'d,'t,'tcx,TYPER> { // It is also a borrow or copy/move of the value being matched. match pat.node { ast::PatIdent(ast::BindByRef(m), _, _) => { - let (r, bk) = { - (ty::ty_region(tcx, pat.span, pat_ty), - ty::BorrowKind::from_mutbl(m)) - }; - delegate.borrow(pat.id, pat.span, cmt_pat, - r, bk, RefBinding); + if let ty::TyRef(&r, _) = pat_ty.sty { + let bk = ty::BorrowKind::from_mutbl(m); + delegate.borrow(pat.id, pat.span, cmt_pat, + r, bk, RefBinding); + } } ast::PatIdent(ast::BindByValue(_), _, _) => { let mode = copy_or_move(typer, &cmt_pat, PatBindingMove); @@ -1152,7 +1149,7 @@ impl<'d,'t,'tcx,TYPER:mc::Typer<'tcx>> ExprUseVisitor<'d,'t,'tcx,TYPER> { Some(def::DefVariant(enum_did, variant_did, _is_struct)) => { let downcast_cmt = - if ty::enum_is_univariant(tcx, enum_did) { + if tcx.enum_is_univariant(enum_did) { cmt_pat } else { let cmt_pat_ty = cmt_pat.ty; @@ -1238,7 +1235,7 @@ impl<'d,'t,'tcx,TYPER:mc::Typer<'tcx>> ExprUseVisitor<'d,'t,'tcx,TYPER> { fn walk_captures(&mut self, closure_expr: &ast::Expr) { debug!("walk_captures({:?})", closure_expr); - ty::with_freevars(self.tcx(), closure_expr.id, |freevars| { + self.tcx().with_freevars(closure_expr.id, |freevars| { for freevar in freevars { let id_var = freevar.def.def_id().node; let upvar_id = ty::UpvarId { var_id: id_var, @@ -1283,7 +1280,7 @@ fn copy_or_move<'tcx>(typer: &mc::Typer<'tcx>, move_reason: MoveReason) -> ConsumeMode { - if typer.type_moves_by_default(cmt.span, cmt.ty) { + if typer.type_moves_by_default(cmt.ty, cmt.span) { Move(move_reason) } else { Copy diff --git a/src/librustc/middle/implicator.rs b/src/librustc/middle/implicator.rs index 3cdf53e6b0acd..d5fa885b16ab5 100644 --- a/src/librustc/middle/implicator.rs +++ b/src/librustc/middle/implicator.rs @@ -112,7 +112,7 @@ impl<'a, 'tcx> Implicator<'a, 'tcx> { ty::TyEnum(def_id, substs) | ty::TyStruct(def_id, substs) => { - let item_scheme = ty::lookup_item_type(self.tcx(), def_id); + let item_scheme = self.tcx().lookup_item_type(def_id); self.accumulate_from_adt(ty, def_id, &item_scheme.generics, substs) } @@ -236,7 +236,7 @@ impl<'a, 'tcx> Implicator<'a, 'tcx> { substs: &Substs<'tcx>) { let predicates = - ty::lookup_predicates(self.tcx(), def_id).instantiate(self.tcx(), substs); + self.tcx().lookup_predicates(def_id).instantiate(self.tcx(), substs); let predicates = match self.fully_normalize(&predicates) { Ok(predicates) => predicates, Err(ErrorReported) => { return; } @@ -250,7 +250,7 @@ impl<'a, 'tcx> Implicator<'a, 'tcx> { ty::Predicate::Equate(..) => { } ty::Predicate::Projection(..) => { } ty::Predicate::RegionOutlives(ref data) => { - match ty::no_late_bound_regions(self.tcx(), data) { + match self.tcx().no_late_bound_regions(data) { None => { } Some(ty::OutlivesPredicate(r_a, r_b)) => { self.push_sub_region_constraint(Some(ty), r_b, r_a); @@ -258,7 +258,7 @@ impl<'a, 'tcx> Implicator<'a, 'tcx> { } } ty::Predicate::TypeOutlives(ref data) => { - match ty::no_late_bound_regions(self.tcx(), data) { + match self.tcx().no_late_bound_regions(data) { None => { } Some(ty::OutlivesPredicate(ty_a, r_b)) => { self.stack.push((r_b, Some(ty))); @@ -275,7 +275,7 @@ impl<'a, 'tcx> Implicator<'a, 'tcx> { .map(|pred| Implication::Predicate(def_id, pred)); self.out.extend(obligations); - let variances = ty::item_variances(self.tcx(), def_id); + let variances = self.tcx().item_variances(def_id); for (®ion, &variance) in substs.regions().iter().zip(&variances.regions) { match variance { @@ -316,7 +316,7 @@ impl<'a, 'tcx> Implicator<'a, 'tcx> { data); for poly_trait_ref in traits::supertraits(self.tcx(), data.to_poly_trait_ref()) { - match ty::no_late_bound_regions(self.tcx(), &poly_trait_ref) { + match self.tcx().no_late_bound_regions(&poly_trait_ref) { Some(trait_ref) => { self.accumulate_from_assoc_types(trait_ref); } None => { } } @@ -330,7 +330,7 @@ impl<'a, 'tcx> Implicator<'a, 'tcx> { trait_ref); let trait_def_id = trait_ref.def_id; - let trait_def = ty::lookup_trait_def(self.tcx(), trait_def_id); + let trait_def = self.tcx().lookup_trait_def(trait_def_id); let assoc_type_projections: Vec<_> = trait_def.associated_type_names .iter() @@ -447,5 +447,5 @@ pub fn object_region_bounds<'tcx>( let mut predicates = others.to_predicates(tcx, open_ty); predicates.extend(trait_refs.iter().map(|t| t.to_predicate())); - ty::required_region_bounds(tcx, open_ty, predicates) + tcx.required_region_bounds(open_ty, predicates) } diff --git a/src/librustc/middle/infer/bivariate.rs b/src/librustc/middle/infer/bivariate.rs index 742ad3f29b780..d2268894b20a1 100644 --- a/src/librustc/middle/infer/bivariate.rs +++ b/src/librustc/middle/infer/bivariate.rs @@ -109,8 +109,8 @@ impl<'a, 'tcx> TypeRelation<'a, 'tcx> for Bivariate<'a, 'tcx> { -> RelateResult<'tcx, ty::Binder> where T: Relate<'a,'tcx> { - let a1 = ty::erase_late_bound_regions(self.tcx(), a); - let b1 = ty::erase_late_bound_regions(self.tcx(), b); + let a1 = self.tcx().erase_late_bound_regions(a); + let b1 = self.tcx().erase_late_bound_regions(b); let c = try!(self.relate(&a1, &b1)); Ok(ty::Binder(c)) } diff --git a/src/librustc/middle/infer/error_reporting.rs b/src/librustc/middle/infer/error_reporting.rs index 8839e68e767f2..17075c0cba6ca 100644 --- a/src/librustc/middle/infer/error_reporting.rs +++ b/src/librustc/middle/infer/error_reporting.rs @@ -91,123 +91,125 @@ use syntax::parse::token; use syntax::print::pprust; use syntax::ptr::P; -pub fn note_and_explain_region(tcx: &ty::ctxt, - prefix: &str, - region: ty::Region, - suffix: &str) { - fn item_scope_tag(item: &ast::Item) -> &'static str { - match item.node { - ast::ItemImpl(..) => "impl", - ast::ItemStruct(..) => "struct", - ast::ItemEnum(..) => "enum", - ast::ItemTrait(..) => "trait", - ast::ItemFn(..) => "function body", - _ => "item" +impl<'tcx> ty::ctxt<'tcx> { + pub fn note_and_explain_region(&self, + prefix: &str, + region: ty::Region, + suffix: &str) { + fn item_scope_tag(item: &ast::Item) -> &'static str { + match item.node { + ast::ItemImpl(..) => "impl", + ast::ItemStruct(..) => "struct", + ast::ItemEnum(..) => "enum", + ast::ItemTrait(..) => "trait", + ast::ItemFn(..) => "function body", + _ => "item" + } } - } - - fn explain_span(tcx: &ty::ctxt, heading: &str, span: Span) - -> (String, Option) { - let lo = tcx.sess.codemap().lookup_char_pos_adj(span.lo); - (format!("the {} at {}:{}", heading, lo.line, lo.col.to_usize()), - Some(span)) - } - let (description, span) = match region { - ty::ReScope(scope) => { - let new_string; - let unknown_scope = || { - format!("{}unknown scope: {:?}{}. Please report a bug.", - prefix, scope, suffix) - }; - let span = match scope.span(&tcx.map) { - Some(s) => s, - None => return tcx.sess.note(&unknown_scope()) - }; - let tag = match tcx.map.find(scope.node_id()) { - Some(ast_map::NodeBlock(_)) => "block", - Some(ast_map::NodeExpr(expr)) => match expr.node { - ast::ExprCall(..) => "call", - ast::ExprMethodCall(..) => "method call", - ast::ExprMatch(_, _, ast::MatchSource::IfLetDesugar { .. }) => "if let", - ast::ExprMatch(_, _, ast::MatchSource::WhileLetDesugar) => "while let", - ast::ExprMatch(_, _, ast::MatchSource::ForLoopDesugar) => "for", - ast::ExprMatch(..) => "match", - _ => "expression", - }, - Some(ast_map::NodeStmt(_)) => "statement", - Some(ast_map::NodeItem(it)) => item_scope_tag(&*it), - Some(_) | None => { - return tcx.sess.span_note(span, &unknown_scope()); - } - }; - let scope_decorated_tag = match scope { - region::CodeExtent::Misc(_) => tag, - region::CodeExtent::ParameterScope { .. } => { - "scope of parameters for function" - } - region::CodeExtent::DestructionScope(_) => { - new_string = format!("destruction scope surrounding {}", tag); - &new_string[..] - } - region::CodeExtent::Remainder(r) => { - new_string = format!("block suffix following statement {}", - r.first_statement_index); - &new_string[..] - } - }; - explain_span(tcx, scope_decorated_tag, span) + fn explain_span(tcx: &ty::ctxt, heading: &str, span: Span) + -> (String, Option) { + let lo = tcx.sess.codemap().lookup_char_pos_adj(span.lo); + (format!("the {} at {}:{}", heading, lo.line, lo.col.to_usize()), + Some(span)) } - ty::ReFree(ref fr) => { - let prefix = match fr.bound_region { - ty::BrAnon(idx) => { - format!("the anonymous lifetime #{} defined on", idx + 1) - } - ty::BrFresh(_) => "an anonymous lifetime defined on".to_owned(), - _ => { - format!("the lifetime {} as defined on", - fr.bound_region) - } - }; + let (description, span) = match region { + ty::ReScope(scope) => { + let new_string; + let unknown_scope = || { + format!("{}unknown scope: {:?}{}. Please report a bug.", + prefix, scope, suffix) + }; + let span = match scope.span(&self.map) { + Some(s) => s, + None => return self.sess.note(&unknown_scope()) + }; + let tag = match self.map.find(scope.node_id()) { + Some(ast_map::NodeBlock(_)) => "block", + Some(ast_map::NodeExpr(expr)) => match expr.node { + ast::ExprCall(..) => "call", + ast::ExprMethodCall(..) => "method call", + ast::ExprMatch(_, _, ast::MatchSource::IfLetDesugar { .. }) => "if let", + ast::ExprMatch(_, _, ast::MatchSource::WhileLetDesugar) => "while let", + ast::ExprMatch(_, _, ast::MatchSource::ForLoopDesugar) => "for", + ast::ExprMatch(..) => "match", + _ => "expression", + }, + Some(ast_map::NodeStmt(_)) => "statement", + Some(ast_map::NodeItem(it)) => item_scope_tag(&*it), + Some(_) | None => { + return self.sess.span_note(span, &unknown_scope()); + } + }; + let scope_decorated_tag = match scope { + region::CodeExtent::Misc(_) => tag, + region::CodeExtent::ParameterScope { .. } => { + "scope of parameters for function" + } + region::CodeExtent::DestructionScope(_) => { + new_string = format!("destruction scope surrounding {}", tag); + &new_string[..] + } + region::CodeExtent::Remainder(r) => { + new_string = format!("block suffix following statement {}", + r.first_statement_index); + &new_string[..] + } + }; + explain_span(self, scope_decorated_tag, span) + } - match tcx.map.find(fr.scope.node_id) { - Some(ast_map::NodeBlock(ref blk)) => { - let (msg, opt_span) = explain_span(tcx, "block", blk.span); - (format!("{} {}", prefix, msg), opt_span) - } - Some(ast_map::NodeItem(it)) => { - let tag = item_scope_tag(&*it); - let (msg, opt_span) = explain_span(tcx, tag, it.span); - (format!("{} {}", prefix, msg), opt_span) - } - Some(_) | None => { - // this really should not happen - (format!("{} unknown free region bounded by scope {:?}", - prefix, fr.scope), None) + ty::ReFree(ref fr) => { + let prefix = match fr.bound_region { + ty::BrAnon(idx) => { + format!("the anonymous lifetime #{} defined on", idx + 1) + } + ty::BrFresh(_) => "an anonymous lifetime defined on".to_owned(), + _ => { + format!("the lifetime {} as defined on", + fr.bound_region) + } + }; + + match self.map.find(fr.scope.node_id) { + Some(ast_map::NodeBlock(ref blk)) => { + let (msg, opt_span) = explain_span(self, "block", blk.span); + (format!("{} {}", prefix, msg), opt_span) + } + Some(ast_map::NodeItem(it)) => { + let tag = item_scope_tag(&*it); + let (msg, opt_span) = explain_span(self, tag, it.span); + (format!("{} {}", prefix, msg), opt_span) + } + Some(_) | None => { + // this really should not happen + (format!("{} unknown free region bounded by scope {:?}", + prefix, fr.scope), None) + } } } - } - ty::ReStatic => ("the static lifetime".to_owned(), None), + ty::ReStatic => ("the static lifetime".to_owned(), None), - ty::ReEmpty => ("the empty lifetime".to_owned(), None), + ty::ReEmpty => ("the empty lifetime".to_owned(), None), - ty::ReEarlyBound(ref data) => { - (format!("{}", token::get_name(data.name)), None) - } + ty::ReEarlyBound(ref data) => { + (format!("{}", token::get_name(data.name)), None) + } - // I believe these cases should not occur (except when debugging, - // perhaps) - ty::ReInfer(_) | ty::ReLateBound(..) => { - (format!("lifetime {:?}", region), None) + // I believe these cases should not occur (except when debugging, + // perhaps) + ty::ReInfer(_) | ty::ReLateBound(..) => { + (format!("lifetime {:?}", region), None) + } + }; + let message = format!("{}{}{}", prefix, description, suffix); + if let Some(span) = span { + self.sess.span_note(span, &message); + } else { + self.sess.note(&message); } - }; - let message = format!("{}{}{}", prefix, description, suffix); - if let Some(span) = span { - tcx.sess.span_note(span, &message); - } else { - tcx.sess.note(&message); } } @@ -491,7 +493,7 @@ impl<'a, 'tcx> ErrorReporting<'tcx> for InferCtxt<'a, 'tcx> { terr: &ty::type_err<'tcx>) { let span = trace.origin.span(); self.report_type_error(trace, terr); - ty::note_and_explain_type_err(self.tcx, terr, span); + self.tcx.note_and_explain_type_err(terr, span); } /// Returns a string of the form "expected `{}`, found `{}`", or None if this is a derived @@ -576,8 +578,7 @@ impl<'a, 'tcx> ErrorReporting<'tcx> for InferCtxt<'a, 'tcx> { &format!( "consider adding an explicit lifetime bound for `{}`", bound_kind)); - note_and_explain_region( - self.tcx, + self.tcx.note_and_explain_region( &format!("{} must be valid for ", labeled_user_string), sub, "..."); @@ -600,13 +601,11 @@ impl<'a, 'tcx> ErrorReporting<'tcx> for InferCtxt<'a, 'tcx> { span_err!(self.tcx.sess, span, E0312, "lifetime of reference outlines \ lifetime of borrowed content..."); - note_and_explain_region( - self.tcx, + self.tcx.note_and_explain_region( "...the reference is valid for ", sub, "..."); - note_and_explain_region( - self.tcx, + self.tcx.note_and_explain_region( "...but the borrowed content is only valid for ", sup, ""); @@ -615,33 +614,25 @@ impl<'a, 'tcx> ErrorReporting<'tcx> for InferCtxt<'a, 'tcx> { span_err!(self.tcx.sess, span, E0313, "lifetime of borrowed pointer outlives \ lifetime of captured variable `{}`...", - ty::local_var_name_str(self.tcx, - upvar_id.var_id) - .to_string()); - note_and_explain_region( - self.tcx, + self.tcx.local_var_name_str(upvar_id.var_id)); + self.tcx.note_and_explain_region( "...the borrowed pointer is valid for ", sub, "..."); - note_and_explain_region( - self.tcx, + self.tcx.note_and_explain_region( &format!("...but `{}` is only valid for ", - ty::local_var_name_str(self.tcx, - upvar_id.var_id) - .to_string()), + self.tcx.local_var_name_str(upvar_id.var_id)), sup, ""); } infer::InfStackClosure(span) => { span_err!(self.tcx.sess, span, E0314, "closure outlives stack frame"); - note_and_explain_region( - self.tcx, + self.tcx.note_and_explain_region( "...the closure must be valid for ", sub, "..."); - note_and_explain_region( - self.tcx, + self.tcx.note_and_explain_region( "...but the closure's stack frame is only valid for ", sup, ""); @@ -649,8 +640,7 @@ impl<'a, 'tcx> ErrorReporting<'tcx> for InferCtxt<'a, 'tcx> { infer::InvokeClosure(span) => { span_err!(self.tcx.sess, span, E0315, "cannot invoke closure outside of its lifetime"); - note_and_explain_region( - self.tcx, + self.tcx.note_and_explain_region( "the closure is only valid for ", sup, ""); @@ -659,8 +649,7 @@ impl<'a, 'tcx> ErrorReporting<'tcx> for InferCtxt<'a, 'tcx> { self.tcx.sess.span_err( span, "dereference of reference outside its lifetime"); - note_and_explain_region( - self.tcx, + self.tcx.note_and_explain_region( "the reference is only valid for ", sup, ""); @@ -669,16 +658,13 @@ impl<'a, 'tcx> ErrorReporting<'tcx> for InferCtxt<'a, 'tcx> { self.tcx.sess.span_err( span, &format!("captured variable `{}` does not \ - outlive the enclosing closure", - ty::local_var_name_str(self.tcx, - id).to_string())); - note_and_explain_region( - self.tcx, + outlive the enclosing closure", + self.tcx.local_var_name_str(id))); + self.tcx.note_and_explain_region( "captured variable is valid for ", sup, ""); - note_and_explain_region( - self.tcx, + self.tcx.note_and_explain_region( "closure is valid for ", sub, ""); @@ -686,8 +672,7 @@ impl<'a, 'tcx> ErrorReporting<'tcx> for InferCtxt<'a, 'tcx> { infer::IndexSlice(span) => { self.tcx.sess.span_err(span, "index of slice outside its lifetime"); - note_and_explain_region( - self.tcx, + self.tcx.note_and_explain_region( "the slice is only valid for ", sup, ""); @@ -697,13 +682,11 @@ impl<'a, 'tcx> ErrorReporting<'tcx> for InferCtxt<'a, 'tcx> { span, "lifetime of the source pointer does not outlive \ lifetime bound of the object type"); - note_and_explain_region( - self.tcx, + self.tcx.note_and_explain_region( "object type is valid for ", sub, ""); - note_and_explain_region( - self.tcx, + self.tcx.note_and_explain_region( "source pointer is only valid for ", sup, ""); @@ -714,7 +697,7 @@ impl<'a, 'tcx> ErrorReporting<'tcx> for InferCtxt<'a, 'tcx> { &format!("the type `{}` does not fulfill the \ required lifetime", self.ty_to_string(ty))); - note_and_explain_region(self.tcx, + self.tcx.note_and_explain_region( "type must outlive ", sub, ""); @@ -723,13 +706,11 @@ impl<'a, 'tcx> ErrorReporting<'tcx> for InferCtxt<'a, 'tcx> { self.tcx.sess.span_err( span, "lifetime bound not satisfied"); - note_and_explain_region( - self.tcx, + self.tcx.note_and_explain_region( "lifetime parameter instantiated with ", sup, ""); - note_and_explain_region( - self.tcx, + self.tcx.note_and_explain_region( "but lifetime parameter must outlive ", sub, ""); @@ -740,7 +721,7 @@ impl<'a, 'tcx> ErrorReporting<'tcx> for InferCtxt<'a, 'tcx> { &format!("the type `{}` (provided as the value of \ a type parameter) is not valid at this point", self.ty_to_string(ty))); - note_and_explain_region(self.tcx, + self.tcx.note_and_explain_region( "type must outlive ", sub, ""); @@ -750,8 +731,7 @@ impl<'a, 'tcx> ErrorReporting<'tcx> for InferCtxt<'a, 'tcx> { span, "lifetime of method receiver does not outlive \ the method call"); - note_and_explain_region( - self.tcx, + self.tcx.note_and_explain_region( "the receiver is only valid for ", sup, ""); @@ -761,8 +741,7 @@ impl<'a, 'tcx> ErrorReporting<'tcx> for InferCtxt<'a, 'tcx> { span, "lifetime of function argument does not outlive \ the function call"); - note_and_explain_region( - self.tcx, + self.tcx.note_and_explain_region( "the function argument is only valid for ", sup, ""); @@ -772,8 +751,7 @@ impl<'a, 'tcx> ErrorReporting<'tcx> for InferCtxt<'a, 'tcx> { span, "lifetime of return value does not outlive \ the function call"); - note_and_explain_region( - self.tcx, + self.tcx.note_and_explain_region( "the return value is only valid for ", sup, ""); @@ -783,8 +761,7 @@ impl<'a, 'tcx> ErrorReporting<'tcx> for InferCtxt<'a, 'tcx> { span, "lifetime of operand does not outlive \ the operation"); - note_and_explain_region( - self.tcx, + self.tcx.note_and_explain_region( "the operand is only valid for ", sup, ""); @@ -794,8 +771,7 @@ impl<'a, 'tcx> ErrorReporting<'tcx> for InferCtxt<'a, 'tcx> { span, "reference is not valid \ at the time of borrow"); - note_and_explain_region( - self.tcx, + self.tcx.note_and_explain_region( "the borrow is only valid for ", sup, ""); @@ -805,8 +781,7 @@ impl<'a, 'tcx> ErrorReporting<'tcx> for InferCtxt<'a, 'tcx> { span, "automatically reference is not valid \ at the time of borrow"); - note_and_explain_region( - self.tcx, + self.tcx.note_and_explain_region( "the automatic borrow is only valid for ", sup, ""); @@ -817,8 +792,7 @@ impl<'a, 'tcx> ErrorReporting<'tcx> for InferCtxt<'a, 'tcx> { &format!("type of expression contains references \ that are not valid during the expression: `{}`", self.ty_to_string(t))); - note_and_explain_region( - self.tcx, + self.tcx.note_and_explain_region( "type is only valid for ", sup, ""); @@ -829,13 +803,11 @@ impl<'a, 'tcx> ErrorReporting<'tcx> for InferCtxt<'a, 'tcx> { "unsafe use of destructor: destructor might be called \ while references are dead"); // FIXME (22171): terms "super/subregion" are suboptimal - note_and_explain_region( - self.tcx, + self.tcx.note_and_explain_region( "superregion: ", sup, ""); - note_and_explain_region( - self.tcx, + self.tcx.note_and_explain_region( "subregion: ", sub, ""); @@ -844,8 +816,7 @@ impl<'a, 'tcx> ErrorReporting<'tcx> for InferCtxt<'a, 'tcx> { self.tcx.sess.span_err( span, "lifetime of variable does not enclose its declaration"); - note_and_explain_region( - self.tcx, + self.tcx.note_and_explain_region( "the variable is only valid for ", sup, ""); @@ -856,13 +827,11 @@ impl<'a, 'tcx> ErrorReporting<'tcx> for InferCtxt<'a, 'tcx> { &format!("in type `{}`, reference has a longer lifetime \ than the data it references", self.ty_to_string(ty))); - note_and_explain_region( - self.tcx, + self.tcx.note_and_explain_region( "the pointer is valid for ", sub, ""); - note_and_explain_region( - self.tcx, + self.tcx.note_and_explain_region( "but the referenced data is only valid for ", sup, ""); @@ -878,16 +847,14 @@ impl<'a, 'tcx> ErrorReporting<'tcx> for InferCtxt<'a, 'tcx> { sup_region: Region) { self.report_inference_failure(var_origin); - note_and_explain_region( - self.tcx, + self.tcx.note_and_explain_region( "first, the lifetime cannot outlive ", sup_region, "..."); self.note_region_origin(&sup_origin); - note_and_explain_region( - self.tcx, + self.tcx.note_and_explain_region( "but, the lifetime must be valid for ", sub_region, "..."); @@ -903,16 +870,14 @@ impl<'a, 'tcx> ErrorReporting<'tcx> for InferCtxt<'a, 'tcx> { region2: Region) { self.report_inference_failure(var_origin); - note_and_explain_region( - self.tcx, + self.tcx.note_and_explain_region( "first, the lifetime must be contained by ", region1, "..."); self.note_region_origin(&origin1); - note_and_explain_region( - self.tcx, + self.tcx.note_and_explain_region( "but, the lifetime must also be contained by ", region2, "..."); @@ -1353,7 +1318,7 @@ impl<'a, 'tcx> Rebuilder<'a, 'tcx> { }; match a_def { def::DefTy(did, _) | def::DefStruct(did) => { - let generics = ty::lookup_item_type(self.tcx, did).generics; + let generics = self.tcx.lookup_item_type(did).generics; let expected = generics.regions.len(subst::TypeSpace) as u32; @@ -1591,7 +1556,7 @@ impl<'a, 'tcx> ErrorReportingHelpers<'tcx> for InferCtxt<'a, 'tcx> { } infer::UpvarRegion(ref upvar_id, _) => { format!(" for capture of `{}` by closure", - ty::local_var_name_str(self.tcx, upvar_id.var_id).to_string()) + self.tcx.local_var_name_str(upvar_id.var_id).to_string()) } }; @@ -1671,7 +1636,7 @@ impl<'a, 'tcx> ErrorReportingHelpers<'tcx> for InferCtxt<'a, 'tcx> { span, &format!( "...so that closure can access `{}`", - ty::local_var_name_str(self.tcx, upvar_id.var_id) + self.tcx.local_var_name_str(upvar_id.var_id) .to_string())) } infer::InfStackClosure(span) => { @@ -1695,9 +1660,7 @@ impl<'a, 'tcx> ErrorReportingHelpers<'tcx> for InferCtxt<'a, 'tcx> { span, &format!("...so that captured variable `{}` \ does not outlive the enclosing closure", - ty::local_var_name_str( - self.tcx, - id).to_string())); + self.tcx.local_var_name_str(id))); } infer::IndexSlice(span) => { self.tcx.sess.span_note( diff --git a/src/librustc/middle/infer/mod.rs b/src/librustc/middle/infer/mod.rs index 2873a59ae8b1a..f1af2705d4ed8 100644 --- a/src/librustc/middle/infer/mod.rs +++ b/src/librustc/middle/infer/mod.rs @@ -983,7 +983,7 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> { error_str)); if let Some(err) = err { - ty::note_and_explain_type_err(self.tcx, err, sp) + self.tcx.note_and_explain_type_err(err, sp) } } } diff --git a/src/librustc/middle/intrinsicck.rs b/src/librustc/middle/intrinsicck.rs index 900dbb444e4e6..c5f6f0126de37 100644 --- a/src/librustc/middle/intrinsicck.rs +++ b/src/librustc/middle/intrinsicck.rs @@ -54,7 +54,7 @@ struct IntrinsicCheckingVisitor<'a, 'tcx: 'a> { impl<'a, 'tcx> IntrinsicCheckingVisitor<'a, 'tcx> { fn def_id_is_transmute(&self, def_id: DefId) -> bool { - let intrinsic = match ty::lookup_item_type(self.tcx, def_id).ty.sty { + let intrinsic = match self.tcx.lookup_item_type(def_id).ty.sty { ty::TyBareFn(_, ref bfty) => bfty.abi == RustIntrinsic, _ => return false }; @@ -160,8 +160,8 @@ impl<'a, 'tcx> IntrinsicCheckingVisitor<'a, 'tcx> { // In all cases, we keep the original unsubstituted types // around for error reporting. - let from_tc = ty::type_contents(self.tcx, from); - let to_tc = ty::type_contents(self.tcx, to); + let from_tc = from.type_contents(self.tcx); + let to_tc = to.type_contents(self.tcx); if from_tc.interior_param() || to_tc.interior_param() { span_err!(self.tcx.sess, span, E0139, "cannot transmute to or from a type that contains \ @@ -213,7 +213,7 @@ impl<'a, 'tcx> IntrinsicCheckingVisitor<'a, 'tcx> { debug!("with_each_combination: space={:?}, index={}, param_ty={:?}", space, index, param_ty); - if !ty::type_is_sized(Some(param_env), self.tcx, span, param_ty) { + if !param_ty.is_sized(param_env, span) { debug!("with_each_combination: param_ty is not known to be sized"); substs.types.get_mut_slice(space)[index] = self.dummy_unsized_ty; @@ -253,9 +253,9 @@ impl<'a, 'tcx, 'v> Visitor<'v> for IntrinsicCheckingVisitor<'a, 'tcx> { fn visit_expr(&mut self, expr: &ast::Expr) { if let ast::ExprPath(..) = expr.node { - match ty::resolve_expr(self.tcx, expr) { + match self.tcx.resolve_expr(expr) { DefFn(did, _) if self.def_id_is_transmute(did) => { - let typ = ty::node_id_to_type(self.tcx, expr.id); + let typ = self.tcx.node_id_to_type(expr.id); match typ.sty { TyBareFn(_, ref bare_fn_ty) if bare_fn_ty.abi == RustIntrinsic => { if let ty::FnConverging(to) = bare_fn_ty.sig.0.output { diff --git a/src/librustc/middle/liveness.rs b/src/librustc/middle/liveness.rs index aa329d1fab6ca..d354c1667da38 100644 --- a/src/librustc/middle/liveness.rs +++ b/src/librustc/middle/liveness.rs @@ -465,7 +465,7 @@ fn visit_expr(ir: &mut IrMaps, expr: &Expr) { // in better error messages than just pointing at the closure // construction site. let mut call_caps = Vec::new(); - ty::with_freevars(ir.tcx, expr.id, |freevars| { + ir.tcx.with_freevars(expr.id, |freevars| { for fv in freevars { if let DefLocal(rv) = fv.def { let fv_ln = ir.add_live_node(FreeVarNode(fv.span)); @@ -1138,7 +1138,7 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> { ast::ExprCall(ref f, ref args) => { let diverges = !self.ir.tcx.is_method_call(expr.id) && - ty::expr_ty_adjusted(self.ir.tcx, &**f).fn_ret().diverges(); + self.ir.tcx.expr_ty_adjusted(&**f).fn_ret().diverges(); let succ = if diverges { self.s.exit_ln } else { @@ -1494,7 +1494,7 @@ fn check_fn(_v: &Liveness, impl<'a, 'tcx> Liveness<'a, 'tcx> { fn fn_ret(&self, id: NodeId) -> ty::PolyFnOutput<'tcx> { - let fn_ty = ty::node_id_to_type(self.ir.tcx, id); + let fn_ty = self.ir.tcx.node_id_to_type(id); match fn_ty.sty { ty::TyClosure(closure_def_id, substs) => self.ir.tcx.closure_type(closure_def_id, substs).sig.output(), @@ -1511,8 +1511,7 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> { { // within the fn body, late-bound regions are liberated: let fn_ret = - ty::liberate_late_bound_regions( - self.ir.tcx, + self.ir.tcx.liberate_late_bound_regions( region::DestructionScopeData::new(body.id), &self.fn_ret(id)); @@ -1527,7 +1526,7 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> { None if !body.stmts.is_empty() => match body.stmts.first().unwrap().node { ast::StmtSemi(ref e, _) => { - ty::expr_ty(self.ir.tcx, &**e) == t_ret + self.ir.tcx.expr_ty(&**e) == t_ret }, _ => false }, diff --git a/src/librustc/middle/mem_categorization.rs b/src/librustc/middle/mem_categorization.rs index 6e3a36d85c6ae..969ffaf88a719 100644 --- a/src/librustc/middle/mem_categorization.rs +++ b/src/librustc/middle/mem_categorization.rs @@ -285,7 +285,7 @@ pub type McResult = Result; pub trait Typer<'tcx> : ty::ClosureTyper<'tcx> { fn node_ty(&self, id: ast::NodeId) -> McResult>; fn expr_ty_adjusted(&self, expr: &ast::Expr) -> McResult>; - fn type_moves_by_default(&self, span: Span, ty: Ty<'tcx>) -> bool; + fn type_moves_by_default(&self, ty: Ty<'tcx>, span: Span) -> bool; fn node_method_ty(&self, method_call: ty::MethodCall) -> Option>; fn node_method_origin(&self, method_call: ty::MethodCall) -> Option>; @@ -406,9 +406,10 @@ impl<'t,'tcx,TYPER:Typer<'tcx>> MemCategorizationContext<'t,TYPER> { fn expr_ty_adjusted(&self, expr: &ast::Expr) -> McResult> { let unadjusted_ty = try!(self.expr_ty(expr)); - Ok(ty::adjust_ty(self.tcx(), expr.span, expr.id, unadjusted_ty, - self.typer.adjustments().borrow().get(&expr.id), - |method_call| self.typer.node_method_ty(method_call))) + Ok(unadjusted_ty.adjust( + self.tcx(), expr.span, expr.id, + self.typer.adjustments().borrow().get(&expr.id), + |method_call| self.typer.node_method_ty(method_call))) } fn node_ty(&self, id: ast::NodeId) -> McResult> { @@ -927,8 +928,7 @@ impl<'t,'tcx,TYPER:Typer<'tcx>> MemCategorizationContext<'t,TYPER> { let base_cmt = match method_ty { Some(method_ty) => { let ref_ty = - ty::no_late_bound_regions( - self.tcx(), &method_ty.fn_ret()).unwrap().unwrap(); + self.tcx().no_late_bound_regions(&method_ty.fn_ret()).unwrap().unwrap(); self.cat_rvalue_node(node.id(), node.span(), ref_ty) } None => base_cmt @@ -1024,7 +1024,7 @@ impl<'t,'tcx,TYPER:Typer<'tcx>> MemCategorizationContext<'t,TYPER> { // FIXME(#20649) -- why are we using the `self_ty` as the element type...? let self_ty = method_ty.fn_sig().input(0); - ty::no_late_bound_regions(self.tcx(), &self_ty).unwrap() + self.tcx().no_late_bound_regions(&self_ty).unwrap() } None => { match base_cmt.ty.builtin_index() { @@ -1244,7 +1244,7 @@ impl<'t,'tcx,TYPER:Typer<'tcx>> MemCategorizationContext<'t,TYPER> { let cmt = match opt_def { Some(def::DefVariant(enum_did, variant_did, _)) // univariant enums do not need downcasts - if !ty::enum_is_univariant(self.tcx(), enum_did) => { + if !self.tcx().enum_is_univariant(enum_did) => { self.cat_downcast(pat, cmt.clone(), cmt.ty, variant_did) } _ => cmt @@ -1375,7 +1375,7 @@ impl<'t,'tcx,TYPER:Typer<'tcx>> MemCategorizationContext<'t,TYPER> { // types are generated by method resolution and always have // all late-bound regions fully instantiated, so we just want // to skip past the binder. - ty::no_late_bound_regions(self.tcx(), &method_ty.fn_ret()) + self.tcx().no_late_bound_regions(&method_ty.fn_ret()) .unwrap() .unwrap() // overloaded ops do not diverge, either } @@ -1583,7 +1583,7 @@ impl<'tcx> fmt::Debug for categorization<'tcx> { cat_static_item => write!(f, "static"), cat_rvalue(r) => write!(f, "rvalue({:?})", r), cat_local(id) => { - let name = ty::tls::with(|tcx| ty::local_var_name_str(tcx, id)); + let name = ty::tls::with(|tcx| tcx.local_var_name_str(id)); write!(f, "local({})", name) } cat_upvar(upvar) => { diff --git a/src/librustc/middle/pat_util.rs b/src/librustc/middle/pat_util.rs index 0cb302d79b866..15a1ba853245b 100644 --- a/src/librustc/middle/pat_util.rs +++ b/src/librustc/middle/pat_util.rs @@ -192,7 +192,7 @@ pub fn simple_identifier<'a>(pat: &'a ast::Pat) -> Option<&'a ast::Ident> { } pub fn def_to_path(tcx: &ty::ctxt, id: ast::DefId) -> ast::Path { - ty::with_path(tcx, id, |path| ast::Path { + tcx.with_path(id, |path| ast::Path { global: false, segments: path.last().map(|elem| ast::PathSegment { identifier: ast::Ident::new(elem.name()), diff --git a/src/librustc/middle/stability.rs b/src/librustc/middle/stability.rs index dad41bdd3a394..4766ae8933d0b 100644 --- a/src/librustc/middle/stability.rs +++ b/src/librustc/middle/stability.rs @@ -382,7 +382,7 @@ pub fn check_item(tcx: &ty::ctxt, item: &ast::Item, warn_about_defns: bool, // items. ast::ItemImpl(_, _, _, Some(ref t), _, ref impl_items) => { let trait_did = tcx.def_map.borrow().get(&t.ref_id).unwrap().def_id(); - let trait_items = ty::trait_items(tcx, trait_did); + let trait_items = tcx.trait_items(trait_did); for impl_item in impl_items { let item = trait_items.iter().find(|item| { @@ -425,7 +425,7 @@ pub fn check_expr(tcx: &ty::ctxt, e: &ast::Expr, method_num: index, .. }) => { - ty::trait_item(tcx, trait_ref.def_id, index).def_id() + tcx.trait_item(trait_ref.def_id, index).def_id() } } } @@ -434,9 +434,9 @@ pub fn check_expr(tcx: &ty::ctxt, e: &ast::Expr, } ast::ExprField(ref base_e, ref field) => { span = field.span; - match ty::expr_ty_adjusted(tcx, base_e).sty { + match tcx.expr_ty_adjusted(base_e).sty { ty::TyStruct(did, _) => { - ty::lookup_struct_fields(tcx, did) + tcx.lookup_struct_fields(did) .iter() .find(|f| f.name == field.node.name) .unwrap_or_else(|| { @@ -451,9 +451,9 @@ pub fn check_expr(tcx: &ty::ctxt, e: &ast::Expr, } ast::ExprTupField(ref base_e, ref field) => { span = field.span; - match ty::expr_ty_adjusted(tcx, base_e).sty { + match tcx.expr_ty_adjusted(base_e).sty { ty::TyStruct(did, _) => { - ty::lookup_struct_fields(tcx, did) + tcx.lookup_struct_fields(did) .get(field.node) .unwrap_or_else(|| { tcx.sess.span_bug(field.span, @@ -468,10 +468,10 @@ pub fn check_expr(tcx: &ty::ctxt, e: &ast::Expr, } } ast::ExprStruct(_, ref expr_fields, _) => { - let type_ = ty::expr_ty(tcx, e); + let type_ = tcx.expr_ty(e); match type_.sty { ty::TyStruct(did, _) => { - let struct_fields = ty::lookup_struct_fields(tcx, did); + let struct_fields = tcx.lookup_struct_fields(did); // check the stability of each field that appears // in the construction expression. for field in expr_fields { @@ -525,11 +525,11 @@ pub fn check_pat(tcx: &ty::ctxt, pat: &ast::Pat, debug!("check_pat(pat = {:?})", pat); if is_internal(tcx, pat.span) { return; } - let did = match ty::pat_ty_opt(tcx, pat) { + let did = match tcx.pat_ty_opt(pat) { Some(&ty::TyS { sty: ty::TyStruct(did, _), .. }) => did, Some(_) | None => return, }; - let struct_fields = ty::lookup_struct_fields(tcx, did); + let struct_fields = tcx.lookup_struct_fields(did); match pat.node { // Foo(a, b, c) ast::PatEnum(_, Some(ref pat_fields)) => { @@ -574,7 +574,7 @@ fn is_internal(tcx: &ty::ctxt, span: Span) -> bool { } fn is_staged_api(tcx: &ty::ctxt, id: DefId) -> bool { - match ty::trait_item_of_item(tcx, id) { + match tcx.trait_item_of_item(id) { Some(ty::MethodTraitItemId(trait_method_id)) if trait_method_id != id => { is_staged_api(tcx, trait_method_id) @@ -602,7 +602,7 @@ fn lookup_uncached<'tcx>(tcx: &ty::ctxt<'tcx>, id: DefId) -> Option<&'tcx Stabil debug!("lookup(id={:?})", id); // is this definition the implementation of a trait method? - match ty::trait_item_of_item(tcx, id) { + match tcx.trait_item_of_item(id) { Some(ty::MethodTraitItemId(trait_method_id)) if trait_method_id != id => { debug!("lookup: trait_method_id={:?}", trait_method_id); return lookup(tcx, trait_method_id) @@ -617,8 +617,8 @@ fn lookup_uncached<'tcx>(tcx: &ty::ctxt<'tcx>, id: DefId) -> Option<&'tcx Stabil }; item_stab.or_else(|| { - if ty::is_impl(tcx, id) { - if let Some(trait_id) = ty::trait_id_of_impl(tcx, id) { + if tcx.is_impl(id) { + if let Some(trait_id) = tcx.trait_id_of_impl(id) { // FIXME (#18969): for the time being, simply use the // stability of the trait to determine the stability of any // unmarked impls for it. See FIXME above for more details. diff --git a/src/librustc/middle/traits/coherence.rs b/src/librustc/middle/traits/coherence.rs index a826836b10c62..371b5c309a850 100644 --- a/src/librustc/middle/traits/coherence.rs +++ b/src/librustc/middle/traits/coherence.rs @@ -38,7 +38,7 @@ pub fn overlapping_impls(infcx: &InferCtxt, impl1_def_id, impl2_def_id); - let param_env = &ty::empty_parameter_environment(infcx.tcx); + let param_env = &infcx.tcx.empty_parameter_environment(); let selcx = &mut SelectionContext::intercrate(infcx, param_env); infcx.probe(|_| { overlap(selcx, impl1_def_id, impl2_def_id) || overlap(selcx, impl2_def_id, impl1_def_id) @@ -111,7 +111,7 @@ pub fn trait_ref_is_knowable<'tcx>(tcx: &ty::ctxt<'tcx>, trait_ref: &ty::TraitRe // already if trait_ref.def_id.krate != ast::LOCAL_CRATE && - !ty::has_attr(tcx, trait_ref.def_id, "fundamental") + !tcx.has_attr(trait_ref.def_id, "fundamental") { debug!("trait_ref_is_knowable: trait is neither local nor fundamental"); return false; @@ -142,13 +142,13 @@ fn impl_trait_ref_and_oblig<'a,'tcx>(selcx: &mut SelectionContext<'a,'tcx>, let impl_substs = &substs_fn(selcx.infcx(), DUMMY_SP, impl_def_id); let impl_trait_ref = - ty::impl_trait_ref(selcx.tcx(), impl_def_id).unwrap(); + selcx.tcx().impl_trait_ref(impl_def_id).unwrap(); let impl_trait_ref = impl_trait_ref.subst(selcx.tcx(), impl_substs); let Normalized { value: impl_trait_ref, obligations: normalization_obligations1 } = project::normalize(selcx, ObligationCause::dummy(), &impl_trait_ref); - let predicates = ty::lookup_predicates(selcx.tcx(), impl_def_id); + let predicates = selcx.tcx().lookup_predicates(impl_def_id); let predicates = predicates.instantiate(selcx.tcx(), impl_substs); let Normalized { value: predicates, obligations: normalization_obligations2 } = project::normalize(selcx, ObligationCause::dummy(), &predicates); @@ -183,7 +183,7 @@ pub fn orphan_check<'tcx>(tcx: &ty::ctxt<'tcx>, // We only except this routine to be invoked on implementations // of a trait, not inherent implementations. - let trait_ref = ty::impl_trait_ref(tcx, impl_def_id).unwrap(); + let trait_ref = tcx.impl_trait_ref(impl_def_id).unwrap(); debug!("orphan_check: trait_ref={:?}", trait_ref); // If the *trait* is local to the crate, ok. @@ -280,9 +280,9 @@ fn fundamental_ty<'tcx>(tcx: &ty::ctxt<'tcx>, ty: Ty<'tcx>) -> bool ty::TyBox(..) | ty::TyRef(..) => true, ty::TyEnum(def_id, _) | ty::TyStruct(def_id, _) => - ty::has_attr(tcx, def_id, "fundamental"), + tcx.has_attr(def_id, "fundamental"), ty::TyTrait(ref data) => - ty::has_attr(tcx, data.principal_def_id(), "fundamental"), + tcx.has_attr(data.principal_def_id(), "fundamental"), _ => false } diff --git a/src/librustc/middle/traits/error_reporting.rs b/src/librustc/middle/traits/error_reporting.rs index 7b86e1b4539e6..582873082a68b 100644 --- a/src/librustc/middle/traits/error_reporting.rs +++ b/src/librustc/middle/traits/error_reporting.rs @@ -79,14 +79,14 @@ fn report_on_unimplemented<'a, 'tcx>(infcx: &InferCtxt<'a, 'tcx>, span: Span) -> Option { let def_id = trait_ref.def_id; let mut report = None; - for item in ty::get_attrs(infcx.tcx, def_id).iter() { + for item in infcx.tcx.get_attrs(def_id).iter() { if item.check_name("rustc_on_unimplemented") { let err_sp = if item.meta().span == DUMMY_SP { span } else { item.meta().span }; - let def = ty::lookup_trait_def(infcx.tcx, def_id); + let def = infcx.tcx.lookup_trait_def(def_id); let trait_str = def.trait_ref.to_string(); if let Some(ref istring) = item.value_str() { let mut generic_map = def.generics.types.iter_enumerated() @@ -260,7 +260,7 @@ pub fn report_selection_error<'a, 'tcx>(infcx: &InferCtxt<'a, 'tcx>, TraitNotObjectSafe(did) => { span_err!(infcx.tcx.sess, obligation.cause.span, E0038, "cannot convert to a trait object because trait `{}` is not object-safe", - ty::item_path_str(infcx.tcx, did)); + infcx.tcx.item_path_str(did)); for violation in object_safety_violations(infcx.tcx, did) { match violation { @@ -401,7 +401,7 @@ fn note_obligation_cause_code<'a, 'tcx, T>(infcx: &InferCtxt<'a, 'tcx>, match *cause_code { ObligationCauseCode::MiscObligation => { } ObligationCauseCode::ItemObligation(item_def_id) => { - let item_name = ty::item_path_str(tcx, item_def_id); + let item_name = tcx.item_path_str(item_def_id); tcx.sess.span_note( cause_span, &format!("required by `{}`", item_name)); @@ -442,8 +442,8 @@ fn note_obligation_cause_code<'a, 'tcx, T>(infcx: &InferCtxt<'a, 'tcx>, } ObligationCauseCode::ClosureCapture(var_id, closure_span, builtin_bound) => { let def_id = tcx.lang_items.from_builtin_kind(builtin_bound).unwrap(); - let trait_name = ty::item_path_str(tcx, def_id); - let name = ty::local_var_name_str(tcx, var_id); + let trait_name = tcx.item_path_str(def_id); + let name = tcx.local_var_name_str(var_id); span_note!(tcx.sess, closure_span, "the closure that captures `{}` requires that all captured variables \ implement the trait `{}`", diff --git a/src/librustc/middle/traits/fulfill.rs b/src/librustc/middle/traits/fulfill.rs index a26dff4e9fdae..5e274dcec70e4 100644 --- a/src/librustc/middle/traits/fulfill.rs +++ b/src/librustc/middle/traits/fulfill.rs @@ -421,7 +421,7 @@ fn process_predicate<'a,'tcx>(selcx: &mut SelectionContext<'a,'tcx>, // regions. If there are, we will call this obligation an // error. Eventually we should be able to support some // cases here, I imagine (e.g., `for<'a> int : 'a`). - if ty::count_late_bound_regions(selcx.tcx(), binder) != 0 { + if selcx.tcx().count_late_bound_regions(binder) != 0 { errors.push( FulfillmentError::new( obligation.clone(), diff --git a/src/librustc/middle/traits/object_safety.rs b/src/librustc/middle/traits/object_safety.rs index db7b91952a885..e7f11b06bd132 100644 --- a/src/librustc/middle/traits/object_safety.rs +++ b/src/librustc/middle/traits/object_safety.rs @@ -57,7 +57,7 @@ pub fn is_object_safe<'tcx>(tcx: &ty::ctxt<'tcx>, -> bool { // Because we query yes/no results frequently, we keep a cache: - let def = ty::lookup_trait_def(tcx, trait_def_id); + let def = tcx.lookup_trait_def(trait_def_id); let result = def.object_safety().unwrap_or_else(|| { let result = object_safety_violations(tcx, trait_def_id).is_empty(); @@ -90,7 +90,7 @@ fn object_safety_violations_for_trait<'tcx>(tcx: &ty::ctxt<'tcx>, { // Check methods for violations. let mut violations: Vec<_> = - ty::trait_items(tcx, trait_def_id).iter() + tcx.trait_items(trait_def_id).iter() .flat_map(|item| { match *item { ty::MethodTraitItem(ref m) => { @@ -122,10 +122,10 @@ fn supertraits_reference_self<'tcx>(tcx: &ty::ctxt<'tcx>, trait_def_id: ast::DefId) -> bool { - let trait_def = ty::lookup_trait_def(tcx, trait_def_id); + let trait_def = tcx.lookup_trait_def(trait_def_id); let trait_ref = trait_def.trait_ref.clone(); let trait_ref = trait_ref.to_poly_trait_ref(); - let predicates = ty::lookup_super_predicates(tcx, trait_def_id); + let predicates = tcx.lookup_super_predicates(trait_def_id); predicates .predicates .into_iter() @@ -153,8 +153,8 @@ fn trait_has_sized_self<'tcx>(tcx: &ty::ctxt<'tcx>, trait_def_id: ast::DefId) -> bool { - let trait_def = ty::lookup_trait_def(tcx, trait_def_id); - let trait_predicates = ty::lookup_predicates(tcx, trait_def_id); + let trait_def = tcx.lookup_trait_def(trait_def_id); + let trait_predicates = tcx.lookup_predicates(trait_def_id); generics_require_sized_self(tcx, &trait_def.generics, &trait_predicates) } @@ -169,7 +169,7 @@ fn generics_require_sized_self<'tcx>(tcx: &ty::ctxt<'tcx>, }; // Search for a predicate like `Self : Sized` amongst the trait bounds. - let free_substs = ty::construct_free_substs(tcx, generics, ast::DUMMY_NODE_ID); + let free_substs = tcx.construct_free_substs(generics, ast::DUMMY_NODE_ID); let predicates = predicates.instantiate(tcx, &free_substs).predicates.into_vec(); elaborate_predicates(tcx, predicates) .any(|predicate| { @@ -321,7 +321,7 @@ fn contains_illegal_self_type_reference<'tcx>(tcx: &ty::ctxt<'tcx>, // Compute supertraits of current trait lazily. if supertraits.is_none() { - let trait_def = ty::lookup_trait_def(tcx, trait_def_id); + let trait_def = tcx.lookup_trait_def(trait_def_id); let trait_ref = ty::Binder(trait_def.trait_ref.clone()); supertraits = Some(traits::supertraits(tcx, trait_ref).collect()); } diff --git a/src/librustc/middle/traits/project.rs b/src/librustc/middle/traits/project.rs index e0709f51ab1b0..184de682c67db 100644 --- a/src/librustc/middle/traits/project.rs +++ b/src/librustc/middle/traits/project.rs @@ -574,7 +574,7 @@ fn assemble_candidates_from_trait_def<'cx,'tcx>( }; // If so, extract what we know from the trait and try to come up with a good answer. - let trait_predicates = ty::lookup_predicates(selcx.tcx(), trait_ref.def_id); + let trait_predicates = selcx.tcx().lookup_predicates(trait_ref.def_id); let bounds = trait_predicates.instantiate(selcx.tcx(), trait_ref.substs); let bounds = elaborate_predicates(selcx.tcx(), bounds.predicates.into_vec()); assemble_candidates_from_predicates(selcx, obligation, obligation_trait_ref, @@ -892,7 +892,7 @@ fn confirm_impl_candidate<'cx,'tcx>( // It is not in the impl - get the default from the trait. let trait_ref = obligation.predicate.trait_ref; - for trait_item in ty::trait_items(selcx.tcx(), trait_ref.def_id).iter() { + for trait_item in selcx.tcx().trait_items(trait_ref.def_id).iter() { if let &ty::TypeTraitItem(ref assoc_ty) = trait_item { if assoc_ty.name == obligation.predicate.item_name { if let Some(ty) = assoc_ty.ty { diff --git a/src/librustc/middle/traits/select.rs b/src/librustc/middle/traits/select.rs index 86d4e8c753375..01faa6b7cf7b9 100644 --- a/src/librustc/middle/traits/select.rs +++ b/src/librustc/middle/traits/select.rs @@ -773,7 +773,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { match candidate { ImplCandidate(def_id) => { - match ty::trait_impl_polarity(self.tcx(), def_id) { + match self.tcx().trait_impl_polarity(def_id) { Some(ast::ImplPolarity::Negative) => return Err(Unimplemented), _ => {} } @@ -1024,7 +1024,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { projection_trait_ref={:?}", projection_trait_ref); - let trait_predicates = ty::lookup_predicates(self.tcx(), projection_trait_ref.def_id); + let trait_predicates = self.tcx().lookup_predicates(projection_trait_ref.def_id); let bounds = trait_predicates.instantiate(self.tcx(), projection_trait_ref.substs); debug!("match_projection_obligation_against_bounds_from_trait: \ bounds={:?}", @@ -1224,7 +1224,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { { debug!("assemble_candidates_from_impls(obligation={:?})", obligation); - let def = ty::lookup_trait_def(self.tcx(), obligation.predicate.def_id()); + let def = self.tcx().lookup_trait_def(obligation.predicate.def_id()); def.for_each_relevant_impl( self.tcx(), @@ -1252,7 +1252,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { let def_id = obligation.predicate.def_id(); - if ty::trait_has_default_impl(self.tcx(), def_id) { + if self.tcx().trait_has_default_impl(def_id) { match self_ty.sty { ty::TyTrait(..) => { // For object types, we don't know what the closed @@ -1264,7 +1264,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { // object types, because it just lets you reflect // onto the object type, not into the object's // interior. - if ty::has_attr(self.tcx(), def_id, "rustc_reflect_like") { + if self.tcx().has_attr(def_id, "rustc_reflect_like") { candidates.vec.push(DefaultImplObjectCandidate(def_id)); } } @@ -1397,7 +1397,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { // T: Trait // so it seems ok if we (conservatively) fail to accept that `Unsize` // obligation above. Should be possible to extend this in the future. - let self_ty = match ty::no_late_bound_regions(self.tcx(), &obligation.self_ty()) { + let self_ty = match self.tcx().no_late_bound_regions(&obligation.self_ty()) { Some(t) => t, None => { // Don't add any candidates if there are bound regions. @@ -1736,7 +1736,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { ty::TyStruct(def_id, substs) => { let types: Vec = - ty::struct_fields(self.tcx(), def_id, substs).iter() + self.tcx().struct_fields(def_id, substs).iter() .map(|f| f.mt.ty) .collect(); nominal(bound, types) @@ -1744,7 +1744,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { ty::TyEnum(def_id, substs) => { let types: Vec = - ty::substd_enum_variants(self.tcx(), def_id, substs) + self.tcx().substd_enum_variants(def_id, substs) .iter() .flat_map(|variant| &variant.args) .cloned() @@ -1881,13 +1881,13 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { } ty::TyStruct(def_id, substs) => { - Some(ty::struct_fields(self.tcx(), def_id, substs).iter() + Some(self.tcx().struct_fields(def_id, substs).iter() .map(|f| f.mt.ty) .collect()) } ty::TyEnum(def_id, substs) => { - Some(ty::substd_enum_variants(self.tcx(), def_id, substs) + Some(self.tcx().substd_enum_variants(def_id, substs) .iter() .flat_map(|variant| &variant.args) .map(|&ty| ty) @@ -2161,7 +2161,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { obligation, trait_def_id); - assert!(ty::has_attr(self.tcx(), trait_def_id, "rustc_reflect_like")); + assert!(self.tcx().has_attr(trait_def_id, "rustc_reflect_like")); // OK to skip binder, it is reintroduced below let self_ty = self.infcx.shallow_resolve(obligation.predicate.skip_binder().self_ty()); @@ -2178,7 +2178,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { // reintroduce the two binding levels we skipped, then flatten into one let all_types = ty::Binder(ty::Binder(all_types)); - let all_types = ty::flatten_late_bound_regions(self.tcx(), &all_types); + let all_types = self.tcx().flatten_late_bound_regions(&all_types); self.vtable_default_impl(obligation, trait_def_id, all_types) } @@ -2434,7 +2434,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { // assemble_candidates_for_unsizing should ensure there are no late bound // regions here. See the comment there for more details. let source = self.infcx.shallow_resolve( - ty::no_late_bound_regions(tcx, &obligation.self_ty()).unwrap()); + tcx.no_late_bound_regions(&obligation.self_ty()).unwrap()); let target = self.infcx.shallow_resolve(obligation.predicate.0.input_types()[0]); debug!("confirm_builtin_unsize_candidate(source={:?}, target={:?})", @@ -2525,8 +2525,8 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { // Struct -> Struct. (&ty::TyStruct(def_id, substs_a), &ty::TyStruct(_, substs_b)) => { - let fields = ty::lookup_struct_fields(tcx, def_id).iter().map(|f| { - ty::lookup_field_type_unsubstituted(tcx, def_id, f.id) + let fields = tcx.lookup_struct_fields(def_id).iter().map(|f| { + tcx.lookup_field_type_unsubstituted(def_id, f.id) }).collect::>(); // The last field of the structure has to exist and contain type parameters. @@ -2628,7 +2628,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { -> Result<(Normalized<'tcx, Substs<'tcx>>, infer::SkolemizationMap), ()> { - let impl_trait_ref = ty::impl_trait_ref(self.tcx(), impl_def_id).unwrap(); + let impl_trait_ref = self.tcx().impl_trait_ref(impl_def_id).unwrap(); // Before we create the substitutions and everything, first // consider a "quick reject". This avoids creating more types @@ -2765,7 +2765,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { impl_def_id); // Find the self type for the impl. - let impl_self_ty = ty::lookup_item_type(self.tcx(), impl_def_id).ty; + let impl_self_ty = self.tcx().lookup_item_type(impl_def_id).ty; let impl_self_ty = impl_self_ty.subst(self.tcx(), &impl_substs); debug!("match_impl_self_types(obligation_self_ty={:?}, impl_self_ty={:?})", @@ -2890,7 +2890,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { { debug!("impl_or_trait_obligations(def_id={:?})", def_id); - let predicates = ty::lookup_predicates(self.tcx(), def_id); + let predicates = self.tcx().lookup_predicates(def_id); let predicates = predicates.instantiate(self.tcx(), substs); let predicates = normalize_with_depth(self, cause.clone(), recursion_depth, &predicates); let mut predicates = self.infcx().plug_leaks(skol_map, snapshot, &predicates); diff --git a/src/librustc/middle/traits/util.rs b/src/librustc/middle/traits/util.rs index 79b9ae22e4b5c..5c9a8d6c1aa3f 100644 --- a/src/librustc/middle/traits/util.rs +++ b/src/librustc/middle/traits/util.rs @@ -43,19 +43,19 @@ impl<'a,'tcx> PredicateSet<'a,'tcx> { // regions before we throw things into the underlying set. let normalized_pred = match *pred { ty::Predicate::Trait(ref data) => - ty::Predicate::Trait(ty::anonymize_late_bound_regions(self.tcx, data)), + ty::Predicate::Trait(self.tcx.anonymize_late_bound_regions(data)), ty::Predicate::Equate(ref data) => - ty::Predicate::Equate(ty::anonymize_late_bound_regions(self.tcx, data)), + ty::Predicate::Equate(self.tcx.anonymize_late_bound_regions(data)), ty::Predicate::RegionOutlives(ref data) => - ty::Predicate::RegionOutlives(ty::anonymize_late_bound_regions(self.tcx, data)), + ty::Predicate::RegionOutlives(self.tcx.anonymize_late_bound_regions(data)), ty::Predicate::TypeOutlives(ref data) => - ty::Predicate::TypeOutlives(ty::anonymize_late_bound_regions(self.tcx, data)), + ty::Predicate::TypeOutlives(self.tcx.anonymize_late_bound_regions(data)), ty::Predicate::Projection(ref data) => - ty::Predicate::Projection(ty::anonymize_late_bound_regions(self.tcx, data)), + ty::Predicate::Projection(self.tcx.anonymize_late_bound_regions(data)), }; self.set.insert(normalized_pred) } @@ -116,7 +116,7 @@ impl<'cx, 'tcx> Elaborator<'cx, 'tcx> { match *predicate { ty::Predicate::Trait(ref data) => { // Predicates declared on the trait. - let predicates = ty::lookup_super_predicates(self.tcx, data.def_id()); + let predicates = self.tcx.lookup_super_predicates(data.def_id()); let mut predicates: Vec<_> = predicates.predicates @@ -236,7 +236,7 @@ impl<'cx, 'tcx> Iterator for SupertraitDefIds<'cx, 'tcx> { None => { return None; } }; - let predicates = ty::lookup_super_predicates(self.tcx, def_id); + let predicates = self.tcx.lookup_super_predicates(def_id); let visited = &mut self.visited; self.stack.extend( predicates.predicates @@ -297,7 +297,7 @@ pub fn fresh_type_vars_for_impl<'a, 'tcx>(infcx: &InferCtxt<'a, 'tcx>, -> Substs<'tcx> { let tcx = infcx.tcx; - let impl_generics = ty::lookup_item_type(tcx, impl_def_id).generics; + let impl_generics = tcx.lookup_item_type(impl_def_id).generics; infcx.fresh_substs_for_generics(span, &impl_generics) } @@ -416,7 +416,7 @@ pub fn get_vtable_index_of_object_method<'tcx>(tcx: &ty::ctxt<'tcx>, break; } - let trait_items = ty::trait_items(tcx, bound_ref.def_id()); + let trait_items = tcx.trait_items(bound_ref.def_id()); for trait_item in trait_items.iter() { match *trait_item { ty::MethodTraitItem(_) => method_count += 1, @@ -427,7 +427,7 @@ pub fn get_vtable_index_of_object_method<'tcx>(tcx: &ty::ctxt<'tcx>, // count number of methods preceding the one we are selecting and // add them to the total offset; skip over associated types. - let trait_items = ty::trait_items(tcx, trait_def_id); + let trait_items = tcx.trait_items(trait_def_id); for trait_item in trait_items.iter().take(method_offset_in_trait) { match *trait_item { ty::MethodTraitItem(_) => method_count += 1, diff --git a/src/librustc/middle/ty.rs b/src/librustc/middle/ty.rs index 185a04bc5215c..302ec08db6f26 100644 --- a/src/librustc/middle/ty.rs +++ b/src/librustc/middle/ty.rs @@ -51,9 +51,9 @@ use middle::def::{self, DefMap, ExportMap}; use middle::dependency_format; use middle::fast_reject; use middle::free_region::FreeRegionMap; -use middle::infer::error_reporting::note_and_explain_region; use middle::lang_items::{FnTraitLangItem, FnMutTraitLangItem, FnOnceTraitLangItem}; use middle::mem_categorization as mc; +use middle::mem_categorization::Typer; use middle::region; use middle::resolve_lifetime; use middle::infer; @@ -117,6 +117,221 @@ pub struct field<'tcx> { pub mt: mt<'tcx> } + + +// Enum information +#[derive(Clone)] +pub struct VariantInfo<'tcx> { + pub args: Vec>, + pub arg_names: Option>, + pub ctor_ty: Option>, + pub name: ast::Name, + pub id: ast::DefId, + pub disr_val: Disr, + pub vis: Visibility +} + +impl<'tcx> VariantInfo<'tcx> { + + /// Creates a new VariantInfo from the corresponding ast representation. + /// + /// Does not do any caching of the value in the type context. + pub fn from_ast_variant(cx: &ctxt<'tcx>, + ast_variant: &ast::Variant, + discriminant: Disr) -> VariantInfo<'tcx> { + let ctor_ty = cx.node_id_to_type(ast_variant.node.id); + + match ast_variant.node.kind { + ast::TupleVariantKind(ref args) => { + let arg_tys = if !args.is_empty() { + // the regions in the argument types come from the + // enum def'n, and hence will all be early bound + cx.no_late_bound_regions(&ctor_ty.fn_args()).unwrap() + } else { + Vec::new() + }; + + return VariantInfo { + args: arg_tys, + arg_names: None, + ctor_ty: Some(ctor_ty), + name: ast_variant.node.name.name, + id: ast_util::local_def(ast_variant.node.id), + disr_val: discriminant, + vis: ast_variant.node.vis + }; + }, + ast::StructVariantKind(ref struct_def) => { + let fields: &[StructField] = &struct_def.fields; + + assert!(!fields.is_empty()); + + let arg_tys = struct_def.fields.iter() + .map(|field| cx.node_id_to_type(field.node.id)).collect(); + let arg_names = fields.iter().map(|field| { + match field.node.kind { + NamedField(ident, _) => ident.name, + UnnamedField(..) => cx.sess.bug( + "enum_variants: all fields in struct must have a name") + } + }).collect(); + + return VariantInfo { + args: arg_tys, + arg_names: Some(arg_names), + ctor_ty: None, + name: ast_variant.node.name.name, + id: ast_util::local_def(ast_variant.node.id), + disr_val: discriminant, + vis: ast_variant.node.vis + }; + } + } + } +} + +#[derive(Copy, Clone)] +pub enum DtorKind { + NoDtor, + TraitDtor(DefId, bool) +} + +impl DtorKind { + pub fn is_present(&self) -> bool { + match *self { + TraitDtor(..) => true, + _ => false + } + } + + pub fn has_drop_flag(&self) -> bool { + match self { + &NoDtor => false, + &TraitDtor(_, flag) => flag + } + } +} + +trait IntTypeExt { + fn to_ty<'tcx>(&self, cx: &ctxt<'tcx>) -> Ty<'tcx>; + fn i64_to_disr(&self, val: i64) -> Option; + fn u64_to_disr(&self, val: u64) -> Option; + fn disr_incr(&self, val: Disr) -> Option; + fn disr_string(&self, val: Disr) -> String; + fn disr_wrap_incr(&self, val: Option) -> Disr; +} + +impl IntTypeExt for attr::IntType { + fn to_ty<'tcx>(&self, cx: &ctxt<'tcx>) -> Ty<'tcx> { + match *self { + SignedInt(ast::TyI8) => cx.types.i8, + SignedInt(ast::TyI16) => cx.types.i16, + SignedInt(ast::TyI32) => cx.types.i32, + SignedInt(ast::TyI64) => cx.types.i64, + SignedInt(ast::TyIs) => cx.types.isize, + UnsignedInt(ast::TyU8) => cx.types.u8, + UnsignedInt(ast::TyU16) => cx.types.u16, + UnsignedInt(ast::TyU32) => cx.types.u32, + UnsignedInt(ast::TyU64) => cx.types.u64, + UnsignedInt(ast::TyUs) => cx.types.usize, + } + } + + fn i64_to_disr(&self, val: i64) -> Option { + match *self { + SignedInt(ast::TyI8) => val.to_i8() .map(|v| v as Disr), + SignedInt(ast::TyI16) => val.to_i16() .map(|v| v as Disr), + SignedInt(ast::TyI32) => val.to_i32() .map(|v| v as Disr), + SignedInt(ast::TyI64) => val.to_i64() .map(|v| v as Disr), + UnsignedInt(ast::TyU8) => val.to_u8() .map(|v| v as Disr), + UnsignedInt(ast::TyU16) => val.to_u16() .map(|v| v as Disr), + UnsignedInt(ast::TyU32) => val.to_u32() .map(|v| v as Disr), + UnsignedInt(ast::TyU64) => val.to_u64() .map(|v| v as Disr), + + UnsignedInt(ast::TyUs) | + SignedInt(ast::TyIs) => unreachable!(), + } + } + + fn u64_to_disr(&self, val: u64) -> Option { + match *self { + SignedInt(ast::TyI8) => val.to_i8() .map(|v| v as Disr), + SignedInt(ast::TyI16) => val.to_i16() .map(|v| v as Disr), + SignedInt(ast::TyI32) => val.to_i32() .map(|v| v as Disr), + SignedInt(ast::TyI64) => val.to_i64() .map(|v| v as Disr), + UnsignedInt(ast::TyU8) => val.to_u8() .map(|v| v as Disr), + UnsignedInt(ast::TyU16) => val.to_u16() .map(|v| v as Disr), + UnsignedInt(ast::TyU32) => val.to_u32() .map(|v| v as Disr), + UnsignedInt(ast::TyU64) => val.to_u64() .map(|v| v as Disr), + + UnsignedInt(ast::TyUs) | + SignedInt(ast::TyIs) => unreachable!(), + } + } + + fn disr_incr(&self, val: Disr) -> Option { + macro_rules! add1 { + ($e:expr) => { $e.and_then(|v|v.checked_add(1)).map(|v| v as Disr) } + } + match *self { + // SignedInt repr means we *want* to reinterpret the bits + // treating the highest bit of Disr as a sign-bit, so + // cast to i64 before range-checking. + SignedInt(ast::TyI8) => add1!((val as i64).to_i8()), + SignedInt(ast::TyI16) => add1!((val as i64).to_i16()), + SignedInt(ast::TyI32) => add1!((val as i64).to_i32()), + SignedInt(ast::TyI64) => add1!(Some(val as i64)), + + UnsignedInt(ast::TyU8) => add1!(val.to_u8()), + UnsignedInt(ast::TyU16) => add1!(val.to_u16()), + UnsignedInt(ast::TyU32) => add1!(val.to_u32()), + UnsignedInt(ast::TyU64) => add1!(Some(val)), + + UnsignedInt(ast::TyUs) | + SignedInt(ast::TyIs) => unreachable!(), + } + } + + // This returns a String because (1.) it is only used for + // rendering an error message and (2.) a string can represent the + // full range from `i64::MIN` through `u64::MAX`. + fn disr_string(&self, val: Disr) -> String { + match *self { + SignedInt(ast::TyI8) => format!("{}", val as i8 ), + SignedInt(ast::TyI16) => format!("{}", val as i16), + SignedInt(ast::TyI32) => format!("{}", val as i32), + SignedInt(ast::TyI64) => format!("{}", val as i64), + UnsignedInt(ast::TyU8) => format!("{}", val as u8 ), + UnsignedInt(ast::TyU16) => format!("{}", val as u16), + UnsignedInt(ast::TyU32) => format!("{}", val as u32), + UnsignedInt(ast::TyU64) => format!("{}", val as u64), + + UnsignedInt(ast::TyUs) | + SignedInt(ast::TyIs) => unreachable!(), + } + } + + fn disr_wrap_incr(&self, val: Option) -> Disr { + macro_rules! add1 { + ($e:expr) => { ($e).wrapping_add(1) as Disr } + } + let val = val.unwrap_or(ty::INITIAL_DISCRIMINANT_VALUE); + match *self { + SignedInt(ast::TyI8) => add1!(val as i8 ), + SignedInt(ast::TyI16) => add1!(val as i16), + SignedInt(ast::TyI32) => add1!(val as i32), + SignedInt(ast::TyI64) => add1!(val as i64), + UnsignedInt(ast::TyU8) => add1!(val as u8 ), + UnsignedInt(ast::TyU16) => add1!(val as u16), + UnsignedInt(ast::TyU32) => add1!(val as u32), + UnsignedInt(ast::TyU64) => add1!(val as u64), + + UnsignedInt(ast::TyUs) | + SignedInt(ast::TyIs) => unreachable!(), + } + } +} + #[derive(Clone, Copy, Debug)] pub enum ImplOrTraitItemContainer { TraitContainer(ast::DefId), @@ -303,6 +518,17 @@ pub enum Variance { Bivariant, // T <: T -- e.g., unused type parameter } +impl fmt::Debug for Variance { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + f.write_str(match *self { + Covariant => "+", + Contravariant => "-", + Invariant => "o", + Bivariant => "*", + }) + } +} + #[derive(Copy, Clone)] pub enum AutoAdjustment<'tcx> { AdjustReifyFnPointer, // go from a fn-item type to a fn-pointer type @@ -963,7 +1189,7 @@ pub mod tls { Some(ast_map::NodeTraitItem(..)) | Some(ast_map::NodeVariant(..)) | Some(ast_map::NodeStructCtor(..)) => { - return write!(f, "{}", ty::item_path_str(tcx, def_id)); + return write!(f, "{}", tcx.item_path_str(def_id)); } _ => {} } @@ -1438,6 +1664,13 @@ pub struct UpvarBorrow { pub type UpvarCaptureMap = FnvHashMap; +#[derive(Copy, Clone)] +pub struct ClosureUpvar<'tcx> { + pub def: def::Def, + pub span: Span, + pub ty: Ty<'tcx>, +} + impl Region { pub fn is_bound(&self) -> bool { match *self { @@ -2511,22 +2744,20 @@ impl<'a, 'tcx> ParameterEnvironment<'a, 'tcx> { match impl_item.node { ast::ConstImplItem(_, _) => { let def_id = ast_util::local_def(id); - let scheme = lookup_item_type(cx, def_id); - let predicates = lookup_predicates(cx, def_id); - construct_parameter_environment(cx, - impl_item.span, - &scheme.generics, - &predicates, - id) + let scheme = cx.lookup_item_type(def_id); + let predicates = cx.lookup_predicates(def_id); + cx.construct_parameter_environment(impl_item.span, + &scheme.generics, + &predicates, + id) } ast::MethodImplItem(_, ref body) => { let method_def_id = ast_util::local_def(id); - match ty::impl_or_trait_item(cx, method_def_id) { + match cx.impl_or_trait_item(method_def_id) { MethodTraitItem(ref method_ty) => { let method_generics = &method_ty.generics; let method_bounds = &method_ty.predicates; - construct_parameter_environment( - cx, + cx.construct_parameter_environment( impl_item.span, method_generics, method_bounds, @@ -2553,13 +2784,12 @@ impl<'a, 'tcx> ParameterEnvironment<'a, 'tcx> { match *default { Some(_) => { let def_id = ast_util::local_def(id); - let scheme = lookup_item_type(cx, def_id); - let predicates = lookup_predicates(cx, def_id); - construct_parameter_environment(cx, - trait_item.span, - &scheme.generics, - &predicates, - id) + let scheme = cx.lookup_item_type(def_id); + let predicates = cx.lookup_predicates(def_id); + cx.construct_parameter_environment(trait_item.span, + &scheme.generics, + &predicates, + id) } None => { cx.sess.bug("ParameterEnvironment::from_item(): \ @@ -2577,12 +2807,11 @@ impl<'a, 'tcx> ParameterEnvironment<'a, 'tcx> { } ast::MethodTraitItem(_, Some(ref body)) => { let method_def_id = ast_util::local_def(id); - match ty::impl_or_trait_item(cx, method_def_id) { + match cx.impl_or_trait_item(method_def_id) { MethodTraitItem(ref method_ty) => { let method_generics = &method_ty.generics; let method_bounds = &method_ty.predicates; - construct_parameter_environment( - cx, + cx.construct_parameter_environment( trait_item.span, method_generics, method_bounds, @@ -2608,14 +2837,13 @@ impl<'a, 'tcx> ParameterEnvironment<'a, 'tcx> { ast::ItemFn(_, _, _, _, _, ref body) => { // We assume this is a function. let fn_def_id = ast_util::local_def(id); - let fn_scheme = lookup_item_type(cx, fn_def_id); - let fn_predicates = lookup_predicates(cx, fn_def_id); - - construct_parameter_environment(cx, - item.span, - &fn_scheme.generics, - &fn_predicates, - body.id) + let fn_scheme = cx.lookup_item_type(fn_def_id); + let fn_predicates = cx.lookup_predicates(fn_def_id); + + cx.construct_parameter_environment(item.span, + &fn_scheme.generics, + &fn_predicates, + body.id) } ast::ItemEnum(..) | ast::ItemStruct(..) | @@ -2623,13 +2851,12 @@ impl<'a, 'tcx> ParameterEnvironment<'a, 'tcx> { ast::ItemConst(..) | ast::ItemStatic(..) => { let def_id = ast_util::local_def(id); - let scheme = lookup_item_type(cx, def_id); - let predicates = lookup_predicates(cx, def_id); - construct_parameter_environment(cx, - item.span, - &scheme.generics, - &predicates, - id) + let scheme = cx.lookup_item_type(def_id); + let predicates = cx.lookup_predicates(def_id); + cx.construct_parameter_environment(item.span, + &scheme.generics, + &predicates, + id) } _ => { cx.sess.span_bug(item.span, @@ -2650,6 +2877,51 @@ impl<'a, 'tcx> ParameterEnvironment<'a, 'tcx> { } } } + + pub fn can_type_implement_copy(&self, self_type: Ty<'tcx>, span: Span) + -> Result<(),CopyImplementationError> { + let tcx = self.tcx; + + let did = match self_type.sty { + ty::TyStruct(struct_did, substs) => { + let fields = tcx.struct_fields(struct_did, substs); + for field in &fields { + if self.type_moves_by_default(field.mt.ty, span) { + return Err(FieldDoesNotImplementCopy(field.name)) + } + } + struct_did + } + ty::TyEnum(enum_did, substs) => { + let enum_variants = tcx.enum_variants(enum_did); + for variant in enum_variants.iter() { + for variant_arg_type in &variant.args { + let substd_arg_type = + variant_arg_type.subst(tcx, substs); + if self.type_moves_by_default(substd_arg_type, span) { + return Err(VariantDoesNotImplementCopy(variant.name)) + } + } + } + enum_did + } + _ => return Err(TypeIsStructural), + }; + + if tcx.has_dtor(did) { + return Err(TypeHasDestructor) + } + + Ok(()) + } +} + +#[derive(Copy, Clone)] +pub enum CopyImplementationError { + FieldDoesNotImplementCopy(ast::Name), + VariantDoesNotImplementCopy(ast::Name), + TypeIsStructural, + TypeHasDestructor, } /// A "type scheme", in ML terminology, is a type combined with some @@ -2777,7 +3049,7 @@ impl<'tcx> TraitDef<'tcx> { pub fn for_each_impl(&self, tcx: &ctxt<'tcx>, mut f: F) { - ty::populate_implementations_for_trait_if_necessary(tcx, self.trait_ref.def_id); + tcx.populate_implementations_for_trait_if_necessary(self.trait_ref.def_id); for &impl_def_id in self.blanket_impls.borrow().iter() { f(impl_def_id); @@ -2795,7 +3067,7 @@ impl<'tcx> TraitDef<'tcx> { self_ty: Ty<'tcx>, mut f: F) { - ty::populate_implementations_for_trait_if_necessary(tcx, self.trait_ref.def_id); + tcx.populate_implementations_for_trait_if_necessary(self.trait_ref.def_id); for &impl_def_id in self.blanket_impls.borrow().iter() { f(impl_def_id); @@ -2902,207 +3174,26 @@ impl<'tcx> CommonTypes<'tcx> { interner: &mut FnvHashMap, Ty<'tcx>>) -> CommonTypes<'tcx> { + let mut mk = |sty| ctxt::intern_ty(arena, interner, sty); CommonTypes { - bool: intern_ty(arena, interner, TyBool), - char: intern_ty(arena, interner, TyChar), - err: intern_ty(arena, interner, TyError), - isize: intern_ty(arena, interner, TyInt(ast::TyIs)), - i8: intern_ty(arena, interner, TyInt(ast::TyI8)), - i16: intern_ty(arena, interner, TyInt(ast::TyI16)), - i32: intern_ty(arena, interner, TyInt(ast::TyI32)), - i64: intern_ty(arena, interner, TyInt(ast::TyI64)), - usize: intern_ty(arena, interner, TyUint(ast::TyUs)), - u8: intern_ty(arena, interner, TyUint(ast::TyU8)), - u16: intern_ty(arena, interner, TyUint(ast::TyU16)), - u32: intern_ty(arena, interner, TyUint(ast::TyU32)), - u64: intern_ty(arena, interner, TyUint(ast::TyU64)), - f32: intern_ty(arena, interner, TyFloat(ast::TyF32)), - f64: intern_ty(arena, interner, TyFloat(ast::TyF64)), - } - } -} - -/// Create a type context and call the closure with a `&ty::ctxt` reference -/// to the context. The closure enforces that the type context and any interned -/// value (types, substs, etc.) can only be used while `ty::tls` has a valid -/// reference to the context, to allow formatting values that need it. -pub fn with_ctxt<'tcx, F, R>(s: Session, - arenas: &'tcx CtxtArenas<'tcx>, - def_map: DefMap, - named_region_map: resolve_lifetime::NamedRegionMap, - map: ast_map::Map<'tcx>, - freevars: RefCell, - region_maps: RegionMaps, - lang_items: middle::lang_items::LanguageItems, - stability: stability::Index<'tcx>, - f: F) -> (Session, R) - where F: FnOnce(&ctxt<'tcx>) -> R -{ - let mut interner = FnvHashMap(); - let common_types = CommonTypes::new(&arenas.type_, &mut interner); - - tls::enter(ctxt { - arenas: arenas, - interner: RefCell::new(interner), - substs_interner: RefCell::new(FnvHashMap()), - bare_fn_interner: RefCell::new(FnvHashMap()), - region_interner: RefCell::new(FnvHashMap()), - stability_interner: RefCell::new(FnvHashMap()), - types: common_types, - named_region_map: named_region_map, - region_maps: region_maps, - free_region_maps: RefCell::new(FnvHashMap()), - item_variance_map: RefCell::new(DefIdMap()), - variance_computed: Cell::new(false), - sess: s, - def_map: def_map, - node_types: RefCell::new(FnvHashMap()), - item_substs: RefCell::new(NodeMap()), - impl_trait_refs: RefCell::new(DefIdMap()), - trait_defs: RefCell::new(DefIdMap()), - predicates: RefCell::new(DefIdMap()), - super_predicates: RefCell::new(DefIdMap()), - fulfilled_predicates: RefCell::new(traits::FulfilledPredicates::new()), - map: map, - freevars: freevars, - tcache: RefCell::new(DefIdMap()), - rcache: RefCell::new(FnvHashMap()), - tc_cache: RefCell::new(FnvHashMap()), - ast_ty_to_ty_cache: RefCell::new(NodeMap()), - enum_var_cache: RefCell::new(DefIdMap()), - impl_or_trait_items: RefCell::new(DefIdMap()), - trait_item_def_ids: RefCell::new(DefIdMap()), - trait_items_cache: RefCell::new(DefIdMap()), - ty_param_defs: RefCell::new(NodeMap()), - adjustments: RefCell::new(NodeMap()), - normalized_cache: RefCell::new(FnvHashMap()), - lang_items: lang_items, - provided_method_sources: RefCell::new(DefIdMap()), - struct_fields: RefCell::new(DefIdMap()), - destructor_for_type: RefCell::new(DefIdMap()), - destructors: RefCell::new(DefIdSet()), - inherent_impls: RefCell::new(DefIdMap()), - impl_items: RefCell::new(DefIdMap()), - used_unsafe: RefCell::new(NodeSet()), - used_mut_nodes: RefCell::new(NodeSet()), - populated_external_types: RefCell::new(DefIdSet()), - populated_external_primitive_impls: RefCell::new(DefIdSet()), - upvar_capture_map: RefCell::new(FnvHashMap()), - extern_const_statics: RefCell::new(DefIdMap()), - extern_const_variants: RefCell::new(DefIdMap()), - extern_const_fns: RefCell::new(DefIdMap()), - method_map: RefCell::new(FnvHashMap()), - dependency_formats: RefCell::new(FnvHashMap()), - closure_kinds: RefCell::new(DefIdMap()), - closure_tys: RefCell::new(DefIdMap()), - node_lint_levels: RefCell::new(FnvHashMap()), - transmute_restrictions: RefCell::new(Vec::new()), - stability: RefCell::new(stability), - selection_cache: traits::SelectionCache::new(), - repr_hint_cache: RefCell::new(DefIdMap()), - const_qualif_map: RefCell::new(NodeMap()), - custom_coerce_unsized_kinds: RefCell::new(DefIdMap()), - cast_kinds: RefCell::new(NodeMap()), - }, f) -} - -// Type constructors - -impl<'tcx> ctxt<'tcx> { - pub fn mk_substs(&self, substs: Substs<'tcx>) -> &'tcx Substs<'tcx> { - if let Some(substs) = self.substs_interner.borrow().get(&substs) { - return *substs; - } - - let substs = self.arenas.substs.alloc(substs); - self.substs_interner.borrow_mut().insert(substs, substs); - substs - } - - /// Create an unsafe fn ty based on a safe fn ty. - pub fn safe_to_unsafe_fn_ty(&self, bare_fn: &BareFnTy<'tcx>) -> Ty<'tcx> { - assert_eq!(bare_fn.unsafety, ast::Unsafety::Normal); - let unsafe_fn_ty_a = self.mk_bare_fn(ty::BareFnTy { - unsafety: ast::Unsafety::Unsafe, - abi: bare_fn.abi, - sig: bare_fn.sig.clone() - }); - self.mk_fn(None, unsafe_fn_ty_a) - } - - pub fn mk_bare_fn(&self, bare_fn: BareFnTy<'tcx>) -> &'tcx BareFnTy<'tcx> { - if let Some(bare_fn) = self.bare_fn_interner.borrow().get(&bare_fn) { - return *bare_fn; - } - - let bare_fn = self.arenas.bare_fn.alloc(bare_fn); - self.bare_fn_interner.borrow_mut().insert(bare_fn, bare_fn); - bare_fn - } - - pub fn mk_region(&self, region: Region) -> &'tcx Region { - if let Some(region) = self.region_interner.borrow().get(®ion) { - return *region; - } - - let region = self.arenas.region.alloc(region); - self.region_interner.borrow_mut().insert(region, region); - region - } - - pub fn closure_kind(&self, def_id: ast::DefId) -> ty::ClosureKind { - *self.closure_kinds.borrow().get(&def_id).unwrap() - } - - pub fn closure_type(&self, - def_id: ast::DefId, - substs: &subst::Substs<'tcx>) - -> ty::ClosureTy<'tcx> - { - self.closure_tys.borrow().get(&def_id).unwrap().subst(self, substs) - } - - pub fn type_parameter_def(&self, - node_id: ast::NodeId) - -> TypeParameterDef<'tcx> - { - self.ty_param_defs.borrow().get(&node_id).unwrap().clone() - } - - pub fn pat_contains_ref_binding(&self, pat: &ast::Pat) -> Option { - pat_util::pat_contains_ref_binding(&self.def_map, pat) - } - - pub fn arm_contains_ref_binding(&self, arm: &ast::Arm) -> Option { - pat_util::arm_contains_ref_binding(&self.def_map, arm) - } -} - -fn intern_ty<'tcx>(type_arena: &'tcx TypedArena>, - interner: &mut FnvHashMap, Ty<'tcx>>, - st: TypeVariants<'tcx>) - -> Ty<'tcx> -{ - match interner.get(&st) { - Some(ty) => return *ty, - _ => () - } - - let flags = FlagComputation::for_sty(&st); - - let ty = match () { - () => type_arena.alloc(TyS { sty: st, - flags: Cell::new(flags.flags), - region_depth: flags.depth, }), - }; - - debug!("Interned type: {:?} Pointer: {:?}", - ty, ty as *const TyS); - - interner.insert(InternedTy { ty: ty }, ty); - - ty -} + bool: mk(TyBool), + char: mk(TyChar), + err: mk(TyError), + isize: mk(TyInt(ast::TyIs)), + i8: mk(TyInt(ast::TyI8)), + i16: mk(TyInt(ast::TyI16)), + i32: mk(TyInt(ast::TyI32)), + i64: mk(TyInt(ast::TyI64)), + usize: mk(TyUint(ast::TyUs)), + u8: mk(TyUint(ast::TyU8)), + u16: mk(TyUint(ast::TyU16)), + u32: mk(TyUint(ast::TyU32)), + u64: mk(TyUint(ast::TyU64)), + f32: mk(TyFloat(ast::TyF32)), + f64: mk(TyFloat(ast::TyF64)), + } + } +} struct FlagComputation { flags: TypeFlags, @@ -3296,11 +3387,190 @@ impl FlagComputation { } impl<'tcx> ctxt<'tcx> { + /// Create a type context and call the closure with a `&ty::ctxt` reference + /// to the context. The closure enforces that the type context and any interned + /// value (types, substs, etc.) can only be used while `ty::tls` has a valid + /// reference to the context, to allow formatting values that need it. + pub fn create_and_enter(s: Session, + arenas: &'tcx CtxtArenas<'tcx>, + def_map: DefMap, + named_region_map: resolve_lifetime::NamedRegionMap, + map: ast_map::Map<'tcx>, + freevars: RefCell, + region_maps: RegionMaps, + lang_items: middle::lang_items::LanguageItems, + stability: stability::Index<'tcx>, + f: F) -> (Session, R) + where F: FnOnce(&ctxt<'tcx>) -> R + { + let mut interner = FnvHashMap(); + let common_types = CommonTypes::new(&arenas.type_, &mut interner); + + tls::enter(ctxt { + arenas: arenas, + interner: RefCell::new(interner), + substs_interner: RefCell::new(FnvHashMap()), + bare_fn_interner: RefCell::new(FnvHashMap()), + region_interner: RefCell::new(FnvHashMap()), + stability_interner: RefCell::new(FnvHashMap()), + types: common_types, + named_region_map: named_region_map, + region_maps: region_maps, + free_region_maps: RefCell::new(FnvHashMap()), + item_variance_map: RefCell::new(DefIdMap()), + variance_computed: Cell::new(false), + sess: s, + def_map: def_map, + node_types: RefCell::new(FnvHashMap()), + item_substs: RefCell::new(NodeMap()), + impl_trait_refs: RefCell::new(DefIdMap()), + trait_defs: RefCell::new(DefIdMap()), + predicates: RefCell::new(DefIdMap()), + super_predicates: RefCell::new(DefIdMap()), + fulfilled_predicates: RefCell::new(traits::FulfilledPredicates::new()), + map: map, + freevars: freevars, + tcache: RefCell::new(DefIdMap()), + rcache: RefCell::new(FnvHashMap()), + tc_cache: RefCell::new(FnvHashMap()), + ast_ty_to_ty_cache: RefCell::new(NodeMap()), + enum_var_cache: RefCell::new(DefIdMap()), + impl_or_trait_items: RefCell::new(DefIdMap()), + trait_item_def_ids: RefCell::new(DefIdMap()), + trait_items_cache: RefCell::new(DefIdMap()), + ty_param_defs: RefCell::new(NodeMap()), + adjustments: RefCell::new(NodeMap()), + normalized_cache: RefCell::new(FnvHashMap()), + lang_items: lang_items, + provided_method_sources: RefCell::new(DefIdMap()), + struct_fields: RefCell::new(DefIdMap()), + destructor_for_type: RefCell::new(DefIdMap()), + destructors: RefCell::new(DefIdSet()), + inherent_impls: RefCell::new(DefIdMap()), + impl_items: RefCell::new(DefIdMap()), + used_unsafe: RefCell::new(NodeSet()), + used_mut_nodes: RefCell::new(NodeSet()), + populated_external_types: RefCell::new(DefIdSet()), + populated_external_primitive_impls: RefCell::new(DefIdSet()), + upvar_capture_map: RefCell::new(FnvHashMap()), + extern_const_statics: RefCell::new(DefIdMap()), + extern_const_variants: RefCell::new(DefIdMap()), + extern_const_fns: RefCell::new(DefIdMap()), + method_map: RefCell::new(FnvHashMap()), + dependency_formats: RefCell::new(FnvHashMap()), + closure_kinds: RefCell::new(DefIdMap()), + closure_tys: RefCell::new(DefIdMap()), + node_lint_levels: RefCell::new(FnvHashMap()), + transmute_restrictions: RefCell::new(Vec::new()), + stability: RefCell::new(stability), + selection_cache: traits::SelectionCache::new(), + repr_hint_cache: RefCell::new(DefIdMap()), + const_qualif_map: RefCell::new(NodeMap()), + custom_coerce_unsized_kinds: RefCell::new(DefIdMap()), + cast_kinds: RefCell::new(NodeMap()), + }, f) + } + + // Type constructors + + pub fn mk_substs(&self, substs: Substs<'tcx>) -> &'tcx Substs<'tcx> { + if let Some(substs) = self.substs_interner.borrow().get(&substs) { + return *substs; + } + + let substs = self.arenas.substs.alloc(substs); + self.substs_interner.borrow_mut().insert(substs, substs); + substs + } + + /// Create an unsafe fn ty based on a safe fn ty. + pub fn safe_to_unsafe_fn_ty(&self, bare_fn: &BareFnTy<'tcx>) -> Ty<'tcx> { + assert_eq!(bare_fn.unsafety, ast::Unsafety::Normal); + let unsafe_fn_ty_a = self.mk_bare_fn(ty::BareFnTy { + unsafety: ast::Unsafety::Unsafe, + abi: bare_fn.abi, + sig: bare_fn.sig.clone() + }); + self.mk_fn(None, unsafe_fn_ty_a) + } + + pub fn mk_bare_fn(&self, bare_fn: BareFnTy<'tcx>) -> &'tcx BareFnTy<'tcx> { + if let Some(bare_fn) = self.bare_fn_interner.borrow().get(&bare_fn) { + return *bare_fn; + } + + let bare_fn = self.arenas.bare_fn.alloc(bare_fn); + self.bare_fn_interner.borrow_mut().insert(bare_fn, bare_fn); + bare_fn + } + + pub fn mk_region(&self, region: Region) -> &'tcx Region { + if let Some(region) = self.region_interner.borrow().get(®ion) { + return *region; + } + + let region = self.arenas.region.alloc(region); + self.region_interner.borrow_mut().insert(region, region); + region + } + + pub fn closure_kind(&self, def_id: ast::DefId) -> ty::ClosureKind { + *self.closure_kinds.borrow().get(&def_id).unwrap() + } + + pub fn closure_type(&self, + def_id: ast::DefId, + substs: &subst::Substs<'tcx>) + -> ty::ClosureTy<'tcx> + { + self.closure_tys.borrow().get(&def_id).unwrap().subst(self, substs) + } + + pub fn type_parameter_def(&self, + node_id: ast::NodeId) + -> TypeParameterDef<'tcx> + { + self.ty_param_defs.borrow().get(&node_id).unwrap().clone() + } + + pub fn pat_contains_ref_binding(&self, pat: &ast::Pat) -> Option { + pat_util::pat_contains_ref_binding(&self.def_map, pat) + } + + pub fn arm_contains_ref_binding(&self, arm: &ast::Arm) -> Option { + pat_util::arm_contains_ref_binding(&self.def_map, arm) + } + + fn intern_ty(type_arena: &'tcx TypedArena>, + interner: &mut FnvHashMap, Ty<'tcx>>, + st: TypeVariants<'tcx>) + -> Ty<'tcx> { + match interner.get(&st) { + Some(ty) => return *ty, + _ => () + } + + let flags = FlagComputation::for_sty(&st); + + let ty = match () { + () => type_arena.alloc(TyS { sty: st, + flags: Cell::new(flags.flags), + region_depth: flags.depth, }), + }; + + debug!("Interned type: {:?} Pointer: {:?}", + ty, ty as *const TyS); + + interner.insert(InternedTy { ty: ty }, ty); + + ty + } + // Interns a type/name combination, stores the resulting box in cx.interner, // and returns the box as cast to an unsafe ptr (see comments for Ty above). pub fn mk_ty(&self, st: TypeVariants<'tcx>) -> Ty<'tcx> { let mut interner = self.interner.borrow_mut(); - intern_ty(&self.arenas.type_, &mut *interner, st) + ctxt::intern_ty(&self.arenas.type_, &mut *interner, st) } pub fn mk_mach_int(&self, tm: ast::IntTy) -> Ty<'tcx> { @@ -3546,16 +3816,6 @@ impl<'tcx> TyS<'tcx> { } } -// Folds types from the bottom up. -pub fn fold_ty<'tcx, F>(cx: &ctxt<'tcx>, t0: Ty<'tcx>, - fldop: F) - -> Ty<'tcx> where - F: FnMut(Ty<'tcx>) -> Ty<'tcx>, -{ - let mut f = ty_fold::BottomUpFolder {tcx: cx, fldop: fldop}; - f.fold_ty(t0) -} - impl ParamTy { pub fn new(space: subst::ParamSpace, index: u32, @@ -3600,6 +3860,13 @@ impl<'tcx> TyS<'tcx> { } } + pub fn is_empty(&self, cx: &ctxt) -> bool { + match self.sty { + TyEnum(did, _) => cx.enum_variants(did).is_empty(), + _ => false + } + } + pub fn is_ty_var(&self) -> bool { match self.sty { TyInfer(TyVar(_)) => true, @@ -3636,7 +3903,7 @@ impl<'tcx> TyS<'tcx> { pub fn is_simd(&self, cx: &ctxt) -> bool { match self.sty { - TyStruct(did, _) => lookup_simd(cx, did), + TyStruct(did, _) => cx.lookup_simd(did), _ => false } } @@ -3653,8 +3920,8 @@ impl<'tcx> TyS<'tcx> { pub fn simd_type(&self, cx: &ctxt<'tcx>) -> Ty<'tcx> { match self.sty { TyStruct(did, substs) => { - let fields = lookup_struct_fields(cx, did); - lookup_field_type(cx, did, fields[0].id, substs) + let fields = cx.lookup_struct_fields(did); + cx.lookup_field_type(did, fields[0].id, substs) } _ => panic!("simd_type called on invalid type") } @@ -3663,8 +3930,7 @@ impl<'tcx> TyS<'tcx> { pub fn simd_size(&self, cx: &ctxt) -> usize { match self.sty { TyStruct(did, _) => { - let fields = lookup_struct_fields(cx, did); - fields.len() + cx.lookup_struct_fields(did).len() } _ => panic!("simd_size called on invalid type") } @@ -3713,6 +3979,16 @@ impl<'tcx> TyS<'tcx> { _ => false, } } + + pub fn ty_to_def_id(&self) -> Option { + match self.sty { + TyTrait(ref tt) => Some(tt.principal_def_id()), + TyStruct(id, _) | + TyEnum(id, _) | + TyClosure(id, _) => Some(id), + _ => None + } + } } /// Type contents is how the type checker reasons about kinds. @@ -3866,454 +4142,425 @@ impl fmt::Debug for TypeContents { } } -pub fn type_contents<'tcx>(cx: &ctxt<'tcx>, ty: Ty<'tcx>) -> TypeContents { - return memoized(&cx.tc_cache, ty, |ty| { - tc_ty(cx, ty, &mut FnvHashMap()) - }); +impl<'tcx> TyS<'tcx> { + pub fn type_contents(&'tcx self, cx: &ctxt<'tcx>) -> TypeContents { + return memoized(&cx.tc_cache, self, |ty| { + tc_ty(cx, ty, &mut FnvHashMap()) + }); - fn tc_ty<'tcx>(cx: &ctxt<'tcx>, - ty: Ty<'tcx>, - cache: &mut FnvHashMap, TypeContents>) -> TypeContents - { - // Subtle: Note that we are *not* using cx.tc_cache here but rather a - // private cache for this walk. This is needed in the case of cyclic - // types like: - // - // struct List { next: Box>, ... } - // - // When computing the type contents of such a type, we wind up deeply - // recursing as we go. So when we encounter the recursive reference - // to List, we temporarily use TC::None as its contents. Later we'll - // patch up the cache with the correct value, once we've computed it - // (this is basically a co-inductive process, if that helps). So in - // the end we'll compute TC::OwnsOwned, in this case. - // - // The problem is, as we are doing the computation, we will also - // compute an *intermediate* contents for, e.g., Option of - // TC::None. This is ok during the computation of List itself, but if - // we stored this intermediate value into cx.tc_cache, then later - // requests for the contents of Option would also yield TC::None - // which is incorrect. This value was computed based on the crutch - // value for the type contents of list. The correct value is - // TC::OwnsOwned. This manifested as issue #4821. - match cache.get(&ty) { - Some(tc) => { return *tc; } - None => {} - } - match cx.tc_cache.borrow().get(&ty) { // Must check both caches! - Some(tc) => { return *tc; } - None => {} - } - cache.insert(ty, TC::None); - - let result = match ty.sty { - // usize and isize are ffi-unsafe - TyUint(ast::TyUs) | TyInt(ast::TyIs) => { - TC::ReachesFfiUnsafe - } - - // Scalar and unique types are sendable, and durable - TyInfer(ty::FreshIntTy(_)) | TyInfer(ty::FreshFloatTy(_)) | - TyBool | TyInt(_) | TyUint(_) | TyFloat(_) | - TyBareFn(..) | ty::TyChar => { - TC::None - } - - TyBox(typ) => { - TC::ReachesFfiUnsafe | match typ.sty { - TyStr => TC::OwnsOwned, - _ => tc_ty(cx, typ, cache).owned_pointer(), + fn tc_ty<'tcx>(cx: &ctxt<'tcx>, + ty: Ty<'tcx>, + cache: &mut FnvHashMap, TypeContents>) -> TypeContents + { + // Subtle: Note that we are *not* using cx.tc_cache here but rather a + // private cache for this walk. This is needed in the case of cyclic + // types like: + // + // struct List { next: Box>, ... } + // + // When computing the type contents of such a type, we wind up deeply + // recursing as we go. So when we encounter the recursive reference + // to List, we temporarily use TC::None as its contents. Later we'll + // patch up the cache with the correct value, once we've computed it + // (this is basically a co-inductive process, if that helps). So in + // the end we'll compute TC::OwnsOwned, in this case. + // + // The problem is, as we are doing the computation, we will also + // compute an *intermediate* contents for, e.g., Option of + // TC::None. This is ok during the computation of List itself, but if + // we stored this intermediate value into cx.tc_cache, then later + // requests for the contents of Option would also yield TC::None + // which is incorrect. This value was computed based on the crutch + // value for the type contents of list. The correct value is + // TC::OwnsOwned. This manifested as issue #4821. + match cache.get(&ty) { + Some(tc) => { return *tc; } + None => {} + } + match cx.tc_cache.borrow().get(&ty) { // Must check both caches! + Some(tc) => { return *tc; } + None => {} + } + cache.insert(ty, TC::None); + + let result = match ty.sty { + // usize and isize are ffi-unsafe + TyUint(ast::TyUs) | TyInt(ast::TyIs) => { + TC::ReachesFfiUnsafe } - } - - TyTrait(box TraitTy { ref bounds, .. }) => { - object_contents(bounds) | TC::ReachesFfiUnsafe | TC::Nonsized - } - TyRawPtr(ref mt) => { - tc_ty(cx, mt.ty, cache).unsafe_pointer() - } + // Scalar and unique types are sendable, and durable + TyInfer(ty::FreshIntTy(_)) | TyInfer(ty::FreshFloatTy(_)) | + TyBool | TyInt(_) | TyUint(_) | TyFloat(_) | + TyBareFn(..) | ty::TyChar => { + TC::None + } - TyRef(r, ref mt) => { - TC::ReachesFfiUnsafe | match mt.ty.sty { - TyStr => borrowed_contents(*r, ast::MutImmutable), - TyArray(..) | - TySlice(_) => tc_ty(cx, mt.ty, cache).reference(borrowed_contents(*r, - mt.mutbl)), - _ => tc_ty(cx, mt.ty, cache).reference(borrowed_contents(*r, mt.mutbl)), + TyBox(typ) => { + TC::ReachesFfiUnsafe | tc_ty(cx, typ, cache).owned_pointer() } - } - TyArray(ty, _) => { - tc_ty(cx, ty, cache) - } + TyTrait(box TraitTy { ref bounds, .. }) => { + object_contents(bounds) | TC::ReachesFfiUnsafe | TC::Nonsized + } - TySlice(ty) => { - tc_ty(cx, ty, cache) | TC::Nonsized - } - TyStr => TC::Nonsized, + TyRawPtr(ref mt) => { + tc_ty(cx, mt.ty, cache).unsafe_pointer() + } - TyStruct(did, substs) => { - let flds = struct_fields(cx, did, substs); - let mut res = - TypeContents::union(&flds[..], - |f| tc_mt(cx, f.mt, cache)); + TyRef(r, ref mt) => { + tc_ty(cx, mt.ty, cache).reference(borrowed_contents(*r, mt.mutbl)) | + TC::ReachesFfiUnsafe + } - if !lookup_repr_hints(cx, did).contains(&attr::ReprExtern) { - res = res | TC::ReachesFfiUnsafe; + TyArray(ty, _) => { + tc_ty(cx, ty, cache) } - if ty::has_dtor(cx, did) { - res = res | TC::OwnsDtor; + TySlice(ty) => { + tc_ty(cx, ty, cache) | TC::Nonsized } - apply_lang_items(cx, did, res) - } + TyStr => TC::Nonsized, - TyClosure(did, substs) => { - // FIXME(#14449): `borrowed_contents` below assumes `&mut` closure. - let param_env = ty::empty_parameter_environment(cx); - let upvars = closure_upvars(¶m_env, did, substs).unwrap(); - TypeContents::union(&upvars, |f| tc_ty(cx, &f.ty, cache)) - } + TyStruct(did, substs) => { + let flds = cx.struct_fields(did, substs); + let mut res = + TypeContents::union(&flds[..], + |f| tc_mt(cx, f.mt, cache)); - TyTuple(ref tys) => { - TypeContents::union(&tys[..], - |ty| tc_ty(cx, *ty, cache)) - } + if !cx.lookup_repr_hints(did).contains(&attr::ReprExtern) { + res = res | TC::ReachesFfiUnsafe; + } - TyEnum(did, substs) => { - let variants = substd_enum_variants(cx, did, substs); - let mut res = - TypeContents::union(&variants[..], |variant| { - TypeContents::union(&variant.args, - |arg_ty| { - tc_ty(cx, *arg_ty, cache) - }) - }); + if cx.has_dtor(did) { + res = res | TC::OwnsDtor; + } + apply_lang_items(cx, did, res) + } - if ty::has_dtor(cx, did) { - res = res | TC::OwnsDtor; + TyClosure(did, substs) => { + // FIXME(#14449): `borrowed_contents` below assumes `&mut` closure. + let param_env = cx.empty_parameter_environment(); + let upvars = param_env.closure_upvars(did, substs).unwrap(); + TypeContents::union(&upvars, |f| tc_ty(cx, &f.ty, cache)) } - if !variants.is_empty() { - let repr_hints = lookup_repr_hints(cx, did); - if repr_hints.len() > 1 { - // this is an error later on, but this type isn't safe - res = res | TC::ReachesFfiUnsafe; + TyTuple(ref tys) => { + TypeContents::union(&tys[..], + |ty| tc_ty(cx, *ty, cache)) + } + + TyEnum(did, substs) => { + let variants = cx.substd_enum_variants(did, substs); + let mut res = + TypeContents::union(&variants[..], |variant| { + TypeContents::union(&variant.args, + |arg_ty| { + tc_ty(cx, *arg_ty, cache) + }) + }); + + if cx.has_dtor(did) { + res = res | TC::OwnsDtor; } - match repr_hints.get(0) { - Some(h) => if !h.is_ffi_safe() { - res = res | TC::ReachesFfiUnsafe; - }, - // ReprAny - None => { + if !variants.is_empty() { + let repr_hints = cx.lookup_repr_hints(did); + if repr_hints.len() > 1 { + // this is an error later on, but this type isn't safe res = res | TC::ReachesFfiUnsafe; + } - // We allow ReprAny enums if they are eligible for - // the nullable pointer optimization and the - // contained type is an `extern fn` + match repr_hints.get(0) { + Some(h) => if !h.is_ffi_safe() { + res = res | TC::ReachesFfiUnsafe; + }, + // ReprAny + None => { + res = res | TC::ReachesFfiUnsafe; - if variants.len() == 2 { - let mut data_idx = 0; + // We allow ReprAny enums if they are eligible for + // the nullable pointer optimization and the + // contained type is an `extern fn` - if variants[0].args.is_empty() { - data_idx = 1; - } + if variants.len() == 2 { + let mut data_idx = 0; - if variants[data_idx].args.len() == 1 { - match variants[data_idx].args[0].sty { - TyBareFn(..) => { res = res - TC::ReachesFfiUnsafe; } - _ => { } + if variants[0].args.is_empty() { + data_idx = 1; + } + + if variants[data_idx].args.len() == 1 { + match variants[data_idx].args[0].sty { + TyBareFn(..) => { res = res - TC::ReachesFfiUnsafe; } + _ => { } + } } } } } } + + + apply_lang_items(cx, did, res) } + TyProjection(..) | + TyParam(_) => { + TC::All + } - apply_lang_items(cx, did, res) - } + TyInfer(_) | + TyError => { + cx.sess.bug("asked to compute contents of error type"); + } + }; - TyProjection(..) | - TyParam(_) => { - TC::All - } + cache.insert(ty, result); + result + } + + fn tc_mt<'tcx>(cx: &ctxt<'tcx>, + mt: mt<'tcx>, + cache: &mut FnvHashMap, TypeContents>) -> TypeContents + { + let mc = TC::ReachesMutable.when(mt.mutbl == MutMutable); + mc | tc_ty(cx, mt.ty, cache) + } - TyInfer(_) | - TyError => { - cx.sess.bug("asked to compute contents of error type"); + fn apply_lang_items(cx: &ctxt, did: ast::DefId, tc: TypeContents) + -> TypeContents { + if Some(did) == cx.lang_items.unsafe_cell_type() { + tc | TC::InteriorUnsafe + } else { + tc } - }; + } - cache.insert(ty, result); - result + /// Type contents due to containing a reference with + /// the region `region` and borrow kind `bk`. + fn borrowed_contents(region: ty::Region, + mutbl: ast::Mutability) + -> TypeContents { + let b = match mutbl { + ast::MutMutable => TC::ReachesMutable, + ast::MutImmutable => TC::None, + }; + b | (TC::ReachesBorrowed).when(region != ty::ReStatic) + } + + fn object_contents(bounds: &ExistentialBounds) -> TypeContents { + // These are the type contents of the (opaque) interior. We + // make no assumptions (other than that it cannot have an + // in-scope type parameter within, which makes no sense). + let mut tc = TC::All - TC::InteriorParam; + for bound in &bounds.builtin_bounds { + tc = tc - match bound { + BoundSync | BoundSend | BoundCopy => TC::None, + BoundSized => TC::Nonsized, + }; + } + return tc; + } } - fn tc_mt<'tcx>(cx: &ctxt<'tcx>, - mt: mt<'tcx>, - cache: &mut FnvHashMap, TypeContents>) -> TypeContents + fn impls_bound<'a>(&'tcx self, param_env: &ParameterEnvironment<'a,'tcx>, + bound: ty::BuiltinBound, + span: Span) + -> bool { - let mc = TC::ReachesMutable.when(mt.mutbl == MutMutable); - mc | tc_ty(cx, mt.ty, cache) - } + let infcx = infer::new_infer_ctxt(param_env.tcx()); - fn apply_lang_items(cx: &ctxt, did: ast::DefId, tc: TypeContents) - -> TypeContents { - if Some(did) == cx.lang_items.unsafe_cell_type() { - tc | TC::InteriorUnsafe - } else { - tc - } - } + let is_impld = traits::type_known_to_meet_builtin_bound(&infcx, param_env, + self, bound, span); - /// Type contents due to containing a reference with the region `region` and borrow kind `bk` - fn borrowed_contents(region: ty::Region, - mutbl: ast::Mutability) - -> TypeContents { - let b = match mutbl { - ast::MutMutable => TC::ReachesMutable, - ast::MutImmutable => TC::None, - }; - b | (TC::ReachesBorrowed).when(region != ty::ReStatic) - } - - fn object_contents(bounds: &ExistentialBounds) -> TypeContents { - // These are the type contents of the (opaque) interior. We - // make no assumptions (other than that it cannot have an - // in-scope type parameter within, which makes no sense). - let mut tc = TC::All - TC::InteriorParam; - for bound in &bounds.builtin_bounds { - tc = tc - match bound { - BoundSync | BoundSend | BoundCopy => TC::None, - BoundSized => TC::Nonsized, - }; - } - return tc; + debug!("Ty::impls_bound({:?}, {:?}) = {:?}", + self, bound, is_impld); + + is_impld } -} -fn type_impls_bound<'a,'tcx>(param_env: Option<&ParameterEnvironment<'a,'tcx>>, - tcx: &ctxt<'tcx>, - ty: Ty<'tcx>, - bound: ty::BuiltinBound, - span: Span) - -> bool -{ - let pe; - let param_env = match param_env { - Some(e) => e, - None => { - pe = empty_parameter_environment(tcx); - &pe + fn moves_by_default<'a>(&'tcx self, param_env: &ParameterEnvironment<'a,'tcx>, + span: Span) -> bool { + if self.flags.get().intersects(TypeFlags::MOVENESS_CACHED) { + return self.flags.get().intersects(TypeFlags::MOVES_BY_DEFAULT); } - }; - let infcx = infer::new_infer_ctxt(tcx); - let is_impld = traits::type_known_to_meet_builtin_bound(&infcx, param_env, ty, bound, span); + assert!(!self.needs_infer()); - debug!("type_impls_bound({:?}, {:?}) = {:?}", - ty, - bound, - is_impld); + // Fast-path for primitive types + let result = match self.sty { + TyBool | TyChar | TyInt(..) | TyUint(..) | TyFloat(..) | + TyRawPtr(..) | TyBareFn(..) | TyRef(_, mt { + mutbl: ast::MutImmutable, .. + }) => Some(false), - is_impld -} + TyStr | TyBox(..) | TyRef(_, mt { + mutbl: ast::MutMutable, .. + }) => Some(true), -pub fn type_moves_by_default<'a,'tcx>(param_env: &ParameterEnvironment<'a,'tcx>, - span: Span, - ty: Ty<'tcx>) - -> bool -{ - if ty.flags.get().intersects(TypeFlags::MOVENESS_CACHED) { - return ty.flags.get().intersects(TypeFlags::MOVES_BY_DEFAULT); - } - - assert!(!ty.needs_infer()); - - // Fast-path for primitive types - let result = match ty.sty { - TyBool | TyChar | TyInt(..) | TyUint(..) | TyFloat(..) | - TyRawPtr(..) | TyBareFn(..) | TyRef(_, mt { - mutbl: ast::MutImmutable, .. - }) => Some(false), - - TyStr | TyBox(..) | TyRef(_, mt { - mutbl: ast::MutMutable, .. - }) => Some(true), - - TyArray(..) | TySlice(_) | TyTrait(..) | TyTuple(..) | - TyClosure(..) | TyEnum(..) | TyStruct(..) | - TyProjection(..) | TyParam(..) | TyInfer(..) | TyError => None - }.unwrap_or_else(|| !type_impls_bound(Some(param_env), - param_env.tcx, - ty, - ty::BoundCopy, - span)); - - if !ty.has_param_types() && !ty.has_self_ty() { - ty.flags.set(ty.flags.get() | if result { - TypeFlags::MOVENESS_CACHED | TypeFlags::MOVES_BY_DEFAULT - } else { - TypeFlags::MOVENESS_CACHED - }); - } + TyArray(..) | TySlice(_) | TyTrait(..) | TyTuple(..) | + TyClosure(..) | TyEnum(..) | TyStruct(..) | + TyProjection(..) | TyParam(..) | TyInfer(..) | TyError => None + }.unwrap_or_else(|| !self.impls_bound(param_env, ty::BoundCopy, span)); - result -} + if !self.has_param_types() && !self.has_self_ty() { + self.flags.set(self.flags.get() | if result { + TypeFlags::MOVENESS_CACHED | TypeFlags::MOVES_BY_DEFAULT + } else { + TypeFlags::MOVENESS_CACHED + }); + } -#[inline] -pub fn type_is_sized<'a,'tcx>(param_env: Option<&ParameterEnvironment<'a,'tcx>>, - tcx: &ctxt<'tcx>, - span: Span, - ty: Ty<'tcx>) - -> bool -{ - if ty.flags.get().intersects(TypeFlags::SIZEDNESS_CACHED) { - let result = ty.flags.get().intersects(TypeFlags::IS_SIZED); - return result; + result } - type_is_sized_uncached(param_env, tcx, span, ty) -} + #[inline] + pub fn is_sized<'a>(&'tcx self, param_env: &ParameterEnvironment<'a,'tcx>, + span: Span) -> bool + { + if self.flags.get().intersects(TypeFlags::SIZEDNESS_CACHED) { + return self.flags.get().intersects(TypeFlags::IS_SIZED); + } -fn type_is_sized_uncached<'a,'tcx>(param_env: Option<&ParameterEnvironment<'a,'tcx>>, - tcx: &ctxt<'tcx>, - span: Span, - ty: Ty<'tcx>) -> bool { - assert!(!ty.needs_infer()); + self.is_sized_uncached(param_env, span) + } - // Fast-path for primitive types - let result = match ty.sty { - TyBool | TyChar | TyInt(..) | TyUint(..) | TyFloat(..) | - TyBox(..) | TyRawPtr(..) | TyRef(..) | TyBareFn(..) | - TyArray(..) | TyTuple(..) | TyClosure(..) => Some(true), + fn is_sized_uncached<'a>(&'tcx self, param_env: &ParameterEnvironment<'a,'tcx>, + span: Span) -> bool { + assert!(!self.needs_infer()); - TyStr | TyTrait(..) | TySlice(_) => Some(false), + // Fast-path for primitive types + let result = match self.sty { + TyBool | TyChar | TyInt(..) | TyUint(..) | TyFloat(..) | + TyBox(..) | TyRawPtr(..) | TyRef(..) | TyBareFn(..) | + TyArray(..) | TyTuple(..) | TyClosure(..) => Some(true), - TyEnum(..) | TyStruct(..) | TyProjection(..) | TyParam(..) | - TyInfer(..) | TyError => None - }.unwrap_or_else(|| type_impls_bound(param_env, tcx, ty, ty::BoundSized, span)); + TyStr | TyTrait(..) | TySlice(_) => Some(false), - if !ty.has_param_types() && !ty.has_self_ty() { - ty.flags.set(ty.flags.get() | if result { - TypeFlags::SIZEDNESS_CACHED | TypeFlags::IS_SIZED - } else { - TypeFlags::SIZEDNESS_CACHED - }); - } + TyEnum(..) | TyStruct(..) | TyProjection(..) | TyParam(..) | + TyInfer(..) | TyError => None + }.unwrap_or_else(|| self.impls_bound(param_env, ty::BoundSized, span)); - result -} + if !self.has_param_types() && !self.has_self_ty() { + self.flags.set(self.flags.get() | if result { + TypeFlags::SIZEDNESS_CACHED | TypeFlags::IS_SIZED + } else { + TypeFlags::SIZEDNESS_CACHED + }); + } -pub fn is_ffi_safe<'tcx>(cx: &ctxt<'tcx>, ty: Ty<'tcx>) -> bool { - !type_contents(cx, ty).intersects(TC::ReachesFfiUnsafe) -} + result + } -// True if instantiating an instance of `r_ty` requires an instance of `r_ty`. -pub fn is_instantiable<'tcx>(cx: &ctxt<'tcx>, r_ty: Ty<'tcx>) -> bool { - fn type_requires<'tcx>(cx: &ctxt<'tcx>, seen: &mut Vec, - r_ty: Ty<'tcx>, ty: Ty<'tcx>) -> bool { - debug!("type_requires({:?}, {:?})?", - r_ty, ty); + pub fn is_ffi_safe(&'tcx self, cx: &ctxt<'tcx>) -> bool { + !self.type_contents(cx).intersects(TC::ReachesFfiUnsafe) + } - let r = r_ty == ty || subtypes_require(cx, seen, r_ty, ty); + // True if instantiating an instance of `r_ty` requires an instance of `r_ty`. + pub fn is_instantiable(&'tcx self, cx: &ctxt<'tcx>) -> bool { + fn type_requires<'tcx>(cx: &ctxt<'tcx>, seen: &mut Vec, + r_ty: Ty<'tcx>, ty: Ty<'tcx>) -> bool { + debug!("type_requires({:?}, {:?})?", + r_ty, ty); - debug!("type_requires({:?}, {:?})? {:?}", - r_ty, ty, r); - return r; - } + let r = r_ty == ty || subtypes_require(cx, seen, r_ty, ty); - fn subtypes_require<'tcx>(cx: &ctxt<'tcx>, seen: &mut Vec, - r_ty: Ty<'tcx>, ty: Ty<'tcx>) -> bool { - debug!("subtypes_require({:?}, {:?})?", - r_ty, ty); + debug!("type_requires({:?}, {:?})? {:?}", + r_ty, ty, r); + return r; + } - let r = match ty.sty { - // fixed length vectors need special treatment compared to - // normal vectors, since they don't necessarily have the - // possibility to have length zero. - TyArray(_, 0) => false, // don't need no contents - TyArray(ty, _) => type_requires(cx, seen, r_ty, ty), + fn subtypes_require<'tcx>(cx: &ctxt<'tcx>, seen: &mut Vec, + r_ty: Ty<'tcx>, ty: Ty<'tcx>) -> bool { + debug!("subtypes_require({:?}, {:?})?", + r_ty, ty); - TyBool | - TyChar | - TyInt(_) | - TyUint(_) | - TyFloat(_) | - TyStr | - TyBareFn(..) | - TyParam(_) | - TyProjection(_) | - TySlice(_) => { - false - } - TyBox(typ) => { - type_requires(cx, seen, r_ty, typ) - } - TyRef(_, ref mt) => { - type_requires(cx, seen, r_ty, mt.ty) - } + let r = match ty.sty { + // fixed length vectors need special treatment compared to + // normal vectors, since they don't necessarily have the + // possibility to have length zero. + TyArray(_, 0) => false, // don't need no contents + TyArray(ty, _) => type_requires(cx, seen, r_ty, ty), - TyRawPtr(..) => { - false // unsafe ptrs can always be NULL - } + TyBool | + TyChar | + TyInt(_) | + TyUint(_) | + TyFloat(_) | + TyStr | + TyBareFn(..) | + TyParam(_) | + TyProjection(_) | + TySlice(_) => { + false + } + TyBox(typ) => { + type_requires(cx, seen, r_ty, typ) + } + TyRef(_, ref mt) => { + type_requires(cx, seen, r_ty, mt.ty) + } - TyTrait(..) => { - false - } + TyRawPtr(..) => { + false // unsafe ptrs can always be NULL + } - TyStruct(ref did, _) if seen.contains(did) => { - false - } + TyTrait(..) => { + false + } - TyStruct(did, substs) => { - seen.push(did); - let fields = struct_fields(cx, did, substs); - let r = fields.iter().any(|f| type_requires(cx, seen, r_ty, f.mt.ty)); - seen.pop().unwrap(); - r - } + TyStruct(ref did, _) if seen.contains(did) => { + false + } - TyError | - TyInfer(_) | - TyClosure(..) => { - // this check is run on type definitions, so we don't expect to see - // inference by-products or closure types - cx.sess.bug(&format!("requires check invoked on inapplicable type: {:?}", ty)) - } + TyStruct(did, substs) => { + seen.push(did); + let fields = cx.struct_fields(did, substs); + let r = fields.iter().any(|f| type_requires(cx, seen, r_ty, f.mt.ty)); + seen.pop().unwrap(); + r + } - TyTuple(ref ts) => { - ts.iter().any(|ty| type_requires(cx, seen, r_ty, *ty)) - } + TyError | + TyInfer(_) | + TyClosure(..) => { + // this check is run on type definitions, so we don't expect to see + // inference by-products or closure types + cx.sess.bug(&format!("requires check invoked on inapplicable type: {:?}", ty)) + } - TyEnum(ref did, _) if seen.contains(did) => { - false - } + TyTuple(ref ts) => { + ts.iter().any(|ty| type_requires(cx, seen, r_ty, *ty)) + } - TyEnum(did, substs) => { - seen.push(did); - let vs = enum_variants(cx, did); - let r = !vs.is_empty() && vs.iter().all(|variant| { - variant.args.iter().any(|aty| { - let sty = aty.subst(cx, substs); - type_requires(cx, seen, r_ty, sty) - }) - }); - seen.pop().unwrap(); - r - } - }; + TyEnum(ref did, _) if seen.contains(did) => { + false + } + + TyEnum(did, substs) => { + seen.push(did); + let vs = cx.enum_variants(did); + let r = !vs.is_empty() && vs.iter().all(|variant| { + variant.args.iter().any(|aty| { + let sty = aty.subst(cx, substs); + type_requires(cx, seen, r_ty, sty) + }) + }); + seen.pop().unwrap(); + r + } + }; - debug!("subtypes_require({:?}, {:?})? {:?}", - r_ty, ty, r); + debug!("subtypes_require({:?}, {:?})? {:?}", + r_ty, ty, r); - return r; - } + return r; + } - let mut seen = Vec::new(); - !subtypes_require(cx, &mut seen, r_ty, r_ty) + let mut seen = Vec::new(); + !subtypes_require(cx, &mut seen, self, self) + } } /// Describes whether a type is representable. For types that are not @@ -4331,161 +4578,161 @@ pub enum Representability { SelfRecursive, } -/// Check whether a type is representable. This means it cannot contain unboxed -/// structural recursion. This check is needed for structs and enums. -pub fn is_type_representable<'tcx>(cx: &ctxt<'tcx>, sp: Span, ty: Ty<'tcx>) - -> Representability { - - // Iterate until something non-representable is found - fn find_nonrepresentable<'tcx, It: Iterator>>(cx: &ctxt<'tcx>, sp: Span, - seen: &mut Vec>, - iter: It) - -> Representability { - iter.fold(Representable, - |r, ty| cmp::max(r, is_type_structurally_recursive(cx, sp, seen, ty))) - } - - fn are_inner_types_recursive<'tcx>(cx: &ctxt<'tcx>, sp: Span, - seen: &mut Vec>, ty: Ty<'tcx>) - -> Representability { - match ty.sty { - TyTuple(ref ts) => { - find_nonrepresentable(cx, sp, seen, ts.iter().cloned()) - } - // Fixed-length vectors. - // FIXME(#11924) Behavior undecided for zero-length vectors. - TyArray(ty, _) => { - is_type_structurally_recursive(cx, sp, seen, ty) - } - TyStruct(did, substs) => { - let fields = struct_fields(cx, did, substs); - find_nonrepresentable(cx, sp, seen, fields.iter().map(|f| f.mt.ty)) - } - TyEnum(did, substs) => { - let vs = enum_variants(cx, did); - let iter = vs.iter() - .flat_map(|variant| &variant.args) - .map(|aty| { aty.subst_spanned(cx, substs, Some(sp)) }); +impl<'tcx> TyS<'tcx> { + /// Check whether a type is representable. This means it cannot contain unboxed + /// structural recursion. This check is needed for structs and enums. + pub fn is_representable(&'tcx self, cx: &ctxt<'tcx>, sp: Span) -> Representability { + + // Iterate until something non-representable is found + fn find_nonrepresentable<'tcx, It: Iterator>>(cx: &ctxt<'tcx>, sp: Span, + seen: &mut Vec>, + iter: It) + -> Representability { + iter.fold(Representable, + |r, ty| cmp::max(r, is_type_structurally_recursive(cx, sp, seen, ty))) + } + + fn are_inner_types_recursive<'tcx>(cx: &ctxt<'tcx>, sp: Span, + seen: &mut Vec>, ty: Ty<'tcx>) + -> Representability { + match ty.sty { + TyTuple(ref ts) => { + find_nonrepresentable(cx, sp, seen, ts.iter().cloned()) + } + // Fixed-length vectors. + // FIXME(#11924) Behavior undecided for zero-length vectors. + TyArray(ty, _) => { + is_type_structurally_recursive(cx, sp, seen, ty) + } + TyStruct(did, substs) => { + let fields = cx.struct_fields(did, substs); + find_nonrepresentable(cx, sp, seen, fields.iter().map(|f| f.mt.ty)) + } + TyEnum(did, substs) => { + let vs = cx.enum_variants(did); + let iter = vs.iter() + .flat_map(|variant| &variant.args) + .map(|aty| { aty.subst_spanned(cx, substs, Some(sp)) }); - find_nonrepresentable(cx, sp, seen, iter) - } - TyClosure(..) => { - // this check is run on type definitions, so we don't expect - // to see closure types - cx.sess.bug(&format!("requires check invoked on inapplicable type: {:?}", ty)) + find_nonrepresentable(cx, sp, seen, iter) + } + TyClosure(..) => { + // this check is run on type definitions, so we don't expect + // to see closure types + cx.sess.bug(&format!("requires check invoked on inapplicable type: {:?}", ty)) + } + _ => Representable, } - _ => Representable, } - } - fn same_struct_or_enum_def_id(ty: Ty, did: DefId) -> bool { - match ty.sty { - TyStruct(ty_did, _) | TyEnum(ty_did, _) => { - ty_did == did + fn same_struct_or_enum_def_id(ty: Ty, did: DefId) -> bool { + match ty.sty { + TyStruct(ty_did, _) | TyEnum(ty_did, _) => { + ty_did == did + } + _ => false } - _ => false } - } - fn same_type<'tcx>(a: Ty<'tcx>, b: Ty<'tcx>) -> bool { - match (&a.sty, &b.sty) { - (&TyStruct(did_a, ref substs_a), &TyStruct(did_b, ref substs_b)) | - (&TyEnum(did_a, ref substs_a), &TyEnum(did_b, ref substs_b)) => { - if did_a != did_b { - return false; - } + fn same_type<'tcx>(a: Ty<'tcx>, b: Ty<'tcx>) -> bool { + match (&a.sty, &b.sty) { + (&TyStruct(did_a, ref substs_a), &TyStruct(did_b, ref substs_b)) | + (&TyEnum(did_a, ref substs_a), &TyEnum(did_b, ref substs_b)) => { + if did_a != did_b { + return false; + } - let types_a = substs_a.types.get_slice(subst::TypeSpace); - let types_b = substs_b.types.get_slice(subst::TypeSpace); + let types_a = substs_a.types.get_slice(subst::TypeSpace); + let types_b = substs_b.types.get_slice(subst::TypeSpace); - let mut pairs = types_a.iter().zip(types_b); + let mut pairs = types_a.iter().zip(types_b); - pairs.all(|(&a, &b)| same_type(a, b)) - } - _ => { - a == b + pairs.all(|(&a, &b)| same_type(a, b)) + } + _ => { + a == b + } } } - } - // Does the type `ty` directly (without indirection through a pointer) - // contain any types on stack `seen`? - fn is_type_structurally_recursive<'tcx>(cx: &ctxt<'tcx>, sp: Span, - seen: &mut Vec>, - ty: Ty<'tcx>) -> Representability { - debug!("is_type_structurally_recursive: {:?}", ty); + // Does the type `ty` directly (without indirection through a pointer) + // contain any types on stack `seen`? + fn is_type_structurally_recursive<'tcx>(cx: &ctxt<'tcx>, sp: Span, + seen: &mut Vec>, + ty: Ty<'tcx>) -> Representability { + debug!("is_type_structurally_recursive: {:?}", ty); - match ty.sty { - TyStruct(did, _) | TyEnum(did, _) => { - { - // Iterate through stack of previously seen types. - let mut iter = seen.iter(); - - // The first item in `seen` is the type we are actually curious about. - // We want to return SelfRecursive if this type contains itself. - // It is important that we DON'T take generic parameters into account - // for this check, so that Bar in this example counts as SelfRecursive: - // - // struct Foo; - // struct Bar { x: Bar } + match ty.sty { + TyStruct(did, _) | TyEnum(did, _) => { + { + // Iterate through stack of previously seen types. + let mut iter = seen.iter(); + + // The first item in `seen` is the type we are actually curious about. + // We want to return SelfRecursive if this type contains itself. + // It is important that we DON'T take generic parameters into account + // for this check, so that Bar in this example counts as SelfRecursive: + // + // struct Foo; + // struct Bar { x: Bar } + + match iter.next() { + Some(&seen_type) => { + if same_struct_or_enum_def_id(seen_type, did) { + debug!("SelfRecursive: {:?} contains {:?}", + seen_type, + ty); + return SelfRecursive; + } + } + None => {} + } - match iter.next() { - Some(&seen_type) => { - if same_struct_or_enum_def_id(seen_type, did) { - debug!("SelfRecursive: {:?} contains {:?}", + // We also need to know whether the first item contains other types + // that are structurally recursive. If we don't catch this case, we + // will recurse infinitely for some inputs. + // + // It is important that we DO take generic parameters into account + // here, so that code like this is considered SelfRecursive, not + // ContainsRecursive: + // + // struct Foo { Option> } + + for &seen_type in iter { + if same_type(ty, seen_type) { + debug!("ContainsRecursive: {:?} contains {:?}", seen_type, ty); - return SelfRecursive; + return ContainsRecursive; } } - None => {} } - // We also need to know whether the first item contains other types that - // are structurally recursive. If we don't catch this case, we will recurse - // infinitely for some inputs. - // - // It is important that we DO take generic parameters into account here, - // so that code like this is considered SelfRecursive, not ContainsRecursive: - // - // struct Foo { Option> } - - for &seen_type in iter { - if same_type(ty, seen_type) { - debug!("ContainsRecursive: {:?} contains {:?}", - seen_type, - ty); - return ContainsRecursive; - } - } + // For structs and enums, track all previously seen types by pushing them + // onto the 'seen' stack. + seen.push(ty); + let out = are_inner_types_recursive(cx, sp, seen, ty); + seen.pop(); + out + } + _ => { + // No need to push in other cases. + are_inner_types_recursive(cx, sp, seen, ty) } - - // For structs and enums, track all previously seen types by pushing them - // onto the 'seen' stack. - seen.push(ty); - let out = are_inner_types_recursive(cx, sp, seen, ty); - seen.pop(); - out - } - _ => { - // No need to push in other cases. - are_inner_types_recursive(cx, sp, seen, ty) } } - } - debug!("is_type_representable: {:?}", ty); + debug!("is_type_representable: {:?}", self); - // To avoid a stack overflow when checking an enum variant or struct that - // contains a different, structurally recursive type, maintain a stack - // of seen types and check recursion for each of them (issues #3008, #3779). - let mut seen: Vec = Vec::new(); - let r = is_type_structurally_recursive(cx, sp, &mut seen, ty); - debug!("is_type_representable: {:?} is {:?}", ty, r); - r -} + // To avoid a stack overflow when checking an enum variant or struct that + // contains a different, structurally recursive type, maintain a stack + // of seen types and check recursion for each of them (issues #3008, #3779). + let mut seen: Vec = Vec::new(); + let r = is_type_structurally_recursive(cx, sp, &mut seen, self); + debug!("is_type_representable: {:?} is {:?}", self, r); + r + } -impl<'tcx> TyS<'tcx> { pub fn is_trait(&self) -> bool { match self.sty { TyTrait(..) => true, @@ -4568,7 +4815,7 @@ impl<'tcx> TyS<'tcx> { pub fn is_c_like_enum(&self, cx: &ctxt) -> bool { match self.sty { TyEnum(did, _) => { - let variants = enum_variants(cx, did); + let variants = cx.enum_variants(did); if variants.is_empty() { false } else { @@ -4604,88 +4851,7 @@ impl<'tcx> TyS<'tcx> { _ => None } } -} - -/// Returns the type of element at index `i` in tuple or tuple-like type `t`. -/// For an enum `t`, `variant` is None only if `t` is a univariant enum. -pub fn positional_element_ty<'tcx>(cx: &ctxt<'tcx>, - ty: Ty<'tcx>, - i: usize, - variant: Option) -> Option> { - - match (&ty.sty, variant) { - (&TyTuple(ref v), None) => v.get(i).cloned(), - - - (&TyStruct(def_id, substs), None) => lookup_struct_fields(cx, def_id) - .get(i) - .map(|&t|lookup_item_type(cx, t.id).ty.subst(cx, substs)), - - (&TyEnum(def_id, substs), Some(variant_def_id)) => { - let variant_info = enum_variant_with_id(cx, def_id, variant_def_id); - variant_info.args.get(i).map(|t|t.subst(cx, substs)) - } - - (&TyEnum(def_id, substs), None) => { - assert!(enum_is_univariant(cx, def_id)); - let enum_variants = enum_variants(cx, def_id); - let variant_info = &(*enum_variants)[0]; - variant_info.args.get(i).map(|t|t.subst(cx, substs)) - } - - _ => None - } -} - -/// Returns the type of element at field `n` in struct or struct-like type `t`. -/// For an enum `t`, `variant` must be some def id. -pub fn named_element_ty<'tcx>(cx: &ctxt<'tcx>, - ty: Ty<'tcx>, - n: ast::Name, - variant: Option) -> Option> { - - match (&ty.sty, variant) { - (&TyStruct(def_id, substs), None) => { - let r = lookup_struct_fields(cx, def_id); - r.iter().find(|f| f.name == n) - .map(|&f| lookup_field_type(cx, def_id, f.id, substs)) - } - (&TyEnum(def_id, substs), Some(variant_def_id)) => { - let variant_info = enum_variant_with_id(cx, def_id, variant_def_id); - variant_info.arg_names.as_ref() - .expect("must have struct enum variant if accessing a named fields") - .iter().zip(&variant_info.args) - .find(|&(&name, _)| name == n) - .map(|(_name, arg_t)| arg_t.subst(cx, substs)) - } - _ => None - } -} - -pub fn node_id_to_type<'tcx>(cx: &ctxt<'tcx>, id: ast::NodeId) -> Ty<'tcx> { - match node_id_to_type_opt(cx, id) { - Some(ty) => ty, - None => cx.sess.bug( - &format!("node_id_to_type: no type for node `{}`", - cx.map.node_to_string(id))) - } -} - -pub fn node_id_to_type_opt<'tcx>(cx: &ctxt<'tcx>, id: ast::NodeId) -> Option> { - match cx.node_types.borrow().get(&id) { - Some(&ty) => Some(ty), - None => None - } -} - -pub fn node_id_item_substs<'tcx>(cx: &ctxt<'tcx>, id: ast::NodeId) -> ItemSubsts<'tcx> { - match cx.item_substs.borrow().get(&id) { - None => ItemSubsts::empty(), - Some(ts) => ts.clone(), - } -} -impl<'tcx> TyS<'tcx> { pub fn fn_sig(&self) -> &'tcx PolyFnSig<'tcx> { match self.sty { TyBareFn(_, ref f) => &f.sig, @@ -4716,339 +4882,144 @@ impl<'tcx> TyS<'tcx> { _ => false } } -} - -pub fn ty_region(tcx: &ctxt, - span: Span, - ty: Ty) -> Region { - match ty.sty { - TyRef(r, _) => *r, - ref s => { - tcx.sess.span_bug( - span, - &format!("ty_region() invoked on an inappropriate ty: {:?}", - s)); - } - } -} - -// Returns the type of a pattern as a monotype. Like @expr_ty, this function -// doesn't provide type parameter substitutions. -pub fn pat_ty<'tcx>(cx: &ctxt<'tcx>, pat: &ast::Pat) -> Ty<'tcx> { - return node_id_to_type(cx, pat.id); -} -pub fn pat_ty_opt<'tcx>(cx: &ctxt<'tcx>, pat: &ast::Pat) -> Option> { - return node_id_to_type_opt(cx, pat.id); -} - - -// Returns the type of an expression as a monotype. -// -// NB (1): This is the PRE-ADJUSTMENT TYPE for the expression. That is, in -// some cases, we insert `AutoAdjustment` annotations such as auto-deref or -// auto-ref. The type returned by this function does not consider such -// adjustments. See `expr_ty_adjusted()` instead. -// -// NB (2): This type doesn't provide type parameter substitutions; e.g. if you -// ask for the type of "id" in "id(3)", it will return "fn(&isize) -> isize" -// instead of "fn(ty) -> T with T = isize". -pub fn expr_ty<'tcx>(cx: &ctxt<'tcx>, expr: &ast::Expr) -> Ty<'tcx> { - return node_id_to_type(cx, expr.id); -} - -pub fn expr_ty_opt<'tcx>(cx: &ctxt<'tcx>, expr: &ast::Expr) -> Option> { - return node_id_to_type_opt(cx, expr.id); -} - -/// Returns the type of `expr`, considering any `AutoAdjustment` -/// entry recorded for that expression. -/// -/// It would almost certainly be better to store the adjusted ty in with -/// the `AutoAdjustment`, but I opted not to do this because it would -/// require serializing and deserializing the type and, although that's not -/// hard to do, I just hate that code so much I didn't want to touch it -/// unless it was to fix it properly, which seemed a distraction from the -/// thread at hand! -nmatsakis -pub fn expr_ty_adjusted<'tcx>(cx: &ctxt<'tcx>, expr: &ast::Expr) -> Ty<'tcx> { - adjust_ty(cx, expr.span, expr.id, expr_ty(cx, expr), - cx.adjustments.borrow().get(&expr.id), - |method_call| cx.method_map.borrow().get(&method_call).map(|method| method.ty)) -} - -pub fn expr_span(cx: &ctxt, id: NodeId) -> Span { - match cx.map.find(id) { - Some(ast_map::NodeExpr(e)) => { - e.span - } - Some(f) => { - cx.sess.bug(&format!("Node id {} is not an expr: {:?}", - id, - f)); - } - None => { - cx.sess.bug(&format!("Node id {} is not present \ - in the node map", id)); - } - } -} -pub fn local_var_name_str(cx: &ctxt, id: NodeId) -> InternedString { - match cx.map.find(id) { - Some(ast_map::NodeLocal(pat)) => { - match pat.node { - ast::PatIdent(_, ref path1, _) => { - token::get_ident(path1.node) - } - _ => { - cx.sess.bug( - &format!("Variable id {} maps to {:?}, not local", - id, - pat)); - } - } - } - r => { - cx.sess.bug(&format!("Variable id {} maps to {:?}, not local", - id, - r)); + /// See `expr_ty_adjusted` + pub fn adjust(&'tcx self, cx: &ctxt<'tcx>, + span: Span, + expr_id: ast::NodeId, + adjustment: Option<&AutoAdjustment<'tcx>>, + mut method_type: F) + -> Ty<'tcx> where + F: FnMut(MethodCall) -> Option>, + { + if let TyError = self.sty { + return self; } - } -} - -/// See `expr_ty_adjusted` -pub fn adjust_ty<'tcx, F>(cx: &ctxt<'tcx>, - span: Span, - expr_id: ast::NodeId, - unadjusted_ty: Ty<'tcx>, - adjustment: Option<&AutoAdjustment<'tcx>>, - mut method_type: F) - -> Ty<'tcx> where - F: FnMut(MethodCall) -> Option>, -{ - if let TyError = unadjusted_ty.sty { - return unadjusted_ty; - } - return match adjustment { - Some(adjustment) => { - match *adjustment { - AdjustReifyFnPointer => { - match unadjusted_ty.sty { - ty::TyBareFn(Some(_), b) => { - cx.mk_fn(None, b) - } - _ => { - cx.sess.bug( - &format!("AdjustReifyFnPointer adjustment on non-fn-item: \ - {:?}", unadjusted_ty)); + return match adjustment { + Some(adjustment) => { + match *adjustment { + AdjustReifyFnPointer => { + match self.sty { + ty::TyBareFn(Some(_), b) => { + cx.mk_fn(None, b) + } + _ => { + cx.sess.bug( + &format!("AdjustReifyFnPointer adjustment on non-fn-item: \ + {:?}", self)); + } } } - } - AdjustUnsafeFnPointer => { - match unadjusted_ty.sty { - ty::TyBareFn(None, b) => cx.safe_to_unsafe_fn_ty(b), - ref b => { - cx.sess.bug( - &format!("AdjustReifyFnPointer adjustment on non-fn-item: \ - {:?}", - b)); + AdjustUnsafeFnPointer => { + match self.sty { + ty::TyBareFn(None, b) => cx.safe_to_unsafe_fn_ty(b), + ref b => { + cx.sess.bug( + &format!("AdjustReifyFnPointer adjustment on non-fn-item: \ + {:?}", + b)); + } } - } - } - - AdjustDerefRef(ref adj) => { - let mut adjusted_ty = unadjusted_ty; - - if !adjusted_ty.references_error() { - for i in 0..adj.autoderefs { - let method_call = MethodCall::autoderef(expr_id, i as u32); - match method_type(method_call) { - Some(method_ty) => { - // Overloaded deref operators have all late-bound - // regions fully instantiated and coverge. - let fn_ret = - ty::no_late_bound_regions(cx, - &method_ty.fn_ret()).unwrap(); - adjusted_ty = fn_ret.unwrap(); + } + + AdjustDerefRef(ref adj) => { + let mut adjusted_ty = self; + + if !adjusted_ty.references_error() { + for i in 0..adj.autoderefs { + let method_call = MethodCall::autoderef(expr_id, i as u32); + match method_type(method_call) { + Some(method_ty) => { + // Overloaded deref operators have all late-bound + // regions fully instantiated and coverge. + let fn_ret = + cx.no_late_bound_regions(&method_ty.fn_ret()).unwrap(); + adjusted_ty = fn_ret.unwrap(); + } + None => {} } - None => {} - } - match adjusted_ty.builtin_deref(true) { - Some(mt) => { adjusted_ty = mt.ty; } - None => { - cx.sess.span_bug( - span, - &format!("the {}th autoderef failed: {}", - i, - adjusted_ty) - ); + match adjusted_ty.builtin_deref(true) { + Some(mt) => { adjusted_ty = mt.ty; } + None => { + cx.sess.span_bug( + span, + &format!("the {}th autoderef failed: {}", + i, + adjusted_ty) + ); + } } } } - } - if let Some(target) = adj.unsize { - target - } else { - adjust_ty_for_autoref(cx, adjusted_ty, adj.autoref) + if let Some(target) = adj.unsize { + target + } else { + adjusted_ty.adjust_for_autoref(cx, adj.autoref) + } } } } - } - None => unadjusted_ty - }; -} - -pub fn adjust_ty_for_autoref<'tcx>(cx: &ctxt<'tcx>, - ty: Ty<'tcx>, - autoref: Option>) - -> Ty<'tcx> { - match autoref { - None => ty, - Some(AutoPtr(r, m)) => { - cx.mk_ref(r, mt { ty: ty, mutbl: m }) - } - Some(AutoUnsafe(m)) => { - cx.mk_ptr(mt { ty: ty, mutbl: m }) - } + None => self + }; } -} -pub fn resolve_expr(tcx: &ctxt, expr: &ast::Expr) -> def::Def { - match tcx.def_map.borrow().get(&expr.id) { - Some(def) => def.full_def(), - None => { - tcx.sess.span_bug(expr.span, &format!( - "no def-map entry for expr {}", expr.id)); + pub fn adjust_for_autoref(&'tcx self, cx: &ctxt<'tcx>, + autoref: Option>) + -> Ty<'tcx> { + match autoref { + None => self, + Some(AutoPtr(r, m)) => { + cx.mk_ref(r, mt { ty: self, mutbl: m }) + } + Some(AutoUnsafe(m)) => { + cx.mk_ptr(mt { ty: self, mutbl: m }) + } } } -} -pub fn expr_is_lval(tcx: &ctxt, expr: &ast::Expr) -> bool { - match expr.node { - ast::ExprPath(..) => { - // We can't use resolve_expr here, as this needs to run on broken - // programs. We don't need to through - associated items are all - // rvalues. - match tcx.def_map.borrow().get(&expr.id) { - Some(&def::PathResolution { - base_def: def::DefStatic(..), .. - }) | Some(&def::PathResolution { - base_def: def::DefUpvar(..), .. - }) | Some(&def::PathResolution { - base_def: def::DefLocal(..), .. - }) => { - true + fn sort_string(&self, cx: &ctxt) -> String { + match self.sty { + TyBool | TyChar | TyInt(_) | + TyUint(_) | TyFloat(_) | TyStr => self.to_string(), + TyTuple(ref tys) if tys.is_empty() => self.to_string(), + + TyEnum(id, _) => format!("enum `{}`", cx.item_path_str(id)), + TyBox(_) => "box".to_string(), + TyArray(_, n) => format!("array of {} elements", n), + TySlice(_) => "slice".to_string(), + TyRawPtr(_) => "*-ptr".to_string(), + TyRef(_, _) => "&-ptr".to_string(), + TyBareFn(Some(_), _) => format!("fn item"), + TyBareFn(None, _) => "fn pointer".to_string(), + TyTrait(ref inner) => { + format!("trait {}", cx.item_path_str(inner.principal_def_id())) + } + TyStruct(id, _) => { + format!("struct `{}`", cx.item_path_str(id)) + } + TyClosure(..) => "closure".to_string(), + TyTuple(_) => "tuple".to_string(), + TyInfer(TyVar(_)) => "inferred type".to_string(), + TyInfer(IntVar(_)) => "integral variable".to_string(), + TyInfer(FloatVar(_)) => "floating-point variable".to_string(), + TyInfer(FreshTy(_)) => "skolemized type".to_string(), + TyInfer(FreshIntTy(_)) => "skolemized integral type".to_string(), + TyInfer(FreshFloatTy(_)) => "skolemized floating-point type".to_string(), + TyProjection(_) => "associated type".to_string(), + TyParam(ref p) => { + if p.space == subst::SelfSpace { + "Self".to_string() + } else { + "type parameter".to_string() } - - Some(..) => false, - - None => tcx.sess.span_bug(expr.span, &format!( - "no def for path {}", expr.id)) - } - } - - ast::ExprUnary(ast::UnDeref, _) | - ast::ExprField(..) | - ast::ExprTupField(..) | - ast::ExprIndex(..) => { - true - } - - ast::ExprCall(..) | - ast::ExprMethodCall(..) | - ast::ExprStruct(..) | - ast::ExprRange(..) | - ast::ExprTup(..) | - ast::ExprIf(..) | - ast::ExprMatch(..) | - ast::ExprClosure(..) | - ast::ExprBlock(..) | - ast::ExprRepeat(..) | - ast::ExprVec(..) | - ast::ExprBreak(..) | - ast::ExprAgain(..) | - ast::ExprRet(..) | - ast::ExprWhile(..) | - ast::ExprLoop(..) | - ast::ExprAssign(..) | - ast::ExprInlineAsm(..) | - ast::ExprAssignOp(..) | - ast::ExprLit(_) | - ast::ExprUnary(..) | - ast::ExprBox(..) | - ast::ExprAddrOf(..) | - ast::ExprBinary(..) | - ast::ExprCast(..) => { - false - } - - ast::ExprParen(ref e) => expr_is_lval(tcx, e), - - ast::ExprIfLet(..) | - ast::ExprWhileLet(..) | - ast::ExprForLoop(..) | - ast::ExprMac(..) => { - tcx.sess.span_bug( - expr.span, - "macro expression remains after expansion"); - } - } -} - -pub fn field_idx_strict(tcx: &ctxt, name: ast::Name, fields: &[field]) - -> usize { - let mut i = 0; - for f in fields { if f.name == name { return i; } i += 1; } - tcx.sess.bug(&format!( - "no field named `{}` found in the list of fields `{:?}`", - token::get_name(name), - fields.iter() - .map(|f| token::get_name(f.name).to_string()) - .collect::>())); -} - -pub fn ty_sort_string(cx: &ctxt, ty: Ty) -> String { - match ty.sty { - TyBool | TyChar | TyInt(_) | - TyUint(_) | TyFloat(_) | TyStr => ty.to_string(), - TyTuple(ref tys) if tys.is_empty() => ty.to_string(), - - TyEnum(id, _) => format!("enum `{}`", item_path_str(cx, id)), - TyBox(_) => "box".to_string(), - TyArray(_, n) => format!("array of {} elements", n), - TySlice(_) => "slice".to_string(), - TyRawPtr(_) => "*-ptr".to_string(), - TyRef(_, _) => "&-ptr".to_string(), - TyBareFn(Some(_), _) => format!("fn item"), - TyBareFn(None, _) => "fn pointer".to_string(), - TyTrait(ref inner) => { - format!("trait {}", item_path_str(cx, inner.principal_def_id())) - } - TyStruct(id, _) => { - format!("struct `{}`", item_path_str(cx, id)) - } - TyClosure(..) => "closure".to_string(), - TyTuple(_) => "tuple".to_string(), - TyInfer(TyVar(_)) => "inferred type".to_string(), - TyInfer(IntVar(_)) => "integral variable".to_string(), - TyInfer(FloatVar(_)) => "floating-point variable".to_string(), - TyInfer(FreshTy(_)) => "skolemized type".to_string(), - TyInfer(FreshIntTy(_)) => "skolemized integral type".to_string(), - TyInfer(FreshFloatTy(_)) => "skolemized floating-point type".to_string(), - TyProjection(_) => "associated type".to_string(), - TyParam(ref p) => { - if p.space == subst::SelfSpace { - "Self".to_string() - } else { - "type parameter".to_string() } + TyError => "type error".to_string(), } - TyError => "type error".to_string(), } } - /// Explains the source of a type err in a short, human readable way. This is meant to be placed /// in parentheses after some larger message. You should also invoke `note_and_explain_type_err()` /// afterwards to present additional details, particularly when it comes to lifetime-related @@ -5116,8 +5087,8 @@ impl<'tcx> fmt::Display for type_err<'tcx> { terr_sorts(values) => tls::with(|tcx| { // A naive approach to making sure that we're not reporting silly errors such as: // (expected closure, found closure). - let expected_str = ty_sort_string(tcx, values.expected); - let found_str = ty_sort_string(tcx, values.found); + let expected_str = values.expected.sort_string(tcx); + let found_str = values.found.sort_string(tcx); if expected_str == found_str { write!(f, "expected {}, found a different {}", expected_str, found_str) } else { @@ -5126,8 +5097,8 @@ impl<'tcx> fmt::Display for type_err<'tcx> { }), terr_traits(values) => tls::with(|tcx| { write!(f, "expected trait `{}`, found trait `{}`", - item_path_str(tcx, values.expected), - item_path_str(tcx, values.found)) + tcx.item_path_str(values.expected), + tcx.item_path_str(values.found)) }), terr_builtin_bounds(values) => { if values.expected.is_empty() { @@ -5179,127 +5150,6 @@ impl<'tcx> fmt::Display for type_err<'tcx> { } } -pub fn note_and_explain_type_err<'tcx>(cx: &ctxt<'tcx>, err: &type_err<'tcx>, sp: Span) { - match *err { - terr_regions_does_not_outlive(subregion, superregion) => { - note_and_explain_region(cx, "", subregion, "..."); - note_and_explain_region(cx, "...does not necessarily outlive ", - superregion, ""); - } - terr_regions_not_same(region1, region2) => { - note_and_explain_region(cx, "", region1, "..."); - note_and_explain_region(cx, "...is not the same lifetime as ", - region2, ""); - } - terr_regions_no_overlap(region1, region2) => { - note_and_explain_region(cx, "", region1, "..."); - note_and_explain_region(cx, "...does not overlap ", - region2, ""); - } - terr_regions_insufficiently_polymorphic(_, conc_region) => { - note_and_explain_region(cx, - "concrete lifetime that was found is ", - conc_region, ""); - } - terr_regions_overly_polymorphic(_, ty::ReInfer(ty::ReVar(_))) => { - // don't bother to print out the message below for - // inference variables, it's not very illuminating. - } - terr_regions_overly_polymorphic(_, conc_region) => { - note_and_explain_region(cx, - "expected concrete lifetime is ", - conc_region, ""); - } - terr_sorts(values) => { - let expected_str = ty_sort_string(cx, values.expected); - let found_str = ty_sort_string(cx, values.found); - if expected_str == found_str && expected_str == "closure" { - cx.sess.span_note(sp, &format!("no two closures, even if identical, have the same \ - type")); - cx.sess.span_help(sp, &format!("consider boxing your closure and/or \ - using it as a trait object")); - } - } - _ => {} - } -} - -pub fn provided_source(cx: &ctxt, id: ast::DefId) -> Option { - cx.provided_method_sources.borrow().get(&id).cloned() -} - -pub fn provided_trait_methods<'tcx>(cx: &ctxt<'tcx>, id: ast::DefId) - -> Vec>> { - if is_local(id) { - if let ItemTrait(_, _, _, ref ms) = cx.map.expect_item(id.node).node { - ms.iter().filter_map(|ti| { - if let ast::MethodTraitItem(_, Some(_)) = ti.node { - match impl_or_trait_item(cx, ast_util::local_def(ti.id)) { - MethodTraitItem(m) => Some(m), - _ => { - cx.sess.bug("provided_trait_methods(): \ - non-method item found from \ - looking up provided method?!") - } - } - } else { - None - } - }).collect() - } else { - cx.sess.bug(&format!("provided_trait_methods: `{:?}` is not a trait", id)) - } - } else { - csearch::get_provided_trait_methods(cx, id) - } -} - -pub fn associated_consts<'tcx>(cx: &ctxt<'tcx>, id: ast::DefId) - -> Vec>> { - if is_local(id) { - match cx.map.expect_item(id.node).node { - ItemTrait(_, _, _, ref tis) => { - tis.iter().filter_map(|ti| { - if let ast::ConstTraitItem(_, _) = ti.node { - match impl_or_trait_item(cx, ast_util::local_def(ti.id)) { - ConstTraitItem(ac) => Some(ac), - _ => { - cx.sess.bug("associated_consts(): \ - non-const item found from \ - looking up a constant?!") - } - } - } else { - None - } - }).collect() - } - ItemImpl(_, _, _, _, _, ref iis) => { - iis.iter().filter_map(|ii| { - if let ast::ConstImplItem(_, _) = ii.node { - match impl_or_trait_item(cx, ast_util::local_def(ii.id)) { - ConstTraitItem(ac) => Some(ac), - _ => { - cx.sess.bug("associated_consts(): \ - non-const item found from \ - looking up a constant?!") - } - } - } else { - None - } - }).collect() - } - _ => { - cx.sess.bug(&format!("associated_consts: `{:?}` is not a trait \ - or impl", id)) - } - } - } else { - csearch::get_associated_consts(cx, id) - } -} - /// Helper for looking things up in the various maps that are populated during /// typeck::collect (e.g., `cx.impl_or_trait_items`, `cx.tcache`, etc). All of /// these share the pattern that if the id is local, it should have been loaded @@ -5326,1448 +5176,1500 @@ fn lookup_locally_or_in_crate_store(descr: &str, v } -pub fn trait_item<'tcx>(cx: &ctxt<'tcx>, trait_did: ast::DefId, idx: usize) - -> ImplOrTraitItem<'tcx> { - let method_def_id = (*ty::trait_item_def_ids(cx, trait_did))[idx].def_id(); - impl_or_trait_item(cx, method_def_id) -} - -pub fn trait_items<'tcx>(cx: &ctxt<'tcx>, trait_did: ast::DefId) - -> Rc>> { - let mut trait_items = cx.trait_items_cache.borrow_mut(); - match trait_items.get(&trait_did).cloned() { - Some(trait_items) => trait_items, - None => { - let def_ids = ty::trait_item_def_ids(cx, trait_did); - let items: Rc> = - Rc::new(def_ids.iter() - .map(|d| impl_or_trait_item(cx, d.def_id())) - .collect()); - trait_items.insert(trait_did, items.clone()); - items - } - } -} - -pub fn trait_impl_polarity<'tcx>(cx: &ctxt<'tcx>, id: ast::DefId) - -> Option { - if id.krate == ast::LOCAL_CRATE { - match cx.map.find(id.node) { - Some(ast_map::NodeItem(item)) => { - match item.node { - ast::ItemImpl(_, polarity, _, _, _, _) => Some(polarity), - _ => None - } - } - _ => None - } - } else { - csearch::get_impl_polarity(cx, id) - } -} - -pub fn custom_coerce_unsized_kind<'tcx>(cx: &ctxt<'tcx>, did: ast::DefId) - -> CustomCoerceUnsized { - memoized(&cx.custom_coerce_unsized_kinds, did, |did: DefId| { - let (kind, src) = if did.krate != ast::LOCAL_CRATE { - (csearch::get_custom_coerce_unsized_kind(cx, did), "external") - } else { - (None, "local") - }; - - match kind { - Some(kind) => kind, - None => { - cx.sess.bug(&format!("custom_coerce_unsized_kind: \ - {} impl `{}` is missing its kind", - src, item_path_str(cx, did))); - } - } - }) -} - -pub fn impl_or_trait_item<'tcx>(cx: &ctxt<'tcx>, id: ast::DefId) - -> ImplOrTraitItem<'tcx> { - lookup_locally_or_in_crate_store( - "impl_or_trait_items", id, &cx.impl_or_trait_items, - || csearch::get_impl_or_trait_item(cx, id)) -} - -/// Returns the parameter index that the given associated type corresponds to. -pub fn associated_type_parameter_index(cx: &ctxt, - trait_def: &TraitDef, - associated_type_id: ast::DefId) - -> usize { - for type_parameter_def in &trait_def.generics.types { - if type_parameter_def.def_id == associated_type_id { - return type_parameter_def.index as usize +impl BorrowKind { + pub fn from_mutbl(m: ast::Mutability) -> BorrowKind { + match m { + ast::MutMutable => MutBorrow, + ast::MutImmutable => ImmBorrow, } } - cx.sess.bug("couldn't find associated type parameter index") -} - -pub fn trait_item_def_ids(cx: &ctxt, id: ast::DefId) - -> Rc> { - lookup_locally_or_in_crate_store( - "trait_item_def_ids", id, &cx.trait_item_def_ids, - || Rc::new(csearch::get_trait_item_def_ids(&cx.sess.cstore, id))) -} -/// Returns the trait-ref corresponding to a given impl, or None if it is -/// an inherent impl. -pub fn impl_trait_ref<'tcx>(cx: &ctxt<'tcx>, id: ast::DefId) - -> Option> -{ - lookup_locally_or_in_crate_store( - "impl_trait_refs", id, &cx.impl_trait_refs, - || csearch::get_impl_trait(cx, id)) -} - -/// Returns whether this DefId refers to an impl -pub fn is_impl<'tcx>(cx: &ctxt<'tcx>, id: ast::DefId) -> bool { - if id.krate == ast::LOCAL_CRATE { - if let Some(ast_map::NodeItem( - &ast::Item { node: ast::ItemImpl(..), .. })) = cx.map.find(id.node) { - true - } else { - false + /// Returns a mutability `m` such that an `&m T` pointer could be used to obtain this borrow + /// kind. Because borrow kinds are richer than mutabilities, we sometimes have to pick a + /// mutability that is stronger than necessary so that it at least *would permit* the borrow in + /// question. + pub fn to_mutbl_lossy(self) -> ast::Mutability { + match self { + MutBorrow => ast::MutMutable, + ImmBorrow => ast::MutImmutable, + + // We have no type corresponding to a unique imm borrow, so + // use `&mut`. It gives all the capabilities of an `&uniq` + // and hence is a safe "over approximation". + UniqueImmBorrow => ast::MutMutable, } - } else { - csearch::is_impl(&cx.sess.cstore, id) } -} -pub fn trait_ref_to_def_id(tcx: &ctxt, tr: &ast::TraitRef) -> ast::DefId { - tcx.def_map.borrow().get(&tr.ref_id).expect("no def-map entry for trait").def_id() -} - -pub fn try_add_builtin_trait( - tcx: &ctxt, - trait_def_id: ast::DefId, - builtin_bounds: &mut EnumSet) - -> bool -{ - //! Checks whether `trait_ref` refers to one of the builtin - //! traits, like `Send`, and adds the corresponding - //! bound to the set `builtin_bounds` if so. Returns true if `trait_ref` - //! is a builtin trait. - - match tcx.lang_items.to_builtin_kind(trait_def_id) { - Some(bound) => { builtin_bounds.insert(bound); true } - None => false - } -} - -pub fn ty_to_def_id(ty: Ty) -> Option { - match ty.sty { - TyTrait(ref tt) => - Some(tt.principal_def_id()), - TyStruct(id, _) | - TyEnum(id, _) | - TyClosure(id, _) => - Some(id), - _ => - None + pub fn to_user_str(&self) -> &'static str { + match *self { + MutBorrow => "mutable", + ImmBorrow => "immutable", + UniqueImmBorrow => "uniquely immutable", + } } } -// Enum information -#[derive(Clone)] -pub struct VariantInfo<'tcx> { - pub args: Vec>, - pub arg_names: Option>, - pub ctor_ty: Option>, - pub name: ast::Name, - pub id: ast::DefId, - pub disr_val: Disr, - pub vis: Visibility -} +impl<'tcx> ctxt<'tcx> { + /// Returns the type of element at index `i` in tuple or tuple-like type `t`. + /// For an enum `t`, `variant` is None only if `t` is a univariant enum. + pub fn positional_element_ty(&self, + ty: Ty<'tcx>, + i: usize, + variant: Option) -> Option> { -impl<'tcx> VariantInfo<'tcx> { + match (&ty.sty, variant) { + (&TyTuple(ref v), None) => v.get(i).cloned(), - /// Creates a new VariantInfo from the corresponding ast representation. - /// - /// Does not do any caching of the value in the type context. - pub fn from_ast_variant(cx: &ctxt<'tcx>, - ast_variant: &ast::Variant, - discriminant: Disr) -> VariantInfo<'tcx> { - let ctor_ty = node_id_to_type(cx, ast_variant.node.id); - match ast_variant.node.kind { - ast::TupleVariantKind(ref args) => { - let arg_tys = if !args.is_empty() { - // the regions in the argument types come from the - // enum def'n, and hence will all be early bound - ty::no_late_bound_regions(cx, &ctor_ty.fn_args()).unwrap() - } else { - Vec::new() - }; + (&TyStruct(def_id, substs), None) => self.lookup_struct_fields(def_id) + .get(i) + .map(|&t| self.lookup_item_type(t.id).ty.subst(self, substs)), - return VariantInfo { - args: arg_tys, - arg_names: None, - ctor_ty: Some(ctor_ty), - name: ast_variant.node.name.name, - id: ast_util::local_def(ast_variant.node.id), - disr_val: discriminant, - vis: ast_variant.node.vis - }; - }, - ast::StructVariantKind(ref struct_def) => { - let fields: &[StructField] = &struct_def.fields; + (&TyEnum(def_id, substs), Some(variant_def_id)) => { + let variant_info = self.enum_variant_with_id(def_id, variant_def_id); + variant_info.args.get(i).map(|t|t.subst(self, substs)) + } - assert!(!fields.is_empty()); + (&TyEnum(def_id, substs), None) => { + assert!(self.enum_is_univariant(def_id)); + let enum_variants = self.enum_variants(def_id); + let variant_info = &enum_variants[0]; + variant_info.args.get(i).map(|t|t.subst(self, substs)) + } - let arg_tys = struct_def.fields.iter() - .map(|field| node_id_to_type(cx, field.node.id)).collect(); - let arg_names = fields.iter().map(|field| { - match field.node.kind { - NamedField(ident, _) => ident.name, - UnnamedField(..) => cx.sess.bug( - "enum_variants: all fields in struct must have a name") - } - }).collect(); + _ => None + } + } - return VariantInfo { - args: arg_tys, - arg_names: Some(arg_names), - ctor_ty: None, - name: ast_variant.node.name.name, - id: ast_util::local_def(ast_variant.node.id), - disr_val: discriminant, - vis: ast_variant.node.vis - }; + /// Returns the type of element at field `n` in struct or struct-like type `t`. + /// For an enum `t`, `variant` must be some def id. + pub fn named_element_ty(&self, + ty: Ty<'tcx>, + n: ast::Name, + variant: Option) -> Option> { + + match (&ty.sty, variant) { + (&TyStruct(def_id, substs), None) => { + let r = self.lookup_struct_fields(def_id); + r.iter().find(|f| f.name == n) + .map(|&f| self.lookup_field_type(def_id, f.id, substs)) } + (&TyEnum(def_id, substs), Some(variant_def_id)) => { + let variant_info = self.enum_variant_with_id(def_id, variant_def_id); + variant_info.arg_names.as_ref() + .expect("must have struct enum variant if accessing a named fields") + .iter().zip(&variant_info.args) + .find(|&(&name, _)| name == n) + .map(|(_name, arg_t)| arg_t.subst(self, substs)) + } + _ => None } } -} - -pub fn substd_enum_variants<'tcx>(cx: &ctxt<'tcx>, - id: ast::DefId, - substs: &Substs<'tcx>) - -> Vec>> { - enum_variants(cx, id).iter().map(|variant_info| { - let substd_args = variant_info.args.iter() - .map(|aty| aty.subst(cx, substs)).collect::>(); - let substd_ctor_ty = variant_info.ctor_ty.subst(cx, substs); + pub fn node_id_to_type(&self, id: ast::NodeId) -> Ty<'tcx> { + match self.node_id_to_type_opt(id) { + Some(ty) => ty, + None => self.sess.bug( + &format!("node_id_to_type: no type for node `{}`", + self.map.node_to_string(id))) + } + } - Rc::new(VariantInfo { - args: substd_args, - ctor_ty: substd_ctor_ty, - ..(**variant_info).clone() - }) - }).collect() -} + pub fn node_id_to_type_opt(&self, id: ast::NodeId) -> Option> { + self.node_types.borrow().get(&id).cloned() + } -pub fn item_path_str(cx: &ctxt, id: ast::DefId) -> String { - with_path(cx, id, |path| ast_map::path_to_string(path)).to_string() -} + pub fn node_id_item_substs(&self, id: ast::NodeId) -> ItemSubsts<'tcx> { + match self.item_substs.borrow().get(&id) { + None => ItemSubsts::empty(), + Some(ts) => ts.clone(), + } + } -#[derive(Copy, Clone)] -pub enum DtorKind { - NoDtor, - TraitDtor(DefId, bool) -} + // Returns the type of a pattern as a monotype. Like @expr_ty, this function + // doesn't provide type parameter substitutions. + pub fn pat_ty(&self, pat: &ast::Pat) -> Ty<'tcx> { + self.node_id_to_type(pat.id) + } + pub fn pat_ty_opt(&self, pat: &ast::Pat) -> Option> { + self.node_id_to_type_opt(pat.id) + } -impl DtorKind { - pub fn is_present(&self) -> bool { - match *self { - TraitDtor(..) => true, - _ => false - } + // Returns the type of an expression as a monotype. + // + // NB (1): This is the PRE-ADJUSTMENT TYPE for the expression. That is, in + // some cases, we insert `AutoAdjustment` annotations such as auto-deref or + // auto-ref. The type returned by this function does not consider such + // adjustments. See `expr_ty_adjusted()` instead. + // + // NB (2): This type doesn't provide type parameter substitutions; e.g. if you + // ask for the type of "id" in "id(3)", it will return "fn(&isize) -> isize" + // instead of "fn(ty) -> T with T = isize". + pub fn expr_ty(&self, expr: &ast::Expr) -> Ty<'tcx> { + self.node_id_to_type(expr.id) } - pub fn has_drop_flag(&self) -> bool { - match self { - &NoDtor => false, - &TraitDtor(_, flag) => flag - } + pub fn expr_ty_opt(&self, expr: &ast::Expr) -> Option> { + self.node_id_to_type_opt(expr.id) } -} -/* If struct_id names a struct with a dtor. */ -pub fn ty_dtor(cx: &ctxt, struct_id: DefId) -> DtorKind { - match cx.destructor_for_type.borrow().get(&struct_id) { - Some(&method_def_id) => { - let flag = !has_attr(cx, struct_id, "unsafe_no_drop_flag"); + /// Returns the type of `expr`, considering any `AutoAdjustment` + /// entry recorded for that expression. + /// + /// It would almost certainly be better to store the adjusted ty in with + /// the `AutoAdjustment`, but I opted not to do this because it would + /// require serializing and deserializing the type and, although that's not + /// hard to do, I just hate that code so much I didn't want to touch it + /// unless it was to fix it properly, which seemed a distraction from the + /// thread at hand! -nmatsakis + pub fn expr_ty_adjusted(&self, expr: &ast::Expr) -> Ty<'tcx> { + self.expr_ty(expr) + .adjust(self, expr.span, expr.id, + self.adjustments.borrow().get(&expr.id), + |method_call| { + self.method_map.borrow().get(&method_call).map(|method| method.ty) + }) + } - TraitDtor(method_def_id, flag) + pub fn expr_span(&self, id: NodeId) -> Span { + match self.map.find(id) { + Some(ast_map::NodeExpr(e)) => { + e.span + } + Some(f) => { + self.sess.bug(&format!("Node id {} is not an expr: {:?}", + id, f)); + } + None => { + self.sess.bug(&format!("Node id {} is not present \ + in the node map", id)); + } } - None => NoDtor, } -} -pub fn has_dtor(cx: &ctxt, struct_id: DefId) -> bool { - cx.destructor_for_type.borrow().contains_key(&struct_id) -} - -pub fn with_path(cx: &ctxt, id: ast::DefId, f: F) -> T where - F: FnOnce(ast_map::PathElems) -> T, -{ - if id.krate == ast::LOCAL_CRATE { - cx.map.with_path(id.node, f) - } else { - f(csearch::get_item_path(cx, id).iter().cloned().chain(LinkedPath::empty())) + pub fn local_var_name_str(&self, id: NodeId) -> InternedString { + match self.map.find(id) { + Some(ast_map::NodeLocal(pat)) => { + match pat.node { + ast::PatIdent(_, ref path1, _) => { + token::get_ident(path1.node) + } + _ => { + self.sess.bug(&format!("Variable id {} maps to {:?}, not local", + id, pat)); + } + } + } + r => { + self.sess.bug(&format!("Variable id {} maps to {:?}, not local", + id, r)); + } + } } -} -pub fn enum_is_univariant(cx: &ctxt, id: ast::DefId) -> bool { - enum_variants(cx, id).len() == 1 -} + pub fn resolve_expr(&self, expr: &ast::Expr) -> def::Def { + match self.def_map.borrow().get(&expr.id) { + Some(def) => def.full_def(), + None => { + self.sess.span_bug(expr.span, &format!( + "no def-map entry for expr {}", expr.id)); + } + } + } + + pub fn expr_is_lval(&self, expr: &ast::Expr) -> bool { + match expr.node { + ast::ExprPath(..) => { + // We can't use resolve_expr here, as this needs to run on broken + // programs. We don't need to through - associated items are all + // rvalues. + match self.def_map.borrow().get(&expr.id) { + Some(&def::PathResolution { + base_def: def::DefStatic(..), .. + }) | Some(&def::PathResolution { + base_def: def::DefUpvar(..), .. + }) | Some(&def::PathResolution { + base_def: def::DefLocal(..), .. + }) => { + true + } -pub fn type_is_empty(cx: &ctxt, ty: Ty) -> bool { - match ty.sty { - TyEnum(did, _) => (*enum_variants(cx, did)).is_empty(), - _ => false - } -} + Some(..) => false, -trait IntTypeExt { - fn to_ty<'tcx>(&self, cx: &ctxt<'tcx>) -> Ty<'tcx>; - fn i64_to_disr(&self, val: i64) -> Option; - fn u64_to_disr(&self, val: u64) -> Option; - fn disr_incr(&self, val: Disr) -> Option; - fn disr_string(&self, val: Disr) -> String; - fn disr_wrap_incr(&self, val: Option) -> Disr; -} + None => self.sess.span_bug(expr.span, &format!( + "no def for path {}", expr.id)) + } + } -impl IntTypeExt for attr::IntType { - fn to_ty<'tcx>(&self, cx: &ctxt<'tcx>) -> Ty<'tcx> { - match *self { - SignedInt(ast::TyI8) => cx.types.i8, - SignedInt(ast::TyI16) => cx.types.i16, - SignedInt(ast::TyI32) => cx.types.i32, - SignedInt(ast::TyI64) => cx.types.i64, - SignedInt(ast::TyIs) => cx.types.isize, - UnsignedInt(ast::TyU8) => cx.types.u8, - UnsignedInt(ast::TyU16) => cx.types.u16, - UnsignedInt(ast::TyU32) => cx.types.u32, - UnsignedInt(ast::TyU64) => cx.types.u64, - UnsignedInt(ast::TyUs) => cx.types.usize, + ast::ExprUnary(ast::UnDeref, _) | + ast::ExprField(..) | + ast::ExprTupField(..) | + ast::ExprIndex(..) => { + true + } + + ast::ExprCall(..) | + ast::ExprMethodCall(..) | + ast::ExprStruct(..) | + ast::ExprRange(..) | + ast::ExprTup(..) | + ast::ExprIf(..) | + ast::ExprMatch(..) | + ast::ExprClosure(..) | + ast::ExprBlock(..) | + ast::ExprRepeat(..) | + ast::ExprVec(..) | + ast::ExprBreak(..) | + ast::ExprAgain(..) | + ast::ExprRet(..) | + ast::ExprWhile(..) | + ast::ExprLoop(..) | + ast::ExprAssign(..) | + ast::ExprInlineAsm(..) | + ast::ExprAssignOp(..) | + ast::ExprLit(_) | + ast::ExprUnary(..) | + ast::ExprBox(..) | + ast::ExprAddrOf(..) | + ast::ExprBinary(..) | + ast::ExprCast(..) => { + false + } + + ast::ExprParen(ref e) => self.expr_is_lval(e), + + ast::ExprIfLet(..) | + ast::ExprWhileLet(..) | + ast::ExprForLoop(..) | + ast::ExprMac(..) => { + self.sess.span_bug( + expr.span, + "macro expression remains after expansion"); + } + } + } + + pub fn field_idx_strict(&self, name: ast::Name, fields: &[field]) + -> usize { + let mut i = 0; + for f in fields { if f.name == name { return i; } i += 1; } + self.sess.bug(&format!( + "no field named `{}` found in the list of fields `{:?}`", + token::get_name(name), + fields.iter() + .map(|f| token::get_name(f.name).to_string()) + .collect::>())); + } + + pub fn note_and_explain_type_err(&self, err: &type_err<'tcx>, sp: Span) { + match *err { + terr_regions_does_not_outlive(subregion, superregion) => { + self.note_and_explain_region("", subregion, "..."); + self.note_and_explain_region("...does not necessarily outlive ", + superregion, ""); + } + terr_regions_not_same(region1, region2) => { + self.note_and_explain_region("", region1, "..."); + self.note_and_explain_region("...is not the same lifetime as ", + region2, ""); + } + terr_regions_no_overlap(region1, region2) => { + self.note_and_explain_region("", region1, "..."); + self.note_and_explain_region("...does not overlap ", + region2, ""); + } + terr_regions_insufficiently_polymorphic(_, conc_region) => { + self.note_and_explain_region("concrete lifetime that was found is ", + conc_region, ""); + } + terr_regions_overly_polymorphic(_, ty::ReInfer(ty::ReVar(_))) => { + // don't bother to print out the message below for + // inference variables, it's not very illuminating. + } + terr_regions_overly_polymorphic(_, conc_region) => { + self.note_and_explain_region("expected concrete lifetime is ", + conc_region, ""); + } + terr_sorts(values) => { + let expected_str = values.expected.sort_string(self); + let found_str = values.found.sort_string(self); + if expected_str == found_str && expected_str == "closure" { + self.sess.span_note(sp, + &format!("no two closures, even if identical, have the same type")); + self.sess.span_help(sp, + &format!("consider boxing your closure and/or \ + using it as a trait object")); + } + } + _ => {} } } - fn i64_to_disr(&self, val: i64) -> Option { - match *self { - SignedInt(ast::TyI8) => val.to_i8() .map(|v| v as Disr), - SignedInt(ast::TyI16) => val.to_i16() .map(|v| v as Disr), - SignedInt(ast::TyI32) => val.to_i32() .map(|v| v as Disr), - SignedInt(ast::TyI64) => val.to_i64() .map(|v| v as Disr), - UnsignedInt(ast::TyU8) => val.to_u8() .map(|v| v as Disr), - UnsignedInt(ast::TyU16) => val.to_u16() .map(|v| v as Disr), - UnsignedInt(ast::TyU32) => val.to_u32() .map(|v| v as Disr), - UnsignedInt(ast::TyU64) => val.to_u64() .map(|v| v as Disr), + pub fn provided_source(&self, id: ast::DefId) -> Option { + self.provided_method_sources.borrow().get(&id).cloned() + } - UnsignedInt(ast::TyUs) | - SignedInt(ast::TyIs) => unreachable!(), + pub fn provided_trait_methods(&self, id: ast::DefId) -> Vec>> { + if is_local(id) { + if let ItemTrait(_, _, _, ref ms) = self.map.expect_item(id.node).node { + ms.iter().filter_map(|ti| { + if let ast::MethodTraitItem(_, Some(_)) = ti.node { + match self.impl_or_trait_item(ast_util::local_def(ti.id)) { + MethodTraitItem(m) => Some(m), + _ => { + self.sess.bug("provided_trait_methods(): \ + non-method item found from \ + looking up provided method?!") + } + } + } else { + None + } + }).collect() + } else { + self.sess.bug(&format!("provided_trait_methods: `{:?}` is not a trait", id)) + } + } else { + csearch::get_provided_trait_methods(self, id) + } + } + + pub fn associated_consts(&self, id: ast::DefId) -> Vec>> { + if is_local(id) { + match self.map.expect_item(id.node).node { + ItemTrait(_, _, _, ref tis) => { + tis.iter().filter_map(|ti| { + if let ast::ConstTraitItem(_, _) = ti.node { + match self.impl_or_trait_item(ast_util::local_def(ti.id)) { + ConstTraitItem(ac) => Some(ac), + _ => { + self.sess.bug("associated_consts(): \ + non-const item found from \ + looking up a constant?!") + } + } + } else { + None + } + }).collect() + } + ItemImpl(_, _, _, _, _, ref iis) => { + iis.iter().filter_map(|ii| { + if let ast::ConstImplItem(_, _) = ii.node { + match self.impl_or_trait_item(ast_util::local_def(ii.id)) { + ConstTraitItem(ac) => Some(ac), + _ => { + self.sess.bug("associated_consts(): \ + non-const item found from \ + looking up a constant?!") + } + } + } else { + None + } + }).collect() + } + _ => { + self.sess.bug(&format!("associated_consts: `{:?}` is not a trait \ + or impl", id)) + } + } + } else { + csearch::get_associated_consts(self, id) } } - fn u64_to_disr(&self, val: u64) -> Option { - match *self { - SignedInt(ast::TyI8) => val.to_i8() .map(|v| v as Disr), - SignedInt(ast::TyI16) => val.to_i16() .map(|v| v as Disr), - SignedInt(ast::TyI32) => val.to_i32() .map(|v| v as Disr), - SignedInt(ast::TyI64) => val.to_i64() .map(|v| v as Disr), - UnsignedInt(ast::TyU8) => val.to_u8() .map(|v| v as Disr), - UnsignedInt(ast::TyU16) => val.to_u16() .map(|v| v as Disr), - UnsignedInt(ast::TyU32) => val.to_u32() .map(|v| v as Disr), - UnsignedInt(ast::TyU64) => val.to_u64() .map(|v| v as Disr), + pub fn trait_item(&self, trait_did: ast::DefId, idx: usize) -> ImplOrTraitItem<'tcx> { + let method_def_id = self.trait_item_def_ids(trait_did)[idx].def_id(); + self.impl_or_trait_item(method_def_id) + } - UnsignedInt(ast::TyUs) | - SignedInt(ast::TyIs) => unreachable!(), + pub fn trait_items(&self, trait_did: ast::DefId) -> Rc>> { + let mut trait_items = self.trait_items_cache.borrow_mut(); + match trait_items.get(&trait_did).cloned() { + Some(trait_items) => trait_items, + None => { + let def_ids = self.trait_item_def_ids(trait_did); + let items: Rc> = + Rc::new(def_ids.iter() + .map(|d| self.impl_or_trait_item(d.def_id())) + .collect()); + trait_items.insert(trait_did, items.clone()); + items + } } } - fn disr_incr(&self, val: Disr) -> Option { - macro_rules! add1 { - ($e:expr) => { $e.and_then(|v|v.checked_add(1)).map(|v| v as Disr) } + pub fn trait_impl_polarity(&self, id: ast::DefId) -> Option { + if id.krate == ast::LOCAL_CRATE { + match self.map.find(id.node) { + Some(ast_map::NodeItem(item)) => { + match item.node { + ast::ItemImpl(_, polarity, _, _, _, _) => Some(polarity), + _ => None + } + } + _ => None + } + } else { + csearch::get_impl_polarity(self, id) } - match *self { - // SignedInt repr means we *want* to reinterpret the bits - // treating the highest bit of Disr as a sign-bit, so - // cast to i64 before range-checking. - SignedInt(ast::TyI8) => add1!((val as i64).to_i8()), - SignedInt(ast::TyI16) => add1!((val as i64).to_i16()), - SignedInt(ast::TyI32) => add1!((val as i64).to_i32()), - SignedInt(ast::TyI64) => add1!(Some(val as i64)), + } - UnsignedInt(ast::TyU8) => add1!(val.to_u8()), - UnsignedInt(ast::TyU16) => add1!(val.to_u16()), - UnsignedInt(ast::TyU32) => add1!(val.to_u32()), - UnsignedInt(ast::TyU64) => add1!(Some(val)), + pub fn custom_coerce_unsized_kind(&self, did: ast::DefId) -> CustomCoerceUnsized { + memoized(&self.custom_coerce_unsized_kinds, did, |did: DefId| { + let (kind, src) = if did.krate != ast::LOCAL_CRATE { + (csearch::get_custom_coerce_unsized_kind(self, did), "external") + } else { + (None, "local") + }; - UnsignedInt(ast::TyUs) | - SignedInt(ast::TyIs) => unreachable!(), + match kind { + Some(kind) => kind, + None => { + self.sess.bug(&format!("custom_coerce_unsized_kind: \ + {} impl `{}` is missing its kind", + src, self.item_path_str(did))); + } + } + }) + } + + pub fn impl_or_trait_item(&self, id: ast::DefId) -> ImplOrTraitItem<'tcx> { + lookup_locally_or_in_crate_store( + "impl_or_trait_items", id, &self.impl_or_trait_items, + || csearch::get_impl_or_trait_item(self, id)) + } + + pub fn trait_item_def_ids(&self, id: ast::DefId) -> Rc> { + lookup_locally_or_in_crate_store( + "trait_item_def_ids", id, &self.trait_item_def_ids, + || Rc::new(csearch::get_trait_item_def_ids(&self.sess.cstore, id))) + } + + /// Returns the trait-ref corresponding to a given impl, or None if it is + /// an inherent impl. + pub fn impl_trait_ref(&self, id: ast::DefId) -> Option> { + lookup_locally_or_in_crate_store( + "impl_trait_refs", id, &self.impl_trait_refs, + || csearch::get_impl_trait(self, id)) + } + + /// Returns whether this DefId refers to an impl + pub fn is_impl(&self, id: ast::DefId) -> bool { + if id.krate == ast::LOCAL_CRATE { + if let Some(ast_map::NodeItem( + &ast::Item { node: ast::ItemImpl(..), .. })) = self.map.find(id.node) { + true + } else { + false + } + } else { + csearch::is_impl(&self.sess.cstore, id) } } - // This returns a String because (1.) it is only used for - // rendering an error message and (2.) a string can represent the - // full range from `i64::MIN` through `u64::MAX`. - fn disr_string(&self, val: Disr) -> String { - match *self { - SignedInt(ast::TyI8) => format!("{}", val as i8 ), - SignedInt(ast::TyI16) => format!("{}", val as i16), - SignedInt(ast::TyI32) => format!("{}", val as i32), - SignedInt(ast::TyI64) => format!("{}", val as i64), - UnsignedInt(ast::TyU8) => format!("{}", val as u8 ), - UnsignedInt(ast::TyU16) => format!("{}", val as u16), - UnsignedInt(ast::TyU32) => format!("{}", val as u32), - UnsignedInt(ast::TyU64) => format!("{}", val as u64), + pub fn trait_ref_to_def_id(&self, tr: &ast::TraitRef) -> ast::DefId { + self.def_map.borrow().get(&tr.ref_id).expect("no def-map entry for trait").def_id() + } - UnsignedInt(ast::TyUs) | - SignedInt(ast::TyIs) => unreachable!(), + pub fn try_add_builtin_trait(&self, + trait_def_id: ast::DefId, + builtin_bounds: &mut EnumSet) + -> bool + { + //! Checks whether `trait_ref` refers to one of the builtin + //! traits, like `Send`, and adds the corresponding + //! bound to the set `builtin_bounds` if so. Returns true if `trait_ref` + //! is a builtin trait. + + match self.lang_items.to_builtin_kind(trait_def_id) { + Some(bound) => { builtin_bounds.insert(bound); true } + None => false } } - fn disr_wrap_incr(&self, val: Option) -> Disr { - macro_rules! add1 { - ($e:expr) => { ($e).wrapping_add(1) as Disr } + pub fn substd_enum_variants(&self, + id: ast::DefId, + substs: &Substs<'tcx>) + -> Vec>> { + self.enum_variants(id).iter().map(|variant_info| { + let substd_args = variant_info.args.iter() + .map(|aty| aty.subst(self, substs)).collect::>(); + + let substd_ctor_ty = variant_info.ctor_ty.subst(self, substs); + + Rc::new(VariantInfo { + args: substd_args, + ctor_ty: substd_ctor_ty, + ..(**variant_info).clone() + }) + }).collect() + } + + pub fn item_path_str(&self, id: ast::DefId) -> String { + self.with_path(id, |path| ast_map::path_to_string(path)) + } + + /* If struct_id names a struct with a dtor. */ + pub fn ty_dtor(&self, struct_id: DefId) -> DtorKind { + match self.destructor_for_type.borrow().get(&struct_id) { + Some(&method_def_id) => { + let flag = !self.has_attr(struct_id, "unsafe_no_drop_flag"); + + TraitDtor(method_def_id, flag) + } + None => NoDtor, } - let val = val.unwrap_or(ty::INITIAL_DISCRIMINANT_VALUE); - match *self { - SignedInt(ast::TyI8) => add1!(val as i8 ), - SignedInt(ast::TyI16) => add1!(val as i16), - SignedInt(ast::TyI32) => add1!(val as i32), - SignedInt(ast::TyI64) => add1!(val as i64), - UnsignedInt(ast::TyU8) => add1!(val as u8 ), - UnsignedInt(ast::TyU16) => add1!(val as u16), - UnsignedInt(ast::TyU32) => add1!(val as u32), - UnsignedInt(ast::TyU64) => add1!(val as u64), + } - UnsignedInt(ast::TyUs) | - SignedInt(ast::TyIs) => unreachable!(), + pub fn has_dtor(&self, struct_id: DefId) -> bool { + self.destructor_for_type.borrow().contains_key(&struct_id) + } + + pub fn with_path(&self, id: ast::DefId, f: F) -> T where + F: FnOnce(ast_map::PathElems) -> T, + { + if id.krate == ast::LOCAL_CRATE { + self.map.with_path(id.node, f) + } else { + f(csearch::get_item_path(self, id).iter().cloned().chain(LinkedPath::empty())) } } -} -/// Returns `(normalized_type, ty)`, where `normalized_type` is the -/// IntType representation of one of {i64,i32,i16,i8,u64,u32,u16,u8}, -/// and `ty` is the original type (i.e. may include `isize` or -/// `usize`). -pub fn enum_repr_type<'tcx>(cx: &ctxt<'tcx>, - opt_hint: Option<&attr::ReprAttr>) - -> (attr::IntType, Ty<'tcx>) -{ - let repr_type = match opt_hint { - // Feed in the given type - Some(&attr::ReprInt(_, int_t)) => int_t, - // ... but provide sensible default if none provided - // - // NB. Historically `fn enum_variants` generate i64 here, while - // rustc_typeck::check would generate isize. - _ => SignedInt(ast::TyIs), - }; - - let repr_type_ty = repr_type.to_ty(cx); - let repr_type = match repr_type { - SignedInt(ast::TyIs) => - SignedInt(cx.sess.target.int_type), - UnsignedInt(ast::TyUs) => - UnsignedInt(cx.sess.target.uint_type), - other => other - }; - - (repr_type, repr_type_ty) -} - -fn report_discrim_overflow(cx: &ctxt, - variant_span: Span, - variant_name: &str, - repr_type: attr::IntType, - prev_val: Disr) { - let computed_value = repr_type.disr_wrap_incr(Some(prev_val)); - let computed_value = repr_type.disr_string(computed_value); - let prev_val = repr_type.disr_string(prev_val); - let repr_type = repr_type.to_ty(cx); - span_err!(cx.sess, variant_span, E0370, - "enum discriminant overflowed on value after {}: {}; \ - set explicitly via {} = {} if that is desired outcome", - prev_val, repr_type, variant_name, computed_value); -} - -// This computes the discriminant values for the sequence of Variants -// attached to a particular enum, taking into account the #[repr] (if -// any) provided via the `opt_hint`. -fn compute_enum_variants<'tcx>(cx: &ctxt<'tcx>, - vs: &'tcx [P], - opt_hint: Option<&attr::ReprAttr>) - -> Vec>> { - let mut variants: Vec> = Vec::new(); - let mut prev_disr_val: Option = None; - - let (repr_type, repr_type_ty) = ty::enum_repr_type(cx, opt_hint); - - for v in vs { - // If the discriminant value is specified explicitly in the - // enum, check whether the initialization expression is valid, - // otherwise use the last value plus one. - let current_disr_val; - - // This closure marks cases where, when an error occurs during - // the computation, attempt to assign a (hopefully) fresh - // value to avoid spurious error reports downstream. - let attempt_fresh_value = move || -> Disr { - repr_type.disr_wrap_incr(prev_disr_val) + pub fn enum_is_univariant(&self, id: ast::DefId) -> bool { + self.enum_variants(id).len() == 1 + } + + /// Returns `(normalized_type, ty)`, where `normalized_type` is the + /// IntType representation of one of {i64,i32,i16,i8,u64,u32,u16,u8}, + /// and `ty` is the original type (i.e. may include `isize` or + /// `usize`). + pub fn enum_repr_type(&self, opt_hint: Option<&attr::ReprAttr>) + -> (attr::IntType, Ty<'tcx>) { + let repr_type = match opt_hint { + // Feed in the given type + Some(&attr::ReprInt(_, int_t)) => int_t, + // ... but provide sensible default if none provided + // + // NB. Historically `fn enum_variants` generate i64 here, while + // rustc_typeck::check would generate isize. + _ => SignedInt(ast::TyIs), }; - match v.node.disr_expr { - Some(ref e) => { - debug!("disr expr, checking {}", pprust::expr_to_string(&**e)); - - // check_expr (from check_const pass) doesn't guarantee - // that the expression is in a form that eval_const_expr can - // handle, so we may still get an internal compiler error - // - // pnkfelix: The above comment was transcribed from - // the version of this code taken from rustc_typeck. - // Presumably the implication is that we need to deal - // with such ICE's as they arise. - // - // Since this can be called from `ty::enum_variants` - // anyway, best thing is to make `eval_const_expr` - // more robust (on case-by-case basis). - - match const_eval::eval_const_expr_partial(cx, &**e, Some(repr_type_ty)) { - Ok(ConstVal::Int(val)) => current_disr_val = val as Disr, - Ok(ConstVal::Uint(val)) => current_disr_val = val as Disr, - Ok(_) => { - let sign_desc = if repr_type.is_signed() { "signed" } else { "unsigned" }; - span_err!(cx.sess, e.span, E0079, - "expected {} integer constant", - sign_desc); - current_disr_val = attempt_fresh_value(); - } - Err(ref err) => { - span_err!(cx.sess, err.span, E0080, - "constant evaluation error: {}", - err.description()); - current_disr_val = attempt_fresh_value(); + let repr_type_ty = repr_type.to_ty(self); + let repr_type = match repr_type { + SignedInt(ast::TyIs) => + SignedInt(self.sess.target.int_type), + UnsignedInt(ast::TyUs) => + UnsignedInt(self.sess.target.uint_type), + other => other + }; + + (repr_type, repr_type_ty) + } + + fn report_discrim_overflow(&self, + variant_span: Span, + variant_name: &str, + repr_type: attr::IntType, + prev_val: Disr) { + let computed_value = repr_type.disr_wrap_incr(Some(prev_val)); + let computed_value = repr_type.disr_string(computed_value); + let prev_val = repr_type.disr_string(prev_val); + let repr_type = repr_type.to_ty(self); + span_err!(self.sess, variant_span, E0370, + "enum discriminant overflowed on value after {}: {}; \ + set explicitly via {} = {} if that is desired outcome", + prev_val, repr_type, variant_name, computed_value); + } + + // This computes the discriminant values for the sequence of Variants + // attached to a particular enum, taking into account the #[repr] (if + // any) provided via the `opt_hint`. + fn compute_enum_variants(&self, + vs: &'tcx [P], + opt_hint: Option<&attr::ReprAttr>) + -> Vec>> { + let mut variants: Vec> = Vec::new(); + let mut prev_disr_val: Option = None; + + let (repr_type, repr_type_ty) = self.enum_repr_type(opt_hint); + + for v in vs { + // If the discriminant value is specified explicitly in the + // enum, check whether the initialization expression is valid, + // otherwise use the last value plus one. + let current_disr_val; + + // This closure marks cases where, when an error occurs during + // the computation, attempt to assign a (hopefully) fresh + // value to avoid spurious error reports downstream. + let attempt_fresh_value = move || -> Disr { + repr_type.disr_wrap_incr(prev_disr_val) + }; + + match v.node.disr_expr { + Some(ref e) => { + debug!("disr expr, checking {}", pprust::expr_to_string(&**e)); + + // check_expr (from check_const pass) doesn't guarantee + // that the expression is in a form that eval_const_expr can + // handle, so we may still get an internal compiler error + // + // pnkfelix: The above comment was transcribed from + // the version of this code taken from rustc_typeck. + // Presumably the implication is that we need to deal + // with such ICE's as they arise. + // + // Since this can be called from `ty::enum_variants` + // anyway, best thing is to make `eval_const_expr` + // more robust (on case-by-case basis). + + match const_eval::eval_const_expr_partial(self, &**e, Some(repr_type_ty)) { + Ok(ConstVal::Int(val)) => current_disr_val = val as Disr, + Ok(ConstVal::Uint(val)) => current_disr_val = val as Disr, + Ok(_) => { + let sign_desc = if repr_type.is_signed() { + "signed" + } else { + "unsigned" + }; + span_err!(self.sess, e.span, E0079, + "expected {} integer constant", + sign_desc); + current_disr_val = attempt_fresh_value(); + } + Err(ref err) => { + span_err!(self.sess, err.span, E0080, + "constant evaluation error: {}", + err.description()); + current_disr_val = attempt_fresh_value(); + } } - } - }, - None => { - current_disr_val = match prev_disr_val { - Some(prev_disr_val) => { - if let Some(v) = repr_type.disr_incr(prev_disr_val) { - v - } else { - report_discrim_overflow(cx, v.span, v.node.name.as_str(), - repr_type, prev_disr_val); - attempt_fresh_value() + }, + None => { + current_disr_val = match prev_disr_val { + Some(prev_disr_val) => { + if let Some(v) = repr_type.disr_incr(prev_disr_val) { + v + } else { + self.report_discrim_overflow(v.span, v.node.name.as_str(), + repr_type, prev_disr_val); + attempt_fresh_value() + } } + None => ty::INITIAL_DISCRIMINANT_VALUE } - None => ty::INITIAL_DISCRIMINANT_VALUE } } - } - let variant_info = Rc::new(VariantInfo::from_ast_variant(cx, &**v, current_disr_val)); - prev_disr_val = Some(current_disr_val); + let variant_info = Rc::new(VariantInfo::from_ast_variant(self, &**v, current_disr_val)); + prev_disr_val = Some(current_disr_val); - variants.push(variant_info); - } + variants.push(variant_info); + } - return variants; -} + variants + } -pub fn enum_variants<'tcx>(cx: &ctxt<'tcx>, id: ast::DefId) - -> Rc>>> { - memoized(&cx.enum_var_cache, id, |id: ast::DefId| { - if ast::LOCAL_CRATE != id.krate { - Rc::new(csearch::get_enum_variants(cx, id)) - } else { - match cx.map.get(id.node) { - ast_map::NodeItem(ref item) => { - match item.node { - ast::ItemEnum(ref enum_definition, _) => { - Rc::new(compute_enum_variants( - cx, - &enum_definition.variants, - lookup_repr_hints(cx, id).get(0))) - } - _ => { - cx.sess.bug("enum_variants: id not bound to an enum") + pub fn enum_variants(&self, id: ast::DefId) -> Rc>>> { + memoized(&self.enum_var_cache, id, |id: ast::DefId| { + if ast::LOCAL_CRATE != id.krate { + Rc::new(csearch::get_enum_variants(self, id)) + } else { + match self.map.get(id.node) { + ast_map::NodeItem(ref item) => { + match item.node { + ast::ItemEnum(ref enum_definition, _) => { + Rc::new(self.compute_enum_variants( + &enum_definition.variants, + self.lookup_repr_hints(id).get(0))) + } + _ => { + self.sess.bug("enum_variants: id not bound to an enum") + } } } + _ => self.sess.bug("enum_variants: id not bound to an enum") } - _ => cx.sess.bug("enum_variants: id not bound to an enum") } - } - }) -} + }) + } -// Returns information about the enum variant with the given ID: -pub fn enum_variant_with_id<'tcx>(cx: &ctxt<'tcx>, - enum_id: ast::DefId, - variant_id: ast::DefId) - -> Rc> { - enum_variants(cx, enum_id).iter() - .find(|variant| variant.id == variant_id) - .expect("enum_variant_with_id(): no variant exists with that ID") - .clone() -} + // Returns information about the enum variant with the given ID: + pub fn enum_variant_with_id(&self, + enum_id: ast::DefId, + variant_id: ast::DefId) + -> Rc> { + self.enum_variants(enum_id).iter() + .find(|variant| variant.id == variant_id) + .expect("enum_variant_with_id(): no variant exists with that ID") + .clone() + } -// If the given item is in an external crate, looks up its type and adds it to -// the type cache. Returns the type parameters and type. -pub fn lookup_item_type<'tcx>(cx: &ctxt<'tcx>, - did: ast::DefId) - -> TypeScheme<'tcx> { - lookup_locally_or_in_crate_store( - "tcache", did, &cx.tcache, - || csearch::get_type(cx, did)) -} + // If the given item is in an external crate, looks up its type and adds it to + // the type cache. Returns the type parameters and type. + pub fn lookup_item_type(&self, did: ast::DefId) -> TypeScheme<'tcx> { + lookup_locally_or_in_crate_store( + "tcache", did, &self.tcache, + || csearch::get_type(self, did)) + } -/// Given the did of a trait, returns its canonical trait ref. -pub fn lookup_trait_def<'tcx>(cx: &ctxt<'tcx>, did: ast::DefId) - -> &'tcx TraitDef<'tcx> { - lookup_locally_or_in_crate_store( - "trait_defs", did, &cx.trait_defs, - || cx.arenas.trait_defs.alloc(csearch::get_trait_def(cx, did)) - ) -} + /// Given the did of a trait, returns its canonical trait ref. + pub fn lookup_trait_def(&self, did: ast::DefId) -> &'tcx TraitDef<'tcx> { + lookup_locally_or_in_crate_store( + "trait_defs", did, &self.trait_defs, + || self.arenas.trait_defs.alloc(csearch::get_trait_def(self, did)) + ) + } -/// Given the did of an item, returns its full set of predicates. -pub fn lookup_predicates<'tcx>(cx: &ctxt<'tcx>, did: ast::DefId) - -> GenericPredicates<'tcx> -{ - lookup_locally_or_in_crate_store( - "predicates", did, &cx.predicates, - || csearch::get_predicates(cx, did)) -} + /// Given the did of an item, returns its full set of predicates. + pub fn lookup_predicates(&self, did: ast::DefId) -> GenericPredicates<'tcx> { + lookup_locally_or_in_crate_store( + "predicates", did, &self.predicates, + || csearch::get_predicates(self, did)) + } -/// Given the did of a trait, returns its superpredicates. -pub fn lookup_super_predicates<'tcx>(cx: &ctxt<'tcx>, did: ast::DefId) - -> GenericPredicates<'tcx> -{ - lookup_locally_or_in_crate_store( - "super_predicates", did, &cx.super_predicates, - || csearch::get_super_predicates(cx, did)) -} + /// Given the did of a trait, returns its superpredicates. + pub fn lookup_super_predicates(&self, did: ast::DefId) -> GenericPredicates<'tcx> { + lookup_locally_or_in_crate_store( + "super_predicates", did, &self.super_predicates, + || csearch::get_super_predicates(self, did)) + } -/// Get the attributes of a definition. -pub fn get_attrs<'tcx>(tcx: &'tcx ctxt, did: DefId) - -> Cow<'tcx, [ast::Attribute]> { - if is_local(did) { - Cow::Borrowed(tcx.map.attrs(did.node)) - } else { - Cow::Owned(csearch::get_item_attrs(&tcx.sess.cstore, did)) + /// Get the attributes of a definition. + pub fn get_attrs(&self, did: DefId) -> Cow<'tcx, [ast::Attribute]> { + if is_local(did) { + Cow::Borrowed(self.map.attrs(did.node)) + } else { + Cow::Owned(csearch::get_item_attrs(&self.sess.cstore, did)) + } } -} -/// Determine whether an item is annotated with an attribute -pub fn has_attr(tcx: &ctxt, did: DefId, attr: &str) -> bool { - get_attrs(tcx, did).iter().any(|item| item.check_name(attr)) -} + /// Determine whether an item is annotated with an attribute + pub fn has_attr(&self, did: DefId, attr: &str) -> bool { + self.get_attrs(did).iter().any(|item| item.check_name(attr)) + } -/// Determine whether an item is annotated with `#[repr(packed)]` -pub fn lookup_packed(tcx: &ctxt, did: DefId) -> bool { - lookup_repr_hints(tcx, did).contains(&attr::ReprPacked) -} + /// Determine whether an item is annotated with `#[repr(packed)]` + pub fn lookup_packed(&self, did: DefId) -> bool { + self.lookup_repr_hints(did).contains(&attr::ReprPacked) + } -/// Determine whether an item is annotated with `#[simd]` -pub fn lookup_simd(tcx: &ctxt, did: DefId) -> bool { - has_attr(tcx, did, "simd") -} + /// Determine whether an item is annotated with `#[simd]` + pub fn lookup_simd(&self, did: DefId) -> bool { + self.has_attr(did, "simd") + } -/// Obtain the representation annotation for a struct definition. -pub fn lookup_repr_hints(tcx: &ctxt, did: DefId) -> Rc> { - memoized(&tcx.repr_hint_cache, did, |did: DefId| { - Rc::new(if did.krate == LOCAL_CRATE { - get_attrs(tcx, did).iter().flat_map(|meta| { - attr::find_repr_attrs(tcx.sess.diagnostic(), meta).into_iter() - }).collect() - } else { - csearch::get_repr_attrs(&tcx.sess.cstore, did) + /// Obtain the representation annotation for a struct definition. + pub fn lookup_repr_hints(&self, did: DefId) -> Rc> { + memoized(&self.repr_hint_cache, did, |did: DefId| { + Rc::new(if did.krate == LOCAL_CRATE { + self.get_attrs(did).iter().flat_map(|meta| { + attr::find_repr_attrs(self.sess.diagnostic(), meta).into_iter() + }).collect() + } else { + csearch::get_repr_attrs(&self.sess.cstore, did) + }) }) - }) -} + } -// Look up a field ID, whether or not it's local -pub fn lookup_field_type_unsubstituted<'tcx>(tcx: &ctxt<'tcx>, - struct_id: DefId, - id: DefId) - -> Ty<'tcx> { - if id.krate == ast::LOCAL_CRATE { - node_id_to_type(tcx, id.node) - } else { - let mut tcache = tcx.tcache.borrow_mut(); - tcache.entry(id).or_insert_with(|| csearch::get_field_type(tcx, struct_id, id)).ty + // Look up a field ID, whether or not it's local + pub fn lookup_field_type_unsubstituted(&self, + struct_id: DefId, + id: DefId) + -> Ty<'tcx> { + if id.krate == ast::LOCAL_CRATE { + self.node_id_to_type(id.node) + } else { + let mut tcache = self.tcache.borrow_mut(); + tcache.entry(id).or_insert_with(|| csearch::get_field_type(self, struct_id, id)).ty + } } -} -// Look up a field ID, whether or not it's local -// Takes a list of type substs in case the struct is generic -pub fn lookup_field_type<'tcx>(tcx: &ctxt<'tcx>, - struct_id: DefId, - id: DefId, - substs: &Substs<'tcx>) - -> Ty<'tcx> { - lookup_field_type_unsubstituted(tcx, struct_id, id).subst(tcx, substs) -} + // Look up a field ID, whether or not it's local + // Takes a list of type substs in case the struct is generic + pub fn lookup_field_type(&self, + struct_id: DefId, + id: DefId, + substs: &Substs<'tcx>) + -> Ty<'tcx> { + self.lookup_field_type_unsubstituted(struct_id, id).subst(self, substs) + } -// Look up the list of field names and IDs for a given struct. -// Panics if the id is not bound to a struct. -pub fn lookup_struct_fields(cx: &ctxt, did: ast::DefId) -> Vec { - if did.krate == ast::LOCAL_CRATE { - let struct_fields = cx.struct_fields.borrow(); - match struct_fields.get(&did) { - Some(fields) => (**fields).clone(), - _ => { - cx.sess.bug( - &format!("ID not mapped to struct fields: {}", - cx.map.node_to_string(did.node))); + // Look up the list of field names and IDs for a given struct. + // Panics if the id is not bound to a struct. + pub fn lookup_struct_fields(&self, did: ast::DefId) -> Vec { + if did.krate == ast::LOCAL_CRATE { + let struct_fields = self.struct_fields.borrow(); + match struct_fields.get(&did) { + Some(fields) => (**fields).clone(), + _ => { + self.sess.bug( + &format!("ID not mapped to struct fields: {}", + self.map.node_to_string(did.node))); + } } + } else { + csearch::get_struct_fields(&self.sess.cstore, did) } - } else { - csearch::get_struct_fields(&cx.sess.cstore, did) } -} -pub fn is_tuple_struct(cx: &ctxt, did: ast::DefId) -> bool { - let fields = lookup_struct_fields(cx, did); - !fields.is_empty() && fields.iter().all(|f| f.name == token::special_names::unnamed_field) -} + pub fn is_tuple_struct(&self, did: ast::DefId) -> bool { + let fields = self.lookup_struct_fields(did); + !fields.is_empty() && fields.iter().all(|f| f.name == token::special_names::unnamed_field) + } -// Returns a list of fields corresponding to the struct's items. trans uses -// this. Takes a list of substs with which to instantiate field types. -pub fn struct_fields<'tcx>(cx: &ctxt<'tcx>, did: ast::DefId, substs: &Substs<'tcx>) - -> Vec> { - lookup_struct_fields(cx, did).iter().map(|f| { - field { - name: f.name, - mt: mt { - ty: lookup_field_type(cx, did, f.id, substs), - mutbl: MutImmutable + // Returns a list of fields corresponding to the struct's items. trans uses + // this. Takes a list of substs with which to instantiate field types. + pub fn struct_fields(&self, did: ast::DefId, substs: &Substs<'tcx>) + -> Vec> { + self.lookup_struct_fields(did).iter().map(|f| { + field { + name: f.name, + mt: mt { + ty: self.lookup_field_type(did, f.id, substs), + mutbl: MutImmutable + } } - } - }).collect() -} + }).collect() + } -// Returns a list of fields corresponding to the tuple's items. trans uses -// this. -pub fn tup_fields<'tcx>(v: &[Ty<'tcx>]) -> Vec> { - v.iter().enumerate().map(|(i, &f)| { - field { - name: token::intern(&i.to_string()), - mt: mt { - ty: f, - mutbl: MutImmutable + /// Returns the deeply last field of nested structures, or the same type, + /// if not a structure at all. Corresponds to the only possible unsized + /// field, and its type can be used to determine unsizing strategy. + pub fn struct_tail(&self, mut ty: Ty<'tcx>) -> Ty<'tcx> { + while let TyStruct(def_id, substs) = ty.sty { + match self.struct_fields(def_id, substs).last() { + Some(f) => ty = f.mt.ty, + None => break } } - }).collect() -} - -/// Returns the deeply last field of nested structures, or the same type, -/// if not a structure at all. Corresponds to the only possible unsized -/// field, and its type can be used to determine unsizing strategy. -pub fn struct_tail<'tcx>(cx: &ctxt<'tcx>, mut ty: Ty<'tcx>) -> Ty<'tcx> { - while let TyStruct(def_id, substs) = ty.sty { - match struct_fields(cx, def_id, substs).last() { - Some(f) => ty = f.mt.ty, - None => break - } + ty } - ty -} -/// Same as applying struct_tail on `source` and `target`, but only -/// keeps going as long as the two types are instances of the same -/// structure definitions. -/// For `(Foo>, Foo)`, the result will be `(Foo, Trait)`, -/// whereas struct_tail produces `T`, and `Trait`, respectively. -pub fn struct_lockstep_tails<'tcx>(cx: &ctxt<'tcx>, - source: Ty<'tcx>, - target: Ty<'tcx>) - -> (Ty<'tcx>, Ty<'tcx>) { - let (mut a, mut b) = (source, target); - while let (&TyStruct(a_did, a_substs), &TyStruct(b_did, b_substs)) = (&a.sty, &b.sty) { - if a_did != b_did { - continue; - } - if let Some(a_f) = struct_fields(cx, a_did, a_substs).last() { - if let Some(b_f) = struct_fields(cx, b_did, b_substs).last() { - a = a_f.mt.ty; - b = b_f.mt.ty; + /// Same as applying struct_tail on `source` and `target`, but only + /// keeps going as long as the two types are instances of the same + /// structure definitions. + /// For `(Foo>, Foo)`, the result will be `(Foo, Trait)`, + /// whereas struct_tail produces `T`, and `Trait`, respectively. + pub fn struct_lockstep_tails(&self, + source: Ty<'tcx>, + target: Ty<'tcx>) + -> (Ty<'tcx>, Ty<'tcx>) { + let (mut a, mut b) = (source, target); + while let (&TyStruct(a_did, a_substs), &TyStruct(b_did, b_substs)) = (&a.sty, &b.sty) { + if a_did != b_did { + break; + } + if let Some(a_f) = self.struct_fields(a_did, a_substs).last() { + if let Some(b_f) = self.struct_fields(b_did, b_substs).last() { + a = a_f.mt.ty; + b = b_f.mt.ty; + } else { + break; + } } else { break; } - } else { - break; } + (a, b) } - (a, b) -} -#[derive(Copy, Clone)] -pub struct ClosureUpvar<'tcx> { - pub def: def::Def, - pub span: Span, - pub ty: Ty<'tcx>, -} + // Returns a list of `ClosureUpvar`s for each upvar. + pub fn closure_upvars(typer: &Typer<'tcx>, + closure_id: ast::DefId, + substs: &Substs<'tcx>) + -> Option>> + { + // Presently an unboxed closure type cannot "escape" out of a + // function, so we will only encounter ones that originated in the + // local crate or were inlined into it along with some function. + // This may change if abstract return types of some sort are + // implemented. + assert!(closure_id.krate == ast::LOCAL_CRATE); + let tcx = typer.tcx(); + match tcx.freevars.borrow().get(&closure_id.node) { + None => Some(vec![]), + Some(ref freevars) => { + freevars.iter() + .map(|freevar| { + let freevar_def_id = freevar.def.def_id(); + let freevar_ty = match typer.node_ty(freevar_def_id.node) { + Ok(t) => { t } + Err(()) => { return None; } + }; + let freevar_ty = freevar_ty.subst(tcx, substs); -// Returns a list of `ClosureUpvar`s for each upvar. -pub fn closure_upvars<'tcx>(typer: &mc::Typer<'tcx>, - closure_id: ast::DefId, - substs: &Substs<'tcx>) - -> Option>> -{ - // Presently an unboxed closure type cannot "escape" out of a - // function, so we will only encounter ones that originated in the - // local crate or were inlined into it along with some function. - // This may change if abstract return types of some sort are - // implemented. - assert!(closure_id.krate == ast::LOCAL_CRATE); - let tcx = typer.tcx(); - match tcx.freevars.borrow().get(&closure_id.node) { - None => Some(vec![]), - Some(ref freevars) => { - freevars.iter() - .map(|freevar| { - let freevar_def_id = freevar.def.def_id(); - let freevar_ty = match typer.node_ty(freevar_def_id.node) { - Ok(t) => { t } - Err(()) => { return None; } - }; - let freevar_ty = freevar_ty.subst(tcx, substs); - - let upvar_id = ty::UpvarId { - var_id: freevar_def_id.node, - closure_expr_id: closure_id.node - }; - - typer.upvar_capture(upvar_id).map(|capture| { - let freevar_ref_ty = match capture { - UpvarCapture::ByValue => { - freevar_ty - } - UpvarCapture::ByRef(borrow) => { - tcx.mk_ref(tcx.mk_region(borrow.region), - ty::mt { - ty: freevar_ty, - mutbl: borrow.kind.to_mutbl_lossy(), - }) - } + let upvar_id = ty::UpvarId { + var_id: freevar_def_id.node, + closure_expr_id: closure_id.node }; - ClosureUpvar { - def: freevar.def, - span: freevar.span, - ty: freevar_ref_ty, - } + typer.upvar_capture(upvar_id).map(|capture| { + let freevar_ref_ty = match capture { + UpvarCapture::ByValue => { + freevar_ty + } + UpvarCapture::ByRef(borrow) => { + tcx.mk_ref(tcx.mk_region(borrow.region), + ty::mt { + ty: freevar_ty, + mutbl: borrow.kind.to_mutbl_lossy(), + }) + } + }; + + ClosureUpvar { + def: freevar.def, + span: freevar.span, + ty: freevar_ref_ty, + } + }) }) - }) - .collect() - } - } -} - -// Returns the repeat count for a repeating vector expression. -pub fn eval_repeat_count(tcx: &ctxt, count_expr: &ast::Expr) -> usize { - match const_eval::eval_const_expr_partial(tcx, count_expr, Some(tcx.types.usize)) { - Ok(val) => { - let found = match val { - ConstVal::Uint(count) => return count as usize, - ConstVal::Int(count) if count >= 0 => return count as usize, - ConstVal::Int(_) => "negative integer", - ConstVal::Float(_) => "float", - ConstVal::Str(_) => "string", - ConstVal::Bool(_) => "boolean", - ConstVal::Binary(_) => "binary array", - ConstVal::Struct(..) => "struct", - ConstVal::Tuple(_) => "tuple" - }; - span_err!(tcx.sess, count_expr.span, E0306, - "expected positive integer for repeat count, found {}", - found); - } - Err(err) => { - let err_description = err.description(); - let found = match count_expr.node { - ast::ExprPath(None, ast::Path { - global: false, - ref segments, - .. - }) if segments.len() == 1 => - format!("{}", "found variable"), - _ => - format!("but {}", err_description), - }; - span_err!(tcx.sess, count_expr.span, E0307, - "expected constant integer for repeat count, {}", - found); + .collect() + } } } - 0 -} -// Iterate over a type parameter's bounded traits and any supertraits -// of those traits, ignoring kinds. -// Here, the supertraits are the transitive closure of the supertrait -// relation on the supertraits from each bounded trait's constraint -// list. -pub fn each_bound_trait_and_supertraits<'tcx, F>(tcx: &ctxt<'tcx>, - bounds: &[PolyTraitRef<'tcx>], - mut f: F) - -> bool where - F: FnMut(PolyTraitRef<'tcx>) -> bool, -{ - for bound_trait_ref in traits::transitive_bounds(tcx, bounds) { - if !f(bound_trait_ref) { - return false; + // Returns the repeat count for a repeating vector expression. + pub fn eval_repeat_count(&self, count_expr: &ast::Expr) -> usize { + match const_eval::eval_const_expr_partial(self, count_expr, Some(self.types.usize)) { + Ok(val) => { + let found = match val { + ConstVal::Uint(count) => return count as usize, + ConstVal::Int(count) if count >= 0 => return count as usize, + ConstVal::Int(_) => "negative integer", + ConstVal::Float(_) => "float", + ConstVal::Str(_) => "string", + ConstVal::Bool(_) => "boolean", + ConstVal::Binary(_) => "binary array", + ConstVal::Struct(..) => "struct", + ConstVal::Tuple(_) => "tuple" + }; + span_err!(self.sess, count_expr.span, E0306, + "expected positive integer for repeat count, found {}", + found); + } + Err(err) => { + let err_description = err.description(); + let found = match count_expr.node { + ast::ExprPath(None, ast::Path { + global: false, + ref segments, + .. + }) if segments.len() == 1 => + format!("{}", "found variable"), + _ => + format!("but {}", err_description), + }; + span_err!(self.sess, count_expr.span, E0307, + "expected constant integer for repeat count, {}", + found); + } } + 0 } - return true; -} -/// Given a set of predicates that apply to an object type, returns -/// the region bounds that the (erased) `Self` type must -/// outlive. Precisely *because* the `Self` type is erased, the -/// parameter `erased_self_ty` must be supplied to indicate what type -/// has been used to represent `Self` in the predicates -/// themselves. This should really be a unique type; `FreshTy(0)` is a -/// popular choice. -/// -/// Requires that trait definitions have been processed so that we can -/// elaborate predicates and walk supertraits. -pub fn required_region_bounds<'tcx>(tcx: &ctxt<'tcx>, - erased_self_ty: Ty<'tcx>, - predicates: Vec>) - -> Vec -{ - debug!("required_region_bounds(erased_self_ty={:?}, predicates={:?})", - erased_self_ty, - predicates); - - assert!(!erased_self_ty.has_escaping_regions()); - - traits::elaborate_predicates(tcx, predicates) - .filter_map(|predicate| { - match predicate { - ty::Predicate::Projection(..) | - ty::Predicate::Trait(..) | - ty::Predicate::Equate(..) | - ty::Predicate::RegionOutlives(..) => { - None - } - ty::Predicate::TypeOutlives(ty::Binder(ty::OutlivesPredicate(t, r))) => { - // Search for a bound of the form `erased_self_ty - // : 'a`, but be wary of something like `for<'a> - // erased_self_ty : 'a` (we interpret a - // higher-ranked bound like that as 'static, - // though at present the code in `fulfill.rs` - // considers such bounds to be unsatisfiable, so - // it's kind of a moot point since you could never - // construct such an object, but this seems - // correct even if that code changes). - if t == erased_self_ty && !r.has_escaping_regions() { - if r.has_escaping_regions() { - Some(ty::ReStatic) + // Iterate over a type parameter's bounded traits and any supertraits + // of those traits, ignoring kinds. + // Here, the supertraits are the transitive closure of the supertrait + // relation on the supertraits from each bounded trait's constraint + // list. + pub fn each_bound_trait_and_supertraits(&self, + bounds: &[PolyTraitRef<'tcx>], + mut f: F) + -> bool where + F: FnMut(PolyTraitRef<'tcx>) -> bool, + { + for bound_trait_ref in traits::transitive_bounds(self, bounds) { + if !f(bound_trait_ref) { + return false; + } + } + return true; + } + + /// Given a set of predicates that apply to an object type, returns + /// the region bounds that the (erased) `Self` type must + /// outlive. Precisely *because* the `Self` type is erased, the + /// parameter `erased_self_ty` must be supplied to indicate what type + /// has been used to represent `Self` in the predicates + /// themselves. This should really be a unique type; `FreshTy(0)` is a + /// popular choice. + /// + /// Requires that trait definitions have been processed so that we can + /// elaborate predicates and walk supertraits. + pub fn required_region_bounds(&self, + erased_self_ty: Ty<'tcx>, + predicates: Vec>) + -> Vec + { + debug!("required_region_bounds(erased_self_ty={:?}, predicates={:?})", + erased_self_ty, + predicates); + + assert!(!erased_self_ty.has_escaping_regions()); + + traits::elaborate_predicates(self, predicates) + .filter_map(|predicate| { + match predicate { + ty::Predicate::Projection(..) | + ty::Predicate::Trait(..) | + ty::Predicate::Equate(..) | + ty::Predicate::RegionOutlives(..) => { + None + } + ty::Predicate::TypeOutlives(ty::Binder(ty::OutlivesPredicate(t, r))) => { + // Search for a bound of the form `erased_self_ty + // : 'a`, but be wary of something like `for<'a> + // erased_self_ty : 'a` (we interpret a + // higher-ranked bound like that as 'static, + // though at present the code in `fulfill.rs` + // considers such bounds to be unsatisfiable, so + // it's kind of a moot point since you could never + // construct such an object, but this seems + // correct even if that code changes). + if t == erased_self_ty && !r.has_escaping_regions() { + if r.has_escaping_regions() { + Some(ty::ReStatic) + } else { + Some(r) + } } else { - Some(r) + None } - } else { - None } } - } - }) - .collect() -} - -pub fn item_variances(tcx: &ctxt, item_id: ast::DefId) -> Rc { - lookup_locally_or_in_crate_store( - "item_variance_map", item_id, &tcx.item_variance_map, - || Rc::new(csearch::get_item_variances(&tcx.sess.cstore, item_id))) -} - -pub fn trait_has_default_impl(tcx: &ctxt, trait_def_id: DefId) -> bool { - populate_implementations_for_trait_if_necessary(tcx, trait_def_id); + }) + .collect() + } - let def = lookup_trait_def(tcx, trait_def_id); - def.flags.get().intersects(TraitFlags::HAS_DEFAULT_IMPL) -} + pub fn item_variances(&self, item_id: ast::DefId) -> Rc { + lookup_locally_or_in_crate_store( + "item_variance_map", item_id, &self.item_variance_map, + || Rc::new(csearch::get_item_variances(&self.sess.cstore, item_id))) + } -/// Records a trait-to-implementation mapping. -pub fn record_trait_has_default_impl(tcx: &ctxt, trait_def_id: DefId) { - let def = lookup_trait_def(tcx, trait_def_id); - def.flags.set(def.flags.get() | TraitFlags::HAS_DEFAULT_IMPL) -} + pub fn trait_has_default_impl(&self, trait_def_id: DefId) -> bool { + self.populate_implementations_for_trait_if_necessary(trait_def_id); -/// Load primitive inherent implementations if necessary -pub fn populate_implementations_for_primitive_if_necessary(tcx: &ctxt, - primitive_def_id: ast::DefId) { - if primitive_def_id.krate == LOCAL_CRATE { - return + let def = self.lookup_trait_def(trait_def_id); + def.flags.get().intersects(TraitFlags::HAS_DEFAULT_IMPL) } - if tcx.populated_external_primitive_impls.borrow().contains(&primitive_def_id) { - return + /// Records a trait-to-implementation mapping. + pub fn record_trait_has_default_impl(&self, trait_def_id: DefId) { + let def = self.lookup_trait_def(trait_def_id); + def.flags.set(def.flags.get() | TraitFlags::HAS_DEFAULT_IMPL) } - debug!("populate_implementations_for_primitive_if_necessary: searching for {:?}", - primitive_def_id); + /// Load primitive inherent implementations if necessary + pub fn populate_implementations_for_primitive_if_necessary(&self, + primitive_def_id: ast::DefId) { + if primitive_def_id.krate == LOCAL_CRATE { + return + } - let impl_items = csearch::get_impl_items(&tcx.sess.cstore, primitive_def_id); + if self.populated_external_primitive_impls.borrow().contains(&primitive_def_id) { + return + } - // Store the implementation info. - tcx.impl_items.borrow_mut().insert(primitive_def_id, impl_items); - tcx.populated_external_primitive_impls.borrow_mut().insert(primitive_def_id); -} + debug!("populate_implementations_for_primitive_if_necessary: searching for {:?}", + primitive_def_id); -/// Populates the type context with all the inherent implementations for -/// the given type if necessary. -pub fn populate_inherent_implementations_for_type_if_necessary(tcx: &ctxt, - type_id: ast::DefId) { - if type_id.krate == LOCAL_CRATE { - return - } + let impl_items = csearch::get_impl_items(&self.sess.cstore, primitive_def_id); - if tcx.populated_external_types.borrow().contains(&type_id) { - return + // Store the implementation info. + self.impl_items.borrow_mut().insert(primitive_def_id, impl_items); + self.populated_external_primitive_impls.borrow_mut().insert(primitive_def_id); } - debug!("populate_inherent_implementations_for_type_if_necessary: searching for {:?}", type_id); + /// Populates the type context with all the inherent implementations for + /// the given type if necessary. + pub fn populate_inherent_implementations_for_type_if_necessary(&self, + type_id: ast::DefId) { + if type_id.krate == LOCAL_CRATE { + return + } + + if self.populated_external_types.borrow().contains(&type_id) { + return + } - let mut inherent_impls = Vec::new(); - csearch::each_inherent_implementation_for_type(&tcx.sess.cstore, type_id, |impl_def_id| { - // Record the implementation. - inherent_impls.push(impl_def_id); + debug!("populate_inherent_implementations_for_type_if_necessary: searching for {:?}", + type_id); - // Store the implementation info. - let impl_items = csearch::get_impl_items(&tcx.sess.cstore, impl_def_id); - tcx.impl_items.borrow_mut().insert(impl_def_id, impl_items); - }); + let mut inherent_impls = Vec::new(); + csearch::each_inherent_implementation_for_type(&self.sess.cstore, type_id, |impl_def_id| { + // Record the implementation. + inherent_impls.push(impl_def_id); - tcx.inherent_impls.borrow_mut().insert(type_id, Rc::new(inherent_impls)); - tcx.populated_external_types.borrow_mut().insert(type_id); -} + // Store the implementation info. + let impl_items = csearch::get_impl_items(&self.sess.cstore, impl_def_id); + self.impl_items.borrow_mut().insert(impl_def_id, impl_items); + }); -/// Populates the type context with all the implementations for the given -/// trait if necessary. -pub fn populate_implementations_for_trait_if_necessary(tcx: &ctxt, trait_id: ast::DefId) { - if trait_id.krate == LOCAL_CRATE { - return + self.inherent_impls.borrow_mut().insert(type_id, Rc::new(inherent_impls)); + self.populated_external_types.borrow_mut().insert(type_id); } - let def = lookup_trait_def(tcx, trait_id); - if def.flags.get().intersects(TraitFlags::IMPLS_VALID) { - return; - } + /// Populates the type context with all the implementations for the given + /// trait if necessary. + pub fn populate_implementations_for_trait_if_necessary(&self, trait_id: ast::DefId) { + if trait_id.krate == LOCAL_CRATE { + return + } - debug!("populate_implementations_for_trait_if_necessary: searching for {:?}", def); + let def = self.lookup_trait_def(trait_id); + if def.flags.get().intersects(TraitFlags::IMPLS_VALID) { + return; + } - if csearch::is_defaulted_trait(&tcx.sess.cstore, trait_id) { - record_trait_has_default_impl(tcx, trait_id); - } + debug!("populate_implementations_for_trait_if_necessary: searching for {:?}", def); - csearch::each_implementation_for_trait(&tcx.sess.cstore, trait_id, |implementation_def_id| { - let impl_items = csearch::get_impl_items(&tcx.sess.cstore, implementation_def_id); - let trait_ref = impl_trait_ref(tcx, implementation_def_id).unwrap(); - // Record the trait->implementation mapping. - def.record_impl(tcx, implementation_def_id, trait_ref); + if csearch::is_defaulted_trait(&self.sess.cstore, trait_id) { + self.record_trait_has_default_impl(trait_id); + } + + csearch::each_implementation_for_trait(&self.sess.cstore, trait_id, |impl_def_id| { + let impl_items = csearch::get_impl_items(&self.sess.cstore, impl_def_id); + let trait_ref = self.impl_trait_ref(impl_def_id).unwrap(); + // Record the trait->implementation mapping. + def.record_impl(self, impl_def_id, trait_ref); - // For any methods that use a default implementation, add them to - // the map. This is a bit unfortunate. - for impl_item_def_id in &impl_items { - let method_def_id = impl_item_def_id.def_id(); - match impl_or_trait_item(tcx, method_def_id) { - MethodTraitItem(method) => { - if let Some(source) = method.provided_source { - tcx.provided_method_sources - .borrow_mut() - .insert(method_def_id, source); + // For any methods that use a default implementation, add them to + // the map. This is a bit unfortunate. + for impl_item_def_id in &impl_items { + let method_def_id = impl_item_def_id.def_id(); + match self.impl_or_trait_item(method_def_id) { + MethodTraitItem(method) => { + if let Some(source) = method.provided_source { + self.provided_method_sources + .borrow_mut() + .insert(method_def_id, source); + } } + _ => {} } - _ => {} } - } - - // Store the implementation info. - tcx.impl_items.borrow_mut().insert(implementation_def_id, impl_items); - }); - def.flags.set(def.flags.get() | TraitFlags::IMPLS_VALID); -} + // Store the implementation info. + self.impl_items.borrow_mut().insert(impl_def_id, impl_items); + }); -/// Given the def_id of an impl, return the def_id of the trait it implements. -/// If it implements no trait, return `None`. -pub fn trait_id_of_impl(tcx: &ctxt, - def_id: ast::DefId) - -> Option { - ty::impl_trait_ref(tcx, def_id).map(|tr| tr.def_id) -} + def.flags.set(def.flags.get() | TraitFlags::IMPLS_VALID); + } -/// If the given def ID describes a method belonging to an impl, return the -/// ID of the impl that the method belongs to. Otherwise, return `None`. -pub fn impl_of_method(tcx: &ctxt, def_id: ast::DefId) - -> Option { - if def_id.krate != LOCAL_CRATE { - return match csearch::get_impl_or_trait_item(tcx, - def_id).container() { - TraitContainer(_) => None, - ImplContainer(def_id) => Some(def_id), - }; + /// Given the def_id of an impl, return the def_id of the trait it implements. + /// If it implements no trait, return `None`. + pub fn trait_id_of_impl(&self, def_id: ast::DefId) -> Option { + self.impl_trait_ref(def_id).map(|tr| tr.def_id) } - match tcx.impl_or_trait_items.borrow().get(&def_id).cloned() { - Some(trait_item) => { - match trait_item.container() { + + /// If the given def ID describes a method belonging to an impl, return the + /// ID of the impl that the method belongs to. Otherwise, return `None`. + pub fn impl_of_method(&self, def_id: ast::DefId) -> Option { + if def_id.krate != LOCAL_CRATE { + return match csearch::get_impl_or_trait_item(self, + def_id).container() { TraitContainer(_) => None, ImplContainer(def_id) => Some(def_id), - } + }; } - None => None - } -} - -/// If the given def ID describes an item belonging to a trait (either a -/// default method or an implementation of a trait method), return the ID of -/// the trait that the method belongs to. Otherwise, return `None`. -pub fn trait_of_item(tcx: &ctxt, def_id: ast::DefId) -> Option { - if def_id.krate != LOCAL_CRATE { - return csearch::get_trait_of_item(&tcx.sess.cstore, def_id, tcx); - } - match tcx.impl_or_trait_items.borrow().get(&def_id).cloned() { - Some(impl_or_trait_item) => { - match impl_or_trait_item.container() { - TraitContainer(def_id) => Some(def_id), - ImplContainer(def_id) => trait_id_of_impl(tcx, def_id), + match self.impl_or_trait_items.borrow().get(&def_id).cloned() { + Some(trait_item) => { + match trait_item.container() { + TraitContainer(_) => None, + ImplContainer(def_id) => Some(def_id), + } } + None => None } - None => None } -} -/// If the given def ID describes an item belonging to a trait, (either a -/// default method or an implementation of a trait method), return the ID of -/// the method inside trait definition (this means that if the given def ID -/// is already that of the original trait method, then the return value is -/// the same). -/// Otherwise, return `None`. -pub fn trait_item_of_item(tcx: &ctxt, def_id: ast::DefId) - -> Option { - let impl_item = match tcx.impl_or_trait_items.borrow().get(&def_id) { - Some(m) => m.clone(), - None => return None, - }; - let name = impl_item.name(); - match trait_of_item(tcx, def_id) { - Some(trait_did) => { - let trait_items = ty::trait_items(tcx, trait_did); - trait_items.iter() - .position(|m| m.name() == name) - .map(|idx| ty::trait_item(tcx, trait_did, idx).id()) + /// If the given def ID describes an item belonging to a trait (either a + /// default method or an implementation of a trait method), return the ID of + /// the trait that the method belongs to. Otherwise, return `None`. + pub fn trait_of_item(&self, def_id: ast::DefId) -> Option { + if def_id.krate != LOCAL_CRATE { + return csearch::get_trait_of_item(&self.sess.cstore, def_id, self); } - None => None - } -} - -/// Creates a hash of the type `Ty` which will be the same no matter what crate -/// context it's calculated within. This is used by the `type_id` intrinsic. -pub fn hash_crate_independent<'tcx>(tcx: &ctxt<'tcx>, ty: Ty<'tcx>, svh: &Svh) -> u64 { - let mut state = SipHasher::new(); - helper(tcx, ty, svh, &mut state); - return state.finish(); - - fn helper<'tcx>(tcx: &ctxt<'tcx>, ty: Ty<'tcx>, svh: &Svh, - state: &mut SipHasher) { - macro_rules! byte { ($b:expr) => { ($b as u8).hash(state) } } - macro_rules! hash { ($e:expr) => { $e.hash(state) } } - - let region = |state: &mut SipHasher, r: Region| { - match r { - ReStatic => {} - ReLateBound(db, BrAnon(i)) => { - db.hash(state); - i.hash(state); + match self.impl_or_trait_items.borrow().get(&def_id).cloned() { + Some(impl_or_trait_item) => { + match impl_or_trait_item.container() { + TraitContainer(def_id) => Some(def_id), + ImplContainer(def_id) => self.trait_id_of_impl(def_id), } - ReEmpty | - ReEarlyBound(..) | - ReLateBound(..) | - ReFree(..) | - ReScope(..) | - ReInfer(..) => { - tcx.sess.bug("unexpected region found when hashing a type") - } - } - }; - let did = |state: &mut SipHasher, did: DefId| { - let h = if ast_util::is_local(did) { - svh.clone() - } else { - tcx.sess.cstore.get_crate_hash(did.krate) - }; - h.as_str().hash(state); - did.node.hash(state); - }; - let mt = |state: &mut SipHasher, mt: mt| { - mt.mutbl.hash(state); - }; - let fn_sig = |state: &mut SipHasher, sig: &Binder>| { - let sig = anonymize_late_bound_regions(tcx, sig).0; - for a in &sig.inputs { helper(tcx, *a, svh, state); } - if let ty::FnConverging(output) = sig.output { - helper(tcx, output, svh, state); } + None => None + } + } + + /// If the given def ID describes an item belonging to a trait, (either a + /// default method or an implementation of a trait method), return the ID of + /// the method inside trait definition (this means that if the given def ID + /// is already that of the original trait method, then the return value is + /// the same). + /// Otherwise, return `None`. + pub fn trait_item_of_item(&self, def_id: ast::DefId) -> Option { + let impl_item = match self.impl_or_trait_items.borrow().get(&def_id) { + Some(m) => m.clone(), + None => return None, }; - ty.maybe_walk(|ty| { - match ty.sty { - TyBool => byte!(2), - TyChar => byte!(3), - TyInt(i) => { - byte!(4); - hash!(i); - } - TyUint(u) => { - byte!(5); - hash!(u); - } - TyFloat(f) => { - byte!(6); - hash!(f); - } - TyStr => { - byte!(7); - } - TyEnum(d, _) => { - byte!(8); - did(state, d); - } - TyBox(_) => { - byte!(9); - } - TyArray(_, n) => { - byte!(10); - n.hash(state); - } - TySlice(_) => { - byte!(11); - } - TyRawPtr(m) => { - byte!(12); - mt(state, m); - } - TyRef(r, m) => { - byte!(13); - region(state, *r); - mt(state, m); + let name = impl_item.name(); + match self.trait_of_item(def_id) { + Some(trait_did) => { + let trait_items = self.trait_items(trait_did); + trait_items.iter() + .position(|m| m.name() == name) + .map(|idx| self.trait_item(trait_did, idx).id()) + } + None => None + } + } + + /// Creates a hash of the type `Ty` which will be the same no matter what crate + /// context it's calculated within. This is used by the `type_id` intrinsic. + pub fn hash_crate_independent(&self, ty: Ty<'tcx>, svh: &Svh) -> u64 { + let mut state = SipHasher::new(); + helper(self, ty, svh, &mut state); + return state.finish(); + + fn helper<'tcx>(tcx: &ctxt<'tcx>, ty: Ty<'tcx>, svh: &Svh, + state: &mut SipHasher) { + macro_rules! byte { ($b:expr) => { ($b as u8).hash(state) } } + macro_rules! hash { ($e:expr) => { $e.hash(state) } } + + let region = |state: &mut SipHasher, r: Region| { + match r { + ReStatic => {} + ReLateBound(db, BrAnon(i)) => { + db.hash(state); + i.hash(state); + } + ReEmpty | + ReEarlyBound(..) | + ReLateBound(..) | + ReFree(..) | + ReScope(..) | + ReInfer(..) => { + tcx.sess.bug("unexpected region found when hashing a type") + } } - TyBareFn(opt_def_id, ref b) => { - byte!(14); - hash!(opt_def_id); - hash!(b.unsafety); - hash!(b.abi); - fn_sig(state, &b.sig); - return false; + }; + let did = |state: &mut SipHasher, did: DefId| { + let h = if ast_util::is_local(did) { + svh.clone() + } else { + tcx.sess.cstore.get_crate_hash(did.krate) + }; + h.as_str().hash(state); + did.node.hash(state); + }; + let mt = |state: &mut SipHasher, mt: mt| { + mt.mutbl.hash(state); + }; + let fn_sig = |state: &mut SipHasher, sig: &Binder>| { + let sig = tcx.anonymize_late_bound_regions(sig).0; + for a in &sig.inputs { helper(tcx, *a, svh, state); } + if let ty::FnConverging(output) = sig.output { + helper(tcx, output, svh, state); } - TyTrait(ref data) => { - byte!(17); - did(state, data.principal_def_id()); - hash!(data.bounds); - - let principal = anonymize_late_bound_regions(tcx, &data.principal).0; - for subty in &principal.substs.types { - helper(tcx, subty, svh, state); + }; + ty.maybe_walk(|ty| { + match ty.sty { + TyBool => byte!(2), + TyChar => byte!(3), + TyInt(i) => { + byte!(4); + hash!(i); + } + TyUint(u) => { + byte!(5); + hash!(u); } + TyFloat(f) => { + byte!(6); + hash!(f); + } + TyStr => { + byte!(7); + } + TyEnum(d, _) => { + byte!(8); + did(state, d); + } + TyBox(_) => { + byte!(9); + } + TyArray(_, n) => { + byte!(10); + n.hash(state); + } + TySlice(_) => { + byte!(11); + } + TyRawPtr(m) => { + byte!(12); + mt(state, m); + } + TyRef(r, m) => { + byte!(13); + region(state, *r); + mt(state, m); + } + TyBareFn(opt_def_id, ref b) => { + byte!(14); + hash!(opt_def_id); + hash!(b.unsafety); + hash!(b.abi); + fn_sig(state, &b.sig); + return false; + } + TyTrait(ref data) => { + byte!(17); + did(state, data.principal_def_id()); + hash!(data.bounds); + + let principal = tcx.anonymize_late_bound_regions(&data.principal).0; + for subty in &principal.substs.types { + helper(tcx, subty, svh, state); + } - return false; - } - TyStruct(d, _) => { - byte!(18); - did(state, d); - } - TyTuple(ref inner) => { - byte!(19); - hash!(inner.len()); - } - TyParam(p) => { - byte!(20); - hash!(p.space); - hash!(p.idx); - hash!(token::get_name(p.name)); - } - TyInfer(_) => unreachable!(), - TyError => byte!(21), - TyClosure(d, _) => { - byte!(22); - did(state, d); - } - TyProjection(ref data) => { - byte!(23); - did(state, data.trait_ref.def_id); - hash!(token::get_name(data.item_name)); + return false; + } + TyStruct(d, _) => { + byte!(18); + did(state, d); + } + TyTuple(ref inner) => { + byte!(19); + hash!(inner.len()); + } + TyParam(p) => { + byte!(20); + hash!(p.space); + hash!(p.idx); + hash!(token::get_name(p.name)); + } + TyInfer(_) => unreachable!(), + TyError => byte!(21), + TyClosure(d, _) => { + byte!(22); + did(state, d); + } + TyProjection(ref data) => { + byte!(23); + did(state, data.trait_ref.def_id); + hash!(token::get_name(data.item_name)); + } } - } - true - }); - } -} - -impl fmt::Debug for Variance { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - f.write_str(match *self { - Covariant => "+", - Contravariant => "-", - Invariant => "o", - Bivariant => "*", - }) - } -} - -/// Construct a parameter environment suitable for static contexts or other contexts where there -/// are no free type/lifetime parameters in scope. -pub fn empty_parameter_environment<'a,'tcx>(cx: &'a ctxt<'tcx>) -> ParameterEnvironment<'a,'tcx> { - ty::ParameterEnvironment { tcx: cx, - free_substs: Substs::empty(), - caller_bounds: Vec::new(), - implicit_region_bound: ty::ReEmpty, - selection_cache: traits::SelectionCache::new(), } -} - -/// Constructs and returns a substitution that can be applied to move from -/// the "outer" view of a type or method to the "inner" view. -/// In general, this means converting from bound parameters to -/// free parameters. Since we currently represent bound/free type -/// parameters in the same way, this only has an effect on regions. -pub fn construct_free_substs<'a,'tcx>( - tcx: &'a ctxt<'tcx>, - generics: &Generics<'tcx>, - free_id: ast::NodeId) - -> Substs<'tcx> -{ - // map T => T - let mut types = VecPerParamSpace::empty(); - push_types_from_defs(tcx, &mut types, generics.types.as_slice()); - - let free_id_outlive = region::DestructionScopeData::new(free_id); - - // map bound 'a => free 'a - let mut regions = VecPerParamSpace::empty(); - push_region_params(&mut regions, free_id_outlive, generics.regions.as_slice()); + true + }); + } + } + + /// Construct a parameter environment suitable for static contexts or other contexts where there + /// are no free type/lifetime parameters in scope. + pub fn empty_parameter_environment<'a>(&'a self) -> ParameterEnvironment<'a,'tcx> { + ty::ParameterEnvironment { tcx: self, + free_substs: Substs::empty(), + caller_bounds: Vec::new(), + implicit_region_bound: ty::ReEmpty, + selection_cache: traits::SelectionCache::new(), } + } + + /// Constructs and returns a substitution that can be applied to move from + /// the "outer" view of a type or method to the "inner" view. + /// In general, this means converting from bound parameters to + /// free parameters. Since we currently represent bound/free type + /// parameters in the same way, this only has an effect on regions. + pub fn construct_free_substs(&self, generics: &Generics<'tcx>, + free_id: ast::NodeId) -> Substs<'tcx> { + // map T => T + let mut types = VecPerParamSpace::empty(); + for def in generics.types.as_slice() { + debug!("construct_parameter_environment(): push_types_from_defs: def={:?}", + def); + types.push(def.space, self.mk_param_from_def(def)); + } - return Substs { - types: types, - regions: subst::NonerasedRegions(regions) - }; + let free_id_outlive = region::DestructionScopeData::new(free_id); - fn push_region_params(regions: &mut VecPerParamSpace, - all_outlive_extent: region::DestructionScopeData, - region_params: &[RegionParameterDef]) - { - for def in region_params { + // map bound 'a => free 'a + let mut regions = VecPerParamSpace::empty(); + for def in generics.regions.as_slice() { let region = - ReFree(FreeRegion { scope: all_outlive_extent, + ReFree(FreeRegion { scope: free_id_outlive, bound_region: BrNamed(def.def_id, def.name) }); debug!("push_region_params {:?}", region); regions.push(def.space, region); } - } - fn push_types_from_defs<'tcx>(tcx: &ctxt<'tcx>, - types: &mut VecPerParamSpace>, - defs: &[TypeParameterDef<'tcx>]) { - for def in defs { - debug!("construct_parameter_environment(): push_types_from_defs: def={:?}", - def); - let ty = tcx.mk_param_from_def(def); - types.push(def.space, ty); - } + Substs { + types: types, + regions: subst::NonerasedRegions(regions) + } } -} - -/// See `ParameterEnvironment` struct def'n for details -pub fn construct_parameter_environment<'a,'tcx>( - tcx: &'a ctxt<'tcx>, - span: Span, - generics: &ty::Generics<'tcx>, - generic_predicates: &ty::GenericPredicates<'tcx>, - free_id: ast::NodeId) - -> ParameterEnvironment<'a, 'tcx> -{ - // - // Construct the free substs. - // - - let free_substs = construct_free_substs(tcx, generics, free_id); - let free_id_outlive = region::DestructionScopeData::new(free_id); - - // - // Compute the bounds on Self and the type parameters. - // - - let bounds = generic_predicates.instantiate(tcx, &free_substs); - let bounds = liberate_late_bound_regions(tcx, free_id_outlive, &ty::Binder(bounds)); - let predicates = bounds.predicates.into_vec(); - debug!("construct_parameter_environment: free_id={:?} free_subst={:?} predicates={:?}", - free_id, - free_substs, - predicates); + /// See `ParameterEnvironment` struct def'n for details + pub fn construct_parameter_environment<'a>(&'a self, + span: Span, + generics: &ty::Generics<'tcx>, + generic_predicates: &ty::GenericPredicates<'tcx>, + free_id: ast::NodeId) + -> ParameterEnvironment<'a, 'tcx> + { + // + // Construct the free substs. + // - // - // Finally, we have to normalize the bounds in the environment, in - // case they contain any associated type projections. This process - // can yield errors if the put in illegal associated types, like - // `::Bar` where `i32` does not implement `Foo`. We - // report these errors right here; this doesn't actually feel - // right to me, because constructing the environment feels like a - // kind of a "idempotent" action, but I'm not sure where would be - // a better place. In practice, we construct environments for - // every fn once during type checking, and we'll abort if there - // are any errors at that point, so after type checking you can be - // sure that this will succeed without errors anyway. - // + let free_substs = self.construct_free_substs(generics, free_id); + let free_id_outlive = region::DestructionScopeData::new(free_id); - let unnormalized_env = ty::ParameterEnvironment { - tcx: tcx, - free_substs: free_substs, - implicit_region_bound: ty::ReScope(free_id_outlive.to_code_extent()), - caller_bounds: predicates, - selection_cache: traits::SelectionCache::new(), - }; + // + // Compute the bounds on Self and the type parameters. + // - let cause = traits::ObligationCause::misc(span, free_id); - traits::normalize_param_env_or_error(unnormalized_env, cause) -} + let bounds = generic_predicates.instantiate(self, &free_substs); + let bounds = self.liberate_late_bound_regions(free_id_outlive, &ty::Binder(bounds)); + let predicates = bounds.predicates.into_vec(); -impl BorrowKind { - pub fn from_mutbl(m: ast::Mutability) -> BorrowKind { - match m { - ast::MutMutable => MutBorrow, - ast::MutImmutable => ImmBorrow, - } - } + debug!("construct_parameter_environment: free_id={:?} free_subst={:?} predicates={:?}", + free_id, + free_substs, + predicates); - /// Returns a mutability `m` such that an `&m T` pointer could be used to obtain this borrow - /// kind. Because borrow kinds are richer than mutabilities, we sometimes have to pick a - /// mutability that is stronger than necessary so that it at least *would permit* the borrow in - /// question. - pub fn to_mutbl_lossy(self) -> ast::Mutability { - match self { - MutBorrow => ast::MutMutable, - ImmBorrow => ast::MutImmutable, + // + // Finally, we have to normalize the bounds in the environment, in + // case they contain any associated type projections. This process + // can yield errors if the put in illegal associated types, like + // `::Bar` where `i32` does not implement `Foo`. We + // report these errors right here; this doesn't actually feel + // right to me, because constructing the environment feels like a + // kind of a "idempotent" action, but I'm not sure where would be + // a better place. In practice, we construct environments for + // every fn once during type checking, and we'll abort if there + // are any errors at that point, so after type checking you can be + // sure that this will succeed without errors anyway. + // - // We have no type corresponding to a unique imm borrow, so - // use `&mut`. It gives all the capabilities of an `&uniq` - // and hence is a safe "over approximation". - UniqueImmBorrow => ast::MutMutable, - } - } + let unnormalized_env = ty::ParameterEnvironment { + tcx: self, + free_substs: free_substs, + implicit_region_bound: ty::ReScope(free_id_outlive.to_code_extent()), + caller_bounds: predicates, + selection_cache: traits::SelectionCache::new(), + }; - pub fn to_user_str(&self) -> &'static str { - match *self { - MutBorrow => "mutable", - ImmBorrow => "immutable", - UniqueImmBorrow => "uniquely immutable", - } + let cause = traits::ObligationCause::misc(span, free_id); + traits::normalize_param_env_or_error(unnormalized_env, cause) } -} -impl<'tcx> ctxt<'tcx> { pub fn is_method_call(&self, expr_id: ast::NodeId) -> bool { self.method_map.borrow().contains_key(&MethodCall::expr(expr_id)) } @@ -6777,13 +6679,13 @@ impl<'tcx> ctxt<'tcx> { } } -impl<'a,'tcx> mc::Typer<'tcx> for ParameterEnvironment<'a,'tcx> { +impl<'a,'tcx> Typer<'tcx> for ParameterEnvironment<'a,'tcx> { fn node_ty(&self, id: ast::NodeId) -> mc::McResult> { - Ok(ty::node_id_to_type(self.tcx, id)) + Ok(self.tcx.node_id_to_type(id)) } fn expr_ty_adjusted(&self, expr: &ast::Expr) -> mc::McResult> { - Ok(ty::expr_ty_adjusted(self.tcx, expr)) + Ok(self.tcx.expr_ty_adjusted(expr)) } fn node_method_ty(&self, method_call: ty::MethodCall) -> Option> { @@ -6812,8 +6714,8 @@ impl<'a,'tcx> mc::Typer<'tcx> for ParameterEnvironment<'a,'tcx> { self.tcx.upvar_capture(upvar_id) } - fn type_moves_by_default(&self, span: Span, ty: Ty<'tcx>) -> bool { - type_moves_by_default(self, span, ty) + fn type_moves_by_default(&self, ty: Ty<'tcx>, span: Span) -> bool { + ty.moves_by_default(self, span) } } @@ -6840,9 +6742,8 @@ impl<'a,'tcx> ClosureTyper<'tcx> for ty::ParameterEnvironment<'a,'tcx> { fn closure_upvars(&self, def_id: ast::DefId, substs: &Substs<'tcx>) - -> Option>> - { - closure_upvars(self, def_id, substs) + -> Option>> { + ctxt::closure_upvars(self, def_id, substs) } } @@ -6856,53 +6757,54 @@ pub enum ExplicitSelfCategory { ByBoxExplicitSelfCategory, } -/// Pushes all the lifetimes in the given type onto the given list. A -/// "lifetime in a type" is a lifetime specified by a reference or a lifetime -/// in a list of type substitutions. This does *not* traverse into nominal -/// types, nor does it resolve fictitious types. -pub fn accumulate_lifetimes_in_type(accumulator: &mut Vec, - ty: Ty) { - for ty in ty.walk() { - match ty.sty { - TyRef(region, _) => { - accumulator.push(*region) - } - TyTrait(ref t) => { - accumulator.push_all(t.principal.0.substs.regions().as_slice()); - } - TyEnum(_, substs) | - TyStruct(_, substs) => { - accum_substs(accumulator, substs); - } - TyClosure(_, substs) => { - accum_substs(accumulator, substs); - } - TyBool | - TyChar | - TyInt(_) | - TyUint(_) | - TyFloat(_) | - TyBox(_) | - TyStr | - TyArray(_, _) | - TySlice(_) | - TyRawPtr(_) | - TyBareFn(..) | - TyTuple(_) | - TyProjection(_) | - TyParam(_) | - TyInfer(_) | - TyError => { +impl<'tcx> TyS<'tcx> { + /// Pushes all the lifetimes in the given type onto the given list. A + /// "lifetime in a type" is a lifetime specified by a reference or a lifetime + /// in a list of type substitutions. This does *not* traverse into nominal + /// types, nor does it resolve fictitious types. + pub fn accumulate_lifetimes_in_type(&self, accumulator: &mut Vec) { + for ty in self.walk() { + match ty.sty { + TyRef(region, _) => { + accumulator.push(*region) + } + TyTrait(ref t) => { + accumulator.push_all(t.principal.0.substs.regions().as_slice()); + } + TyEnum(_, substs) | + TyStruct(_, substs) => { + accum_substs(accumulator, substs); + } + TyClosure(_, substs) => { + accum_substs(accumulator, substs); + } + TyBool | + TyChar | + TyInt(_) | + TyUint(_) | + TyFloat(_) | + TyBox(_) | + TyStr | + TyArray(_, _) | + TySlice(_) | + TyRawPtr(_) | + TyBareFn(..) | + TyTuple(_) | + TyProjection(_) | + TyParam(_) | + TyInfer(_) | + TyError => { + } } } - } - fn accum_substs(accumulator: &mut Vec, substs: &Substs) { - match substs.regions { - subst::ErasedRegions => {} - subst::NonerasedRegions(ref regions) => { - for region in regions { - accumulator.push(*region) + fn accum_substs(accumulator: &mut Vec, substs: &Substs) { + match substs.regions { + subst::ErasedRegions => {} + subst::NonerasedRegions(ref regions) => { + for region in regions { + accumulator.push(*region) + } } } } @@ -6930,15 +6832,6 @@ pub type TraitMap = NodeMap>; // imported. pub type GlobMap = HashMap>; -pub fn with_freevars(tcx: &ctxt, fid: ast::NodeId, f: F) -> T where - F: FnOnce(&[Freevar]) -> T, -{ - match tcx.freevars.borrow().get(&fid) { - None => f(&[]), - Some(d) => f(&d[..]) - } -} - impl<'tcx> AutoAdjustment<'tcx> { pub fn is_identity(&self) -> bool { match *self { @@ -6955,106 +6848,123 @@ impl<'tcx> AutoDerefRef<'tcx> { } } -/// Replace any late-bound regions bound in `value` with free variants attached to scope-id -/// `scope_id`. -pub fn liberate_late_bound_regions<'tcx, T>( - tcx: &ctxt<'tcx>, - all_outlive_scope: region::DestructionScopeData, - value: &Binder) - -> T - where T : TypeFoldable<'tcx> -{ - ty_fold::replace_late_bound_regions( - tcx, value, - |br| ty::ReFree(ty::FreeRegion{scope: all_outlive_scope, bound_region: br})).0 -} +impl<'tcx> ctxt<'tcx> { + pub fn with_freevars(&self, fid: ast::NodeId, f: F) -> T where + F: FnOnce(&[Freevar]) -> T, + { + match self.freevars.borrow().get(&fid) { + None => f(&[]), + Some(d) => f(&d[..]) + } + } -pub fn count_late_bound_regions<'tcx, T>( - tcx: &ctxt<'tcx>, - value: &Binder) - -> usize - where T : TypeFoldable<'tcx> -{ - let (_, skol_map) = ty_fold::replace_late_bound_regions(tcx, value, |_| ty::ReStatic); - skol_map.len() -} + /// Replace any late-bound regions bound in `value` with free variants attached to scope-id + /// `scope_id`. + pub fn liberate_late_bound_regions(&self, + all_outlive_scope: region::DestructionScopeData, + value: &Binder) + -> T + where T : TypeFoldable<'tcx> + { + ty_fold::replace_late_bound_regions( + self, value, + |br| ty::ReFree(ty::FreeRegion{scope: all_outlive_scope, bound_region: br})).0 + } -pub fn binds_late_bound_regions<'tcx, T>( - tcx: &ctxt<'tcx>, - value: &Binder) - -> bool - where T : TypeFoldable<'tcx> -{ - count_late_bound_regions(tcx, value) > 0 -} + pub fn count_late_bound_regions(&self, value: &Binder) -> usize + where T : TypeFoldable<'tcx> + { + let (_, skol_map) = ty_fold::replace_late_bound_regions(self, value, |_| ty::ReStatic); + skol_map.len() + } -/// Flattens two binding levels into one. So `for<'a> for<'b> Foo` -/// becomes `for<'a,'b> Foo`. -pub fn flatten_late_bound_regions<'tcx, T>( - tcx: &ctxt<'tcx>, - bound2_value: &Binder>) - -> Binder - where T: TypeFoldable<'tcx> -{ - let bound0_value = bound2_value.skip_binder().skip_binder(); - let value = ty_fold::fold_regions(tcx, bound0_value, |region, current_depth| { - match region { - ty::ReLateBound(debruijn, br) if debruijn.depth >= current_depth => { - // should be true if no escaping regions from bound2_value - assert!(debruijn.depth - current_depth <= 1); - ty::ReLateBound(DebruijnIndex::new(current_depth), br) - } - _ => { - region + pub fn binds_late_bound_regions(&self, value: &Binder) -> bool + where T : TypeFoldable<'tcx> + { + self.count_late_bound_regions(value) > 0 + } + + /// Flattens two binding levels into one. So `for<'a> for<'b> Foo` + /// becomes `for<'a,'b> Foo`. + pub fn flatten_late_bound_regions(&self, bound2_value: &Binder>) + -> Binder + where T: TypeFoldable<'tcx> + { + let bound0_value = bound2_value.skip_binder().skip_binder(); + let value = ty_fold::fold_regions(self, bound0_value, |region, current_depth| { + match region { + ty::ReLateBound(debruijn, br) if debruijn.depth >= current_depth => { + // should be true if no escaping regions from bound2_value + assert!(debruijn.depth - current_depth <= 1); + ty::ReLateBound(DebruijnIndex::new(current_depth), br) + } + _ => { + region + } } + }); + Binder(value) + } + + pub fn no_late_bound_regions(&self, value: &Binder) -> Option + where T : TypeFoldable<'tcx> + { + if self.binds_late_bound_regions(value) { + None + } else { + Some(value.0.clone()) } - }); - Binder(value) -} + } -pub fn no_late_bound_regions<'tcx, T>( - tcx: &ctxt<'tcx>, - value: &Binder) - -> Option - where T : TypeFoldable<'tcx> -{ - if binds_late_bound_regions(tcx, value) { - None - } else { - Some(value.0.clone()) + /// Replace any late-bound regions bound in `value` with `'static`. Useful in trans but also + /// method lookup and a few other places where precise region relationships are not required. + pub fn erase_late_bound_regions(&self, value: &Binder) -> T + where T : TypeFoldable<'tcx> + { + ty_fold::replace_late_bound_regions(self, value, |_| ty::ReStatic).0 } -} -/// Replace any late-bound regions bound in `value` with `'static`. Useful in trans but also -/// method lookup and a few other places where precise region relationships are not required. -pub fn erase_late_bound_regions<'tcx, T>( - tcx: &ctxt<'tcx>, - value: &Binder) - -> T - where T : TypeFoldable<'tcx> -{ - ty_fold::replace_late_bound_regions(tcx, value, |_| ty::ReStatic).0 -} + /// Rewrite any late-bound regions so that they are anonymous. Region numbers are + /// assigned starting at 1 and increasing monotonically in the order traversed + /// by the fold operation. + /// + /// The chief purpose of this function is to canonicalize regions so that two + /// `FnSig`s or `TraitRef`s which are equivalent up to region naming will become + /// structurally identical. For example, `for<'a, 'b> fn(&'a isize, &'b isize)` and + /// `for<'a, 'b> fn(&'b isize, &'a isize)` will become identical after anonymization. + pub fn anonymize_late_bound_regions(&self, sig: &Binder) -> Binder + where T : TypeFoldable<'tcx>, + { + let mut counter = 0; + ty::Binder(ty_fold::replace_late_bound_regions(self, sig, |_| { + counter += 1; + ReLateBound(ty::DebruijnIndex::new(1), BrAnon(counter)) + }).0) + } -/// Rewrite any late-bound regions so that they are anonymous. Region numbers are -/// assigned starting at 1 and increasing monotonically in the order traversed -/// by the fold operation. -/// -/// The chief purpose of this function is to canonicalize regions so that two -/// `FnSig`s or `TraitRef`s which are equivalent up to region naming will become -/// structurally identical. For example, `for<'a, 'b> fn(&'a isize, &'b isize)` and -/// `for<'a, 'b> fn(&'b isize, &'a isize)` will become identical after anonymization. -pub fn anonymize_late_bound_regions<'tcx, T>( - tcx: &ctxt<'tcx>, - sig: &Binder) - -> Binder - where T : TypeFoldable<'tcx>, -{ - let mut counter = 0; - ty::Binder(ty_fold::replace_late_bound_regions(tcx, sig, |_| { - counter += 1; - ReLateBound(ty::DebruijnIndex::new(1), BrAnon(counter)) - }).0) + pub fn make_substs_for_receiver_types(&self, + trait_ref: &ty::TraitRef<'tcx>, + method: &ty::Method<'tcx>) + -> subst::Substs<'tcx> + { + /*! + * Substitutes the values for the receiver's type parameters + * that are found in method, leaving the method's type parameters + * intact. + */ + + let meth_tps: Vec = + method.generics.types.get_slice(subst::FnSpace) + .iter() + .map(|def| self.mk_param_from_def(def)) + .collect(); + let meth_regions: Vec = + method.generics.regions.get_slice(subst::FnSpace) + .iter() + .map(|def| def.to_early_bound_region()) + .collect(); + trait_ref.substs.clone().with_method(meth_tps, meth_regions) + } } impl DebruijnIndex { @@ -7111,78 +7021,6 @@ impl<'tcx> fmt::Debug for ty::Predicate<'tcx> { } } -pub fn make_substs_for_receiver_types<'tcx>(tcx: &ctxt<'tcx>, - trait_ref: &ty::TraitRef<'tcx>, - method: &ty::Method<'tcx>) - -> subst::Substs<'tcx> -{ - /*! - * Substitutes the values for the receiver's type parameters - * that are found in method, leaving the method's type parameters - * intact. - */ - - let meth_tps: Vec = - method.generics.types.get_slice(subst::FnSpace) - .iter() - .map(|def| tcx.mk_param_from_def(def)) - .collect(); - let meth_regions: Vec = - method.generics.regions.get_slice(subst::FnSpace) - .iter() - .map(|def| def.to_early_bound_region()) - .collect(); - trait_ref.substs.clone().with_method(meth_tps, meth_regions) -} - -#[derive(Copy, Clone)] -pub enum CopyImplementationError { - FieldDoesNotImplementCopy(ast::Name), - VariantDoesNotImplementCopy(ast::Name), - TypeIsStructural, - TypeHasDestructor, -} - -pub fn can_type_implement_copy<'a,'tcx>(param_env: &ParameterEnvironment<'a, 'tcx>, - span: Span, - self_type: Ty<'tcx>) - -> Result<(),CopyImplementationError> -{ - let tcx = param_env.tcx; - - let did = match self_type.sty { - ty::TyStruct(struct_did, substs) => { - let fields = ty::struct_fields(tcx, struct_did, substs); - for field in &fields { - if type_moves_by_default(param_env, span, field.mt.ty) { - return Err(FieldDoesNotImplementCopy(field.name)) - } - } - struct_did - } - ty::TyEnum(enum_did, substs) => { - let enum_variants = ty::enum_variants(tcx, enum_did); - for variant in enum_variants.iter() { - for variant_arg_type in &variant.args { - let substd_arg_type = - variant_arg_type.subst(tcx, substs); - if type_moves_by_default(param_env, span, substd_arg_type) { - return Err(VariantDoesNotImplementCopy(variant.name)) - } - } - } - enum_did - } - _ => return Err(TypeIsStructural), - }; - - if ty::has_dtor(tcx, did) { - return Err(TypeHasDestructor) - } - - Ok(()) -} - // FIXME(#20298) -- all of these traits basically walk various // structures to test whether types/regions are reachable with various // properties. It should be possible to express them in terms of one diff --git a/src/librustc/middle/ty_relate/mod.rs b/src/librustc/middle/ty_relate/mod.rs index 422498624a9d3..4e88e23377d0c 100644 --- a/src/librustc/middle/ty_relate/mod.rs +++ b/src/librustc/middle/ty_relate/mod.rs @@ -113,7 +113,7 @@ fn relate_item_substs<'a,'tcx:'a,R>(relation: &mut R, let variances; let opt_variances = if relation.tcx().variance_computed.get() { - variances = ty::item_variances(relation.tcx(), item_def_id); + variances = relation.tcx().item_variances(item_def_id); Some(&*variances) } else { None diff --git a/src/librustc/util/ppaux.rs b/src/librustc/util/ppaux.rs index 71f3675aecee1..dcdf457965efa 100644 --- a/src/librustc/util/ppaux.rs +++ b/src/librustc/util/ppaux.rs @@ -71,7 +71,7 @@ fn parameterized(f: &mut fmt::Formatter, where GG: for<'tcx> FnOnce(&ty::ctxt<'tcx>) -> ty::Generics<'tcx> { let (fn_trait_kind, verbose) = try!(ty::tls::with(|tcx| { - try!(write!(f, "{}", ty::item_path_str(tcx, did))); + try!(write!(f, "{}", tcx.item_path_str(did))); Ok((tcx.lang_items.fn_trait_kind(did), tcx.sess.verbose())) })); @@ -265,7 +265,7 @@ impl<'tcx> fmt::Display for TraitAndProjections<'tcx> { parameterized(f, trait_ref.substs, trait_ref.def_id, projection_bounds, - |tcx| ty::lookup_trait_def(tcx, trait_ref.def_id).generics.clone()) + |tcx| tcx.lookup_trait_def(trait_ref.def_id).generics.clone()) } } @@ -616,7 +616,7 @@ impl fmt::Display for ty::Binder> impl<'tcx> fmt::Display for ty::TraitRef<'tcx> { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { parameterized(f, self.substs, self.def_id, &[], - |tcx| ty::lookup_trait_def(tcx, self.def_id).generics.clone()) + |tcx| tcx.lookup_trait_def(self.def_id).generics.clone()) } } @@ -671,7 +671,7 @@ impl<'tcx> fmt::Display for ty::TypeVariants<'tcx> { if let Some(def_id) = opt_def_id { try!(write!(f, " {{{}}}", ty::tls::with(|tcx| { - ty::item_path_str(tcx, def_id) + tcx.item_path_str(def_id) }))); } Ok(()) @@ -681,7 +681,7 @@ impl<'tcx> fmt::Display for ty::TypeVariants<'tcx> { TyParam(ref param_ty) => write!(f, "{}", param_ty), TyEnum(did, substs) | TyStruct(did, substs) => { parameterized(f, substs, did, &[], - |tcx| ty::lookup_item_type(tcx, did).generics) + |tcx| tcx.lookup_item_type(did).generics) } TyTrait(ref data) => write!(f, "{}", data), ty::TyProjection(ref data) => write!(f, "{}", data), @@ -720,7 +720,7 @@ impl fmt::Debug for ty::UpvarId { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "UpvarId({};`{}`;{})", self.var_id, - ty::tls::with(|tcx| ty::local_var_name_str(tcx, self.var_id)), + ty::tls::with(|tcx| tcx.local_var_name_str(self.var_id)), self.closure_expr_id) } } diff --git a/src/librustc_borrowck/borrowck/check_loans.rs b/src/librustc_borrowck/borrowck/check_loans.rs index 49933441cf01e..9d4fb4c994d40 100644 --- a/src/librustc_borrowck/borrowck/check_loans.rs +++ b/src/librustc_borrowck/borrowck/check_loans.rs @@ -752,7 +752,7 @@ impl<'a, 'tcx> CheckLoanCtxt<'a, 'tcx> { LpExtend(ref lp_base, _, LpInterior(InteriorField(_))) => { match lp_base.to_type().sty { ty::TyStruct(def_id, _) | ty::TyEnum(def_id, _) => { - if ty::has_dtor(self.tcx(), def_id) { + if self.tcx().has_dtor(def_id) { // In the case where the owner implements drop, then // the path must be initialized to prevent a case of // partial reinitialization diff --git a/src/librustc_borrowck/borrowck/fragments.rs b/src/librustc_borrowck/borrowck/fragments.rs index 93f5ac529d3fd..9bd4da28c99fb 100644 --- a/src/librustc_borrowck/borrowck/fragments.rs +++ b/src/librustc_borrowck/borrowck/fragments.rs @@ -353,7 +353,7 @@ fn add_fragment_siblings_for_extension<'tcx>(this: &MoveData<'tcx>, } (&ty::TyStruct(def_id, ref _substs), None) => { - let fields = ty::lookup_struct_fields(tcx, def_id); + let fields = tcx.lookup_struct_fields(def_id); match *origin_field_name { mc::NamedField(ast_name) => { for f in &fields { @@ -378,7 +378,7 @@ fn add_fragment_siblings_for_extension<'tcx>(this: &MoveData<'tcx>, (&ty::TyEnum(enum_def_id, substs), ref enum_variant_info) => { let variant_info = { - let mut variants = ty::substd_enum_variants(tcx, enum_def_id, substs); + let mut variants = tcx.substd_enum_variants(enum_def_id, substs); match *enum_variant_info { Some((variant_def_id, ref _lp2)) => variants.iter() @@ -442,9 +442,9 @@ fn add_fragment_sibling_core<'tcx>(this: &MoveData<'tcx>, let loan_path_elem = LpInterior(InteriorField(new_field_name)); let new_lp_type = match new_field_name { mc::NamedField(ast_name) => - ty::named_element_ty(tcx, parent.to_type(), ast_name, opt_variant_did), + tcx.named_element_ty(parent.to_type(), ast_name, opt_variant_did), mc::PositionalField(idx) => - ty::positional_element_ty(tcx, parent.to_type(), idx, opt_variant_did), + tcx.positional_element_ty(parent.to_type(), idx, opt_variant_did), }; let new_lp_variant = LpExtend(parent, mc, loan_path_elem); let new_lp = LoanPath::new(new_lp_variant, new_lp_type.unwrap()); diff --git a/src/librustc_borrowck/borrowck/gather_loans/gather_moves.rs b/src/librustc_borrowck/borrowck/gather_loans/gather_moves.rs index 7b6c54dbaca44..2b33dde2cbe2d 100644 --- a/src/librustc_borrowck/borrowck/gather_loans/gather_moves.rs +++ b/src/librustc_borrowck/borrowck/gather_loans/gather_moves.rs @@ -35,7 +35,7 @@ pub fn gather_decl<'a, 'tcx>(bccx: &BorrowckCtxt<'a, 'tcx>, decl_id: ast::NodeId, _decl_span: Span, var_id: ast::NodeId) { - let ty = ty::node_id_to_type(bccx.tcx, var_id); + let ty = bccx.tcx.node_id_to_type(var_id); let loan_path = Rc::new(LoanPath::new(LpVar(var_id), ty)); move_data.add_move(bccx.tcx, loan_path, decl_id, Declared); } @@ -180,7 +180,7 @@ fn check_and_get_illegal_move_origin<'a, 'tcx>(bccx: &BorrowckCtxt<'a, 'tcx>, mc::cat_interior(ref b, mc::InteriorElement(Kind::Pattern, _)) => { match b.ty.sty { ty::TyStruct(did, _) | ty::TyEnum(did, _) => { - if ty::has_dtor(bccx.tcx, did) { + if bccx.tcx.has_dtor(did) { Some(cmt.clone()) } else { check_and_get_illegal_move_origin(bccx, b) diff --git a/src/librustc_borrowck/borrowck/gather_loans/mod.rs b/src/librustc_borrowck/borrowck/gather_loans/mod.rs index f00eb872642f4..44a4a0d250402 100644 --- a/src/librustc_borrowck/borrowck/gather_loans/mod.rs +++ b/src/librustc_borrowck/borrowck/gather_loans/mod.rs @@ -490,7 +490,7 @@ struct StaticInitializerCtxt<'a, 'tcx: 'a> { impl<'a, 'tcx, 'v> Visitor<'v> for StaticInitializerCtxt<'a, 'tcx> { fn visit_expr(&mut self, ex: &Expr) { if let ast::ExprAddrOf(mutbl, ref base) = ex.node { - let param_env = ty::empty_parameter_environment(self.bccx.tcx); + let param_env = self.bccx.tcx.empty_parameter_environment(); let mc = mc::MemCategorizationContext::new(¶m_env); let base_cmt = mc.cat_expr(&**base).unwrap(); let borrow_kind = ty::BorrowKind::from_mutbl(mutbl); diff --git a/src/librustc_borrowck/borrowck/gather_loans/move_error.rs b/src/librustc_borrowck/borrowck/gather_loans/move_error.rs index 9a29ed91339e2..5baabebea116b 100644 --- a/src/librustc_borrowck/borrowck/gather_loans/move_error.rs +++ b/src/librustc_borrowck/borrowck/gather_loans/move_error.rs @@ -137,7 +137,7 @@ fn report_cannot_move_out_of<'a, 'tcx>(bccx: &BorrowckCtxt<'a, 'tcx>, mc::cat_interior(ref b, mc::InteriorField(_)) => { match b.ty.sty { ty::TyStruct(did, _) | - ty::TyEnum(did, _) if ty::has_dtor(bccx.tcx, did) => { + ty::TyEnum(did, _) if bccx.tcx.has_dtor(did) => { bccx.span_err( move_from.span, &format!("cannot move out of type `{}`, \ diff --git a/src/librustc_borrowck/borrowck/mod.rs b/src/librustc_borrowck/borrowck/mod.rs index ec92c2ed05a36..4f726044a1bac 100644 --- a/src/librustc_borrowck/borrowck/mod.rs +++ b/src/librustc_borrowck/borrowck/mod.rs @@ -29,8 +29,8 @@ use rustc::middle::dataflow::DataFlowOperator; use rustc::middle::dataflow::KillFrom; use rustc::middle::expr_use_visitor as euv; use rustc::middle::free_region::FreeRegionMap; -use rustc::middle::infer::error_reporting::note_and_explain_region; use rustc::middle::mem_categorization as mc; +use rustc::middle::mem_categorization::Typer; use rustc::middle::region; use rustc::middle::ty::{self, Ty}; @@ -662,7 +662,7 @@ impl<'a, 'tcx> BorrowckCtxt<'a, 'tcx> { .map .find(the_move.id) { Some(ast_map::NodeExpr(expr)) => { - (ty::expr_ty_adjusted(self.tcx, &*expr), expr.span) + (self.tcx.expr_ty_adjusted(&*expr), expr.span) } r => { self.tcx.sess.bug(&format!("MoveExpr({}) maps to \ @@ -696,7 +696,7 @@ impl<'a, 'tcx> BorrowckCtxt<'a, 'tcx> { } move_data::MovePat => { - let pat_ty = ty::node_id_to_type(self.tcx, the_move.id); + let pat_ty = self.tcx.node_id_to_type(the_move.id); let span = self.tcx.map.span(the_move.id); self.tcx.sess.span_note(span, &format!("`{}` moved here{} because it has type `{}`, \ @@ -713,7 +713,7 @@ impl<'a, 'tcx> BorrowckCtxt<'a, 'tcx> { .map .find(the_move.id) { Some(ast_map::NodeExpr(expr)) => { - (ty::expr_ty_adjusted(self.tcx, &*expr), expr.span) + (self.tcx.expr_ty_adjusted(&*expr), expr.span) } r => { self.tcx.sess.bug(&format!("Captured({}) maps to \ @@ -747,7 +747,7 @@ impl<'a, 'tcx> BorrowckCtxt<'a, 'tcx> { -> (&'static str, &'static str) { match ty.sty { _ => { - if ty::type_moves_by_default(param_env, span, ty) { + if param_env.type_moves_by_default(ty, span) { ("non-copyable", "perhaps you meant to use `clone()`?") } else { @@ -997,13 +997,11 @@ impl<'a, 'tcx> BorrowckCtxt<'a, 'tcx> { } err_out_of_scope(super_scope, sub_scope) => { - note_and_explain_region( - self.tcx, + self.tcx.note_and_explain_region( "reference must be valid for ", sub_scope, "..."); - note_and_explain_region( - self.tcx, + self.tcx.note_and_explain_region( "...but borrowed value is only valid for ", super_scope, ""); @@ -1020,14 +1018,12 @@ impl<'a, 'tcx> BorrowckCtxt<'a, 'tcx> { } None => self.cmt_to_string(&*err.cmt), }; - note_and_explain_region( - self.tcx, + self.tcx.note_and_explain_region( &format!("{} would have to be valid for ", descr), loan_scope, "..."); - note_and_explain_region( - self.tcx, + self.tcx.note_and_explain_region( &format!("...but {} is only valid for ", descr), ptr_scope, ""); @@ -1041,14 +1037,14 @@ impl<'a, 'tcx> BorrowckCtxt<'a, 'tcx> { match loan_path.kind { LpUpvar(ty::UpvarId{ var_id: id, closure_expr_id: _ }) | LpVar(id) => { - out.push_str(&ty::local_var_name_str(self.tcx, id)); + out.push_str(&self.tcx.local_var_name_str(id)); } LpDowncast(ref lp_base, variant_def_id) => { out.push('('); self.append_loan_path_to_string(&**lp_base, out); out.push_str(DOWNCAST_PRINTED_OPERATOR); - out.push_str(&ty::item_path_str(self.tcx, variant_def_id)); + out.push_str(&self.tcx.item_path_str(variant_def_id)); out.push(')'); } @@ -1094,7 +1090,7 @@ impl<'a, 'tcx> BorrowckCtxt<'a, 'tcx> { out.push('('); self.append_autoderefd_loan_path_to_string(&**lp_base, out); out.push(':'); - out.push_str(&ty::item_path_str(self.tcx, variant_def_id)); + out.push_str(&self.tcx.item_path_str(variant_def_id)); out.push(')'); } @@ -1184,7 +1180,7 @@ impl<'tcx> fmt::Debug for LoanPath<'tcx> { LpDowncast(ref lp, variant_def_id) => { let variant_str = if variant_def_id.krate == ast::LOCAL_CRATE { - ty::tls::with(|tcx| ty::item_path_str(tcx, variant_def_id)) + ty::tls::with(|tcx| tcx.item_path_str(variant_def_id)) } else { format!("{:?}", variant_def_id) }; @@ -1216,7 +1212,7 @@ impl<'tcx> fmt::Display for LoanPath<'tcx> { LpDowncast(ref lp, variant_def_id) => { let variant_str = if variant_def_id.krate == ast::LOCAL_CRATE { - ty::tls::with(|tcx| ty::item_path_str(tcx, variant_def_id)) + ty::tls::with(|tcx| tcx.item_path_str(variant_def_id)) } else { format!("{:?}", variant_def_id) }; diff --git a/src/librustc_driver/driver.rs b/src/librustc_driver/driver.rs index d3297562aef16..1ad3f53c328d9 100644 --- a/src/librustc_driver/driver.rs +++ b/src/librustc_driver/driver.rs @@ -648,16 +648,16 @@ pub fn phase_3_run_analysis_passes<'tcx, F, R>(sess: Session, time(time_passes, "static item recursion checking", (), |_| middle::check_static_recursion::check_crate(&sess, krate, &def_map, &ast_map)); - ty::with_ctxt(sess, - arenas, - def_map, - named_region_map, - ast_map, - freevars, - region_map, - lang_items, - stability::Index::new(krate), - |tcx| { + ty::ctxt::create_and_enter(sess, + arenas, + def_map, + named_region_map, + ast_map, + freevars, + region_map, + lang_items, + stability::Index::new(krate), + |tcx| { // passes are timed inside typeck typeck::check_crate(tcx, trait_map); diff --git a/src/librustc_driver/pretty.rs b/src/librustc_driver/pretty.rs index a40cb94204d9c..610f3f3a75ee6 100644 --- a/src/librustc_driver/pretty.rs +++ b/src/librustc_driver/pretty.rs @@ -317,7 +317,7 @@ impl<'a, 'tcx> pprust::PpAnn for TypedAnnotation<'a, 'tcx> { try!(pp::word(&mut s.s, "as")); try!(pp::space(&mut s.s)); try!(pp::word(&mut s.s, - &ty::expr_ty(self.tcx, expr).to_string())); + &self.tcx.expr_ty(expr).to_string())); s.pclose() } _ => Ok(()) diff --git a/src/librustc_driver/test.rs b/src/librustc_driver/test.rs index 02ea8859b5c75..5ec6e293684cc 100644 --- a/src/librustc_driver/test.rs +++ b/src/librustc_driver/test.rs @@ -130,16 +130,16 @@ fn test_env(source_string: &str, resolve::resolve_crate(&sess, &ast_map, resolve::MakeGlobMap::No); let named_region_map = resolve_lifetime::krate(&sess, krate, &def_map); let region_map = region::resolve_crate(&sess, krate); - ty::with_ctxt(sess, - &arenas, - def_map, - named_region_map, - ast_map, - freevars, - region_map, - lang_items, - stability::Index::new(krate), - |tcx| { + ty::ctxt::create_and_enter(sess, + &arenas, + def_map, + named_region_map, + ast_map, + freevars, + region_map, + lang_items, + stability::Index::new(krate), + |tcx| { let infcx = infer::new_infer_ctxt(tcx); body(Env { infcx: &infcx }); let free_regions = FreeRegionMap::new(); diff --git a/src/librustc_lint/builtin.rs b/src/librustc_lint/builtin.rs index 29799d34ee583..8fe07da157970 100644 --- a/src/librustc_lint/builtin.rs +++ b/src/librustc_lint/builtin.rs @@ -30,6 +30,7 @@ use metadata::{csearch, decoder}; use middle::def::*; +use middle::mem_categorization::Typer; use middle::subst::Substs; use middle::ty::{self, Ty}; use middle::{def, pat_util, stability}; @@ -142,7 +143,7 @@ impl LintPass for TypeLimits { } }, _ => { - let t = ty::expr_ty(cx.tcx, &**expr); + let t = cx.tcx.expr_ty(&**expr); match t.sty { ty::TyUint(_) => { cx.span_lint(UNSIGNED_NEGATION, e.span, @@ -168,7 +169,7 @@ impl LintPass for TypeLimits { } if is_shift_binop(binop.node) { - let opt_ty_bits = match ty::expr_ty(cx.tcx, &**l).sty { + let opt_ty_bits = match cx.tcx.expr_ty(&**l).sty { ty::TyInt(t) => Some(int_ty_bits(t, cx.sess().target.int_type)), ty::TyUint(t) => Some(uint_ty_bits(t, cx.sess().target.uint_type)), _ => None @@ -193,7 +194,7 @@ impl LintPass for TypeLimits { } }, ast::ExprLit(ref lit) => { - match ty::expr_ty(cx.tcx, e).sty { + match cx.tcx.expr_ty(e).sty { ty::TyInt(t) => { match lit.node { ast::LitInt(v, ast::SignedIntLit(_, ast::Plus)) | @@ -343,7 +344,7 @@ impl LintPass for TypeLimits { } else { binop }; - match ty::expr_ty(tcx, expr).sty { + match tcx.expr_ty(expr).sty { ty::TyInt(int_ty) => { let (min, max) = int_ty_range(int_ty); let lit_val: i64 = match lit.node { @@ -412,7 +413,7 @@ impl<'a, 'tcx> ImproperCTypesVisitor<'a, 'tcx> { None => panic!("ast_ty_to_ty_cache was incomplete after typeck!") }; - if !ty::is_ffi_safe(self.cx.tcx, tty) { + if !tty.is_ffi_safe(self.cx.tcx) { self.cx.span_lint(IMPROPER_CTYPES, sp, "found type without foreign-function-safe \ representation annotation in foreign module, consider \ @@ -482,20 +483,11 @@ pub struct BoxPointers; impl BoxPointers { fn check_heap_type<'a, 'tcx>(&self, cx: &Context<'a, 'tcx>, span: Span, ty: Ty<'tcx>) { - let mut n_uniq: usize = 0; - ty::fold_ty(cx.tcx, ty, |t| { - match t.sty { - ty::TyBox(_) => { - n_uniq += 1; - } - _ => () - }; - t - }); - - if n_uniq > 0 { - let m = format!("type uses owned (Box type) pointers: {}", ty); - cx.span_lint(BOX_POINTERS, span, &m[..]); + for leaf_ty in ty.walk() { + if let ty::TyBox(_) = leaf_ty.sty { + let m = format!("type uses owned (Box type) pointers: {}", ty); + cx.span_lint(BOX_POINTERS, span, &m); + } } } } @@ -512,7 +504,7 @@ impl LintPass for BoxPointers { ast::ItemEnum(..) | ast::ItemStruct(..) => self.check_heap_type(cx, it.span, - ty::node_id_to_type(cx.tcx, it.id)), + cx.tcx.node_id_to_type(it.id)), _ => () } @@ -521,7 +513,7 @@ impl LintPass for BoxPointers { ast::ItemStruct(ref struct_def, _) => { for struct_field in &struct_def.fields { self.check_heap_type(cx, struct_field.span, - ty::node_id_to_type(cx.tcx, struct_field.node.id)); + cx.tcx.node_id_to_type(struct_field.node.id)); } } _ => () @@ -529,7 +521,7 @@ impl LintPass for BoxPointers { } fn check_expr(&mut self, cx: &Context, e: &ast::Expr) { - let ty = ty::expr_ty(cx.tcx, e); + let ty = cx.tcx.expr_ty(e); self.check_heap_type(cx, e.span, ty); } } @@ -582,13 +574,13 @@ impl LintPass for RawPointerDerive { ast::ItemImpl(_, _, _, ref t_ref_opt, _, _) => { // Deriving the Copy trait does not cause a warning if let &Some(ref trait_ref) = t_ref_opt { - let def_id = ty::trait_ref_to_def_id(cx.tcx, trait_ref); + let def_id = cx.tcx.trait_ref_to_def_id(trait_ref); if Some(def_id) == cx.tcx.lang_items.copy_trait() { return; } } - match ty::node_id_to_type(cx.tcx, item.id).sty { + match cx.tcx.node_id_to_type(item.id).sty { ty::TyEnum(did, _) => did, ty::TyStruct(did, _) => did, _ => return, @@ -732,7 +724,7 @@ impl LintPass for UnusedResults { return; } - let t = ty::expr_ty(cx.tcx, expr); + let t = cx.tcx.expr_ty(expr); let warned = match t.sty { ty::TyTuple(ref tys) if tys.is_empty() => return, ty::TyBool => return, @@ -877,7 +869,7 @@ fn method_context(cx: &Context, id: ast::NodeId, span: Span) -> MethodContext { Some(item) => match item.container() { ty::TraitContainer(..) => MethodContext::TraitDefaultImpl, ty::ImplContainer(cid) => { - match ty::impl_trait_ref(cx.tcx, cid) { + match cx.tcx.impl_trait_ref(cid) { Some(_) => MethodContext::TraitImpl, None => MethodContext::PlainImpl } @@ -1601,7 +1593,7 @@ impl LintPass for MissingDoc { ast::ItemImpl(_, _, _, Some(ref trait_ref), _, ref impl_items) => { // If the trait is private, add the impl items to private_traits so they don't get // reported for missing docs. - let real_trait = ty::trait_ref_to_def_id(cx.tcx, trait_ref); + let real_trait = cx.tcx.trait_ref_to_def_id(trait_ref); match cx.tcx.map.find(real_trait.node) { Some(ast_map::NodeItem(item)) => if item.vis == ast::Visibility::Inherited { for itm in impl_items { @@ -1711,11 +1703,11 @@ impl LintPass for MissingCopyImplementations { } _ => return, }; - let parameter_environment = ty::empty_parameter_environment(cx.tcx); - if !ty::type_moves_by_default(¶meter_environment, item.span, ty) { + let parameter_environment = cx.tcx.empty_parameter_environment(); + if !parameter_environment.type_moves_by_default(ty, item.span) { return; } - if ty::can_type_implement_copy(¶meter_environment, item.span, ty).is_ok() { + if parameter_environment.can_type_implement_copy(ty, item.span).is_ok() { cx.span_lint(MISSING_COPY_IMPLEMENTATIONS, item.span, "type could implement `Copy`; consider adding `impl \ @@ -1763,11 +1755,11 @@ impl LintPass for MissingDebugImplementations { }; if self.impling_types.is_none() { - let debug_def = ty::lookup_trait_def(cx.tcx, debug); + let debug_def = cx.tcx.lookup_trait_def(debug); let mut impls = NodeSet(); debug_def.for_each_impl(cx.tcx, |d| { if d.krate == ast::LOCAL_CRATE { - if let Some(ty_def) = ty::ty_to_def_id(ty::node_id_to_type(cx.tcx, d.node)) { + if let Some(ty_def) = cx.tcx.node_id_to_type(d.node).ty_to_def_id() { impls.insert(ty_def.node); } } @@ -1878,7 +1870,7 @@ impl LintPass for UnconditionalRecursion { visit::FkFnBlock => return }; - let impl_def_id = ty::impl_of_method(cx.tcx, local_def(id)) + let impl_def_id = cx.tcx.impl_of_method(local_def(id)) .unwrap_or(local_def(ast::DUMMY_NODE_ID)); assert!(ast_util::is_local(impl_def_id)); let impl_node_id = impl_def_id.node; @@ -2010,7 +2002,7 @@ impl LintPass for UnconditionalRecursion { // method instead. ty::MethodTypeParam( ty::MethodParam { ref trait_ref, method_num, impl_def_id: None, }) => { - ty::trait_item(tcx, trait_ref.def_id, method_num).def_id() + tcx.trait_item(trait_ref.def_id, method_num).def_id() } // The `impl` is known, so we check that with a @@ -2175,11 +2167,11 @@ impl LintPass for MutableTransmutes { ast::ExprPath(..) => (), _ => return None } - if let DefFn(did, _) = ty::resolve_expr(cx.tcx, expr) { + if let DefFn(did, _) = cx.tcx.resolve_expr(expr) { if !def_id_is_transmute(cx, did) { return None; } - let typ = ty::node_id_to_type(cx.tcx, expr.id); + let typ = cx.tcx.node_id_to_type(expr.id); match typ.sty { ty::TyBareFn(_, ref bare_fn) if bare_fn.abi == RustIntrinsic => { if let ty::FnConverging(to) = bare_fn.sig.0.output { @@ -2194,11 +2186,11 @@ impl LintPass for MutableTransmutes { } fn def_id_is_transmute(cx: &Context, def_id: DefId) -> bool { - match ty::lookup_item_type(cx.tcx, def_id).ty.sty { + match cx.tcx.lookup_item_type(def_id).ty.sty { ty::TyBareFn(_, ref bfty) if bfty.abi == RustIntrinsic => (), _ => return false } - ty::with_path(cx.tcx, def_id, |path| match path.last() { + cx.tcx.with_path(def_id, |path| match path.last() { Some(ref last) => last.name().as_str() == "transmute", _ => false }) @@ -2251,7 +2243,7 @@ impl LintPass for DropWithReprExtern { let (drop_impl_did, dtor_self_type) = if dtor_did.krate == ast::LOCAL_CRATE { let impl_did = ctx.tcx.map.get_parent_did(dtor_did.node); - let ty = ty::lookup_item_type(ctx.tcx, impl_did).ty; + let ty = ctx.tcx.lookup_item_type(impl_did).ty; (impl_did, ty) } else { continue; @@ -2261,9 +2253,9 @@ impl LintPass for DropWithReprExtern { ty::TyEnum(self_type_did, _) | ty::TyStruct(self_type_did, _) | ty::TyClosure(self_type_did, _) => { - let hints = ty::lookup_repr_hints(ctx.tcx, self_type_did); + let hints = ctx.tcx.lookup_repr_hints(self_type_did); if hints.iter().any(|attr| *attr == attr::ReprExtern) && - ty::ty_dtor(ctx.tcx, self_type_did).has_drop_flag() { + ctx.tcx.ty_dtor(self_type_did).has_drop_flag() { let drop_impl_span = ctx.tcx.map.def_id_span(drop_impl_did, codemap::DUMMY_SP); let self_defn_span = ctx.tcx.map.def_id_span(self_type_did, diff --git a/src/librustc_privacy/lib.rs b/src/librustc_privacy/lib.rs index cae93baaf74be..24803562fa373 100644 --- a/src/librustc_privacy/lib.rs +++ b/src/librustc_privacy/lib.rs @@ -273,7 +273,7 @@ impl<'a, 'tcx, 'v> Visitor<'v> for EmbargoVisitor<'a, 'tcx> { } _ => true, }; - let tr = ty::impl_trait_ref(self.tcx, local_def(item.id)); + let tr = self.tcx.impl_trait_ref(local_def(item.id)); let public_trait = tr.clone().map_or(false, |tr| { !is_local(tr.def_id) || self.exported_items.contains(&tr.def_id.node) @@ -423,7 +423,7 @@ impl<'a, 'tcx> PrivacyVisitor<'a, 'tcx> { self.def_privacy(id) } ty::ImplContainer(id) => { - match ty::impl_trait_ref(self.tcx, id) { + match self.tcx.impl_trait_ref(id) { Some(t) => { debug!("privacy - impl of trait {:?}", id); self.def_privacy(t.def_id) @@ -451,7 +451,7 @@ impl<'a, 'tcx> PrivacyVisitor<'a, 'tcx> { self.def_privacy(id) } ty::ImplContainer(id) => { - match ty::impl_trait_ref(self.tcx, id) { + match self.tcx.impl_trait_ref(id) { Some(t) => { debug!("privacy - impl of trait {:?}", id); self.def_privacy(t.def_id) @@ -476,7 +476,7 @@ impl<'a, 'tcx> PrivacyVisitor<'a, 'tcx> { self.def_privacy(id) } ty::ImplContainer(id) => { - match ty::impl_trait_ref(self.tcx, id) { + match self.tcx.impl_trait_ref(id) { Some(t) => { debug!("privacy - impl of trait {:?}", id); self.def_privacy(t.def_id) @@ -537,7 +537,7 @@ impl<'a, 'tcx> PrivacyVisitor<'a, 'tcx> { ast::MethodImplItem(..) => { let imp = self.tcx.map .get_parent_did(closest_private_id); - match ty::impl_trait_ref(self.tcx, imp) { + match self.tcx.impl_trait_ref(imp) { Some(..) => return Allowable, _ if ii.vis == ast::Public => { return Allowable @@ -696,7 +696,7 @@ impl<'a, 'tcx> PrivacyVisitor<'a, 'tcx> { span: Span, id: ast::DefId, name: FieldName) { - let fields = ty::lookup_struct_fields(self.tcx, id); + let fields = self.tcx.lookup_struct_fields(id); let field = match name { NamedField(f_name) => { debug!("privacy - check named field {} in struct {:?}", f_name, id); @@ -709,10 +709,10 @@ impl<'a, 'tcx> PrivacyVisitor<'a, 'tcx> { return } - let struct_type = ty::lookup_item_type(self.tcx, id).ty; + let struct_type = self.tcx.lookup_item_type(id).ty; let struct_desc = match struct_type.sty { ty::TyStruct(_, _) => - format!("struct `{}`", ty::item_path_str(self.tcx, id)), + format!("struct `{}`", self.tcx.item_path_str(id)), // struct variant fields have inherited visibility ty::TyEnum(..) => return, _ => self.tcx.sess.span_bug(span, "can't find struct for field") @@ -733,7 +733,7 @@ impl<'a, 'tcx> PrivacyVisitor<'a, 'tcx> { name: ast::Name) { // If the method is a default method, we need to use the def_id of // the default implementation. - let method_id = match ty::impl_or_trait_item(self.tcx, method_id) { + let method_id = match self.tcx.impl_or_trait_item(method_id) { ty::MethodTraitItem(method_type) => { method_type.provided_source.unwrap_or(method_id) } @@ -893,12 +893,12 @@ impl<'a, 'tcx, 'v> Visitor<'v> for PrivacyVisitor<'a, 'tcx> { fn visit_expr(&mut self, expr: &ast::Expr) { match expr.node { ast::ExprField(ref base, ident) => { - if let ty::TyStruct(id, _) = ty::expr_ty_adjusted(self.tcx, &**base).sty { + if let ty::TyStruct(id, _) = self.tcx.expr_ty_adjusted(&**base).sty { self.check_field(expr.span, id, NamedField(ident.node.name)); } } ast::ExprTupField(ref base, idx) => { - if let ty::TyStruct(id, _) = ty::expr_ty_adjusted(self.tcx, &**base).sty { + if let ty::TyStruct(id, _) = self.tcx.expr_ty_adjusted(&**base).sty { self.check_field(expr.span, id, UnnamedField(idx.node)); } } @@ -917,12 +917,12 @@ impl<'a, 'tcx, 'v> Visitor<'v> for PrivacyVisitor<'a, 'tcx> { } } ast::ExprStruct(_, ref fields, _) => { - match ty::expr_ty(self.tcx, expr).sty { + match self.tcx.expr_ty(expr).sty { ty::TyStruct(ctor_id, _) => { // RFC 736: ensure all unmentioned fields are visible. // Rather than computing the set of unmentioned fields // (i.e. `all_fields - fields`), just check them all. - let all_fields = ty::lookup_struct_fields(self.tcx, ctor_id); + let all_fields = self.tcx.lookup_struct_fields(ctor_id); for field in all_fields { self.check_field(expr.span, ctor_id, NamedField(field.name)); @@ -950,7 +950,7 @@ impl<'a, 'tcx, 'v> Visitor<'v> for PrivacyVisitor<'a, 'tcx> { } ast::ExprPath(..) => { let guard = |did: ast::DefId| { - let fields = ty::lookup_struct_fields(self.tcx, did); + let fields = self.tcx.lookup_struct_fields(did); let any_priv = fields.iter().any(|f| { f.vis != ast::Public && ( !is_local(f.id) || @@ -994,7 +994,7 @@ impl<'a, 'tcx, 'v> Visitor<'v> for PrivacyVisitor<'a, 'tcx> { match pattern.node { ast::PatStruct(_, ref fields, _) => { - match ty::pat_ty(self.tcx, pattern).sty { + match self.tcx.pat_ty(pattern).sty { ty::TyStruct(id, _) => { for field in fields { self.check_field(pattern.span, id, @@ -1025,7 +1025,7 @@ impl<'a, 'tcx, 'v> Visitor<'v> for PrivacyVisitor<'a, 'tcx> { // Patterns which bind no fields are allowable (the path is check // elsewhere). ast::PatEnum(_, Some(ref fields)) => { - match ty::pat_ty(self.tcx, pattern).sty { + match self.tcx.pat_ty(pattern).sty { ty::TyStruct(id, _) => { for (i, field) in fields.iter().enumerate() { if let ast::PatWild(..) = field.node { @@ -1337,7 +1337,7 @@ impl<'a, 'tcx, 'v> Visitor<'v> for VisiblePrivateTypesVisitor<'a, 'tcx> { let not_private_trait = trait_ref.as_ref().map_or(true, // no trait counts as public trait |tr| { - let did = ty::trait_ref_to_def_id(self.tcx, tr); + let did = self.tcx.trait_ref_to_def_id(tr); !is_local(did) || self.trait_is_public(did.node) }); diff --git a/src/librustc_trans/save/dump_csv.rs b/src/librustc_trans/save/dump_csv.rs index 65d9d9809c926..5ddad0e1947e8 100644 --- a/src/librustc_trans/save/dump_csv.rs +++ b/src/librustc_trans/save/dump_csv.rs @@ -311,7 +311,7 @@ impl <'l, 'tcx> DumpCsvVisitor<'l, 'tcx> { let mut scope_id; // The qualname for a method is the trait name or name of the struct in an impl in // which the method is declared in, followed by the method's name. - let qualname = match ty::impl_of_method(self.tcx, ast_util::local_def(id)) { + let qualname = match self.tcx.impl_of_method(ast_util::local_def(id)) { Some(impl_id) => match self.tcx.map.get(impl_id.node) { NodeItem(item) => { scope_id = item.id; @@ -320,11 +320,11 @@ impl <'l, 'tcx> DumpCsvVisitor<'l, 'tcx> { let mut result = String::from("<"); result.push_str(&ty_to_string(&**ty)); - match ty::trait_of_item(self.tcx, ast_util::local_def(id)) { + match self.tcx.trait_of_item(ast_util::local_def(id)) { Some(def_id) => { result.push_str(" as "); result.push_str( - &ty::item_path_str(self.tcx, def_id)); + &self.tcx.item_path_str(def_id)); }, None => {} } @@ -344,12 +344,12 @@ impl <'l, 'tcx> DumpCsvVisitor<'l, 'tcx> { impl_id.node, id, self.tcx.map.get(impl_id.node))); }, }, - None => match ty::trait_of_item(self.tcx, ast_util::local_def(id)) { + None => match self.tcx.trait_of_item(ast_util::local_def(id)) { Some(def_id) => { scope_id = def_id.node; match self.tcx.map.get(def_id.node) { NodeItem(_) => { - format!("::{}", ty::item_path_str(self.tcx, def_id)) + format!("::{}", self.tcx.item_path_str(def_id)) } _ => { self.sess.span_bug(span, @@ -368,7 +368,7 @@ impl <'l, 'tcx> DumpCsvVisitor<'l, 'tcx> { let qualname = &format!("{}::{}", qualname, &token::get_name(name)); // record the decl for this def (if it has one) - let decl_id = ty::trait_item_of_item(self.tcx, ast_util::local_def(id)) + let decl_id = self.tcx.trait_item_of_item(ast_util::local_def(id)) .and_then(|new_id| { let def_id = new_id.def_id(); if def_id.node != 0 && def_id != ast_util::local_def(id) { @@ -776,10 +776,10 @@ impl <'l, 'tcx> DumpCsvVisitor<'l, 'tcx> { def::DefMethod(declid, provenence) => { let sub_span = self.span.sub_span_for_meth_name(span); let defid = if declid.krate == ast::LOCAL_CRATE { - let ti = ty::impl_or_trait_item(self.tcx, declid); + let ti = self.tcx.impl_or_trait_item(declid); match provenence { def::FromTrait(def_id) => { - Some(ty::trait_items(self.tcx, def_id) + Some(self.tcx.trait_items(def_id) .iter() .find(|mr| { mr.name() == ti.name() @@ -793,10 +793,8 @@ impl <'l, 'tcx> DumpCsvVisitor<'l, 'tcx> { .unwrap() .iter() .find(|mr| { - ty::impl_or_trait_item( - self.tcx, - mr.def_id() - ).name() == ti.name() + self.tcx.impl_or_trait_item(mr.def_id()).name() + == ti.name() }) .unwrap() .def_id()) @@ -826,7 +824,7 @@ impl <'l, 'tcx> DumpCsvVisitor<'l, 'tcx> { // modules or types in the path prefix match def { def::DefMethod(did, _) => { - let ti = ty::impl_or_trait_item(self.tcx, did); + let ti = self.tcx.impl_or_trait_item(did); if let ty::MethodTraitItem(m) = ti { if m.explicit_self == ty::StaticExplicitSelfCategory { self.write_sub_path_trait_truncated(path); @@ -895,14 +893,14 @@ impl <'l, 'tcx> DumpCsvVisitor<'l, 'tcx> { ty::MethodStaticClosure(def_id) => { // method invoked on an object with a concrete type (not a static method) let decl_id = - match ty::trait_item_of_item(self.tcx, def_id) { + match self.tcx.trait_item_of_item(def_id) { None => None, Some(decl_id) => Some(decl_id.def_id()), }; // This incantation is required if the method referenced is a // trait's default implementation. - let def_id = match ty::impl_or_trait_item(self.tcx, def_id) { + let def_id = match self.tcx.impl_or_trait_item(def_id) { ty::MethodTraitItem(method) => { method.provided_source.unwrap_or(def_id) } @@ -915,16 +913,14 @@ impl <'l, 'tcx> DumpCsvVisitor<'l, 'tcx> { } ty::MethodTypeParam(ref mp) => { // method invoked on a type parameter - let trait_item = ty::trait_item(self.tcx, - mp.trait_ref.def_id, - mp.method_num); + let trait_item = self.tcx.trait_item(mp.trait_ref.def_id, + mp.method_num); (None, Some(trait_item.def_id())) } ty::MethodTraitObject(ref mo) => { // method invoked on a trait instance - let trait_item = ty::trait_item(self.tcx, - mo.trait_ref.def_id, - mo.method_num); + let trait_item = self.tcx.trait_item(mo.trait_ref.def_id, + mo.method_num); (None, Some(trait_item.def_id())) } }; @@ -953,7 +949,7 @@ impl <'l, 'tcx> DumpCsvVisitor<'l, 'tcx> { def::DefConst(..) | def::DefAssociatedConst(..) => None, def::DefVariant(_, variant_id, _) => Some(variant_id), _ => { - match ty::ty_to_def_id(ty::node_id_to_type(self.tcx, p.id)) { + match self.tcx.node_id_to_type(p.id).ty_to_def_id() { None => { self.sess.span_bug(p.span, &format!("Could not find struct_def for `{}`", @@ -965,7 +961,7 @@ impl <'l, 'tcx> DumpCsvVisitor<'l, 'tcx> { }; if let Some(struct_def) = struct_def { - let struct_fields = ty::lookup_struct_fields(self.tcx, struct_def); + let struct_fields = self.tcx.lookup_struct_fields(struct_def); for &Spanned { node: ref field, span } in fields { let sub_span = self.span.span_for_first_ident(span); for f in &struct_fields { @@ -1252,10 +1248,10 @@ impl<'l, 'tcx, 'v> Visitor<'v> for DumpCsvVisitor<'l, 'tcx> { self.visit_expr(&**sub_ex); - let ty = &ty::expr_ty_adjusted(self.tcx, &**sub_ex).sty; + let ty = &self.tcx.expr_ty_adjusted(&**sub_ex).sty; match *ty { ty::TyStruct(def_id, _) => { - let fields = ty::lookup_struct_fields(self.tcx, def_id); + let fields = self.tcx.lookup_struct_fields(def_id); for (i, f) in fields.iter().enumerate() { if i == idx.node { let sub_span = self.span.sub_span_after_token(ex.span, token::Dot); diff --git a/src/librustc_trans/save/mod.rs b/src/librustc_trans/save/mod.rs index fdfb101ed78cc..27805b9d8330b 100644 --- a/src/librustc_trans/save/mod.rs +++ b/src/librustc_trans/save/mod.rs @@ -327,10 +327,10 @@ impl<'l, 'tcx: 'l> SaveContext<'l, 'tcx> { pub fn get_expr_data(&self, expr: &ast::Expr) -> Option { match expr.node { ast::ExprField(ref sub_ex, ident) => { - let ty = &ty::expr_ty_adjusted(self.tcx, &sub_ex).sty; + let ty = &self.tcx.expr_ty_adjusted(&sub_ex).sty; match *ty { ty::TyStruct(def_id, _) => { - let fields = ty::lookup_struct_fields(self.tcx, def_id); + let fields = self.tcx.lookup_struct_fields(def_id); for f in &fields { if f.name == ident.node.name { let sub_span = self.span_utils.span_for_last_ident(expr.span); @@ -354,7 +354,7 @@ impl<'l, 'tcx: 'l> SaveContext<'l, 'tcx> { } } ast::ExprStruct(ref path, _, _) => { - let ty = &ty::expr_ty_adjusted(&self.tcx, expr).sty; + let ty = &self.tcx.expr_ty_adjusted(expr).sty; match *ty { ty::TyStruct(def_id, _) => { let sub_span = self.span_utils.span_for_last_ident(path.span); @@ -384,7 +384,7 @@ impl<'l, 'tcx: 'l> SaveContext<'l, 'tcx> { struct_id: DefId, parent: NodeId) -> VariableRefData { - let fields = ty::lookup_struct_fields(&self.tcx, struct_id); + let fields = self.tcx.lookup_struct_fields(struct_id); let field_name = get_ident(field_ref.ident.node).to_string(); for f in &fields { if f.name == field_ref.ident.node.name { diff --git a/src/librustc_trans/trans/_match.rs b/src/librustc_trans/trans/_match.rs index 4667e36c64a9a..47c2a5e579d94 100644 --- a/src/librustc_trans/trans/_match.rs +++ b/src/librustc_trans/trans/_match.rs @@ -197,6 +197,7 @@ use middle::def::{self, DefMap}; use middle::expr_use_visitor as euv; use middle::lang_items::StrEqFnLangItem; use middle::mem_categorization as mc; +use middle::mem_categorization::Typer; use middle::pat_util::*; use trans::adt; use trans::base::*; @@ -235,7 +236,7 @@ struct ConstantExpr<'a>(&'a ast::Expr); impl<'a> ConstantExpr<'a> { fn eq(self, other: ConstantExpr<'a>, tcx: &ty::ctxt) -> bool { match const_eval::compare_lit_exprs(tcx, self.0, other.0, None, - |id| {ty::node_id_item_substs(tcx, id).substs}) { + |id| {tcx.node_id_item_substs(id).substs}) { Some(result) => result == Ordering::Equal, None => panic!("compare_list_exprs: type mismatch"), } @@ -279,7 +280,7 @@ impl<'a, 'tcx> Opt<'a, 'tcx> { let ccx = bcx.ccx(); match *self { ConstantValue(ConstantExpr(lit_expr), _) => { - let lit_ty = ty::node_id_to_type(bcx.tcx(), lit_expr.id); + let lit_ty = bcx.tcx().node_id_to_type(lit_expr.id); let (llval, _) = consts::const_expr(ccx, &*lit_expr, bcx.fcx.param_substs, None); let lit_datum = immediate_rvalue(llval, lit_ty); let lit_datum = unpack_datum!(bcx, lit_datum.to_appropriate_datum(bcx)); @@ -562,7 +563,7 @@ fn enter_opt<'a, 'p, 'blk, 'tcx>( check_match::Constructor::Variant(def_id) }; - let param_env = ty::empty_parameter_environment(bcx.tcx()); + let param_env = bcx.tcx().empty_parameter_environment(); let mcx = check_match::MatchCheckCtxt { tcx: bcx.tcx(), param_env: param_env, @@ -603,7 +604,7 @@ fn get_branches<'a, 'p, 'blk, 'tcx>(bcx: Block<'blk, 'tcx>, let opt_def = tcx.def_map.borrow().get(&cur.id).map(|d| d.full_def()); match opt_def { Some(def::DefVariant(enum_id, var_id, _)) => { - let variant = ty::enum_variant_with_id(tcx, enum_id, var_id); + let variant = tcx.enum_variant_with_id(enum_id, var_id); Variant(variant.disr_val, adt::represent_node(bcx, cur.id), var_id, @@ -1067,7 +1068,7 @@ fn compile_submatch_continue<'a, 'p, 'blk, 'tcx>(mut bcx: Block<'blk, 'tcx>, let mcx = check_match::MatchCheckCtxt { tcx: bcx.tcx(), - param_env: ty::empty_parameter_environment(bcx.tcx()), + param_env: bcx.tcx().empty_parameter_environment(), }; let adt_vals = if any_irrefutable_adt_pat(bcx.tcx(), m, col) { let repr = adt::represent_type(bcx.ccx(), left_ty); @@ -1090,9 +1091,9 @@ fn compile_submatch_continue<'a, 'p, 'blk, 'tcx>(mut bcx: Block<'blk, 'tcx>, // The last field is technically unsized but // since we can only ever match that field behind // a reference we construct a fat ptr here. - let fields = ty::lookup_struct_fields(bcx.tcx(), def_id); + let fields = bcx.tcx().lookup_struct_fields(def_id); let unsized_ty = fields.iter().last().map(|field| { - let fty = ty::lookup_field_type(bcx.tcx(), def_id, field.id, substs); + let fty = bcx.tcx().lookup_field_type(def_id, field.id, substs); monomorphize::normalize_associated_type(bcx.tcx(), &fty) }).unwrap(); let llty = type_of::type_of(bcx.ccx(), unsized_ty); @@ -1409,13 +1410,13 @@ fn create_bindings_map<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, pat: &ast::Pat, let variable_ty = node_id_type(bcx, p_id); let llvariable_ty = type_of::type_of(ccx, variable_ty); let tcx = bcx.tcx(); - let param_env = ty::empty_parameter_environment(tcx); + let param_env = tcx.empty_parameter_environment(); let llmatch; let trmode; match bm { ast::BindByValue(_) - if !ty::type_moves_by_default(¶m_env, span, variable_ty) || reassigned => + if !param_env.type_moves_by_default(variable_ty, span) || reassigned => { llmatch = alloca_no_lifetime(bcx, llvariable_ty.ptr_to(), @@ -1468,7 +1469,7 @@ fn trans_match_inner<'blk, 'tcx>(scope_cx: Block<'blk, 'tcx>, } let t = node_id_type(bcx, discr_expr.id); - let chk = if ty::type_is_empty(tcx, t) { + let chk = if t.is_empty(tcx) { Unreachable } else { Infallible @@ -1747,9 +1748,7 @@ fn bind_irrefutable_pat<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, match opt_def { Some(def::DefVariant(enum_id, var_id, _)) => { let repr = adt::represent_node(bcx, pat.id); - let vinfo = ty::enum_variant_with_id(ccx.tcx(), - enum_id, - var_id); + let vinfo = ccx.tcx().enum_variant_with_id(enum_id, var_id); let args = extract_variant_args(bcx, &*repr, vinfo.disr_val, @@ -1789,7 +1788,7 @@ fn bind_irrefutable_pat<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, let pat_repr = adt::represent_type(bcx.ccx(), pat_ty); expr::with_field_tys(tcx, pat_ty, Some(pat.id), |discr, field_tys| { for f in fields { - let ix = ty::field_idx_strict(tcx, f.node.ident.name, field_tys); + let ix = tcx.field_idx_strict(f.node.ident.name, field_tys); let fldptr = adt::trans_field_ptr(bcx, &*pat_repr, val, discr, ix); bcx = bind_irrefutable_pat(bcx, &*f.node.pat, fldptr, cleanup_scope); diff --git a/src/librustc_trans/trans/adt.rs b/src/librustc_trans/trans/adt.rs index 255920aa96d54..3ce76167e8517 100644 --- a/src/librustc_trans/trans/adt.rs +++ b/src/librustc_trans/trans/adt.rs @@ -209,13 +209,13 @@ fn represent_type_uncached<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, Univariant(mk_struct(cx, &elems[..], false, t), 0) } ty::TyStruct(def_id, substs) => { - let fields = ty::lookup_struct_fields(cx.tcx(), def_id); + let fields = cx.tcx().lookup_struct_fields(def_id); let mut ftys = fields.iter().map(|field| { - let fty = ty::lookup_field_type(cx.tcx(), def_id, field.id, substs); + let fty = cx.tcx().lookup_field_type(def_id, field.id, substs); monomorphize::normalize_associated_type(cx.tcx(), &fty) }).collect::>(); - let packed = ty::lookup_packed(cx.tcx(), def_id); - let dtor = ty::ty_dtor(cx.tcx(), def_id).has_drop_flag(); + let packed = cx.tcx().lookup_packed(def_id); + let dtor = cx.tcx().ty_dtor(def_id).has_drop_flag(); if dtor { ftys.push(cx.tcx().dtor_type()); } @@ -230,10 +230,10 @@ fn represent_type_uncached<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, } ty::TyEnum(def_id, substs) => { let cases = get_cases(cx.tcx(), def_id, substs); - let hint = *ty::lookup_repr_hints(cx.tcx(), def_id).get(0) + let hint = *cx.tcx().lookup_repr_hints(def_id).get(0) .unwrap_or(&attr::ReprAny); - let dtor = ty::ty_dtor(cx.tcx(), def_id).has_drop_flag(); + let dtor = cx.tcx().ty_dtor(def_id).has_drop_flag(); if cases.is_empty() { // Uninhabitable; represent as unit @@ -261,9 +261,8 @@ fn represent_type_uncached<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, // been rejected by a checker before this point. if !cases.iter().enumerate().all(|(i,c)| c.discr == (i as Disr)) { cx.sess().bug(&format!("non-C-like enum {} with specified \ - discriminants", - ty::item_path_str(cx.tcx(), - def_id))); + discriminants", + cx.tcx().item_path_str(def_id))); } if cases.len() == 1 { @@ -411,9 +410,9 @@ fn find_discr_field_candidate<'tcx>(tcx: &ty::ctxt<'tcx>, // Is this the NonZero lang item wrapping a pointer or integer type? ty::TyStruct(did, substs) if Some(did) == tcx.lang_items.non_zero() => { - let nonzero_fields = ty::lookup_struct_fields(tcx, did); + let nonzero_fields = tcx.lookup_struct_fields(did); assert_eq!(nonzero_fields.len(), 1); - let nonzero_field = ty::lookup_field_type(tcx, did, nonzero_fields[0].id, substs); + let nonzero_field = tcx.lookup_field_type(did, nonzero_fields[0].id, substs); match nonzero_field.sty { ty::TyRawPtr(ty::mt { ty, .. }) if !type_is_sized(tcx, ty) => { path.push_all(&[0, FAT_PTR_ADDR]); @@ -430,9 +429,9 @@ fn find_discr_field_candidate<'tcx>(tcx: &ty::ctxt<'tcx>, // Perhaps one of the fields of this struct is non-zero // let's recurse and find out ty::TyStruct(def_id, substs) => { - let fields = ty::lookup_struct_fields(tcx, def_id); + let fields = tcx.lookup_struct_fields(def_id); for (j, field) in fields.iter().enumerate() { - let field_ty = ty::lookup_field_type(tcx, def_id, field.id, substs); + let field_ty = tcx.lookup_field_type(def_id, field.id, substs); if let Some(mut fpath) = find_discr_field_candidate(tcx, field_ty, path.clone()) { fpath.push(j); return Some(fpath); @@ -504,7 +503,7 @@ fn get_cases<'tcx>(tcx: &ty::ctxt<'tcx>, def_id: ast::DefId, substs: &subst::Substs<'tcx>) -> Vec> { - ty::enum_variants(tcx, def_id).iter().map(|vi| { + tcx.enum_variants(def_id).iter().map(|vi| { let arg_tys = vi.args.iter().map(|&raw_ty| { monomorphize::apply_param_substs(tcx, substs, &raw_ty) }).collect(); diff --git a/src/librustc_trans/trans/attributes.rs b/src/librustc_trans/trans/attributes.rs index db29a43afce77..b432560bc4b3c 100644 --- a/src/librustc_trans/trans/attributes.rs +++ b/src/librustc_trans/trans/attributes.rs @@ -153,7 +153,7 @@ pub fn from_fn_type<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, fn_type: ty::Ty<'tcx _ => ccx.sess().bug("expected closure or function.") }; - let fn_sig = ty::erase_late_bound_regions(ccx.tcx(), fn_sig); + let fn_sig = ccx.tcx().erase_late_bound_regions(fn_sig); let mut attrs = llvm::AttrBuilder::new(); let ret_ty = fn_sig.output; @@ -274,7 +274,7 @@ pub fn from_fn_type<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, fn_type: ty::Ty<'tcx // `&T` where `T` contains no `UnsafeCell` is immutable, and can be marked as // both `readonly` and `noalias`, as LLVM's definition of `noalias` is based solely // on memory dependencies rather than pointer equality - let interior_unsafe = ty::type_contents(ccx.tcx(), mt.ty).interior_unsafe(); + let interior_unsafe = mt.ty.type_contents(ccx.tcx()).interior_unsafe(); if mt.mutbl == ast::MutMutable || !interior_unsafe { attrs.arg(idx, llvm::Attribute::NoAlias); diff --git a/src/librustc_trans/trans/base.rs b/src/librustc_trans/trans/base.rs index b86bf67869d77..42108d6d6e7b7 100644 --- a/src/librustc_trans/trans/base.rs +++ b/src/librustc_trans/trans/base.rs @@ -232,7 +232,7 @@ pub fn get_extern_const<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, did: ast::DefId, // don't do this then linker errors can be generated where the linker // complains that one object files has a thread local version of the // symbol and another one doesn't. - for attr in ty::get_attrs(ccx.tcx(), did).iter() { + for attr in ccx.tcx().get_attrs(did).iter() { if attr.check_name("thread_local") { llvm::set_thread_local(c, true); } @@ -462,7 +462,7 @@ pub fn iter_structural_ty<'blk, 'tcx, F>(cx: Block<'blk, 'tcx>, let ccx = fcx.ccx; let repr = adt::represent_type(ccx, t); - let variants = ty::enum_variants(ccx.tcx(), tid); + let variants = ccx.tcx().enum_variants(tid); let n_variants = (*variants).len(); // NB: we must hit the discriminant first so that structural @@ -1216,7 +1216,7 @@ pub fn new_fn_ctxt<'a, 'tcx>(ccx: &'a CrateContext<'a, 'tcx>, llfn: llfndecl, llenv: None, llretslotptr: Cell::new(None), - param_env: ty::empty_parameter_environment(ccx.tcx()), + param_env: ccx.tcx().empty_parameter_environment(), alloca_insert_pt: Cell::new(None), llreturn: Cell::new(None), needs_ret_allocas: nested_returns, @@ -1668,8 +1668,8 @@ pub fn trans_fn<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, let _s = StatRecorder::new(ccx, ccx.tcx().map.path_to_string(id).to_string()); debug!("trans_fn(param_substs={:?})", param_substs); let _icx = push_ctxt("trans_fn"); - let fn_ty = ty::node_id_to_type(ccx.tcx(), id); - let output_type = ty::erase_late_bound_regions(ccx.tcx(), &fn_ty.fn_ret()); + let fn_ty = ccx.tcx().node_id_to_type(id); + let output_type = ccx.tcx().erase_late_bound_regions(&fn_ty.fn_ret()); let abi = fn_ty.fn_abi(); trans_closure(ccx, decl, body, llfndecl, param_substs, id, attrs, output_type, abi, closure::ClosureEnv::NotClosure); @@ -1704,7 +1704,7 @@ pub fn trans_named_tuple_constructor<'blk, 'tcx>(mut bcx: Block<'blk, 'tcx>, let result_ty = match ctor_ty.sty { ty::TyBareFn(_, ref bft) => { - ty::erase_late_bound_regions(bcx.tcx(), &bft.sig.output()).unwrap() + bcx.tcx().erase_late_bound_regions(&bft.sig.output()).unwrap() } _ => ccx.sess().bug( &format!("trans_enum_variant_constructor: \ @@ -1777,12 +1777,12 @@ fn trans_enum_variant_or_tuple_like_struct<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx disr: ty::Disr, param_substs: &'tcx Substs<'tcx>, llfndecl: ValueRef) { - let ctor_ty = ty::node_id_to_type(ccx.tcx(), ctor_id); + let ctor_ty = ccx.tcx().node_id_to_type(ctor_id); let ctor_ty = monomorphize::apply_param_substs(ccx.tcx(), param_substs, &ctor_ty); let result_ty = match ctor_ty.sty { ty::TyBareFn(_, ref bft) => { - ty::erase_late_bound_regions(ccx.tcx(), &bft.sig.output()) + ccx.tcx().erase_late_bound_regions(&bft.sig.output()) } _ => ccx.sess().bug( &format!("trans_enum_variant_or_tuple_like_struct: \ @@ -1798,9 +1798,7 @@ fn trans_enum_variant_or_tuple_like_struct<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx assert!(!fcx.needs_ret_allocas); - let arg_tys = - ty::erase_late_bound_regions( - ccx.tcx(), &ctor_ty.fn_args()); + let arg_tys = ccx.tcx().erase_late_bound_regions(&ctor_ty.fn_args()); let arg_datums = create_datums_for_fn_args(bcx, &arg_tys[..]); @@ -1836,7 +1834,7 @@ fn enum_variant_size_lint(ccx: &CrateContext, enum_def: &ast::EnumDef, sp: Span, return } - let ty = ty::node_id_to_type(ccx.tcx(), id); + let ty = ccx.tcx().node_id_to_type(id); let avar = adt::represent_type(ccx, ty); match *avar { adt::General(_, ref variants, _) => { @@ -2035,7 +2033,7 @@ pub fn trans_item(ccx: &CrateContext, item: &ast::Item) { // error in trans. This is used to write compile-fail tests // that actually test that compilation succeeds without // reporting an error. - if ty::has_attr(ccx.tcx(), local_def(item.id), "rustc_error") { + if ccx.tcx().has_attr(local_def(item.id), "rustc_error") { ccx.tcx().sess.span_fatal(item.span, "compilation successful"); } } @@ -2314,7 +2312,7 @@ pub fn get_item_val(ccx: &CrateContext, id: ast::NodeId) -> ValueRef { debug!("get_item_val: id={} item={:?}", id, item); let val = match item { ast_map::NodeItem(i) => { - let ty = ty::node_id_to_type(ccx.tcx(), i.id); + let ty = ccx.tcx().node_id_to_type(i.id); let sym = || exported_name(ccx, id, ty, &i.attrs); let v = match i.node { @@ -2421,7 +2419,7 @@ pub fn get_item_val(ccx: &CrateContext, id: ast::NodeId) -> ValueRef { match ni.node { ast::ForeignItemFn(..) => { let abi = ccx.tcx().map.get_foreign_abi(id); - let ty = ty::node_id_to_type(ccx.tcx(), ni.id); + let ty = ccx.tcx().node_id_to_type(ni.id); let name = foreign::link_name(&*ni); let llfn = foreign::register_foreign_item_fn(ccx, abi, ty, &name); attributes::from_fn_attrs(ccx, &ni.attrs, llfn); @@ -2442,7 +2440,7 @@ pub fn get_item_val(ccx: &CrateContext, id: ast::NodeId) -> ValueRef { } }; assert!(!args.is_empty()); - let ty = ty::node_id_to_type(ccx.tcx(), id); + let ty = ccx.tcx().node_id_to_type(id); let parent = ccx.tcx().map.get_parent(id); let enm = ccx.tcx().map.expect_item(parent); let sym = exported_name(ccx, @@ -2471,7 +2469,7 @@ pub fn get_item_val(ccx: &CrateContext, id: ast::NodeId) -> ValueRef { }; let parent = ccx.tcx().map.get_parent(id); let struct_item = ccx.tcx().map.expect_item(parent); - let ty = ty::node_id_to_type(ccx.tcx(), ctor_id); + let ty = ccx.tcx().node_id_to_type(ctor_id); let sym = exported_name(ccx, id, ty, @@ -2503,7 +2501,7 @@ pub fn get_item_val(ccx: &CrateContext, id: ast::NodeId) -> ValueRef { fn register_method(ccx: &CrateContext, id: ast::NodeId, attrs: &[ast::Attribute], span: Span) -> ValueRef { - let mty = ty::node_id_to_type(ccx.tcx(), id); + let mty = ccx.tcx().node_id_to_type(id); let sym = exported_name(ccx, id, mty, &attrs); diff --git a/src/librustc_trans/trans/callee.rs b/src/librustc_trans/trans/callee.rs index a7c01036f845e..24abe0ed3fdd2 100644 --- a/src/librustc_trans/trans/callee.rs +++ b/src/librustc_trans/trans/callee.rs @@ -173,7 +173,7 @@ fn trans<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, expr: &ast::Expr) bcx.fcx.param_substs).val) } def::DefVariant(tid, vid, _) => { - let vinfo = ty::enum_variant_with_id(bcx.tcx(), tid, vid); + let vinfo = bcx.tcx().enum_variant_with_id(tid, vid); let substs = common::node_id_substs(bcx.ccx(), ExprId(ref_expr.id), bcx.fcx.param_substs); @@ -307,7 +307,7 @@ pub fn trans_fn_pointer_shim<'a, 'tcx>( bare_fn_ty)); } }; - let sig = ty::erase_late_bound_regions(tcx, sig); + let sig = tcx.erase_late_bound_regions(sig); let tuple_input_ty = tcx.mk_tup(sig.inputs.to_vec()); let tuple_fn_ty = tcx.mk_fn(opt_def_id, tcx.mk_bare_fn(ty::BareFnTy { @@ -406,17 +406,17 @@ pub fn trans_fn_ref_with_substs<'a, 'tcx>( let substs = substs.erase_regions(); // Load the info for the appropriate trait if necessary. - match ty::trait_of_item(tcx, def_id) { + match tcx.trait_of_item(def_id) { None => {} Some(trait_id) => { - ty::populate_implementations_for_trait_if_necessary(tcx, trait_id) + tcx.populate_implementations_for_trait_if_necessary(trait_id) } } // We need to do a bunch of special handling for default methods. // We need to modify the def_id and our substs in order to monomorphize // the function. - let (is_default, def_id, substs) = match ty::provided_source(tcx, def_id) { + let (is_default, def_id, substs) = match tcx.provided_source(def_id) { None => { (false, def_id, tcx.mk_substs(substs)) } @@ -434,16 +434,16 @@ pub fn trans_fn_ref_with_substs<'a, 'tcx>( // So, what we need to do is find this substitution and // compose it with the one we already have. - let impl_id = ty::impl_or_trait_item(tcx, def_id).container() + let impl_id = tcx.impl_or_trait_item(def_id).container() .id(); - let impl_or_trait_item = ty::impl_or_trait_item(tcx, source_id); + let impl_or_trait_item = tcx.impl_or_trait_item(source_id); match impl_or_trait_item { ty::MethodTraitItem(method) => { - let trait_ref = ty::impl_trait_ref(tcx, impl_id).unwrap(); + let trait_ref = tcx.impl_trait_ref(impl_id).unwrap(); // Compute the first substitution let first_subst = - ty::make_substs_for_receiver_types(tcx, &trait_ref, &*method) + tcx.make_substs_for_receiver_types(&trait_ref, &*method) .erase_regions(); // And compose them @@ -516,7 +516,7 @@ pub fn trans_fn_ref_with_substs<'a, 'tcx>( // Monotype of the REFERENCE to the function (type params // are subst'd) let ref_ty = match node { - ExprId(id) => ty::node_id_to_type(tcx, id), + ExprId(id) => tcx.node_id_to_type(id), MethodCallKey(method_call) => { tcx.method_map.borrow().get(&method_call).unwrap().ty } @@ -534,7 +534,7 @@ pub fn trans_fn_ref_with_substs<'a, 'tcx>( } // Type scheme of the function item (may have type params) - let fn_type_scheme = ty::lookup_item_type(tcx, def_id); + let fn_type_scheme = tcx.lookup_item_type(def_id); let fn_type = monomorphize::normalize_associated_type(tcx, &fn_type_scheme.ty); // Find the actual function pointer. @@ -640,7 +640,7 @@ pub fn trans_lang_call<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, debug_loc: DebugLoc) -> Result<'blk, 'tcx> { let fty = if did.krate == ast::LOCAL_CRATE { - ty::node_id_to_type(bcx.tcx(), did.node) + bcx.tcx().node_id_to_type(did.node) } else { csearch::get_type(bcx.tcx(), did).ty }; @@ -692,7 +692,7 @@ pub fn trans_call_inner<'a, 'blk, 'tcx, F>(bcx: Block<'blk, 'tcx>, let (abi, ret_ty) = match callee_ty.sty { ty::TyBareFn(_, ref f) => { - let output = ty::erase_late_bound_regions(bcx.tcx(), &f.sig.output()); + let output = bcx.tcx().erase_late_bound_regions(&f.sig.output()); (f.abi, output) } _ => panic!("expected bare rust fn or closure in trans_call_inner") @@ -914,9 +914,7 @@ fn trans_args_under_call_abi<'blk, 'tcx>( ignore_self: bool) -> Block<'blk, 'tcx> { - let args = - ty::erase_late_bound_regions( - bcx.tcx(), &fn_ty.fn_args()); + let args = bcx.tcx().erase_late_bound_regions(&fn_ty.fn_args()); // Translate the `self` argument first. if !ignore_self { @@ -977,7 +975,7 @@ fn trans_overloaded_call_args<'blk, 'tcx>( ignore_self: bool) -> Block<'blk, 'tcx> { // Translate the `self` argument first. - let arg_tys = ty::erase_late_bound_regions(bcx.tcx(), &fn_ty.fn_args()); + let arg_tys = bcx.tcx().erase_late_bound_regions( &fn_ty.fn_args()); if !ignore_self { let arg_datum = unpack_datum!(bcx, expr::trans(bcx, arg_exprs[0])); bcx = trans_arg_datum(bcx, @@ -1023,7 +1021,7 @@ pub fn trans_args<'a, 'blk, 'tcx>(cx: Block<'blk, 'tcx>, debug!("trans_args(abi={})", abi); let _icx = push_ctxt("trans_args"); - let arg_tys = ty::erase_late_bound_regions(cx.tcx(), &fn_ty.fn_args()); + let arg_tys = cx.tcx().erase_late_bound_regions(&fn_ty.fn_args()); let variadic = fn_ty.fn_sig().0.variadic; let mut bcx = cx; diff --git a/src/librustc_trans/trans/closure.rs b/src/librustc_trans/trans/closure.rs index b1c8671383767..cb30bcdbf5399 100644 --- a/src/librustc_trans/trans/closure.rs +++ b/src/librustc_trans/trans/closure.rs @@ -135,7 +135,7 @@ pub fn get_or_create_declaration_if_closure<'a, 'tcx>(ccx: &CrateContext<'a, 'tc return None } - let function_type = ty::node_id_to_type(ccx.tcx(), closure_id.node); + let function_type = ccx.tcx().node_id_to_type(closure_id.node); let function_type = monomorphize::apply_param_substs(ccx.tcx(), substs, &function_type); // Normalize type so differences in regions and typedefs don't cause @@ -218,9 +218,9 @@ pub fn trans_closure_expr<'a, 'tcx>(dest: Dest<'a, 'tcx>, let function_type = typer.closure_type(closure_id, param_substs); let freevars: Vec = - ty::with_freevars(tcx, id, |fv| fv.iter().cloned().collect()); + tcx.with_freevars(id, |fv| fv.iter().cloned().collect()); - let sig = ty::erase_late_bound_regions(tcx, &function_type.sig); + let sig = tcx.erase_late_bound_regions(&function_type.sig); trans_closure(ccx, decl, @@ -392,7 +392,7 @@ fn trans_fn_once_adapter_shim<'a, 'tcx>( ccx.sess().bug(&format!("symbol `{}` already defined", function_name)); }); - let sig = ty::erase_late_bound_regions(tcx, &llonce_bare_fn_ty.sig); + let sig = tcx.erase_late_bound_regions(&llonce_bare_fn_ty.sig); let (block_arena, fcx): (TypedArena<_>, FunctionContext); block_arena = TypedArena::new(); fcx = new_fn_ctxt(ccx, diff --git a/src/librustc_trans/trans/common.rs b/src/librustc_trans/trans/common.rs index 2aa12e088aa12..777b61f25f0ef 100644 --- a/src/librustc_trans/trans/common.rs +++ b/src/librustc_trans/trans/common.rs @@ -23,6 +23,7 @@ use middle::def; use middle::infer; use middle::lang_items::LangItem; use middle::mem_categorization as mc; +use middle::mem_categorization::Typer; use middle::region; use middle::subst::{self, Subst, Substs}; use trans::base; @@ -89,7 +90,7 @@ pub fn erase_regions<'tcx,T>(cx: &ty::ctxt<'tcx>, value: &T) -> T fn fold_binder(&mut self, t: &ty::Binder) -> ty::Binder where T : TypeFoldable<'tcx> { - let u = ty::anonymize_late_bound_regions(self.tcx(), t); + let u = self.tcx().anonymize_late_bound_regions(t); ty_fold::super_fold_binder(self, &u) } @@ -119,7 +120,7 @@ pub fn erase_regions<'tcx,T>(cx: &ty::ctxt<'tcx>, value: &T) -> T /// Is the type's representation size known at compile time? pub fn type_is_sized<'tcx>(tcx: &ty::ctxt<'tcx>, ty: Ty<'tcx>) -> bool { - ty::type_is_sized(None, tcx, DUMMY_SP, ty) + ty.is_sized(&tcx.empty_parameter_environment(), DUMMY_SP) } pub fn type_is_fat_ptr<'tcx>(cx: &ty::ctxt<'tcx>, ty: Ty<'tcx>) -> bool { @@ -161,7 +162,7 @@ pub fn type_needs_unwind_cleanup<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, ty: Ty< ty::TyFloat(_) | ty::TyTuple(_) | ty::TyRawPtr(_) => false, ty::TyEnum(did, substs) => - ty::enum_variants(tcx, did).iter().any(|v| + tcx.enum_variants(did).iter().any(|v| v.args.iter().any(|&aty| { let t = aty.subst(tcx, substs); type_needs_unwind_cleanup_(tcx, t, tycache) @@ -183,7 +184,7 @@ pub fn type_needs_unwind_cleanup<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, ty: Ty< /// (Note that this implies that if `ty` has a destructor attached, /// then `type_needs_drop` will definitely return `true` for `ty`.) pub fn type_needs_drop<'tcx>(cx: &ty::ctxt<'tcx>, ty: Ty<'tcx>) -> bool { - type_needs_drop_given_env(cx, ty, &ty::empty_parameter_environment(cx)) + type_needs_drop_given_env(cx, ty, &cx.empty_parameter_environment()) } /// Core implementation of type_needs_drop, potentially making use of @@ -195,7 +196,7 @@ fn type_needs_drop_given_env<'a,'tcx>(cx: &ty::ctxt<'tcx>, // normalized version of the type, and therefore will definitely // know whether the type implements Copy (and thus needs no // cleanup/drop/zeroing) ... - let implements_copy = !ty::type_moves_by_default(¶m_env, DUMMY_SP, ty); + let implements_copy = !param_env.type_moves_by_default(ty, DUMMY_SP); if implements_copy { return false; } @@ -210,7 +211,7 @@ fn type_needs_drop_given_env<'a,'tcx>(cx: &ty::ctxt<'tcx>, // bound attached (see above), it is sound to treat it as having a // destructor (e.g. zero its memory on move). - let contents = ty::type_contents(cx, ty); + let contents = ty.type_contents(cx); debug!("type_needs_drop ty={:?} contents={:?}", ty, contents); contents.needs_drop(cx) } @@ -218,9 +219,9 @@ fn type_needs_drop_given_env<'a,'tcx>(cx: &ty::ctxt<'tcx>, fn type_is_newtype_immediate<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, ty: Ty<'tcx>) -> bool { match ty.sty { ty::TyStruct(def_id, substs) => { - let fields = ty::lookup_struct_fields(ccx.tcx(), def_id); + let fields = ccx.tcx().lookup_struct_fields(def_id); fields.len() == 1 && { - let ty = ty::lookup_field_type(ccx.tcx(), def_id, fields[0].id, substs); + let ty = ccx.tcx().lookup_field_type(def_id, fields[0].id, substs); let ty = monomorphize::normalize_associated_type(ccx.tcx(), &ty); type_is_immediate(ccx, ty) } @@ -267,7 +268,7 @@ pub fn type_is_zero_size<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, ty: Ty<'tcx>) - /// zero-size, but not all zero-size types use a `void` return type (in order to aid with C ABI /// compatibility). pub fn return_type_is_void(ccx: &CrateContext, ty: Ty) -> bool { - ty.is_nil() || ty::type_is_empty(ccx.tcx(), ty) + ty.is_nil() || ty.is_empty(ccx.tcx()) } /// Generates a unique symbol based off the name given. This is used to create @@ -661,8 +662,8 @@ impl<'blk, 'tcx> mc::Typer<'tcx> for BlockS<'blk, 'tcx> { Some(self.tcx().upvar_capture_map.borrow().get(&upvar_id).unwrap().clone()) } - fn type_moves_by_default(&self, span: Span, ty: Ty<'tcx>) -> bool { - self.fcx.param_env.type_moves_by_default(span, ty) + fn type_moves_by_default(&self, ty: Ty<'tcx>, span: Span) -> bool { + self.fcx.param_env.type_moves_by_default(ty, span) } } @@ -952,7 +953,7 @@ pub fn monomorphize_type<'blk, 'tcx>(bcx: &BlockS<'blk, 'tcx>, t: Ty<'tcx>) -> T pub fn node_id_type<'blk, 'tcx>(bcx: &BlockS<'blk, 'tcx>, id: ast::NodeId) -> Ty<'tcx> { let tcx = bcx.tcx(); - let t = ty::node_id_to_type(tcx, id); + let t = tcx.node_id_to_type(id); monomorphize_type(bcx, t) } @@ -961,7 +962,7 @@ pub fn expr_ty<'blk, 'tcx>(bcx: &BlockS<'blk, 'tcx>, ex: &ast::Expr) -> Ty<'tcx> } pub fn expr_ty_adjusted<'blk, 'tcx>(bcx: &BlockS<'blk, 'tcx>, ex: &ast::Expr) -> Ty<'tcx> { - monomorphize_type(bcx, ty::expr_ty_adjusted(bcx.tcx(), ex)) + monomorphize_type(bcx, bcx.tcx().expr_ty_adjusted(ex)) } /// Attempts to resolve an obligation. The result is a shallow vtable resolution -- meaning that we @@ -989,7 +990,7 @@ pub fn fulfill_obligation<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, debug!("trans fulfill_obligation: trait_ref={:?} def_id={:?}", trait_ref, trait_ref.def_id()); - ty::populate_implementations_for_trait_if_necessary(tcx, trait_ref.def_id()); + tcx.populate_implementations_for_trait_if_necessary(trait_ref.def_id()); let infcx = infer::new_infer_ctxt(tcx); // Do the initial selection for the obligation. This yields the @@ -1077,7 +1078,7 @@ impl<'a,'tcx> NormalizingClosureTyper<'a,'tcx> { pub fn new(tcx: &'a ty::ctxt<'tcx>) -> NormalizingClosureTyper<'a,'tcx> { // Parameter environment is used to give details about type parameters, // but since we are in trans, everything is fully monomorphized. - NormalizingClosureTyper { param_env: ty::empty_parameter_environment(tcx) } + NormalizingClosureTyper { param_env: tcx.empty_parameter_environment() } } } @@ -1111,7 +1112,7 @@ impl<'a,'tcx> ty::ClosureTyper<'tcx> for NormalizingClosureTyper<'a,'tcx> { { // the substitutions in `substs` are already monomorphized, // but we still must normalize associated types - let result = ty::closure_upvars(&self.param_env, def_id, substs); + let result = self.param_env.closure_upvars(def_id, substs); monomorphize::normalize_associated_type(self.param_env.tcx, &result) } } @@ -1187,7 +1188,7 @@ pub fn node_id_substs<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, let substs = match node { ExprId(id) => { - ty::node_id_item_substs(tcx, id).substs + tcx.node_id_item_substs(id).substs } MethodCallKey(method_call) => { tcx.method_map.borrow().get(&method_call).unwrap().substs.clone() diff --git a/src/librustc_trans/trans/consts.rs b/src/librustc_trans/trans/consts.rs index a12c07c975017..8ec60000ee842 100644 --- a/src/librustc_trans/trans/consts.rs +++ b/src/librustc_trans/trans/consts.rs @@ -57,7 +57,7 @@ pub fn const_lit(cx: &CrateContext, e: &ast::Expr, lit: &ast::Lit) C_integral(Type::uint_from_ty(cx, t), u, false) } ast::LitInt(i, ast::UnsuffixedIntLit(_)) => { - let lit_int_ty = ty::node_id_to_type(cx.tcx(), e.id); + let lit_int_ty = cx.tcx().node_id_to_type(e.id); match lit_int_ty.sty { ty::TyInt(t) => { C_integral(Type::int_from_ty(cx, t), i as u64, true) @@ -75,7 +75,7 @@ pub fn const_lit(cx: &CrateContext, e: &ast::Expr, lit: &ast::Lit) C_floating(&fs, Type::float_from_ty(cx, t)) } ast::LitFloatUnsuffixed(ref fs) => { - let lit_float_ty = ty::node_id_to_type(cx.tcx(), e.id); + let lit_float_ty = cx.tcx().node_id_to_type(e.id); match lit_float_ty.sty { ty::TyFloat(t) => { C_floating(&fs, Type::float_from_ty(cx, t)) @@ -249,7 +249,7 @@ pub fn get_const_expr_as_global<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, // Avoid autorefs as they would create global instead of stack // references, even when only the latter are correct. let ty = monomorphize::apply_param_substs(ccx.tcx(), param_substs, - &ty::expr_ty(ccx.tcx(), expr)); + &ccx.tcx().expr_ty(expr)); const_expr_unadjusted(ccx, expr, ty, param_substs, None) } else { const_expr(ccx, expr, param_substs, None).0 @@ -276,11 +276,11 @@ pub fn const_expr<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, fn_args: FnArgMap) -> (ValueRef, Ty<'tcx>) { let ety = monomorphize::apply_param_substs(cx.tcx(), param_substs, - &ty::expr_ty(cx.tcx(), e)); + &cx.tcx().expr_ty(e)); let llconst = const_expr_unadjusted(cx, e, ety, param_substs, fn_args); let mut llconst = llconst; let mut ety_adjusted = monomorphize::apply_param_substs(cx.tcx(), param_substs, - &ty::expr_ty_adjusted(cx.tcx(), e)); + &cx.tcx().expr_ty_adjusted(e)); let opt_adj = cx.tcx().adjustments.borrow().get(&e.id).cloned(); match opt_adj { Some(ty::AdjustReifyFnPointer) => { @@ -588,7 +588,7 @@ fn const_expr_unadjusted<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, let (bv, bt) = const_expr(cx, &**base, param_substs, fn_args); let brepr = adt::represent_type(cx, bt); expr::with_field_tys(cx.tcx(), bt, None, |discr, field_tys| { - let ix = ty::field_idx_strict(cx.tcx(), field.node.name, field_tys); + let ix = cx.tcx().field_idx_strict(field.node.name, field_tys); adt::const_get_field(cx, &*brepr, bv, discr, ix) }) } @@ -803,7 +803,7 @@ fn const_expr_unadjusted<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, ast::ExprRepeat(ref elem, ref count) => { let unit_ty = ety.sequence_element_type(cx.tcx()); let llunitty = type_of::type_of(cx, unit_ty); - let n = ty::eval_repeat_count(cx.tcx(), count); + let n = cx.tcx().eval_repeat_count(count); let unit_val = const_expr(cx, &**elem, param_substs, fn_args).0; let vs: Vec<_> = repeat(unit_val).take(n).collect(); if val_ty(unit_val) != llunitty { @@ -829,9 +829,7 @@ fn const_expr_unadjusted<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, const_deref_ptr(cx, get_const_val(cx, def_id, e)) } def::DefVariant(enum_did, variant_did, _) => { - let vinfo = ty::enum_variant_with_id(cx.tcx(), - enum_did, - variant_did); + let vinfo = cx.tcx().enum_variant_with_id(enum_did, variant_did); if !vinfo.args.is_empty() { // N-ary variant. expr::trans_def_fn_unadjusted(cx, e, def, param_substs).val @@ -884,9 +882,7 @@ fn const_expr_unadjusted<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, } def::DefVariant(enum_did, variant_did, _) => { let repr = adt::represent_type(cx, ety); - let vinfo = ty::enum_variant_with_id(cx.tcx(), - enum_did, - variant_did); + let vinfo = cx.tcx().enum_variant_with_id(enum_did, variant_did); adt::trans_const(cx, &*repr, vinfo.disr_val, @@ -945,8 +941,8 @@ pub fn trans_static(ccx: &CrateContext, m: ast::Mutability, id: ast::NodeId) -> // As an optimization, all shared statics which do not have interior // mutability are placed into read-only memory. if m != ast::MutMutable { - let node_ty = ty::node_id_to_type(ccx.tcx(), id); - let tcontents = ty::type_contents(ccx.tcx(), node_ty); + let node_ty = ccx.tcx().node_id_to_type(id); + let tcontents = node_ty.type_contents(ccx.tcx()); if !tcontents.interior_unsafe() { llvm::LLVMSetGlobalConstant(g, True); } diff --git a/src/librustc_trans/trans/datum.rs b/src/librustc_trans/trans/datum.rs index d7083eb2d3336..2c539b67cb627 100644 --- a/src/librustc_trans/trans/datum.rs +++ b/src/librustc_trans/trans/datum.rs @@ -101,7 +101,8 @@ use trans::cleanup::CleanupMethods; use trans::expr; use trans::tvec; use trans::type_of; -use middle::ty::{self, Ty}; +use middle::mem_categorization::Typer; +use middle::ty::Ty; use std::fmt; use syntax::ast; @@ -605,9 +606,8 @@ impl<'tcx, K: KindOps + fmt::Debug> Datum<'tcx, K> { * affine values (since they must never be duplicated). */ - assert!(!ty::type_moves_by_default(&ty::empty_parameter_environment(bcx.tcx()), - DUMMY_SP, - self.ty)); + assert!(!bcx.tcx().empty_parameter_environment() + .type_moves_by_default(self.ty, DUMMY_SP)); self.shallow_copy_raw(bcx, dst) } diff --git a/src/librustc_trans/trans/debuginfo/metadata.rs b/src/librustc_trans/trans/debuginfo/metadata.rs index 54cb87f8a7b3c..1fbbf0763aa53 100644 --- a/src/librustc_trans/trans/debuginfo/metadata.rs +++ b/src/librustc_trans/trans/debuginfo/metadata.rs @@ -242,9 +242,7 @@ impl<'tcx> TypeMap<'tcx> { ty::TyTrait(ref trait_data) => { unique_type_id.push_str("trait "); - let principal = - ty::erase_late_bound_regions(cx.tcx(), - &trait_data.principal); + let principal = cx.tcx().erase_late_bound_regions(&trait_data.principal); from_def_id_and_substs(self, cx, @@ -261,7 +259,7 @@ impl<'tcx> TypeMap<'tcx> { unique_type_id.push_str(" fn("); - let sig = ty::erase_late_bound_regions(cx.tcx(), sig); + let sig = cx.tcx().erase_late_bound_regions(sig); for ¶meter_type in &sig.inputs { let parameter_type_id = @@ -376,7 +374,7 @@ impl<'tcx> TypeMap<'tcx> { unique_type_id.push_str("|"); - let sig = ty::erase_late_bound_regions(cx.tcx(), sig); + let sig = cx.tcx().erase_late_bound_regions(sig); for ¶meter_type in &sig.inputs { let parameter_type_id = @@ -626,7 +624,7 @@ fn subroutine_type_metadata<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, span: Span) -> MetadataCreationResult { - let signature = ty::erase_late_bound_regions(cx.tcx(), signature); + let signature = cx.tcx().erase_late_bound_regions(signature); let mut signature_metadata: Vec = Vec::with_capacity(signature.inputs.len() + 1); @@ -1176,7 +1174,7 @@ fn prepare_struct_metadata<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, unique_type_id, containing_scope); - let mut fields = ty::struct_fields(cx.tcx(), def_id, substs); + let mut fields = cx.tcx().struct_fields(def_id, substs); // The `Ty` values returned by `ty::struct_fields` can still contain // `TyProjection` variants, so normalize those away. @@ -1588,7 +1586,7 @@ fn prepare_enum_metadata<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, let loc = span_start(cx, definition_span); let file_metadata = file_metadata(cx, &loc.file.name); - let variants = ty::enum_variants(cx.tcx(), enum_def_id); + let variants = cx.tcx().enum_variants(enum_def_id); let enumerators_metadata: Vec = variants .iter() @@ -1891,7 +1889,7 @@ pub fn create_global_var_metadata(cx: &CrateContext, }; let is_local_to_unit = is_node_local_to_unit(cx, node_id); - let variable_type = ty::node_id_to_type(cx.tcx(), node_id); + let variable_type = cx.tcx().node_id_to_type(node_id); let type_metadata = type_metadata(cx, variable_type, span); let namespace_node = namespace_for_item(cx, ast_util::local_def(node_id)); let var_name = token::get_name(name).to_string(); diff --git a/src/librustc_trans/trans/debuginfo/mod.rs b/src/librustc_trans/trans/debuginfo/mod.rs index 3c63f0fa30c1a..7487e8d331bf5 100644 --- a/src/librustc_trans/trans/debuginfo/mod.rs +++ b/src/librustc_trans/trans/debuginfo/mod.rs @@ -30,7 +30,7 @@ use rustc::ast_map; use trans::common::{NodeIdAndSpan, CrateContext, FunctionContext, Block}; use trans; use trans::monomorphize; -use middle::ty::{self, Ty, ClosureTyper}; +use middle::ty::{Ty, ClosureTyper}; use session::config::{self, FullDebugInfo, LimitedDebugInfo, NoDebugInfo}; use util::nodemap::{DefIdMap, NodeMap, FnvHashMap, FnvHashSet}; @@ -412,7 +412,7 @@ pub fn create_function_debug_context<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, // Return type -- llvm::DIBuilder wants this at index 0 assert_type_for_node_id(cx, fn_ast_id, error_reporting_span); - let return_type = ty::node_id_to_type(cx.tcx(), fn_ast_id); + let return_type = cx.tcx().node_id_to_type(fn_ast_id); let return_type = monomorphize::apply_param_substs(cx.tcx(), param_substs, &return_type); @@ -425,7 +425,7 @@ pub fn create_function_debug_context<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, // Arguments types for arg in &fn_decl.inputs { assert_type_for_node_id(cx, arg.pat.id, arg.pat.span); - let arg_type = ty::node_id_to_type(cx.tcx(), arg.pat.id); + let arg_type = cx.tcx().node_id_to_type(arg.pat.id); let arg_type = monomorphize::apply_param_substs(cx.tcx(), param_substs, &arg_type); diff --git a/src/librustc_trans/trans/debuginfo/namespace.rs b/src/librustc_trans/trans/debuginfo/namespace.rs index e6fe674f22057..2e5943a248a5f 100644 --- a/src/librustc_trans/trans/debuginfo/namespace.rs +++ b/src/librustc_trans/trans/debuginfo/namespace.rs @@ -16,7 +16,7 @@ use llvm; use llvm::debuginfo::DIScope; use rustc::ast_map; use trans::common::CrateContext; -use middle::ty::{self, ClosureTyper}; +use middle::ty::ClosureTyper; use std::ffi::CString; use std::ptr; @@ -56,7 +56,7 @@ pub fn crate_root_namespace<'a>(cx: &'a CrateContext) -> &'a str { } pub fn namespace_for_item(cx: &CrateContext, def_id: ast::DefId) -> Rc { - ty::with_path(cx.tcx(), def_id, |path| { + cx.tcx().with_path(def_id, |path| { // prepend crate name if not already present let krate = if def_id.krate == ast::LOCAL_CRATE { let crate_namespace_name = token::intern(crate_root_namespace(cx)); diff --git a/src/librustc_trans/trans/debuginfo/type_names.rs b/src/librustc_trans/trans/debuginfo/type_names.rs index 4092ba8bfa55a..6ea43d7392c94 100644 --- a/src/librustc_trans/trans/debuginfo/type_names.rs +++ b/src/librustc_trans/trans/debuginfo/type_names.rs @@ -106,7 +106,7 @@ pub fn push_debuginfo_type_name<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, output.push(']'); }, ty::TyTrait(ref trait_data) => { - let principal = ty::erase_late_bound_regions(cx.tcx(), &trait_data.principal); + let principal = cx.tcx().erase_late_bound_regions(&trait_data.principal); push_item_name(cx, principal.def_id, false, output); push_type_params(cx, principal.substs, output); }, @@ -123,7 +123,7 @@ pub fn push_debuginfo_type_name<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, output.push_str("fn("); - let sig = ty::erase_late_bound_regions(cx.tcx(), sig); + let sig = cx.tcx().erase_late_bound_regions(sig); if !sig.inputs.is_empty() { for ¶meter_type in &sig.inputs { push_debuginfo_type_name(cx, parameter_type, true, output); @@ -170,7 +170,7 @@ pub fn push_debuginfo_type_name<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, def_id: ast::DefId, qualified: bool, output: &mut String) { - ty::with_path(cx.tcx(), def_id, |path| { + cx.tcx().with_path(def_id, |path| { if qualified { if def_id.krate == ast::LOCAL_CRATE { output.push_str(crate_root_namespace(cx)); diff --git a/src/librustc_trans/trans/declare.rs b/src/librustc_trans/trans/declare.rs index 8bc3326d30093..646ca6733c3b6 100644 --- a/src/librustc_trans/trans/declare.rs +++ b/src/librustc_trans/trans/declare.rs @@ -128,7 +128,7 @@ pub fn declare_rust_fn<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, name: &str, _ => ccx.sess().bug("expected closure or fn") }; - let sig = ty::Binder(ty::erase_late_bound_regions(ccx.tcx(), sig)); + let sig = ty::Binder(ccx.tcx().erase_late_bound_regions(sig)); debug!("declare_rust_fn (after region erasure) sig={:?}", sig); let llfty = type_of::type_of_rust_fn(ccx, env, &sig, abi); debug!("declare_rust_fn llfty={}", ccx.tn().type_to_string(llfty)); diff --git a/src/librustc_trans/trans/expr.rs b/src/librustc_trans/trans/expr.rs index 2187b7f6ae1c6..8fd88055b8e45 100644 --- a/src/librustc_trans/trans/expr.rs +++ b/src/librustc_trans/trans/expr.rs @@ -73,7 +73,6 @@ use trans::monomorphize; use trans::tvec; use trans::type_of; use middle::cast::{CastKind, CastTy}; -use middle::ty::{struct_fields, tup_fields}; use middle::ty::{AdjustDerefRef, AdjustReifyFnPointer, AdjustUnsafeFnPointer}; use middle::ty::{self, Ty}; use middle::ty::MethodCall; @@ -313,7 +312,7 @@ pub fn unsized_info<'ccx, 'tcx>(ccx: &CrateContext<'ccx, 'tcx>, old_info: Option, param_substs: &'tcx Substs<'tcx>) -> ValueRef { - let (source, target) = ty::struct_lockstep_tails(ccx.tcx(), source, target); + let (source, target) = ccx.tcx().struct_lockstep_tails(source, target); match (&source.sty, &target.sty) { (&ty::TyArray(_, len), &ty::TySlice(_)) => C_uint(ccx, len), (&ty::TyTrait(_), &ty::TyTrait(_)) => { @@ -500,7 +499,7 @@ fn coerce_unsized<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, let kind = match fulfill_obligation(bcx.ccx(), span, trait_ref) { traits::VtableImpl(traits::VtableImplData { impl_def_id, .. }) => { - ty::custom_coerce_unsized_kind(bcx.tcx(), impl_def_id) + bcx.tcx().custom_coerce_unsized_kind(impl_def_id) } vtable => { bcx.sess().span_bug(span, &format!("invalid CoerceUnsized vtable: {:?}", @@ -748,7 +747,7 @@ fn trans_rec_field<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, base: &ast::Expr, field: ast::Name) -> DatumBlock<'blk, 'tcx, Expr> { - trans_field(bcx, base, |tcx, field_tys| ty::field_idx_strict(tcx, field, field_tys)) + trans_field(bcx, base, |tcx, field_tys| tcx.field_idx_strict(field, field_tys)) } /// Translates `base.`. @@ -789,8 +788,7 @@ fn trans_index<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, let ix_datum = unpack_datum!(bcx, trans(bcx, idx)); let ref_ty = // invoked methods have LB regions instantiated: - ty::no_late_bound_regions( - bcx.tcx(), &method_ty.fn_ret()).unwrap().unwrap(); + bcx.tcx().no_late_bound_regions(&method_ty.fn_ret()).unwrap().unwrap(); let elt_ty = match ref_ty.builtin_deref(true) { None => { bcx.tcx().sess.span_bug(index_expr.span, @@ -1227,7 +1225,7 @@ fn trans_def_dps_unadjusted<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, match def { def::DefVariant(tid, vid, _) => { - let variant_info = ty::enum_variant_with_id(bcx.tcx(), tid, vid); + let variant_info = bcx.tcx().enum_variant_with_id(tid, vid); if !variant_info.args.is_empty() { // N-ary variant. let llfn = callee::trans_fn_ref(bcx.ccx(), vid, @@ -1247,7 +1245,7 @@ fn trans_def_dps_unadjusted<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, def::DefStruct(_) => { let ty = expr_ty(bcx, ref_expr); match ty.sty { - ty::TyStruct(did, _) if ty::has_dtor(bcx.tcx(), did) => { + ty::TyStruct(did, _) if bcx.tcx().has_dtor(did) => { let repr = adt::represent_type(bcx.ccx(), ty); adt::trans_set_discr(bcx, &*repr, lldest, 0); } @@ -1342,13 +1340,22 @@ pub fn with_field_tys<'tcx, R, F>(tcx: &ty::ctxt<'tcx>, { match ty.sty { ty::TyStruct(did, substs) => { - let fields = struct_fields(tcx, did, substs); + let fields = tcx.struct_fields(did, substs); let fields = monomorphize::normalize_associated_type(tcx, &fields); op(0, &fields[..]) } ty::TyTuple(ref v) => { - op(0, &tup_fields(&v[..])) + let fields: Vec<_> = v.iter().enumerate().map(|(i, &f)| { + ty::field { + name: token::intern(&i.to_string()), + mt: ty::mt { + ty: f, + mutbl: ast::MutImmutable + } + } + }).collect(); + op(0, &fields) } ty::TyEnum(_, substs) => { @@ -1364,8 +1371,8 @@ pub fn with_field_tys<'tcx, R, F>(tcx: &ty::ctxt<'tcx>, let def = tcx.def_map.borrow().get(&node_id).unwrap().full_def(); match def { def::DefVariant(enum_id, variant_id, _) => { - let variant_info = ty::enum_variant_with_id(tcx, enum_id, variant_id); - let fields = struct_fields(tcx, variant_id, substs); + let variant_info = tcx.enum_variant_with_id(enum_id, variant_id); + let fields = tcx.struct_fields(variant_id, substs); let fields = monomorphize::normalize_associated_type(tcx, &fields); op(variant_info.disr_val, &fields[..]) } @@ -2241,8 +2248,7 @@ fn deref_once<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, }; let ref_ty = // invoked methods have their LB regions instantiated - ty::no_late_bound_regions( - ccx.tcx(), &method_ty.fn_ret()).unwrap().unwrap(); + ccx.tcx().no_late_bound_regions(&method_ty.fn_ret()).unwrap().unwrap(); let scratch = rvalue_scratch_datum(bcx, ref_ty, "overloaded_deref"); unpack_result!(bcx, trans_overloaded_op(bcx, expr, method_call, @@ -2629,9 +2635,9 @@ fn expr_kind(tcx: &ty::ctxt, expr: &ast::Expr) -> ExprKind { match expr.node { ast::ExprPath(..) => { - match ty::resolve_expr(tcx, expr) { + match tcx.resolve_expr(expr) { def::DefStruct(_) | def::DefVariant(..) => { - if let ty::TyBareFn(..) = ty::node_id_to_type(tcx, expr.id).sty { + if let ty::TyBareFn(..) = tcx.node_id_to_type(expr.id).sty { // ctor function ExprKind::RvalueDatum } else { diff --git a/src/librustc_trans/trans/foreign.rs b/src/librustc_trans/trans/foreign.rs index 6f3346b9329a2..9e8c0189a9762 100644 --- a/src/librustc_trans/trans/foreign.rs +++ b/src/librustc_trans/trans/foreign.rs @@ -109,7 +109,7 @@ pub fn llvm_calling_convention(ccx: &CrateContext, pub fn register_static(ccx: &CrateContext, foreign_item: &ast::ForeignItem) -> ValueRef { - let ty = ty::node_id_to_type(ccx.tcx(), foreign_item.id); + let ty = ccx.tcx().node_id_to_type(foreign_item.id); let llty = type_of::type_of(ccx, ty); let ident = link_name(foreign_item); @@ -245,7 +245,7 @@ pub fn trans_native_call<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, ty::TyBareFn(_, ref fn_ty) => (fn_ty.abi, &fn_ty.sig), _ => ccx.sess().bug("trans_native_call called on non-function type") }; - let fn_sig = ty::erase_late_bound_regions(ccx.tcx(), fn_sig); + let fn_sig = ccx.tcx().erase_late_bound_regions(fn_sig); let llsig = foreign_signature(ccx, &fn_sig, &passed_arg_tys[..]); let fn_type = cabi::compute_abi_info(ccx, &llsig.llarg_tys, @@ -478,7 +478,7 @@ pub fn trans_foreign_mod(ccx: &CrateContext, foreign_mod: &ast::ForeignMod) { match foreign_mod.abi { Rust | RustIntrinsic => {} abi => { - let ty = ty::node_id_to_type(ccx.tcx(), foreign_item.id); + let ty = ccx.tcx().node_id_to_type(foreign_item.id); match ty.sty { ty::TyBareFn(_, bft) => gate_simd_ffi(ccx.tcx(), &**decl, bft), _ => ccx.tcx().sess.span_bug(foreign_item.span, @@ -554,7 +554,7 @@ pub fn register_rust_fn_with_foreign_abi(ccx: &CrateContext, let tys = foreign_types_for_id(ccx, node_id); let llfn_ty = lltype_for_fn_from_foreign_types(ccx, &tys); - let t = ty::node_id_to_type(ccx.tcx(), node_id); + let t = ccx.tcx().node_id_to_type(node_id); let cconv = match t.sty { ty::TyBareFn(_, ref fn_ty) => { llvm_calling_convention(ccx, fn_ty.abi) @@ -578,7 +578,7 @@ pub fn trans_rust_fn_with_foreign_abi<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, hash: Option<&str>) { let _icx = push_ctxt("foreign::build_foreign_fn"); - let fnty = ty::node_id_to_type(ccx.tcx(), id); + let fnty = ccx.tcx().node_id_to_type(id); let mty = monomorphize::apply_param_substs(ccx.tcx(), param_substs, &fnty); let tys = foreign_types_for_fn_ty(ccx, mty); @@ -601,7 +601,7 @@ pub fn trans_rust_fn_with_foreign_abi<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, { let _icx = push_ctxt("foreign::foreign::build_rust_fn"); let tcx = ccx.tcx(); - let t = ty::node_id_to_type(tcx, id); + let t = tcx.node_id_to_type(id); let t = monomorphize::apply_param_substs(tcx, param_substs, &t); let ps = ccx.tcx().map.with_path(id, |path| { @@ -933,7 +933,7 @@ fn foreign_signature<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, fn foreign_types_for_id<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, id: ast::NodeId) -> ForeignTypes<'tcx> { - foreign_types_for_fn_ty(ccx, ty::node_id_to_type(ccx.tcx(), id)) + foreign_types_for_fn_ty(ccx, ccx.tcx().node_id_to_type(id)) } fn foreign_types_for_fn_ty<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, @@ -942,7 +942,7 @@ fn foreign_types_for_fn_ty<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, ty::TyBareFn(_, ref fn_ty) => &fn_ty.sig, _ => ccx.sess().bug("foreign_types_for_fn_ty called on non-function type") }; - let fn_sig = ty::erase_late_bound_regions(ccx.tcx(), fn_sig); + let fn_sig = ccx.tcx().erase_late_bound_regions(fn_sig); let llsig = foreign_signature(ccx, &fn_sig, &fn_sig.inputs); let fn_ty = cabi::compute_abi_info(ccx, &llsig.llarg_tys, diff --git a/src/librustc_trans/trans/glue.rs b/src/librustc_trans/trans/glue.rs index 7a5ccd5b9c617..3bcdcd89c47f5 100644 --- a/src/librustc_trans/trans/glue.rs +++ b/src/librustc_trans/trans/glue.rs @@ -326,7 +326,7 @@ pub fn get_res_dtor<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, } else { let tcx = ccx.tcx(); let name = csearch::get_symbol(&ccx.sess().cstore, did); - let class_ty = ty::lookup_item_type(tcx, parent_id).ty.subst(tcx, substs); + let class_ty = tcx.lookup_item_type(parent_id).ty.subst(tcx, substs); let llty = type_of_dtor(ccx, class_ty); let dtor_ty = ccx.tcx().mk_ctor_fn(did, &[get_drop_glue_type(ccx, t)], @@ -399,7 +399,7 @@ pub fn size_and_align_of_dst<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, t: Ty<'tcx>, in // Recurse to get the size of the dynamically sized field (must be // the last field). - let fields = ty::struct_fields(bcx.tcx(), id, substs); + let fields = bcx.tcx().struct_fields(id, substs); let last_field = fields[fields.len()-1]; let field_ty = last_field.mt.ty; let (unsized_size, unsized_align) = size_and_align_of_dst(bcx, field_ty, info); @@ -495,7 +495,7 @@ fn make_drop_glue<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, v0: ValueRef, g: DropGlueK } ty::TyStruct(did, substs) | ty::TyEnum(did, substs) => { let tcx = bcx.tcx(); - match (ty::ty_dtor(tcx, did), skip_dtor) { + match (tcx.ty_dtor(did), skip_dtor) { (ty::TraitDtor(dtor, true), false) => { // FIXME(16758) Since the struct is unsized, it is hard to // find the drop flag (which is at the end of the struct). diff --git a/src/librustc_trans/trans/inline.rs b/src/librustc_trans/trans/inline.rs index f860fe44f28e7..75c80690f2ad4 100644 --- a/src/librustc_trans/trans/inline.rs +++ b/src/librustc_trans/trans/inline.rs @@ -14,7 +14,6 @@ use middle::astencode; use middle::subst::Substs; use trans::base::{push_ctxt, trans_item, get_item_val, trans_fn}; use trans::common::*; -use middle::ty; use syntax::ast; use syntax::ast_util::local_def; @@ -28,7 +27,7 @@ fn instantiate_inline(ccx: &CrateContext, fn_id: ast::DefId) Some(&Some(node_id)) => { // Already inline debug!("instantiate_inline({}): already inline as node id {}", - ty::item_path_str(ccx.tcx(), fn_id), node_id); + ccx.tcx().item_path_str(fn_id), node_id); return Some(local_def(node_id)); } Some(&None) => { @@ -104,8 +103,8 @@ fn instantiate_inline(ccx: &CrateContext, fn_id: ast::DefId) let mut my_id = 0; match item.node { ast::ItemEnum(_, _) => { - let vs_here = ty::enum_variants(ccx.tcx(), local_def(item.id)); - let vs_there = ty::enum_variants(ccx.tcx(), parent_id); + let vs_here = ccx.tcx().enum_variants(local_def(item.id)); + let vs_there = ccx.tcx().enum_variants(parent_id); for (here, there) in vs_here.iter().zip(vs_there.iter()) { if there.id == fn_id { my_id = here.id.node; } ccx.external().borrow_mut().insert(there.id, Some(here.id.node)); @@ -140,7 +139,7 @@ fn instantiate_inline(ccx: &CrateContext, fn_id: ast::DefId) // the logic to do that already exists in `middle`. In order to // reuse that code, it needs to be able to look up the traits for // inlined items. - let ty_trait_item = ty::impl_or_trait_item(ccx.tcx(), fn_id).clone(); + let ty_trait_item = ccx.tcx().impl_or_trait_item(fn_id).clone(); ccx.tcx().impl_or_trait_items.borrow_mut() .insert(local_def(trait_item.id), ty_trait_item); @@ -157,7 +156,7 @@ fn instantiate_inline(ccx: &CrateContext, fn_id: ast::DefId) // Translate monomorphic impl methods immediately. if let ast::MethodImplItem(ref sig, ref body) = impl_item.node { - let impl_tpt = ty::lookup_item_type(ccx.tcx(), impl_did); + let impl_tpt = ccx.tcx().lookup_item_type(impl_did); if impl_tpt.generics.types.is_empty() && sig.generics.ty_params.is_empty() { let empty_substs = ccx.tcx().mk_substs(Substs::trans_empty()); diff --git a/src/librustc_trans/trans/intrinsic.rs b/src/librustc_trans/trans/intrinsic.rs index a90b462b98572..b449c3ad060b8 100644 --- a/src/librustc_trans/trans/intrinsic.rs +++ b/src/librustc_trans/trans/intrinsic.rs @@ -163,7 +163,7 @@ pub fn trans_intrinsic_call<'a, 'blk, 'tcx>(mut bcx: Block<'blk, 'tcx>, let ret_ty = match callee_ty.sty { ty::TyBareFn(_, ref f) => { - ty::erase_late_bound_regions(bcx.tcx(), &f.sig.output()) + bcx.tcx().erase_late_bound_regions(&f.sig.output()) } _ => panic!("expected bare_fn in trans_intrinsic_call") }; @@ -411,10 +411,8 @@ pub fn trans_intrinsic_call<'a, 'blk, 'tcx>(mut bcx: Block<'blk, 'tcx>, C_str_slice(ccx, ty_name) } (_, "type_id") => { - let hash = ty::hash_crate_independent( - ccx.tcx(), - *substs.types.get(FnSpace, 0), - &ccx.link_meta().crate_hash); + let hash = ccx.tcx().hash_crate_independent(*substs.types.get(FnSpace, 0), + &ccx.link_meta().crate_hash); C_u64(ccx, hash) } (_, "init_dropped") => { diff --git a/src/librustc_trans/trans/meth.rs b/src/librustc_trans/trans/meth.rs index c6107f7d268af..a3e5b640fd0f1 100644 --- a/src/librustc_trans/trans/meth.rs +++ b/src/librustc_trans/trans/meth.rs @@ -182,7 +182,7 @@ pub fn trans_static_method_callee<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, debug!("trans_static_method_callee(method_id={:?}, trait_id={}, \ expr_id={})", method_id, - ty::item_path_str(tcx, trait_id), + tcx.item_path_str(trait_id), expr_id); let mname = if method_id.krate == ast::LOCAL_CRATE { @@ -282,7 +282,7 @@ pub fn trans_static_method_callee<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, } traits::VtableObject(ref data) => { let trait_item_def_ids = - ty::trait_item_def_ids(ccx.tcx(), trait_id); + ccx.tcx().trait_item_def_ids(trait_id); let method_offset_in_trait = trait_item_def_ids.iter() .position(|item| item.def_id() == method_id) @@ -314,7 +314,7 @@ fn method_with_name(ccx: &CrateContext, impl_id: ast::DefId, name: ast::Name) .expect("could not find impl while translating"); let meth_did = impl_items.iter() .find(|&did| { - ty::impl_or_trait_item(ccx.tcx(), did.def_id()).name() == name + ccx.tcx().impl_or_trait_item(did.def_id()).name() == name }).expect("could not find method while \ translating"); @@ -334,7 +334,7 @@ fn trans_monomorphized_callee<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, traits::VtableImpl(vtable_impl) => { let ccx = bcx.ccx(); let impl_did = vtable_impl.impl_def_id; - let mname = match ty::trait_item(ccx.tcx(), trait_id, n_method) { + let mname = match ccx.tcx().trait_item(trait_id, n_method) { ty::MethodTraitItem(method) => method.name, _ => { bcx.tcx().sess.bug("can't monomorphize a non-method trait \ @@ -567,12 +567,12 @@ pub fn trans_object_shim<'a, 'tcx>( }; // Upcast to the trait in question and extract out the substitutions. - let upcast_trait_ref = ty::erase_late_bound_regions(tcx, &upcast_trait_ref); + let upcast_trait_ref = tcx.erase_late_bound_regions(&upcast_trait_ref); let object_substs = upcast_trait_ref.substs.clone().erase_regions(); debug!("trans_object_shim: object_substs={:?}", object_substs); // Lookup the type of this method as declared in the trait and apply substitutions. - let method_ty = match ty::trait_item(tcx, trait_id, method_offset_in_trait) { + let method_ty = match tcx.trait_item(trait_id, method_offset_in_trait) { ty::MethodTraitItem(method) => method, _ => { tcx.sess.bug("can't create a method shim for a non-method item") @@ -591,7 +591,7 @@ pub fn trans_object_shim<'a, 'tcx>( ccx.sess().bug(&format!("symbol `{}` already defined", function_name)); }); - let sig = ty::erase_late_bound_regions(ccx.tcx(), &fty.sig); + let sig = ccx.tcx().erase_late_bound_regions(&fty.sig); let empty_substs = tcx.mk_substs(Substs::trans_empty()); let (block_arena, fcx): (TypedArena<_>, FunctionContext); @@ -747,16 +747,16 @@ fn emit_vtable_methods<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, substs, param_substs); - let trt_id = match ty::impl_trait_ref(tcx, impl_id) { + let trt_id = match tcx.impl_trait_ref(impl_id) { Some(t_id) => t_id.def_id, None => ccx.sess().bug("make_impl_vtable: don't know how to \ make a vtable for a type impl!") }; - ty::populate_implementations_for_trait_if_necessary(tcx, trt_id); + tcx.populate_implementations_for_trait_if_necessary(trt_id); let nullptr = C_null(Type::nil(ccx).ptr_to()); - let trait_item_def_ids = ty::trait_item_def_ids(tcx, trt_id); + let trait_item_def_ids = tcx.trait_item_def_ids(trt_id); trait_item_def_ids .iter() @@ -775,7 +775,7 @@ fn emit_vtable_methods<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, debug!("emit_vtable_methods: trait_method_def_id={:?}", trait_method_def_id); - let trait_method_type = match ty::impl_or_trait_item(tcx, trait_method_def_id) { + let trait_method_type = match tcx.impl_or_trait_item(trait_method_def_id) { ty::MethodTraitItem(m) => m, _ => ccx.sess().bug("should be a method, not other assoc item"), }; @@ -793,7 +793,7 @@ fn emit_vtable_methods<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, // The substitutions we have are on the impl, so we grab // the method type from the impl to substitute into. let impl_method_def_id = method_with_name(ccx, impl_id, name); - let impl_method_type = match ty::impl_or_trait_item(tcx, impl_method_def_id) { + let impl_method_type = match tcx.impl_or_trait_item(impl_method_def_id) { ty::MethodTraitItem(m) => m, _ => ccx.sess().bug("should be a method, not other assoc item"), }; @@ -806,7 +806,7 @@ fn emit_vtable_methods<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, // particular set of type parameters. Note that this // method could then never be called, so we do not want to // try and trans it, in that case. Issue #23435. - if ty::provided_source(tcx, impl_method_def_id).is_some() { + if tcx.provided_source(impl_method_def_id).is_some() { let predicates = impl_method_type.predicates.predicates.subst(tcx, &substs); if !normalize_and_test_predicates(ccx, predicates.into_vec()) { debug!("emit_vtable_methods: predicates do not hold"); diff --git a/src/librustc_trans/trans/monomorphize.rs b/src/librustc_trans/trans/monomorphize.rs index 4d64b1c03b800..cae810c9082e5 100644 --- a/src/librustc_trans/trans/monomorphize.rs +++ b/src/librustc_trans/trans/monomorphize.rs @@ -56,7 +56,7 @@ pub fn monomorphic_fn<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, params: &psubsts.types }; - let item_ty = ty::lookup_item_type(ccx.tcx(), fn_id).ty; + let item_ty = ccx.tcx().lookup_item_type(fn_id).ty; debug!("monomorphic_fn about to subst into {:?}", item_ty); let mono_ty = item_ty.subst(ccx.tcx(), psubsts); @@ -64,7 +64,7 @@ pub fn monomorphic_fn<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, match ccx.monomorphized().borrow().get(&hash_id) { Some(&val) => { debug!("leaving monomorphic fn {}", - ty::item_path_str(ccx.tcx(), fn_id)); + ccx.tcx().item_path_str(fn_id)); return (val, mono_ty, false); } None => () @@ -198,7 +198,7 @@ pub fn monomorphic_fn<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, } ast_map::NodeVariant(v) => { let parent = ccx.tcx().map.get_parent(fn_id.node); - let tvs = ty::enum_variants(ccx.tcx(), local_def(parent)); + let tvs = ccx.tcx().enum_variants(local_def(parent)); let this_tv = tvs.iter().find(|tv| { tv.id.node == fn_id.node}).unwrap(); let d = mk_lldecl(abi::Rust); attributes::inline(d, attributes::InlineAttr::Hint); @@ -284,7 +284,7 @@ pub fn monomorphic_fn<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, ccx.monomorphizing().borrow_mut().insert(fn_id, depth); - debug!("leaving monomorphic fn {}", ty::item_path_str(ccx.tcx(), fn_id)); + debug!("leaving monomorphic fn {}", ccx.tcx().item_path_str(fn_id)); (lldecl, mono_ty, true) } diff --git a/src/librustc_trans/trans/tvec.rs b/src/librustc_trans/trans/tvec.rs index 3c6770caef8d1..d94a0e235ee86 100644 --- a/src/librustc_trans/trans/tvec.rs +++ b/src/librustc_trans/trans/tvec.rs @@ -225,7 +225,7 @@ fn write_content<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, return expr::trans_into(bcx, &**element, Ignore); } SaveIn(lldest) => { - match ty::eval_repeat_count(bcx.tcx(), &**count_expr) { + match bcx.tcx().eval_repeat_count(&**count_expr) { 0 => expr::trans_into(bcx, &**element, Ignore), 1 => expr::trans_into(bcx, &**element, SaveIn(lldest)), count => { @@ -277,7 +277,7 @@ fn elements_required(bcx: Block, content_expr: &ast::Expr) -> usize { }, ast::ExprVec(ref es) => es.len(), ast::ExprRepeat(_, ref count_expr) => { - ty::eval_repeat_count(bcx.tcx(), &**count_expr) + bcx.tcx().eval_repeat_count(&**count_expr) } _ => bcx.tcx().sess.span_bug(content_expr.span, "unexpected vec content") diff --git a/src/librustc_trans/trans/type_of.rs b/src/librustc_trans/trans/type_of.rs index 96eae5fd184ab..20d25518e2700 100644 --- a/src/librustc_trans/trans/type_of.rs +++ b/src/librustc_trans/trans/type_of.rs @@ -102,7 +102,7 @@ pub fn type_of_rust_fn<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, sig, abi); - let sig = ty::erase_late_bound_regions(cx.tcx(), sig); + let sig = cx.tcx().erase_late_bound_regions(sig); assert!(!sig.variadic); // rust fns are never variadic let mut atys: Vec = Vec::new(); @@ -362,7 +362,7 @@ pub fn in_memory_type_of<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, t: Ty<'tcx>) -> cx.tn().find_type("str_slice").unwrap() } else { let ptr_ty = in_memory_type_of(cx, ty).ptr_to(); - let unsized_part = ty::struct_tail(cx.tcx(), ty); + let unsized_part = cx.tcx().struct_tail(ty); let info_ty = match unsized_part.sty { ty::TyStr | ty::TyArray(..) | ty::TySlice(_) => { Type::uint_from_ty(cx, ast::TyUs) @@ -454,7 +454,7 @@ fn llvm_type_name<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, did: ast::DefId, tps: &[Ty<'tcx>]) -> String { - let base = ty::item_path_str(cx.tcx(), did); + let base = cx.tcx().item_path_str(did); let strings: Vec = tps.iter().map(|t| t.to_string()).collect(); let tstr = if strings.is_empty() { base diff --git a/src/librustc_typeck/astconv.rs b/src/librustc_typeck/astconv.rs index d5e57e163029d..2575dc0184f8c 100644 --- a/src/librustc_typeck/astconv.rs +++ b/src/librustc_typeck/astconv.rs @@ -124,7 +124,7 @@ pub trait AstConv<'tcx> { item_name: ast::Name) -> Ty<'tcx> { - if ty::binds_late_bound_regions(self.tcx(), &poly_trait_ref) { + if self.tcx().binds_late_bound_regions(&poly_trait_ref) { span_err!(self.tcx().sess, span, E0212, "cannot extract an associated type from a higher-ranked trait bound \ in this context"); @@ -513,7 +513,7 @@ fn find_implied_output_region(input_tys: &[Ty], input_pats: Vec) for (input_type, input_pat) in input_tys.iter().zip(input_pats) { let mut accumulator = Vec::new(); - ty::accumulate_lifetimes_in_type(&mut accumulator, *input_type); + input_type.accumulate_lifetimes_in_type(&mut accumulator); if accumulator.len() == 1 { // there's a chance that the unique lifetime of this @@ -1060,7 +1060,7 @@ fn make_object_type<'tcx>(this: &AstConv<'tcx>, let mut associated_types: FnvHashSet<(ast::DefId, ast::Name)> = traits::supertraits(tcx, object_trait_ref) .flat_map(|tr| { - let trait_def = ty::lookup_trait_def(tcx, tr.def_id()); + let trait_def = tcx.lookup_trait_def(tr.def_id()); trait_def.associated_type_names .clone() .into_iter() @@ -1078,7 +1078,7 @@ fn make_object_type<'tcx>(this: &AstConv<'tcx>, span_err!(tcx.sess, span, E0191, "the value of the associated type `{}` (from the trait `{}`) must be specified", name, - ty::item_path_str(tcx, trait_def_id)); + tcx.item_path_str(trait_def_id)); } tcx.mk_trait(object.principal, object.bounds) @@ -1265,7 +1265,7 @@ fn associated_path_def_to_ty<'tcx>(this: &AstConv<'tcx>, _ => unreachable!() } } else { - let trait_items = ty::trait_items(tcx, trait_did); + let trait_items = tcx.trait_items(trait_did); let item = trait_items.iter().find(|i| i.name() == assoc_name); item.expect("missing associated type").def_id() }; @@ -1290,7 +1290,7 @@ fn qpath_to_ty<'tcx>(this: &AstConv<'tcx>, let self_ty = if let Some(ty) = opt_self_ty { ty } else { - let path_str = ty::item_path_str(tcx, trait_def_id); + let path_str = tcx.item_path_str(trait_def_id); report_ambiguous_associated_type(tcx, span, "Type", @@ -2116,8 +2116,7 @@ pub fn partition_bounds<'a>(tcx: &ty::ctxt, ast::TraitTyParamBound(ref b, ast::TraitBoundModifier::None) => { match ::lookup_full_def(tcx, b.trait_ref.path.span, b.trait_ref.ref_id) { def::DefTrait(trait_did) => { - if ty::try_add_builtin_trait(tcx, - trait_did, + if tcx.try_add_builtin_trait(trait_did, &mut builtin_bounds) { let segments = &b.trait_ref.path.segments; let parameters = &segments[segments.len() - 1].parameters; diff --git a/src/librustc_typeck/check/_match.rs b/src/librustc_typeck/check/_match.rs index c223809b8c80e..87f867d7f90ac 100644 --- a/src/librustc_typeck/check/_match.rs +++ b/src/librustc_typeck/check/_match.rs @@ -147,7 +147,7 @@ pub fn check_pat<'a, 'tcx>(pcx: &pat_ctxt<'a, 'tcx>, } ast::PatEnum(..) | ast::PatIdent(..) if pat_is_resolved_const(&tcx.def_map, pat) => { let const_did = tcx.def_map.borrow().get(&pat.id).unwrap().def_id(); - let const_scheme = ty::lookup_item_type(tcx, const_did); + let const_scheme = tcx.lookup_item_type(const_did); assert!(const_scheme.generics.is_empty()); let const_ty = pcx.fcx.instantiate_type_scheme(pat.span, &Substs::empty(), @@ -227,8 +227,8 @@ pub fn check_pat<'a, 'tcx>(pcx: &pat_ctxt<'a, 'tcx>, resolve_ty_and_def_ufcs(fcx, path_res, Some(self_ty), path, pat.span, pat.id) { if check_assoc_item_is_const(pcx, def, pat.span) { - let scheme = ty::lookup_item_type(tcx, def.def_id()); - let predicates = ty::lookup_predicates(tcx, def.def_id()); + let scheme = tcx.lookup_item_type(def.def_id()); + let predicates = tcx.lookup_predicates(def.def_id()); instantiate_path(fcx, segments, scheme, &predicates, opt_ty, def, pat.span, pat.id); @@ -555,7 +555,7 @@ pub fn check_pat_struct<'a, 'tcx>(pcx: &pat_ctxt<'a, 'tcx>, pat: &'tcx ast::Pat, return; }, _ => { - let def_type = ty::lookup_item_type(tcx, def.def_id()); + let def_type = tcx.lookup_item_type(def.def_id()); match def_type.ty.sty { ty::TyStruct(struct_def_id, _) => (struct_def_id, struct_def_id), @@ -579,8 +579,8 @@ pub fn check_pat_struct<'a, 'tcx>(pcx: &pat_ctxt<'a, 'tcx>, pat: &'tcx ast::Pat, instantiate_path(pcx.fcx, &path.segments, - ty::lookup_item_type(tcx, enum_def_id), - &ty::lookup_predicates(tcx, enum_def_id), + tcx.lookup_item_type(enum_def_id), + &tcx.lookup_predicates(enum_def_id), None, def, pat.span, @@ -595,7 +595,7 @@ pub fn check_pat_struct<'a, 'tcx>(pcx: &pat_ctxt<'a, 'tcx>, pat: &'tcx ast::Pat, .map(|substs| substs.substs.clone()) .unwrap_or_else(|| Substs::empty()); - let struct_fields = ty::struct_fields(tcx, variant_def_id, &item_substs); + let struct_fields = tcx.struct_fields(variant_def_id, &item_substs); check_struct_pat_fields(pcx, pat.span, fields, &struct_fields, variant_def_id, etc); } @@ -631,10 +631,10 @@ pub fn check_pat_enum<'a, 'tcx>(pcx: &pat_ctxt<'a, 'tcx>, let enum_def = def.variant_def_ids() .map_or_else(|| def.def_id(), |(enum_def, _)| enum_def); - let ctor_scheme = ty::lookup_item_type(tcx, enum_def); - let ctor_predicates = ty::lookup_predicates(tcx, enum_def); + let ctor_scheme = tcx.lookup_item_type(enum_def); + let ctor_predicates = tcx.lookup_predicates(enum_def); let path_scheme = if ctor_scheme.ty.is_fn() { - let fn_ret = ty::no_late_bound_regions(tcx, &ctor_scheme.ty.fn_ret()).unwrap(); + let fn_ret = tcx.no_late_bound_regions(&ctor_scheme.ty.fn_ret()).unwrap(); ty::TypeScheme { ty: fn_ret.unwrap(), generics: ctor_scheme.generics, @@ -664,14 +664,14 @@ pub fn check_pat_enum<'a, 'tcx>(pcx: &pat_ctxt<'a, 'tcx>, ty::TyEnum(enum_def_id, expected_substs) if def == def::DefVariant(enum_def_id, def.def_id(), false) => { - let variant = ty::enum_variant_with_id(tcx, enum_def_id, def.def_id()); + let variant = tcx.enum_variant_with_id(enum_def_id, def.def_id()); (variant.args.iter() .map(|t| fcx.instantiate_type_scheme(pat.span, expected_substs, t)) .collect(), "variant") } ty::TyStruct(struct_def_id, expected_substs) => { - let struct_fields = ty::struct_fields(tcx, struct_def_id, expected_substs); + let struct_fields = tcx.struct_fields(struct_def_id, expected_substs); (struct_fields.iter() .map(|field| fcx.instantiate_type_scheme(pat.span, expected_substs, @@ -761,7 +761,7 @@ pub fn check_struct_pat_fields<'a, 'tcx>(pcx: &pat_ctxt<'a, 'tcx>, .unwrap_or_else(|| { span_err!(tcx.sess, span, E0026, "struct `{}` does not have a field named `{}`", - ty::item_path_str(tcx, struct_id), + tcx.item_path_str(struct_id), token::get_ident(field.ident)); tcx.types.err }) diff --git a/src/librustc_typeck/check/callee.rs b/src/librustc_typeck/check/callee.rs index 30ed9d9eb2f24..7109e45b55279 100644 --- a/src/librustc_typeck/check/callee.rs +++ b/src/librustc_typeck/check/callee.rs @@ -358,9 +358,8 @@ impl<'tcx> DeferredCallResolution<'tcx> for CallResolution<'tcx> { // can't because of the annoying need for a TypeTrace. // (This always bites me, should find a way to // refactor it.) - let method_sig = - ty::no_late_bound_regions(fcx.tcx(), - method_callee.ty.fn_sig()).unwrap(); + let method_sig = fcx.tcx().no_late_bound_regions(method_callee.ty.fn_sig()) + .unwrap(); debug!("attempt_resolution: method_callee={:?}", method_callee); diff --git a/src/librustc_typeck/check/cast.rs b/src/librustc_typeck/check/cast.rs index 1ff4c4eb0f455..49b47da517720 100644 --- a/src/librustc_typeck/check/cast.rs +++ b/src/librustc_typeck/check/cast.rs @@ -80,7 +80,7 @@ fn unsize_kind<'a,'tcx>(fcx: &FnCtxt<'a, 'tcx>, ty::TySlice(_) | ty::TyStr => Some(UnsizeKind::Length), ty::TyTrait(ref tty) => Some(UnsizeKind::Vtable(tty.principal_def_id())), ty::TyStruct(did, substs) => { - match ty::struct_fields(fcx.tcx(), did, substs).pop() { + match fcx.tcx().struct_fields(did, substs).pop() { None => None, Some(f) => unsize_kind(fcx, f.mt.ty) } diff --git a/src/librustc_typeck/check/closure.rs b/src/librustc_typeck/check/closure.rs index ec4c4a3271433..d431c0fda9865 100644 --- a/src/librustc_typeck/check/closure.rs +++ b/src/librustc_typeck/check/closure.rs @@ -65,10 +65,8 @@ fn check_closure<'a,'tcx>(fcx: &FnCtxt<'a,'tcx>, fcx.write_ty(expr.id, closure_type); - let fn_sig = - ty::liberate_late_bound_regions(fcx.tcx(), - region::DestructionScopeData::new(body.id), - &fn_ty.sig); + let fn_sig = fcx.tcx().liberate_late_bound_regions( + region::DestructionScopeData::new(body.id), &fn_ty.sig); check_fn(fcx.ccx, ast::Unsafety::Normal, diff --git a/src/librustc_typeck/check/coercion.rs b/src/librustc_typeck/check/coercion.rs index 612b574dfa7c6..73b9a16d1ebea 100644 --- a/src/librustc_typeck/check/coercion.rs +++ b/src/librustc_typeck/check/coercion.rs @@ -271,7 +271,7 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> { } _ => (source, None) }; - let source = ty::adjust_ty_for_autoref(self.tcx(), source, reborrow); + let source = source.adjust_for_autoref(self.tcx(), reborrow); let mut selcx = traits::SelectionContext::new(self.fcx.infcx(), self.fcx); diff --git a/src/librustc_typeck/check/compare_method.rs b/src/librustc_typeck/check/compare_method.rs index 44768990d68c4..349d1a8bb65a8 100644 --- a/src/librustc_typeck/check/compare_method.rs +++ b/src/librustc_typeck/check/compare_method.rs @@ -100,7 +100,7 @@ pub fn compare_impl_method<'tcx>(tcx: &ty::ctxt<'tcx>, token::get_name(trait_m.name), impl_m.fty.sig.0.inputs.len(), if impl_m.fty.sig.0.inputs.len() == 1 {""} else {"s"}, - ty::item_path_str(tcx, trait_m.def_id), + tcx.item_path_str(trait_m.def_id), trait_m.fty.sig.0.inputs.len()); return; } diff --git a/src/librustc_typeck/check/dropck.rs b/src/librustc_typeck/check/dropck.rs index fb17f41d88d9a..a48cffb4472f4 100644 --- a/src/librustc_typeck/check/dropck.rs +++ b/src/librustc_typeck/check/dropck.rs @@ -37,8 +37,8 @@ use syntax::codemap::{self, Span}; /// pub fn check_drop_impl(tcx: &ty::ctxt, drop_impl_did: ast::DefId) -> Result<(), ()> { let ty::TypeScheme { generics: ref dtor_generics, - ty: dtor_self_type } = ty::lookup_item_type(tcx, drop_impl_did); - let dtor_predicates = ty::lookup_predicates(tcx, drop_impl_did); + ty: dtor_self_type } = tcx.lookup_item_type(drop_impl_did); + let dtor_predicates = tcx.lookup_predicates(drop_impl_did); match dtor_self_type.sty { ty::TyEnum(self_type_did, self_to_impl_substs) | ty::TyStruct(self_type_did, self_to_impl_substs) | @@ -91,7 +91,7 @@ fn ensure_drop_params_and_item_params_correspond<'tcx>( let ty::TypeScheme { generics: ref named_type_generics, ty: named_type } = - ty::lookup_item_type(tcx, self_type_did); + tcx.lookup_item_type(self_type_did); let infcx = infer::new_infer_ctxt(tcx); infcx.commit_if_ok(|snapshot| { @@ -179,7 +179,7 @@ fn ensure_drop_predicates_are_implied_by_item_defn<'tcx>( // We can assume the predicates attached to struct/enum definition // hold. - let generic_assumptions = ty::lookup_predicates(tcx, self_type_did); + let generic_assumptions = tcx.lookup_predicates(self_type_did); let assumptions_in_impl_context = generic_assumptions.instantiate(tcx, &self_to_impl_substs); assert!(assumptions_in_impl_context.predicates.is_empty_in(subst::SelfSpace)); @@ -288,7 +288,7 @@ pub fn check_safety_of_destructor_if_necessary<'a, 'tcx>(rcx: &mut Rcx<'a, 'tcx> rcx.tcx().sess, span, "overflowed on enum {} variant {} argument {} type: {}", - ty::item_path_str(tcx, def_id), + tcx.item_path_str(def_id), variant, arg_index, detected_on_typ); @@ -298,7 +298,7 @@ pub fn check_safety_of_destructor_if_necessary<'a, 'tcx>(rcx: &mut Rcx<'a, 'tcx> rcx.tcx().sess, span, "overflowed on struct {} field {} type: {}", - ty::item_path_str(tcx, def_id), + tcx.item_path_str(def_id), field, detected_on_typ); } @@ -365,7 +365,7 @@ fn iterate_over_potentially_unsafe_regions_in_type<'a, 'tcx>( let (typ, xref_depth) = match typ.sty { ty::TyStruct(struct_did, substs) => { if opt_phantom_data_def_id == Some(struct_did) { - let item_type = ty::lookup_item_type(rcx.tcx(), struct_did); + let item_type = rcx.tcx().lookup_item_type(struct_did); let tp_def = item_type.generics.types .opt_get(subst::TypeSpace, 0).unwrap(); let new_typ = substs.type_for_def(tp_def); @@ -471,13 +471,11 @@ fn iterate_over_potentially_unsafe_regions_in_type<'a, 'tcx>( walker.skip_current_subtree(); let fields = - ty::lookup_struct_fields(rcx.tcx(), struct_did); + rcx.tcx().lookup_struct_fields(struct_did); for field in &fields { - let field_type = - ty::lookup_field_type(rcx.tcx(), - struct_did, - field.id, - substs); + let field_type = rcx.tcx().lookup_field_type(struct_did, + field.id, + substs); try!(iterate_over_potentially_unsafe_regions_in_type( rcx, breadcrumbs, @@ -501,9 +499,7 @@ fn iterate_over_potentially_unsafe_regions_in_type<'a, 'tcx>( walker.skip_current_subtree(); let all_variant_info = - ty::substd_enum_variants(rcx.tcx(), - enum_did, - substs); + rcx.tcx().substd_enum_variants(enum_did, substs); for variant_info in &all_variant_info { for (i, arg_type) in variant_info.args.iter().enumerate() { try!(iterate_over_potentially_unsafe_regions_in_type( @@ -591,13 +587,13 @@ fn has_dtor_of_interest<'tcx>(tcx: &ty::ctxt<'tcx>, } } DtorKind::KnownDropMethod(dtor_method_did) => { - let impl_did = ty::impl_of_method(tcx, dtor_method_did) + let impl_did = tcx.impl_of_method(dtor_method_did) .unwrap_or_else(|| { tcx.sess.span_bug( span, "no Drop impl found for drop method") }); - let dtor_typescheme = ty::lookup_item_type(tcx, impl_did); + let dtor_typescheme = tcx.lookup_item_type(impl_did); let dtor_generics = dtor_typescheme.generics; let mut has_pred_of_interest = false; @@ -609,7 +605,7 @@ fn has_dtor_of_interest<'tcx>(tcx: &ty::ctxt<'tcx>, continue; } - for pred in ty::lookup_predicates(tcx, item_def_id).predicates { + for pred in tcx.lookup_predicates(item_def_id).predicates { let result = match pred { ty::Predicate::Equate(..) | ty::Predicate::RegionOutlives(..) | @@ -623,7 +619,7 @@ fn has_dtor_of_interest<'tcx>(tcx: &ty::ctxt<'tcx>, ty::Predicate::Trait(ty::Binder(ref t_pred)) => { let def_id = t_pred.trait_ref.def_id; - if ty::trait_items(tcx, def_id).len() != 0 { + if tcx.trait_items(def_id).len() != 0 { // If trait has items, assume it adds // capability to access borrowed data. true diff --git a/src/librustc_typeck/check/method/confirm.rs b/src/librustc_typeck/check/method/confirm.rs index 2104ebaec45c9..5f7a78ec611a2 100644 --- a/src/librustc_typeck/check/method/confirm.rs +++ b/src/librustc_typeck/check/method/confirm.rs @@ -139,7 +139,7 @@ impl<'a,'tcx> ConfirmContext<'a,'tcx> { let region = self.infcx().next_region_var(infer::Autoref(self.span)); let autoref = ty::AutoPtr(self.tcx().mk_region(region), mutbl); (Some(autoref), pick.unsize.map(|target| { - ty::adjust_ty_for_autoref(self.tcx(), target, Some(autoref)) + target.adjust_for_autoref(self.tcx(), Some(autoref)) })) } else { // No unsizing should be performed without autoref (at @@ -179,7 +179,7 @@ impl<'a,'tcx> ConfirmContext<'a,'tcx> { if let Some(target) = unsize { target } else { - ty::adjust_ty_for_autoref(self.tcx(), autoderefd_ty, autoref) + autoderefd_ty.adjust_for_autoref(self.tcx(), autoref) } } @@ -199,7 +199,7 @@ impl<'a,'tcx> ConfirmContext<'a,'tcx> { { match pick.kind { probe::InherentImplPick(impl_def_id) => { - assert!(ty::impl_trait_ref(self.tcx(), impl_def_id).is_none(), + assert!(self.tcx().impl_trait_ref(impl_def_id).is_none(), "impl {:?} is not an inherent impl", impl_def_id); let impl_polytype = check::impl_self_ty(self.fcx, self.span, impl_def_id); @@ -254,7 +254,7 @@ impl<'a,'tcx> ConfirmContext<'a,'tcx> { self.fcx.instantiate_type_scheme( self.span, &impl_polytype.substs, - &ty::impl_trait_ref(self.tcx(), impl_def_id).unwrap()); + &self.tcx().impl_trait_ref(impl_def_id).unwrap()); let origin = MethodTypeParam(MethodParam { trait_ref: impl_trait_ref.clone(), method_num: method_num, impl_def_id: Some(impl_def_id) }); @@ -262,7 +262,7 @@ impl<'a,'tcx> ConfirmContext<'a,'tcx> { } probe::TraitPick(trait_def_id, method_num) => { - let trait_def = ty::lookup_trait_def(self.tcx(), trait_def_id); + let trait_def = self.tcx().lookup_trait_def(trait_def_id); // Make a trait reference `$0 : Trait<$1...$n>` // consisting entirely of type variables. Later on in diff --git a/src/librustc_typeck/check/method/mod.rs b/src/librustc_typeck/check/method/mod.rs index 6ba9704aa987f..0f8048f27a0e3 100644 --- a/src/librustc_typeck/check/method/mod.rs +++ b/src/librustc_typeck/check/method/mod.rs @@ -167,7 +167,7 @@ pub fn lookup_in_trait_adjusted<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, m_name, trait_def_id); - let trait_def = ty::lookup_trait_def(fcx.tcx(), trait_def_id); + let trait_def = fcx.tcx().lookup_trait_def(trait_def_id); let expected_number_of_input_types = trait_def.generics.types.len(subst::TypeSpace); let input_types = match opt_input_types { @@ -359,7 +359,7 @@ fn trait_item<'tcx>(tcx: &ty::ctxt<'tcx>, item_name: ast::Name) -> Option<(usize, ty::ImplOrTraitItem<'tcx>)> { - let trait_items = ty::trait_items(tcx, trait_def_id); + let trait_items = tcx.trait_items(trait_def_id); trait_items .iter() .enumerate() @@ -376,6 +376,6 @@ fn impl_item<'tcx>(tcx: &ty::ctxt<'tcx>, let impl_items = impl_items.get(&impl_def_id).unwrap(); impl_items .iter() - .map(|&did| ty::impl_or_trait_item(tcx, did.def_id())) + .map(|&did| tcx.impl_or_trait_item(did.def_id())) .find(|m| m.name() == item_name) } diff --git a/src/librustc_typeck/check/method/probe.rs b/src/librustc_typeck/check/method/probe.rs index a8fc411410567..8026fce69ecca 100644 --- a/src/librustc_typeck/check/method/probe.rs +++ b/src/librustc_typeck/check/method/probe.rs @@ -377,7 +377,7 @@ impl<'a,'tcx> ProbeContext<'a,'tcx> { fn assemble_inherent_impl_for_primitive(&mut self, lang_def_id: Option) { if let Some(impl_def_id) = lang_def_id { - ty::populate_implementations_for_primitive_if_necessary(self.tcx(), impl_def_id); + self.tcx().populate_implementations_for_primitive_if_necessary(impl_def_id); self.assemble_inherent_impl_probe(impl_def_id); } @@ -386,7 +386,7 @@ impl<'a,'tcx> ProbeContext<'a,'tcx> { fn assemble_inherent_impl_candidates_for_type(&mut self, def_id: ast::DefId) { // Read the inherent implementation candidates for this type from the // metadata if necessary. - ty::populate_inherent_implementations_for_type_if_necessary(self.tcx(), def_id); + self.tcx().populate_inherent_implementations_for_type_if_necessary(def_id); if let Some(impl_infos) = self.tcx().inherent_impls.borrow().get(&def_id) { for &impl_def_id in impl_infos.iter() { @@ -606,7 +606,7 @@ impl<'a,'tcx> ProbeContext<'a,'tcx> { // Check whether `trait_def_id` defines a method with suitable name: let trait_items = - ty::trait_items(self.tcx(), trait_def_id); + self.tcx().trait_items(trait_def_id); let matching_index = trait_items.iter() .position(|item| item.name() == self.item_name); @@ -647,7 +647,7 @@ impl<'a,'tcx> ProbeContext<'a,'tcx> { item: ty::ImplOrTraitItem<'tcx>, item_index: usize) { - let trait_def = ty::lookup_trait_def(self.tcx(), trait_def_id); + let trait_def = self.tcx().lookup_trait_def(trait_def_id); // FIXME(arielb1): can we use for_each_relevant_impl here? trait_def.for_each_impl(self.tcx(), |impl_def_id| { @@ -665,7 +665,7 @@ impl<'a,'tcx> ProbeContext<'a,'tcx> { debug!("impl_substs={:?}", impl_substs); let impl_trait_ref = - ty::impl_trait_ref(self.tcx(), impl_def_id) + self.tcx().impl_trait_ref(impl_def_id) .unwrap() // we know this is a trait impl .subst(self.tcx(), &impl_substs); @@ -705,7 +705,7 @@ impl<'a,'tcx> ProbeContext<'a,'tcx> { None => { return true; } }; - let impl_type = ty::lookup_item_type(self.tcx(), impl_def_id); + let impl_type = self.tcx().lookup_item_type(impl_def_id); let impl_simplified_type = match fast_reject::simplify_type(self.tcx(), impl_type.ty, false) { Some(simplified_type) => simplified_type, @@ -759,7 +759,7 @@ impl<'a,'tcx> ProbeContext<'a,'tcx> { // for the purposes of our method lookup, we only take // receiver type into account, so we can just substitute // fresh types here to use during substitution and subtyping. - let trait_def = ty::lookup_trait_def(self.tcx(), trait_def_id); + let trait_def = self.tcx().lookup_trait_def(trait_def_id); let substs = self.infcx().fresh_substs_for_trait(self.span, &trait_def.generics, step.self_ty); @@ -802,8 +802,7 @@ impl<'a,'tcx> ProbeContext<'a,'tcx> { debug!("assemble_projection_candidates: projection_trait_ref={:?}", projection_trait_ref); - let trait_predicates = ty::lookup_predicates(self.tcx(), - projection_trait_ref.def_id); + let trait_predicates = self.tcx().lookup_predicates(projection_trait_ref.def_id); let bounds = trait_predicates.instantiate(self.tcx(), projection_trait_ref.substs); let predicates = bounds.predicates.into_vec(); debug!("assemble_projection_candidates: predicates={:?}", @@ -894,7 +893,7 @@ impl<'a,'tcx> ProbeContext<'a,'tcx> { match source { TraitSource(id) => id, ImplSource(impl_id) => { - match ty::trait_id_of_impl(tcx, impl_id) { + match tcx.trait_id_of_impl(impl_id) { Some(id) => id, None => tcx.sess.span_bug(span, @@ -1081,7 +1080,7 @@ impl<'a,'tcx> ProbeContext<'a,'tcx> { let cause = traits::ObligationCause::misc(self.span, self.fcx.body_id); // Check whether the impl imposes obligations we have to worry about. - let impl_bounds = ty::lookup_predicates(self.tcx(), impl_def_id); + let impl_bounds = self.tcx().lookup_predicates(impl_def_id); let impl_bounds = impl_bounds.instantiate(self.tcx(), substs); let traits::Normalized { value: impl_bounds, obligations: norm_obligations } = @@ -1266,7 +1265,7 @@ impl<'a,'tcx> ProbeContext<'a,'tcx> { impl_def_id: ast::DefId) -> (Ty<'tcx>, subst::Substs<'tcx>) { - let impl_pty = ty::lookup_item_type(self.tcx(), impl_def_id); + let impl_pty = self.tcx().lookup_item_type(impl_def_id); let type_vars = impl_pty.generics.types.map( @@ -1301,7 +1300,7 @@ impl<'a,'tcx> ProbeContext<'a,'tcx> { fn erase_late_bound_regions(&self, value: &ty::Binder) -> T where T : TypeFoldable<'tcx> { - ty::erase_late_bound_regions(self.tcx(), value) + self.tcx().erase_late_bound_regions(value) } } @@ -1314,7 +1313,7 @@ fn impl_item<'tcx>(tcx: &ty::ctxt<'tcx>, let impl_items = impl_items.get(&impl_def_id).unwrap(); impl_items .iter() - .map(|&did| ty::impl_or_trait_item(tcx, did.def_id())) + .map(|&did| tcx.impl_or_trait_item(did.def_id())) .find(|item| item.name() == item_name) } @@ -1325,7 +1324,7 @@ fn trait_item<'tcx>(tcx: &ty::ctxt<'tcx>, item_name: ast::Name) -> Option<(usize, ty::ImplOrTraitItem<'tcx>)> { - let trait_items = ty::trait_items(tcx, trait_def_id); + let trait_items = tcx.trait_items(trait_def_id); debug!("trait_method; items: {:?}", trait_items); trait_items .iter() diff --git a/src/librustc_typeck/check/method/suggest.rs b/src/librustc_typeck/check/method/suggest.rs index de8629da3cade..b193ddcb21349 100644 --- a/src/librustc_typeck/check/method/suggest.rs +++ b/src/librustc_typeck/check/method/suggest.rs @@ -66,7 +66,7 @@ pub fn report_error<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, // If the item has the name of a field, give a help note if let (&ty::TyStruct(did, substs), Some(expr)) = (&rcvr_ty.sty, rcvr_expr) { - let fields = ty::lookup_struct_fields(cx, did); + let fields = cx.lookup_struct_fields(did); if let Some(field) = fields.iter().find(|f| f.name == item_name) { let expr_string = match cx.sess.codemap().span_to_snippet(expr.span) { @@ -89,7 +89,7 @@ pub fn report_error<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, }; // Determine if the field can be used as a function in some way - let field_ty = ty::lookup_field_type(cx, did, field.id, substs); + let field_ty = cx.lookup_field_type(did, field.id, substs); if let Ok(fn_once_trait_did) = cx.lang_items.require(FnOnceTraitLangItem) { let infcx = fcx.infcx(); infcx.probe(|_| { @@ -159,7 +159,7 @@ pub fn report_error<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, invoked on this closure as we have not yet inferred what \ kind of closure it is", item_name, - ty::item_path_str(fcx.tcx(), trait_def_id)); + fcx.tcx().item_path_str(trait_def_id)); let msg = if let Some(callee) = rcvr_expr { format!("{}; use overloaded call notation instead (e.g., `{}()`)", msg, pprust::expr_to_string(callee)) @@ -188,11 +188,12 @@ pub fn report_error<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, let impl_ty = check::impl_self_ty(fcx, span, impl_did).ty; - let insertion = match ty::impl_trait_ref(fcx.tcx(), impl_did) { + let insertion = match fcx.tcx().impl_trait_ref(impl_did) { None => format!(""), - Some(trait_ref) => format!(" of the trait `{}`", - ty::item_path_str(fcx.tcx(), - trait_ref.def_id)), + Some(trait_ref) => { + format!(" of the trait `{}`", + fcx.tcx().item_path_str(trait_ref.def_id)) + } }; span_note!(fcx.sess(), item_span, @@ -207,7 +208,7 @@ pub fn report_error<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, span_note!(fcx.sess(), item_span, "candidate #{} is defined in the trait `{}`", idx + 1, - ty::item_path_str(fcx.tcx(), trait_did)); + fcx.tcx().item_path_str(trait_did)); } } } @@ -243,7 +244,7 @@ fn suggest_traits_to_import<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, fcx.sess().fileline_help(span, &*format!("candidate #{}: use `{}`", i + 1, - ty::item_path_str(fcx.tcx(), *trait_did))) + fcx.tcx().item_path_str(*trait_did))) } return @@ -289,7 +290,7 @@ fn suggest_traits_to_import<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, fcx.sess().fileline_help(span, &*format!("candidate #{}: `{}`", i + 1, - ty::item_path_str(fcx.tcx(), trait_info.def_id))) + fcx.tcx().item_path_str(trait_info.def_id))) } } } diff --git a/src/librustc_typeck/check/mod.rs b/src/librustc_typeck/check/mod.rs index 6826c33359aee..299ccd579ccb7 100644 --- a/src/librustc_typeck/check/mod.rs +++ b/src/librustc_typeck/check/mod.rs @@ -97,7 +97,6 @@ use middle::traits::{self, report_fulfillment_errors}; use middle::ty::{FnSig, GenericPredicates, TypeScheme}; use middle::ty::{Disr, ParamTy, ParameterEnvironment}; use middle::ty::{self, HasTypeFlags, RegionEscape, ToPolyTraitRef, Ty}; -use middle::ty::liberate_late_bound_regions; use middle::ty::{MethodCall, MethodCallee, MethodMap}; use middle::ty_fold::{TypeFolder, TypeFoldable}; use rscope::RegionScope; @@ -308,7 +307,7 @@ impl<'a, 'tcx> mc::Typer<'tcx> for FnCtxt<'a, 'tcx> { let ty = self.adjust_expr_ty(expr, self.inh.adjustments.borrow().get(&expr.id)); self.resolve_type_vars_or_error(&ty) } - fn type_moves_by_default(&self, span: Span, ty: Ty<'tcx>) -> bool { + fn type_moves_by_default(&self, ty: Ty<'tcx>, span: Span) -> bool { let ty = self.infcx().resolve_type_vars_if_possible(&ty); !traits::type_known_to_meet_builtin_bound(self.infcx(), self, ty, ty::BoundCopy, span) } @@ -363,9 +362,8 @@ impl<'a, 'tcx> ty::ClosureTyper<'tcx> for FnCtxt<'a, 'tcx> { fn closure_upvars(&self, def_id: ast::DefId, substs: &Substs<'tcx>) - -> Option>> - { - ty::closure_upvars(self, def_id, substs) + -> Option>> { + ty::ctxt::closure_upvars(self, def_id, substs) } } @@ -430,7 +428,7 @@ fn static_inherited_fields<'a, 'tcx>(ccx: &'a CrateCtxt<'a, 'tcx>) -> Inherited<'a, 'tcx> { // It's kind of a kludge to manufacture a fake function context // and statement context, but we might as well do write the code only once - let param_env = ty::empty_parameter_environment(ccx.tcx); + let param_env = ccx.tcx.empty_parameter_environment(); Inherited::new(ccx.tcx, param_env) } @@ -512,9 +510,8 @@ fn check_bare_fn<'a, 'tcx>(ccx: &CrateCtxt<'a, 'tcx>, let fn_sig = fn_ty.sig.subst(ccx.tcx, &inh.param_env.free_substs); let fn_sig = - liberate_late_bound_regions(ccx.tcx, - region::DestructionScopeData::new(body.id), - &fn_sig); + ccx.tcx.liberate_late_bound_regions(region::DestructionScopeData::new(body.id), + &fn_sig); let fn_sig = inh.normalize_associated_types_in(&inh.param_env, body.span, body.id, &fn_sig); @@ -718,7 +715,7 @@ pub fn check_struct(ccx: &CrateCtxt, id: ast::NodeId, span: Span) { check_representable(tcx, span, id, "struct"); check_instantiable(tcx, span, id); - if ty::lookup_simd(tcx, local_def(id)) { + if tcx.lookup_simd(local_def(id)) { check_simd(tcx, span, id); } } @@ -726,7 +723,7 @@ pub fn check_struct(ccx: &CrateCtxt, id: ast::NodeId, span: Span) { pub fn check_item_type<'a,'tcx>(ccx: &CrateCtxt<'a,'tcx>, it: &'tcx ast::Item) { debug!("check_item_type(it.id={}, it.ident={})", it.id, - ty::item_path_str(ccx.tcx, local_def(it.id))); + ccx.tcx.item_path_str(local_def(it.id))); let _indenter = indenter(); match it.node { // Consts can play a role in type-checking, so they are included here. @@ -741,7 +738,7 @@ pub fn check_item_type<'a,'tcx>(ccx: &CrateCtxt<'a,'tcx>, it: &'tcx ast::Item) { ast::ItemFn(..) => {} // entirely within check_item_body ast::ItemImpl(_, _, _, _, _, ref impl_items) => { debug!("ItemImpl {} with id {}", token::get_ident(it.ident), it.id); - match ty::impl_trait_ref(ccx.tcx, local_def(it.id)) { + match ccx.tcx.impl_trait_ref(local_def(it.id)) { Some(impl_trait_ref) => { check_impl_items_against_trait(ccx, it.span, @@ -758,7 +755,7 @@ pub fn check_item_type<'a,'tcx>(ccx: &CrateCtxt<'a,'tcx>, it: &'tcx ast::Item) { check_struct(ccx, it.id, it.span); } ast::ItemTy(ref t, ref generics) => { - let pty_ty = ty::node_id_to_type(ccx.tcx, it.id); + let pty_ty = ccx.tcx.node_id_to_type(it.id); check_bounds_are_used(ccx, t.span, &generics.ty_params, pty_ty); } ast::ItemForeignMod(ref m) => { @@ -768,7 +765,7 @@ pub fn check_item_type<'a,'tcx>(ccx: &CrateCtxt<'a,'tcx>, it: &'tcx ast::Item) { } } else { for item in &m.items { - let pty = ty::lookup_item_type(ccx.tcx, local_def(item.id)); + let pty = ccx.tcx.lookup_item_type(local_def(item.id)); if !pty.generics.types.is_empty() { span_err!(ccx.tcx.sess, item.span, E0044, "foreign items may not have type parameters"); @@ -790,18 +787,18 @@ pub fn check_item_type<'a,'tcx>(ccx: &CrateCtxt<'a,'tcx>, it: &'tcx ast::Item) { pub fn check_item_body<'a,'tcx>(ccx: &CrateCtxt<'a,'tcx>, it: &'tcx ast::Item) { debug!("check_item_body(it.id={}, it.ident={})", it.id, - ty::item_path_str(ccx.tcx, local_def(it.id))); + ccx.tcx.item_path_str(local_def(it.id))); let _indenter = indenter(); match it.node { ast::ItemFn(ref decl, _, _, _, _, ref body) => { - let fn_pty = ty::lookup_item_type(ccx.tcx, ast_util::local_def(it.id)); + let fn_pty = ccx.tcx.lookup_item_type(ast_util::local_def(it.id)); let param_env = ParameterEnvironment::for_item(ccx.tcx, it.id); check_bare_fn(ccx, &**decl, &**body, it.id, it.span, fn_pty.ty, param_env); } ast::ItemImpl(_, _, _, _, _, ref impl_items) => { debug!("ItemImpl {} with id {}", token::get_ident(it.ident), it.id); - let impl_pty = ty::lookup_item_type(ccx.tcx, ast_util::local_def(it.id)); + let impl_pty = ccx.tcx.lookup_item_type(ast_util::local_def(it.id)); for impl_item in impl_items { match impl_item.node { @@ -820,7 +817,7 @@ pub fn check_item_body<'a,'tcx>(ccx: &CrateCtxt<'a,'tcx>, it: &'tcx ast::Item) { } } ast::ItemTrait(_, _, _, ref trait_items) => { - let trait_def = ty::lookup_trait_def(ccx.tcx, local_def(it.id)); + let trait_def = ccx.tcx.lookup_trait_def(local_def(it.id)); for trait_item in trait_items { match trait_item.node { ast::ConstTraitItem(_, Some(ref expr)) => { @@ -921,7 +918,7 @@ fn check_method_body<'a, 'tcx>(ccx: &CrateCtxt<'a, 'tcx>, item_generics, id); let param_env = ParameterEnvironment::for_item(ccx.tcx, id); - let fty = ty::node_id_to_type(ccx.tcx, id); + let fty = ccx.tcx.node_id_to_type(id); debug!("check_method_body: fty={:?}", fty); check_bare_fn(ccx, &sig.decl, body, id, span, fty, param_env); @@ -933,7 +930,7 @@ fn check_impl_items_against_trait<'a, 'tcx>(ccx: &CrateCtxt<'a, 'tcx>, impl_items: &[P]) { // Locate trait methods let tcx = ccx.tcx; - let trait_items = ty::trait_items(tcx, impl_trait_ref.def_id); + let trait_items = tcx.trait_items(impl_trait_ref.def_id); // Check existing impl methods to see if they are both present in trait // and compatible with trait signature @@ -941,8 +938,7 @@ fn check_impl_items_against_trait<'a, 'tcx>(ccx: &CrateCtxt<'a, 'tcx>, match impl_item.node { ast::ConstImplItem(..) => { let impl_const_def_id = local_def(impl_item.id); - let impl_const_ty = ty::impl_or_trait_item(ccx.tcx, - impl_const_def_id); + let impl_const_ty = ccx.tcx.impl_or_trait_item(impl_const_def_id); // Find associated const definition. let opt_associated_const = @@ -985,8 +981,7 @@ fn check_impl_items_against_trait<'a, 'tcx>(ccx: &CrateCtxt<'a, 'tcx>, check_trait_fn_not_const(ccx, impl_item.span, sig.constness); let impl_method_def_id = local_def(impl_item.id); - let impl_item_ty = ty::impl_or_trait_item(ccx.tcx, - impl_method_def_id); + let impl_item_ty = ccx.tcx.impl_or_trait_item(impl_method_def_id); // If this is an impl of a trait method, find the // corresponding method definition in the trait. @@ -1027,8 +1022,7 @@ fn check_impl_items_against_trait<'a, 'tcx>(ccx: &CrateCtxt<'a, 'tcx>, } ast::TypeImplItem(_) => { let typedef_def_id = local_def(impl_item.id); - let typedef_ty = ty::impl_or_trait_item(ccx.tcx, - typedef_def_id); + let typedef_ty = ccx.tcx.impl_or_trait_item(typedef_def_id); // If this is an impl of an associated type, find the // corresponding type definition in the trait. @@ -1067,8 +1061,8 @@ fn check_impl_items_against_trait<'a, 'tcx>(ccx: &CrateCtxt<'a, 'tcx>, } // Check for missing items from trait - let provided_methods = ty::provided_trait_methods(tcx, impl_trait_ref.def_id); - let associated_consts = ty::associated_consts(tcx, impl_trait_ref.def_id); + let provided_methods = tcx.provided_trait_methods(impl_trait_ref.def_id); + let associated_consts = tcx.associated_consts(impl_trait_ref.def_id); let mut missing_items = Vec::new(); for trait_item in trait_items.iter() { match *trait_item { @@ -1189,13 +1183,13 @@ impl<'a, 'tcx> AstConv<'tcx> for FnCtxt<'a, 'tcx> { fn get_item_type_scheme(&self, _: Span, id: ast::DefId) -> Result, ErrorReported> { - Ok(ty::lookup_item_type(self.tcx(), id)) + Ok(self.tcx().lookup_item_type(id)) } fn get_trait_def(&self, _: Span, id: ast::DefId) -> Result<&'tcx ty::TraitDef<'tcx>, ErrorReported> { - Ok(ty::lookup_trait_def(self.tcx(), id)) + Ok(self.tcx().lookup_trait_def(id)) } fn ensure_super_predicates(&self, _: Span, _: ast::DefId) -> Result<(), ErrorReported> { @@ -1238,7 +1232,7 @@ impl<'a, 'tcx> AstConv<'tcx> for FnCtxt<'a, 'tcx> { assoc_name: ast::Name) -> bool { - let trait_def = ty::lookup_trait_def(self.ccx.tcx, trait_def_id); + let trait_def = self.ccx.tcx.lookup_trait_def(trait_def_id); trait_def.associated_type_names.contains(&assoc_name) } @@ -1506,9 +1500,9 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { -> TypeAndSubsts<'tcx> { let type_scheme = - ty::lookup_item_type(self.tcx(), def_id); + self.tcx().lookup_item_type(def_id); let type_predicates = - ty::lookup_predicates(self.tcx(), def_id); + self.tcx().lookup_predicates(def_id); let substs = self.infcx().fresh_substs_for_generics( span, @@ -1543,7 +1537,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { let tcx = self.tcx(); let ty::TypeScheme { generics, ty: decl_ty } = - ty::lookup_item_type(tcx, did); + tcx.lookup_item_type(did); let substs = astconv::ast_path_substs_for_ty(self, self, path.span, @@ -1651,14 +1645,10 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { let raw_ty = self.expr_ty(expr); let raw_ty = self.infcx().shallow_resolve(raw_ty); let resolve_ty = |ty: Ty<'tcx>| self.infcx().resolve_type_vars_if_possible(&ty); - ty::adjust_ty(self.tcx(), - expr.span, - expr.id, - raw_ty, - adjustment, - |method_call| self.inh.method_map.borrow() - .get(&method_call) - .map(|method| resolve_ty(method.ty))) + raw_ty.adjust(self.tcx(), expr.span, expr.id, adjustment, |method_call| { + self.inh.method_map.borrow().get(&method_call) + .map(|method| resolve_ty(method.ty)) + }) } pub fn node_ty(&self, id: ast::NodeId) -> Ty<'tcx> { @@ -1798,7 +1788,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { -> Option> { let o_field = items.iter().find(|f| f.name == fieldname); - o_field.map(|f| ty::lookup_field_type(self.tcx(), class_id, f.id, substs)) + o_field.map(|f| self.tcx().lookup_field_type(class_id, f.id, substs)) .map(|t| self.normalize_associated_types_in(span, &t)) } @@ -1811,7 +1801,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { -> Option> { let o_field = if idx < items.len() { Some(&items[idx]) } else { None }; - o_field.map(|f| ty::lookup_field_type(self.tcx(), class_id, f.id, substs)) + o_field.map(|f| self.tcx().lookup_field_type(class_id, f.id, substs)) .map(|t| self.normalize_associated_types_in(span, &t)) } @@ -2046,7 +2036,7 @@ fn make_overloaded_lvalue_return_type<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, // extract method method return type, which will be &T; // all LB regions should have been instantiated during method lookup let ret_ty = method.ty.fn_ret(); - let ret_ty = ty::no_late_bound_regions(fcx.tcx(), &ret_ty).unwrap().unwrap(); + let ret_ty = fcx.tcx().no_late_bound_regions(&ret_ty).unwrap().unwrap(); if let Some(method_call) = method_call { fcx.inh.method_map.borrow_mut().insert(method_call, method); @@ -2528,7 +2518,7 @@ pub fn impl_self_ty<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, -> TypeAndSubsts<'tcx> { let tcx = fcx.tcx(); - let ity = ty::lookup_item_type(tcx, did); + let ity = tcx.lookup_item_type(did); let (n_tps, rps, raw_ty) = (ity.generics.types.len(subst::TypeSpace), ity.generics.regions.get_slice(subst::TypeSpace), @@ -2738,7 +2728,7 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>, match base_t.sty { ty::TyStruct(base_id, substs) => { debug!("struct named {:?}", base_t); - let fields = ty::lookup_struct_fields(tcx, base_id); + let fields = tcx.lookup_struct_fields(base_id); fcx.lookup_field_ty(expr.span, base_id, &fields[..], field.node.name, &(*substs)) } @@ -2794,7 +2784,7 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>, let name = &ident; // only find fits with at least one matching letter let mut best_dist = name.len(); - let fields = ty::lookup_struct_fields(tcx, id); + let fields = tcx.lookup_struct_fields(id); let mut best = None; for elem in &fields { let n = elem.name.as_str(); @@ -2839,10 +2829,10 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>, |base_t, _| { match base_t.sty { ty::TyStruct(base_id, substs) => { - tuple_like = ty::is_tuple_struct(tcx, base_id); + tuple_like = tcx.is_tuple_struct(base_id); if tuple_like { debug!("tuple struct named {:?}", base_t); - let fields = ty::lookup_struct_fields(tcx, base_id); + let fields = tcx.lookup_struct_fields(base_id); fcx.lookup_tup_field_ty(expr.span, base_id, &fields[..], idx.node, &(*substs)) } else { @@ -2915,8 +2905,7 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>, field.ident.span, |actual| match enum_id_opt { Some(enum_id) => { - let variant_type = ty::enum_variant_with_id(tcx, - enum_id, + let variant_type = tcx.enum_variant_with_id(enum_id, class_id); format!("struct variant `{}::{}` has no field named `{}`", actual, variant_type.name.as_str(), @@ -2934,7 +2923,7 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>, let skip_fields = ast_fields.iter().map(|ref x| x.ident.node.name.as_str()); let actual_id = match enum_id_opt { Some(_) => class_id, - None => ty::ty_to_def_id(struct_ty).unwrap() + None => struct_ty.ty_to_def_id().unwrap() }; suggest_field_names(actual_id, &field.ident, tcx, skip_fields.collect()); error_happened = true; @@ -2947,8 +2936,7 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>, } Some((field_id, false)) => { expected_field_type = - ty::lookup_field_type( - tcx, class_id, field_id, substitutions); + tcx.lookup_field_type(class_id, field_id, substitutions); expected_field_type = fcx.normalize_associated_types_in( field.span, &expected_field_type); @@ -3008,7 +2996,7 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>, } = fcx.instantiate_type(span, class_id); // Look up and check the fields. - let class_fields = ty::lookup_struct_fields(tcx, class_id); + let class_fields = tcx.lookup_struct_fields(class_id); check_struct_or_variant_fields(fcx, struct_type, span, @@ -3051,7 +3039,7 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>, } = fcx.instantiate_type(span, enum_id); // Look up and check the enum variant fields. - let variant_fields = ty::lookup_struct_fields(tcx, variant_id); + let variant_fields = tcx.lookup_struct_fields(variant_id); check_struct_or_variant_fields(fcx, enum_type, span, @@ -3208,7 +3196,7 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>, let hint = expected.only_has_type(fcx).map_or(NoExpectation, |ty| { match ty.sty { ty::TyRef(_, ref mt) | ty::TyRawPtr(ref mt) => { - if ty::expr_is_lval(fcx.tcx(), &**oprnd) { + if fcx.tcx().expr_is_lval(&**oprnd) { // Lvalues may legitimately have unsized types. // For example, dereferences of a fat pointer and // the last field of a struct can be unsized. @@ -3336,7 +3324,7 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>, check_expr_with_lvalue_pref(fcx, &**lhs, PreferMutLvalue); let tcx = fcx.tcx(); - if !ty::expr_is_lval(tcx, &**lhs) { + if !tcx.expr_is_lval(&**lhs) { span_err!(tcx.sess, expr.span, E0070, "illegal left-hand side expression"); } @@ -3465,7 +3453,7 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>, } ast::ExprRepeat(ref element, ref count_expr) => { check_expr_has_type(fcx, &**count_expr, tcx.types.usize); - let count = ty::eval_repeat_count(fcx.tcx(), &**count_expr); + let count = fcx.tcx().eval_repeat_count(&**count_expr); let uty = match expected { ExpectHasType(uty) => { @@ -3558,7 +3546,7 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>, }, def => { // Verify that this was actually a struct. - let typ = ty::lookup_item_type(fcx.ccx.tcx, def.def_id()); + let typ = fcx.ccx.tcx.lookup_item_type(def.def_id()); match typ.ty.sty { ty::TyStruct(struct_did, _) => { check_struct_constructor(fcx, @@ -3605,7 +3593,7 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>, .ty_to_string( actual_structure_type), type_error); - ty::note_and_explain_type_err(tcx, &type_error, path.span); + tcx.note_and_explain_type_err(&type_error, path.span); } } } @@ -3700,7 +3688,7 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>, }; if let Some(did) = did { - let predicates = ty::lookup_predicates(tcx, did); + let predicates = tcx.lookup_predicates(did); let substs = Substs::new_type(vec![idx_type], vec![]); let bounds = fcx.instantiate_bounds(expr.span, &substs, &predicates); fcx.add_obligations_for_parameters( @@ -4096,7 +4084,7 @@ fn check_const<'a,'tcx>(ccx: &CrateCtxt<'a,'tcx>, e: &'tcx ast::Expr, id: ast::NodeId) { let inh = static_inherited_fields(ccx); - let rty = ty::node_id_to_type(ccx.tcx, id); + let rty = ccx.tcx.node_id_to_type(id); let fcx = blank_fn_ctxt(ccx, &inh, ty::FnConverging(rty), e.id); let declty = fcx.ccx.tcx.tcache.borrow().get(&local_def(id)).unwrap().ty; check_const_with_ty(&fcx, sp, e, declty); @@ -4129,14 +4117,14 @@ pub fn check_representable(tcx: &ty::ctxt, sp: Span, item_id: ast::NodeId, designation: &str) -> bool { - let rty = ty::node_id_to_type(tcx, item_id); + let rty = tcx.node_id_to_type(item_id); // Check that it is possible to represent this type. This call identifies // (1) types that contain themselves and (2) types that contain a different // recursive type. It is only necessary to throw an error on those that // contain themselves. For case 2, there must be an inner type that will be // caught by case 1. - match ty::is_type_representable(tcx, sp, rty) { + match rty.is_representable(tcx, sp) { ty::SelfRecursive => { span_err!(tcx.sess, sp, E0072, "illegal recursive {} type; \ @@ -4164,8 +4152,8 @@ pub fn check_instantiable(tcx: &ty::ctxt, sp: Span, item_id: ast::NodeId) -> bool { - let item_ty = ty::node_id_to_type(tcx, item_id); - if !ty::is_instantiable(tcx, item_ty) { + let item_ty = tcx.node_id_to_type(item_id); + if !item_ty.is_instantiable(tcx) { span_err!(tcx.sess, sp, E0073, "this type cannot be instantiated without an \ instance of itself"); @@ -4178,21 +4166,21 @@ pub fn check_instantiable(tcx: &ty::ctxt, } pub fn check_simd(tcx: &ty::ctxt, sp: Span, id: ast::NodeId) { - let t = ty::node_id_to_type(tcx, id); + let t = tcx.node_id_to_type(id); if t.needs_subst() { span_err!(tcx.sess, sp, E0074, "SIMD vector cannot be generic"); return; } match t.sty { ty::TyStruct(did, substs) => { - let fields = ty::lookup_struct_fields(tcx, did); + let fields = tcx.lookup_struct_fields(did); if fields.is_empty() { span_err!(tcx.sess, sp, E0075, "SIMD vector cannot be empty"); return; } - let e = ty::lookup_field_type(tcx, did, fields[0].id, substs); + let e = tcx.lookup_field_type(did, fields[0].id, substs); if !fields.iter().all( - |f| ty::lookup_field_type(tcx, did, f.id, substs) == e) { + |f| tcx.lookup_field_type(did, f.id, substs) == e) { span_err!(tcx.sess, sp, E0076, "SIMD vector should be homogeneous"); return; } @@ -4244,13 +4232,13 @@ pub fn check_enum_variants<'a,'tcx>(ccx: &CrateCtxt<'a,'tcx>, hint: attr::ReprAttr) { #![allow(trivial_numeric_casts)] - let rty = ty::node_id_to_type(ccx.tcx, id); + let rty = ccx.tcx.node_id_to_type(id); let mut disr_vals: Vec = Vec::new(); let inh = static_inherited_fields(ccx); let fcx = blank_fn_ctxt(ccx, &inh, ty::FnConverging(rty), id); - let (_, repr_type_ty) = ty::enum_repr_type(ccx.tcx, Some(&hint)); + let (_, repr_type_ty) = ccx.tcx.enum_repr_type(Some(&hint)); for v in vs { if let Some(ref e) = v.node.disr_expr { check_const_with_ty(&fcx, e.span, e, repr_type_ty); @@ -4261,7 +4249,7 @@ pub fn check_enum_variants<'a,'tcx>(ccx: &CrateCtxt<'a,'tcx>, // ty::enum_variants guards against discriminant overflows, so // we need not check for that. - let variants = ty::enum_variants(ccx.tcx, def_id); + let variants = ccx.tcx.enum_variants(def_id); for (v, variant) in vs.iter().zip(variants.iter()) { let current_disr_val = variant.disr_val; @@ -4295,7 +4283,7 @@ pub fn check_enum_variants<'a,'tcx>(ccx: &CrateCtxt<'a,'tcx>, } } - let hint = *ty::lookup_repr_hints(ccx.tcx, ast::DefId { krate: ast::LOCAL_CRATE, node: id }) + let hint = *ccx.tcx.lookup_repr_hints(ast::DefId { krate: ast::LOCAL_CRATE, node: id }) .get(0).unwrap_or(&attr::ReprAny); if hint != attr::ReprAny && vs.len() <= 1 { @@ -4333,7 +4321,7 @@ fn type_scheme_and_predicates_for_def<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, def::DefFn(id, _) | def::DefMethod(id, _) | def::DefStatic(id, _) | def::DefVariant(_, id, _) | def::DefStruct(id) | def::DefConst(id) | def::DefAssociatedConst(id, _) => { - (ty::lookup_item_type(fcx.tcx(), id), ty::lookup_predicates(fcx.tcx(), id)) + (fcx.tcx().lookup_item_type(id), fcx.tcx().lookup_predicates(id)) } def::DefTrait(_) | def::DefTy(..) | @@ -4595,7 +4583,7 @@ pub fn instantiate_path<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, // is inherent, there is no `Self` parameter, instead, the impl needs // type parameters, which we can infer by unifying the provided `Self` // with the substituted impl type. - let impl_scheme = ty::lookup_item_type(fcx.tcx(), impl_def_id); + let impl_scheme = fcx.tcx().lookup_item_type(impl_def_id); assert_eq!(substs.types.len(subst::TypeSpace), impl_scheme.generics.types.len(subst::TypeSpace)); assert_eq!(substs.regions().len(subst::TypeSpace), @@ -5221,7 +5209,7 @@ pub fn check_intrinsic_type(ccx: &CrateCtxt, it: &ast::ForeignItem) { variadic: false, }), })); - let i_ty = ty::lookup_item_type(ccx.tcx, local_def(it.id)); + let i_ty = ccx.tcx.lookup_item_type(local_def(it.id)); let i_n_tps = i_ty.generics.types.len(subst::FnSpace); if i_n_tps != n_tps { span_err!(tcx.sess, it.span, E0094, diff --git a/src/librustc_typeck/check/op.rs b/src/librustc_typeck/check/op.rs index b41bb9feb5212..5a114c811191c 100644 --- a/src/librustc_typeck/check/op.rs +++ b/src/librustc_typeck/check/op.rs @@ -56,7 +56,7 @@ pub fn check_binop_assign<'a,'tcx>(fcx: &FnCtxt<'a,'tcx>, } let tcx = fcx.tcx(); - if !ty::expr_is_lval(tcx, lhs_expr) { + if !tcx.expr_is_lval(lhs_expr) { span_err!(tcx.sess, lhs_expr.span, E0067, "illegal left-hand side expression"); } @@ -335,7 +335,7 @@ fn lookup_op_method<'a, 'tcx>(fcx: &'a FnCtxt<'a, 'tcx>, // extract return type for method; all late bound regions // should have been instantiated by now let ret_ty = method_ty.fn_ret(); - Ok(ty::no_late_bound_regions(fcx.tcx(), &ret_ty).unwrap().unwrap()) + Ok(fcx.tcx().no_late_bound_regions(&ret_ty).unwrap().unwrap()) } None => { Err(()) diff --git a/src/librustc_typeck/check/regionck.rs b/src/librustc_typeck/check/regionck.rs index c659357dd0305..13961834aebdd 100644 --- a/src/librustc_typeck/check/regionck.rs +++ b/src/librustc_typeck/check/regionck.rs @@ -265,10 +265,10 @@ impl<'a, 'tcx> Rcx<'a, 'tcx> { if ty_unadjusted.references_error() { ty_unadjusted } else { - let tcx = self.fcx.tcx(); - ty::adjust_ty(tcx, expr.span, expr.id, ty_unadjusted, - self.fcx.inh.adjustments.borrow().get(&expr.id), - |method_call| self.resolve_method_type(method_call)) + ty_unadjusted.adjust( + self.fcx.tcx(), expr.span, expr.id, + self.fcx.inh.adjustments.borrow().get(&expr.id), + |method_call| self.resolve_method_type(method_call)) } } @@ -662,7 +662,7 @@ fn visit_expr(rcx: &mut Rcx, expr: &ast::Expr) { constrain_call(rcx, expr, Some(&**base), None::.iter(), true); let fn_ret = // late-bound regions in overloaded method calls are instantiated - ty::no_late_bound_regions(rcx.tcx(), &method.ty.fn_ret()).unwrap(); + rcx.tcx().no_late_bound_regions(&method.ty.fn_ret()).unwrap(); fn_ret.unwrap() } None => rcx.resolve_node_type(base.id) @@ -893,7 +893,7 @@ fn constrain_autoderefs<'a, 'tcx>(rcx: &mut Rcx<'a, 'tcx>, // was applied on the base type, as that is always the case. let fn_sig = method.ty.fn_sig(); let fn_sig = // late-bound regions should have been instantiated - ty::no_late_bound_regions(rcx.tcx(), fn_sig).unwrap(); + rcx.tcx().no_late_bound_regions(fn_sig).unwrap(); let self_ty = fn_sig.inputs[0]; let (m, r) = match self_ty.sty { ty::TyRef(r, ref m) => (m.mutbl, r), @@ -1017,9 +1017,9 @@ fn type_of_node_must_outlive<'a, 'tcx>( // is going to fail anyway, so just stop here and let typeck // report errors later on in the writeback phase. let ty0 = rcx.resolve_node_type(id); - let ty = ty::adjust_ty(tcx, origin.span(), id, ty0, - rcx.fcx.inh.adjustments.borrow().get(&id), - |method_call| rcx.resolve_method_type(method_call)); + let ty = ty0.adjust(tcx, origin.span(), id, + rcx.fcx.inh.adjustments.borrow().get(&id), + |method_call| rcx.resolve_method_type(method_call)); debug!("constrain_regions_in_type_of_node(\ ty={}, ty0={}, id={}, minimum_lifetime={:?})", ty, ty0, @@ -1172,10 +1172,8 @@ fn link_region_from_node_type<'a, 'tcx>(rcx: &Rcx<'a, 'tcx>, id, mutbl, cmt_borrowed); let rptr_ty = rcx.resolve_node_type(id); - if !rptr_ty.references_error() { - let tcx = rcx.fcx.ccx.tcx; + if let ty::TyRef(&r, _) = rptr_ty.sty { debug!("rptr_ty={}", rptr_ty); - let r = ty::ty_region(tcx, span, rptr_ty); link_region(rcx, span, &r, ty::BorrowKind::from_mutbl(mutbl), cmt_borrowed); } @@ -1462,10 +1460,8 @@ fn generic_must_outlive<'a, 'tcx>(rcx: &Rcx<'a, 'tcx>, generic); // To start, collect bounds from user: - let mut param_bounds = - ty::required_region_bounds(rcx.tcx(), - generic.to_ty(rcx.tcx()), - param_env.caller_bounds.clone()); + let mut param_bounds = rcx.tcx().required_region_bounds(generic.to_ty(rcx.tcx()), + param_env.caller_bounds.clone()); // In the case of a projection T::Foo, we may be able to extract bounds from the trait def: match *generic { @@ -1532,7 +1528,7 @@ fn projection_bounds<'a,'tcx>(rcx: &Rcx<'a, 'tcx>, // ``` // // we can thus deduce that `>::SomeType : 'a`. - let trait_predicates = ty::lookup_predicates(tcx, projection_ty.trait_ref.def_id); + let trait_predicates = tcx.lookup_predicates(projection_ty.trait_ref.def_id); let predicates = trait_predicates.predicates.as_slice().to_vec(); traits::elaborate_predicates(tcx, predicates) .filter_map(|predicate| { diff --git a/src/librustc_typeck/check/upvar.rs b/src/librustc_typeck/check/upvar.rs index 99e6309918c97..1345f322476b9 100644 --- a/src/librustc_typeck/check/upvar.rs +++ b/src/librustc_typeck/check/upvar.rs @@ -136,7 +136,7 @@ impl<'a,'tcx> SeedBorrowKind<'a,'tcx> { closure_def_id); } - ty::with_freevars(self.tcx(), expr.id, |freevars| { + self.tcx().with_freevars(expr.id, |freevars| { for freevar in freevars { let var_node_id = freevar.def.local_node_id(); let upvar_id = ty::UpvarId { var_id: var_node_id, diff --git a/src/librustc_typeck/check/wf.rs b/src/librustc_typeck/check/wf.rs index aa6f533401dd6..00bbbafd5cd32 100644 --- a/src/librustc_typeck/check/wf.rs +++ b/src/librustc_typeck/check/wf.rs @@ -16,7 +16,6 @@ use middle::region; use middle::subst::{self, TypeSpace, FnSpace, ParamSpace, SelfSpace}; use middle::traits; use middle::ty::{self, Ty}; -use middle::ty::liberate_late_bound_regions; use middle::ty_fold::{TypeFolder, TypeFoldable, super_fold_ty}; use std::collections::HashSet; @@ -56,7 +55,7 @@ impl<'ccx, 'tcx> CheckTypeWellFormedVisitor<'ccx, 'tcx> { let ccx = self.ccx; debug!("check_item_well_formed(it.id={}, it.ident={})", item.id, - ty::item_path_str(ccx.tcx, local_def(item.id))); + ccx.tcx.item_path_str(local_def(item.id))); match item.node { /// Right now we check that every default trait implementation @@ -80,13 +79,12 @@ impl<'ccx, 'tcx> CheckTypeWellFormedVisitor<'ccx, 'tcx> { self.check_impl(item); } ast::ItemImpl(_, ast::ImplPolarity::Negative, _, Some(_), _, _) => { - let trait_ref = ty::impl_trait_ref(ccx.tcx, - local_def(item.id)).unwrap(); - ty::populate_implementations_for_trait_if_necessary(ccx.tcx, trait_ref.def_id); + let trait_ref = ccx.tcx.impl_trait_ref(local_def(item.id)).unwrap(); + ccx.tcx.populate_implementations_for_trait_if_necessary(trait_ref.def_id); match ccx.tcx.lang_items.to_builtin_kind(trait_ref.def_id) { Some(ty::BoundSend) | Some(ty::BoundSync) => {} Some(_) | None => { - if !ty::trait_has_default_impl(ccx.tcx, trait_ref.def_id) { + if !ccx.tcx.trait_has_default_impl(trait_ref.def_id) { span_err!(ccx.tcx.sess, item.span, E0192, "negative impls are only allowed for traits with \ default impls (e.g., `Send` and `Sync`)") @@ -119,9 +117,9 @@ impl<'ccx, 'tcx> CheckTypeWellFormedVisitor<'ccx, 'tcx> { } ast::ItemTrait(_, _, _, ref items) => { let trait_predicates = - ty::lookup_predicates(ccx.tcx, local_def(item.id)); + ccx.tcx.lookup_predicates(local_def(item.id)); reject_non_type_param_bounds(ccx.tcx, item.span, &trait_predicates); - if ty::trait_has_default_impl(ccx.tcx, local_def(item.id)) { + if ccx.tcx.trait_has_default_impl(local_def(item.id)) { if !items.is_empty() { span_err!(ccx.tcx.sess, item.span, E0380, "traits with default impls (`e.g. unsafe impl \ @@ -138,15 +136,13 @@ impl<'ccx, 'tcx> CheckTypeWellFormedVisitor<'ccx, 'tcx> { { let ccx = self.ccx; let item_def_id = local_def(item.id); - let type_scheme = ty::lookup_item_type(ccx.tcx, item_def_id); - let type_predicates = ty::lookup_predicates(ccx.tcx, item_def_id); + let type_scheme = ccx.tcx.lookup_item_type(item_def_id); + let type_predicates = ccx.tcx.lookup_predicates(item_def_id); reject_non_type_param_bounds(ccx.tcx, item.span, &type_predicates); - let param_env = - ty::construct_parameter_environment(ccx.tcx, - item.span, - &type_scheme.generics, - &type_predicates, - item.id); + let param_env = ccx.tcx.construct_parameter_environment(item.span, + &type_scheme.generics, + &type_predicates, + item.id); let inh = Inherited::new(ccx.tcx, param_env); let fcx = blank_fn_ctxt(ccx, &inh, ty::FnConverging(type_scheme.ty), item.id); f(self, &fcx); @@ -201,7 +197,7 @@ impl<'ccx, 'tcx> CheckTypeWellFormedVisitor<'ccx, 'tcx> { Some(&mut this.cache)); debug!("check_item_type at bounds_checker.scope: {:?}", bounds_checker.scope); - let type_scheme = ty::lookup_item_type(fcx.tcx(), local_def(item.id)); + let type_scheme = fcx.tcx().lookup_item_type(local_def(item.id)); let item_ty = fcx.instantiate_type_scheme(item.span, &fcx.inh.param_env.free_substs, &type_scheme.ty); @@ -222,7 +218,7 @@ impl<'ccx, 'tcx> CheckTypeWellFormedVisitor<'ccx, 'tcx> { // Find the impl self type as seen from the "inside" -- // that is, with all type parameters converted from bound // to free. - let self_ty = ty::node_id_to_type(fcx.tcx(), item.id); + let self_ty = fcx.tcx().node_id_to_type(item.id); let self_ty = fcx.instantiate_type_scheme(item.span, &fcx.inh.param_env.free_substs, &self_ty); @@ -231,7 +227,7 @@ impl<'ccx, 'tcx> CheckTypeWellFormedVisitor<'ccx, 'tcx> { // Similarly, obtain an "inside" reference to the trait // that the impl implements. - let trait_ref = match ty::impl_trait_ref(fcx.tcx(), local_def(item.id)) { + let trait_ref = match fcx.tcx().impl_trait_ref(local_def(item.id)) { None => { return; } Some(t) => { t } }; @@ -258,7 +254,7 @@ impl<'ccx, 'tcx> CheckTypeWellFormedVisitor<'ccx, 'tcx> { // Find the supertrait bounds. This will add `int:Bar`. let poly_trait_ref = ty::Binder(trait_ref); - let predicates = ty::lookup_super_predicates(fcx.tcx(), poly_trait_ref.def_id()); + let predicates = fcx.tcx().lookup_super_predicates(poly_trait_ref.def_id()); let predicates = predicates.instantiate_supertrait(fcx.tcx(), &poly_trait_ref); let predicates = { let selcx = &mut traits::SelectionContext::new(fcx.infcx(), fcx); @@ -278,8 +274,8 @@ impl<'ccx, 'tcx> CheckTypeWellFormedVisitor<'ccx, 'tcx> { ast_generics: &ast::Generics) { let item_def_id = local_def(item.id); - let ty_predicates = ty::lookup_predicates(self.tcx(), item_def_id); - let variances = ty::item_variances(self.tcx(), item_def_id); + let ty_predicates = self.tcx().lookup_predicates(item_def_id); + let variances = self.tcx().item_variances(item_def_id); let mut constrained_parameters: HashSet<_> = variances.types @@ -358,7 +354,7 @@ impl<'ccx, 'tcx> CheckTypeWellFormedVisitor<'ccx, 'tcx> { span, &format!("consider removing `{}` or using a marker such as `{}`", param_name, - ty::item_path_str(self.tcx(), def_id))); + self.tcx().item_path_str(def_id))); } None => { // no lang items, no help! @@ -432,7 +428,7 @@ impl<'ccx, 'tcx, 'v> Visitor<'v> for CheckTypeWellFormedVisitor<'ccx, 'tcx> { match fk { visit::FkFnBlock | visit::FkItemFn(..) => {} visit::FkMethod(..) => { - match ty::impl_or_trait_item(self.tcx(), local_def(id)) { + match self.tcx().impl_or_trait_item(local_def(id)) { ty::ImplOrTraitItem::MethodTraitItem(ty_method) => { reject_shadowing_type_parameters(self.tcx(), span, &ty_method.generics) } @@ -445,7 +441,7 @@ impl<'ccx, 'tcx, 'v> Visitor<'v> for CheckTypeWellFormedVisitor<'ccx, 'tcx> { fn visit_trait_item(&mut self, trait_item: &'v ast::TraitItem) { if let ast::MethodTraitItem(_, None) = trait_item.node { - match ty::impl_or_trait_item(self.tcx(), local_def(trait_item.id)) { + match self.tcx().impl_or_trait_item(local_def(trait_item.id)) { ty::ImplOrTraitItem::MethodTraitItem(ty_method) => { reject_non_type_param_bounds( self.tcx(), @@ -496,7 +492,7 @@ impl<'cx,'tcx> BoundsChecker<'cx,'tcx> { /// Note that it does not (currently, at least) check that `A : Copy` (that check is delegated /// to the point where impl `A : Trait` is implemented). pub fn check_trait_ref(&mut self, trait_ref: &ty::TraitRef<'tcx>, span: Span) { - let trait_predicates = ty::lookup_predicates(self.fcx.tcx(), trait_ref.def_id); + let trait_predicates = self.fcx.tcx().lookup_predicates(trait_ref.def_id); let bounds = self.fcx.instantiate_bounds(span, trait_ref.substs, @@ -538,8 +534,7 @@ impl<'cx,'tcx> TypeFolder<'tcx> for BoundsChecker<'cx,'tcx> { where T : TypeFoldable<'tcx> { self.binding_count += 1; - let value = liberate_late_bound_regions( - self.fcx.tcx(), + let value = self.fcx.tcx().liberate_late_bound_regions( region::DestructionScopeData::new(self.scope), binder); debug!("BoundsChecker::fold_binder: late-bound regions replaced: {:?} at scope: {:?}", @@ -567,7 +562,7 @@ impl<'cx,'tcx> TypeFolder<'tcx> for BoundsChecker<'cx,'tcx> { match t.sty{ ty::TyStruct(type_id, substs) | ty::TyEnum(type_id, substs) => { - let type_predicates = ty::lookup_predicates(self.fcx.tcx(), type_id); + let type_predicates = self.fcx.tcx().lookup_predicates(type_id); let bounds = self.fcx.instantiate_bounds(self.span, substs, &type_predicates); @@ -638,7 +633,7 @@ fn struct_variant<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, struct_def.fields .iter() .map(|field| { - let field_ty = ty::node_id_to_type(fcx.tcx(), field.node.id); + let field_ty = fcx.tcx().node_id_to_type(field.node.id); let field_ty = fcx.instantiate_type_scheme(field.span, &fcx.inh.param_env.free_substs, &field_ty); @@ -655,13 +650,11 @@ fn enum_variants<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, .map(|variant| { match variant.node.kind { ast::TupleVariantKind(ref args) if !args.is_empty() => { - let ctor_ty = ty::node_id_to_type(fcx.tcx(), variant.node.id); + let ctor_ty = fcx.tcx().node_id_to_type(variant.node.id); // the regions in the argument types come from the // enum def'n, and hence will all be early bound - let arg_tys = - ty::no_late_bound_regions( - fcx.tcx(), &ctor_ty.fn_args()).unwrap(); + let arg_tys = fcx.tcx().no_late_bound_regions(&ctor_ty.fn_args()).unwrap(); AdtVariant { fields: args.iter().enumerate().map(|(index, arg)| { let arg_ty = arg_tys[index]; diff --git a/src/librustc_typeck/check/writeback.rs b/src/librustc_typeck/check/writeback.rs index 9abee1a3aaab6..29119f3b5946d 100644 --- a/src/librustc_typeck/check/writeback.rs +++ b/src/librustc_typeck/check/writeback.rs @@ -171,7 +171,7 @@ impl<'cx, 'tcx, 'v> Visitor<'v> for WritebackCx<'cx, 'tcx> { debug!("Type for pattern binding {} (id {}) resolved to {:?}", pat_to_string(p), p.id, - ty::node_id_to_type(self.tcx(), p.id)); + self.tcx().node_id_to_type(p.id)); visit::walk_pat(self, p); } @@ -334,11 +334,11 @@ impl ResolveReason { ResolvingLocal(s) => s, ResolvingPattern(s) => s, ResolvingUpvar(upvar_id) => { - ty::expr_span(tcx, upvar_id.closure_expr_id) + tcx.expr_span(upvar_id.closure_expr_id) } ResolvingClosure(did) => { if did.krate == ast::LOCAL_CRATE { - ty::expr_span(tcx, did.node) + tcx.expr_span(did.node) } else { DUMMY_SP } @@ -403,7 +403,7 @@ impl<'cx, 'tcx> Resolver<'cx, 'tcx> { let span = self.reason.span(self.tcx); span_err!(self.tcx.sess, span, E0104, "cannot resolve lifetime for captured variable `{}`: {}", - ty::local_var_name_str(self.tcx, upvar_id.var_id).to_string(), + self.tcx.local_var_name_str(upvar_id.var_id).to_string(), infer::fixup_err_to_string(e)); } diff --git a/src/librustc_typeck/coherence/mod.rs b/src/librustc_typeck/coherence/mod.rs index 266babda57824..06bd572ac12f3 100644 --- a/src/librustc_typeck/coherence/mod.rs +++ b/src/librustc_typeck/coherence/mod.rs @@ -139,15 +139,14 @@ impl<'a, 'tcx> CoherenceChecker<'a, 'tcx> { fn check_implementation(&self, item: &Item) { let tcx = self.crate_context.tcx; let impl_did = local_def(item.id); - let self_type = ty::lookup_item_type(tcx, impl_did); + let self_type = tcx.lookup_item_type(impl_did); // If there are no traits, then this implementation must have a // base type. let impl_items = self.create_impl_from_item(item); - if let Some(trait_ref) = ty::impl_trait_ref(self.crate_context.tcx, - impl_did) { + if let Some(trait_ref) = self.crate_context.tcx.impl_trait_ref(impl_did) { debug!("(checking implementation) adding impl for trait '{:?}', item '{}'", trait_ref, item.ident); @@ -181,9 +180,9 @@ impl<'a, 'tcx> CoherenceChecker<'a, 'tcx> { debug!("instantiate_default_methods(impl_id={:?}, trait_ref={:?})", impl_id, trait_ref); - let impl_type_scheme = ty::lookup_item_type(tcx, impl_id); + let impl_type_scheme = tcx.lookup_item_type(impl_id); - let prov = ty::provided_trait_methods(tcx, trait_ref.def_id); + let prov = tcx.provided_trait_methods(trait_ref.def_id); for trait_method in &prov { // Synthesize an ID. let new_id = tcx.sess.next_node_id(); @@ -245,8 +244,7 @@ impl<'a, 'tcx> CoherenceChecker<'a, 'tcx> { fn add_trait_impl(&self, impl_trait_ref: ty::TraitRef<'tcx>, impl_def_id: DefId) { debug!("add_trait_impl: impl_trait_ref={:?} impl_def_id={:?}", impl_trait_ref, impl_def_id); - let trait_def = ty::lookup_trait_def(self.crate_context.tcx, - impl_trait_ref.def_id); + let trait_def = self.crate_context.tcx.lookup_trait_def(impl_trait_ref.def_id); trait_def.record_impl(self.crate_context.tcx, impl_def_id, impl_trait_ref); } @@ -273,11 +271,9 @@ impl<'a, 'tcx> CoherenceChecker<'a, 'tcx> { } }).collect(); - if let Some(trait_ref) = ty::impl_trait_ref(self.crate_context.tcx, - local_def(item.id)) { - self.instantiate_default_methods(local_def(item.id), - &trait_ref, - &mut items); + let def_id = local_def(item.id); + if let Some(trait_ref) = self.crate_context.tcx.impl_trait_ref(def_id) { + self.instantiate_default_methods(def_id, &trait_ref, &mut items); } items @@ -299,8 +295,8 @@ impl<'a, 'tcx> CoherenceChecker<'a, 'tcx> { let drop_trait = match tcx.lang_items.drop_trait() { Some(id) => id, None => { return } }; - ty::populate_implementations_for_trait_if_necessary(tcx, drop_trait); - let drop_trait = ty::lookup_trait_def(tcx, drop_trait); + tcx.populate_implementations_for_trait_if_necessary(drop_trait); + let drop_trait = tcx.lookup_trait_def(drop_trait); let impl_items = tcx.impl_items.borrow(); @@ -312,7 +308,7 @@ impl<'a, 'tcx> CoherenceChecker<'a, 'tcx> { } let method_def_id = items[0]; - let self_type = ty::lookup_item_type(tcx, impl_did); + let self_type = tcx.lookup_item_type(impl_did); match self_type.ty.sty { ty::TyEnum(type_def_id, _) | ty::TyStruct(type_def_id, _) | @@ -355,8 +351,8 @@ impl<'a, 'tcx> CoherenceChecker<'a, 'tcx> { Some(id) => id, None => return, }; - ty::populate_implementations_for_trait_if_necessary(tcx, copy_trait); - let copy_trait = ty::lookup_trait_def(tcx, copy_trait); + tcx.populate_implementations_for_trait_if_necessary(copy_trait); + let copy_trait = tcx.lookup_trait_def(copy_trait); copy_trait.for_each_impl(tcx, |impl_did| { debug!("check_implementations_of_copy: impl_did={:?}", @@ -368,7 +364,7 @@ impl<'a, 'tcx> CoherenceChecker<'a, 'tcx> { return } - let self_type = ty::lookup_item_type(tcx, impl_did); + let self_type = tcx.lookup_item_type(impl_did); debug!("check_implementations_of_copy: self_type={:?} (bound)", self_type); @@ -380,7 +376,7 @@ impl<'a, 'tcx> CoherenceChecker<'a, 'tcx> { debug!("check_implementations_of_copy: self_type={:?} (free)", self_type); - match ty::can_type_implement_copy(¶m_env, span, self_type) { + match param_env.can_type_implement_copy(self_type, span) { Ok(()) => {} Err(ty::FieldDoesNotImplementCopy(name)) => { span_err!(tcx.sess, span, E0204, @@ -425,7 +421,7 @@ impl<'a, 'tcx> CoherenceChecker<'a, 'tcx> { } }; - let trait_def = ty::lookup_trait_def(tcx, coerce_unsized_trait); + let trait_def = tcx.lookup_trait_def(coerce_unsized_trait); trait_def.for_each_impl(tcx, |impl_did| { debug!("check_implementations_of_coerce_unsized: impl_did={:?}", @@ -437,9 +433,8 @@ impl<'a, 'tcx> CoherenceChecker<'a, 'tcx> { return; } - let source = ty::lookup_item_type(tcx, impl_did).ty; - let trait_ref = ty::impl_trait_ref(self.crate_context.tcx, - impl_did).unwrap(); + let source = tcx.lookup_item_type(impl_did).ty; + let trait_ref = self.crate_context.tcx.impl_trait_ref(impl_did).unwrap(); let target = *trait_ref.substs.types.get(subst::TypeSpace, 0); debug!("check_implementations_of_coerce_unsized: {:?} -> {:?} (bound)", source, target); @@ -478,8 +473,8 @@ impl<'a, 'tcx> CoherenceChecker<'a, 'tcx> { (&ty::TyStruct(def_id_a, substs_a), &ty::TyStruct(def_id_b, substs_b)) => { if def_id_a != def_id_b { - let source_path = ty::item_path_str(tcx, def_id_a); - let target_path = ty::item_path_str(tcx, def_id_b); + let source_path = tcx.item_path_str(def_id_a); + let target_path = tcx.item_path_str(def_id_b); span_err!(tcx.sess, span, E0377, "the trait `CoerceUnsized` may only be implemented \ for a coercion between structures with the same \ @@ -489,9 +484,9 @@ impl<'a, 'tcx> CoherenceChecker<'a, 'tcx> { } let origin = infer::Misc(span); - let fields = ty::lookup_struct_fields(tcx, def_id_a); + let fields = tcx.lookup_struct_fields(def_id_a); let diff_fields = fields.iter().enumerate().filter_map(|(i, f)| { - let ty = ty::lookup_field_type_unsubstituted(tcx, def_id_a, f.id); + let ty = tcx.lookup_field_type_unsubstituted(def_id_a, f.id); let (a, b) = (ty.subst(tcx, substs_a), ty.subst(tcx, substs_b)); if infcx.sub_types(false, origin, b, a).is_ok() { None @@ -592,7 +587,7 @@ fn subst_receiver_types_in_method_ty<'tcx>(tcx: &ty::ctxt<'tcx>, provided_source: Option) -> ty::Method<'tcx> { - let combined_substs = ty::make_substs_for_receiver_types(tcx, trait_ref, method); + let combined_substs = tcx.make_substs_for_receiver_types(trait_ref, method); debug!("subst_receiver_types_in_method_ty: combined_substs={:?}", combined_substs); diff --git a/src/librustc_typeck/coherence/orphan.rs b/src/librustc_typeck/coherence/orphan.rs index 8376b92da3dea..e585b8cd2bde0 100644 --- a/src/librustc_typeck/coherence/orphan.rs +++ b/src/librustc_typeck/coherence/orphan.rs @@ -67,7 +67,7 @@ impl<'cx, 'tcx> OrphanChecker<'cx, 'tcx> { // defined in this crate. debug!("coherence2::orphan check: inherent impl {}", self.tcx.map.node_to_string(item.id)); - let self_ty = ty::lookup_item_type(self.tcx, def_id).ty; + let self_ty = self.tcx.lookup_item_type(def_id).ty; match self_ty.sty { ty::TyEnum(def_id, _) | ty::TyStruct(def_id, _) => { @@ -210,7 +210,7 @@ impl<'cx, 'tcx> OrphanChecker<'cx, 'tcx> { // "Trait" impl debug!("coherence2::orphan check: trait impl {}", self.tcx.map.node_to_string(item.id)); - let trait_ref = ty::impl_trait_ref(self.tcx, def_id).unwrap(); + let trait_ref = self.tcx.impl_trait_ref(def_id).unwrap(); let trait_def_id = trait_ref.def_id; match traits::orphan_check(self.tcx, def_id) { Ok(()) => { } @@ -269,9 +269,9 @@ impl<'cx, 'tcx> OrphanChecker<'cx, 'tcx> { debug!("trait_ref={:?} trait_def_id={:?} trait_has_default_impl={}", trait_ref, trait_def_id, - ty::trait_has_default_impl(self.tcx, trait_def_id)); + self.tcx.trait_has_default_impl(trait_def_id)); if - ty::trait_has_default_impl(self.tcx, trait_def_id) && + self.tcx.trait_has_default_impl(trait_def_id) && trait_def_id.krate != ast::LOCAL_CRATE { let self_ty = trait_ref.self_ty(); @@ -297,7 +297,7 @@ impl<'cx, 'tcx> OrphanChecker<'cx, 'tcx> { "cross-crate traits with a default impl, like `{}`, \ can only be implemented for a struct/enum type \ defined in the current crate", - ty::item_path_str(self.tcx, trait_def_id))) + self.tcx.item_path_str(trait_def_id))) } } _ => { @@ -305,7 +305,7 @@ impl<'cx, 'tcx> OrphanChecker<'cx, 'tcx> { "cross-crate traits with a default impl, like `{}`, \ can only be implemented for a struct/enum type, \ not `{}`", - ty::item_path_str(self.tcx, trait_def_id), + self.tcx.item_path_str(trait_def_id), self_ty)) } }; @@ -332,7 +332,7 @@ impl<'cx, 'tcx> OrphanChecker<'cx, 'tcx> { // "Trait" impl debug!("coherence2::orphan check: default trait impl {}", self.tcx.map.node_to_string(item.id)); - let trait_ref = ty::impl_trait_ref(self.tcx, def_id).unwrap(); + let trait_ref = self.tcx.impl_trait_ref(def_id).unwrap(); if trait_ref.def_id.krate != ast::LOCAL_CRATE { span_err!(self.tcx.sess, item.span, E0318, "cannot create default implementations for traits outside the \ diff --git a/src/librustc_typeck/coherence/overlap.rs b/src/librustc_typeck/coherence/overlap.rs index 0e8067e7181bd..b4ad55ef2e46b 100644 --- a/src/librustc_typeck/coherence/overlap.rs +++ b/src/librustc_typeck/coherence/overlap.rs @@ -50,9 +50,7 @@ impl<'cx, 'tcx> OverlapChecker<'cx, 'tcx> { let trait_defs: Vec<_> = self.tcx.trait_defs.borrow().values().cloned().collect(); for trait_def in trait_defs { - ty::populate_implementations_for_trait_if_necessary( - self.tcx, - trait_def.trait_ref.def_id); + self.tcx.populate_implementations_for_trait_if_necessary(trait_def.trait_ref.def_id); self.check_for_overlapping_impls_of_trait(trait_def); } } @@ -147,7 +145,7 @@ impl<'cx, 'tcx> OverlapChecker<'cx, 'tcx> { span_err!(self.tcx.sess, self.span_of_impl(impl1), E0119, "conflicting implementations for trait `{}`", - ty::item_path_str(self.tcx, trait_def_id)); + self.tcx.item_path_str(trait_def_id)); self.report_overlap_note(impl1, impl2); } @@ -181,7 +179,7 @@ impl<'cx, 'tcx,'v> visit::Visitor<'v> for OverlapChecker<'cx, 'tcx> { // general orphan/coherence rules, it must always be // in this crate. let impl_def_id = ast_util::local_def(item.id); - let trait_ref = ty::impl_trait_ref(self.tcx, impl_def_id).unwrap(); + let trait_ref = self.tcx.impl_trait_ref(impl_def_id).unwrap(); let prev_default_impl = self.default_impls.insert(trait_ref.def_id, item.id); match prev_default_impl { Some(prev_id) => { @@ -194,7 +192,7 @@ impl<'cx, 'tcx,'v> visit::Visitor<'v> for OverlapChecker<'cx, 'tcx> { } ast::ItemImpl(_, _, _, Some(_), ref self_ty, _) => { let impl_def_id = ast_util::local_def(item.id); - let trait_ref = ty::impl_trait_ref(self.tcx, impl_def_id).unwrap(); + let trait_ref = self.tcx.impl_trait_ref(impl_def_id).unwrap(); let trait_def_id = trait_ref.def_id; match trait_ref.self_ty().sty { ty::TyTrait(ref data) => { @@ -208,7 +206,7 @@ impl<'cx, 'tcx,'v> visit::Visitor<'v> for OverlapChecker<'cx, 'tcx> { // giving a misleading message below. span_err!(self.tcx.sess, self_ty.span, E0372, "the trait `{}` cannot be made into an object", - ty::item_path_str(self.tcx, data.principal_def_id())); + self.tcx.item_path_str(data.principal_def_id())); } else { let mut supertrait_def_ids = traits::supertrait_def_ids(self.tcx, data.principal_def_id()); @@ -217,7 +215,7 @@ impl<'cx, 'tcx,'v> visit::Visitor<'v> for OverlapChecker<'cx, 'tcx> { "the object type `{}` automatically \ implements the trait `{}`", trait_ref.self_ty(), - ty::item_path_str(self.tcx, trait_def_id)); + self.tcx.item_path_str(trait_def_id)); } } } diff --git a/src/librustc_typeck/coherence/unsafety.rs b/src/librustc_typeck/coherence/unsafety.rs index fa39e9d0491f9..c0323ba60fc47 100644 --- a/src/librustc_typeck/coherence/unsafety.rs +++ b/src/librustc_typeck/coherence/unsafety.rs @@ -30,7 +30,7 @@ impl<'cx, 'tcx, 'v> UnsafetyChecker<'cx, 'tcx> { fn check_unsafety_coherence(&mut self, item: &'v ast::Item, unsafety: ast::Unsafety, polarity: ast::ImplPolarity) { - match ty::impl_trait_ref(self.tcx, ast_util::local_def(item.id)) { + match self.tcx.impl_trait_ref(ast_util::local_def(item.id)) { None => { // Inherent impl. match unsafety { @@ -43,7 +43,7 @@ impl<'cx, 'tcx, 'v> UnsafetyChecker<'cx, 'tcx> { } Some(trait_ref) => { - let trait_def = ty::lookup_trait_def(self.tcx, trait_ref.def_id); + let trait_def = self.tcx.lookup_trait_def(trait_ref.def_id); match (trait_def.unsafety, unsafety, polarity) { (ast::Unsafety::Unsafe, ast::Unsafety::Unsafe, ast::ImplPolarity::Negative) => { diff --git a/src/librustc_typeck/collect.rs b/src/librustc_typeck/collect.rs index 4c550e5d44ae4..e43a3542b6e33 100644 --- a/src/librustc_typeck/collect.rs +++ b/src/librustc_typeck/collect.rs @@ -242,12 +242,12 @@ impl<'a,'tcx> CrateCtxt<'a,'tcx> { AstConvRequest::GetTraitDef(def_id) => { tcx.sess.note( &format!("the cycle begins when processing `{}`...", - ty::item_path_str(tcx, def_id))); + tcx.item_path_str(def_id))); } AstConvRequest::EnsureSuperPredicates(def_id) => { tcx.sess.note( &format!("the cycle begins when computing the supertraits of `{}`...", - ty::item_path_str(tcx, def_id))); + tcx.item_path_str(def_id))); } AstConvRequest::GetTypeParameterBounds(id) => { let def = tcx.type_parameter_def(id); @@ -264,12 +264,12 @@ impl<'a,'tcx> CrateCtxt<'a,'tcx> { AstConvRequest::GetTraitDef(def_id) => { tcx.sess.note( &format!("...which then requires processing `{}`...", - ty::item_path_str(tcx, def_id))); + tcx.item_path_str(def_id))); } AstConvRequest::EnsureSuperPredicates(def_id) => { tcx.sess.note( &format!("...which then requires computing the supertraits of `{}`...", - ty::item_path_str(tcx, def_id))); + tcx.item_path_str(def_id))); } AstConvRequest::GetTypeParameterBounds(id) => { let def = tcx.type_parameter_def(id); @@ -286,13 +286,13 @@ impl<'a,'tcx> CrateCtxt<'a,'tcx> { AstConvRequest::GetTraitDef(def_id) => { tcx.sess.note( &format!("...which then again requires processing `{}`, completing the cycle.", - ty::item_path_str(tcx, def_id))); + tcx.item_path_str(def_id))); } AstConvRequest::EnsureSuperPredicates(def_id) => { tcx.sess.note( &format!("...which then again requires computing the supertraits of `{}`, \ completing the cycle.", - ty::item_path_str(tcx, def_id))); + tcx.item_path_str(def_id))); } AstConvRequest::GetTypeParameterBounds(id) => { let def = tcx.type_parameter_def(id); @@ -311,7 +311,7 @@ impl<'a,'tcx> CrateCtxt<'a,'tcx> { let tcx = self.tcx; if trait_id.krate != ast::LOCAL_CRATE { - return ty::lookup_trait_def(tcx, trait_id) + return tcx.lookup_trait_def(trait_id) } let item = match tcx.map.get(trait_id.node) { @@ -399,7 +399,7 @@ impl<'a, 'tcx> AstConv<'tcx> for ItemCtxt<'a, 'tcx> { if trait_def_id.krate == ast::LOCAL_CRATE { trait_defines_associated_type_named(self.ccx, trait_def_id.node, assoc_name) } else { - let trait_def = ty::lookup_trait_def(self.tcx(), trait_def_id); + let trait_def = self.tcx().lookup_trait_def(trait_def_id); trait_def.associated_type_names.contains(&assoc_name) } } @@ -822,7 +822,7 @@ fn convert_item(ccx: &CrateCtxt, it: &ast::Item) { ast_trait_ref, None); - ty::record_trait_has_default_impl(tcx, trait_ref.def_id); + tcx.record_trait_has_default_impl(trait_ref.def_id); tcx.impl_trait_refs.borrow_mut().insert(local_def(it.id), Some(trait_ref)); } @@ -944,7 +944,7 @@ fn convert_item(ccx: &CrateCtxt, it: &ast::Item) { let _: Result<(), ErrorReported> = // any error is already reported, can ignore ccx.ensure_super_predicates(it.span, local_def(it.id)); convert_trait_predicates(ccx, it); - let trait_predicates = ty::lookup_predicates(tcx, local_def(it.id)); + let trait_predicates = tcx.lookup_predicates(local_def(it.id)); debug!("convert: trait_bounds={:?}", trait_predicates); @@ -1230,7 +1230,7 @@ fn trait_def_of_item<'a, 'tcx>(ccx: &CrateCtxt<'a, 'tcx>, _ => tcx.sess.span_bug(it.span, "trait_def_of_item invoked on non-trait"), }; - let paren_sugar = ty::has_attr(tcx, def_id, "rustc_paren_sugar"); + let paren_sugar = tcx.has_attr(def_id, "rustc_paren_sugar"); if paren_sugar && !ccx.tcx.sess.features.borrow().unboxed_closures { ccx.tcx.sess.span_err( it.span, @@ -1343,7 +1343,7 @@ fn convert_trait_predicates<'a, 'tcx>(ccx: &CrateCtxt<'a, 'tcx>, it: &ast::Item) } }; - let super_predicates = ty::lookup_super_predicates(ccx.tcx, def_id); + let super_predicates = ccx.tcx.lookup_super_predicates(def_id); // `ty_generic_predicates` below will consider the bounds on the type // parameters (including `Self`) and the explicit where-clauses, @@ -1407,7 +1407,7 @@ fn type_scheme_of_def_id<'a,'tcx>(ccx: &CrateCtxt<'a,'tcx>, -> ty::TypeScheme<'tcx> { if def_id.krate != ast::LOCAL_CRATE { - return ty::lookup_item_type(ccx.tcx, def_id); + return ccx.tcx.lookup_item_type(def_id); } match ccx.tcx.map.find(def_id.node) { @@ -1529,7 +1529,7 @@ fn convert_typed_item<'a, 'tcx>(ccx: &CrateCtxt<'a, 'tcx>, assert!(prev_predicates.is_none()); // Debugging aid. - if ty::has_attr(tcx, local_def(it.id), "rustc_object_lifetime_default") { + if tcx.has_attr(local_def(it.id), "rustc_object_lifetime_default") { let object_lifetime_default_reprs: String = scheme.generics.types.iter() .map(|t| match t.object_lifetime_default { @@ -1691,20 +1691,20 @@ fn add_unsized_bound<'tcx>(astconv: &AstConv<'tcx>, match unbound { Some(ref tpb) => { // FIXME(#8559) currently requires the unbound to be built-in. - let trait_def_id = ty::trait_ref_to_def_id(tcx, tpb); + let trait_def_id = tcx.trait_ref_to_def_id(tpb); match kind_id { Ok(kind_id) if trait_def_id != kind_id => { tcx.sess.span_warn(span, "default bound relaxed for a type parameter, but \ this does nothing because the given bound is not \ a default. Only `?Sized` is supported"); - ty::try_add_builtin_trait(tcx, kind_id, bounds); + tcx.try_add_builtin_trait(kind_id, bounds); } _ => {} } } _ if kind_id.is_ok() => { - ty::try_add_builtin_trait(tcx, kind_id.unwrap(), bounds); + tcx.try_add_builtin_trait(kind_id.unwrap(), bounds); } // No lang item for Sized, so we can't add it as a bound. None => {} @@ -2187,8 +2187,7 @@ fn check_method_self_type<'a, 'tcx, RS:RegionScope>( let required_type_free = liberate_early_bound_regions( tcx, body_scope, - &ty::liberate_late_bound_regions( - tcx, body_scope, &ty::Binder(required_type))); + &tcx.liberate_late_bound_regions(body_scope, &ty::Binder(required_type))); // The "base type" comes from the impl. It too may have late-bound // regions from the method. @@ -2196,8 +2195,7 @@ fn check_method_self_type<'a, 'tcx, RS:RegionScope>( let base_type_free = liberate_early_bound_regions( tcx, body_scope, - &ty::liberate_late_bound_regions( - tcx, body_scope, &ty::Binder(base_type))); + &tcx.liberate_late_bound_regions(body_scope, &ty::Binder(base_type))); debug!("required_type={:?} required_type_free={:?} \ base_type={:?} base_type_free={:?}", @@ -2262,9 +2260,9 @@ fn enforce_impl_params_are_constrained<'tcx>(tcx: &ty::ctxt<'tcx>, impl_def_id: ast::DefId, impl_items: &[P]) { - let impl_scheme = ty::lookup_item_type(tcx, impl_def_id); - let impl_predicates = ty::lookup_predicates(tcx, impl_def_id); - let impl_trait_ref = ty::impl_trait_ref(tcx, impl_def_id); + let impl_scheme = tcx.lookup_item_type(impl_def_id); + let impl_predicates = tcx.lookup_predicates(impl_def_id); + let impl_trait_ref = tcx.impl_trait_ref(impl_def_id); // The trait reference is an input, so find all type parameters // reachable from there, to start (if this is an inherent impl, @@ -2293,7 +2291,7 @@ fn enforce_impl_params_are_constrained<'tcx>(tcx: &ty::ctxt<'tcx>, let lifetimes_in_associated_types: HashSet<_> = impl_items.iter() - .map(|item| ty::impl_or_trait_item(tcx, local_def(item.id))) + .map(|item| tcx.impl_or_trait_item(local_def(item.id))) .filter_map(|item| match item { ty::TypeTraitItem(ref assoc_ty) => assoc_ty.ty, ty::ConstTraitItem(..) | ty::MethodTraitItem(..) => None diff --git a/src/librustc_typeck/lib.rs b/src/librustc_typeck/lib.rs index 34f166e0e0dfb..fc825c198e751 100644 --- a/src/librustc_typeck/lib.rs +++ b/src/librustc_typeck/lib.rs @@ -199,7 +199,7 @@ fn require_same_types<'a, 'tcx, M>(tcx: &ty::ctxt<'tcx>, Ok(_) => true, Err(ref terr) => { span_err!(tcx.sess, span, E0211, "{}: {}", msg(), terr); - ty::note_and_explain_type_err(tcx, terr, span); + tcx.note_and_explain_type_err(terr, span); false } } @@ -209,7 +209,7 @@ fn check_main_fn_ty(ccx: &CrateCtxt, main_id: ast::NodeId, main_span: Span) { let tcx = ccx.tcx; - let main_t = ty::node_id_to_type(tcx, main_id); + let main_t = tcx.node_id_to_type(main_id); match main_t.sty { ty::TyBareFn(..) => { match tcx.map.find(main_id) { @@ -254,7 +254,7 @@ fn check_start_fn_ty(ccx: &CrateCtxt, start_id: ast::NodeId, start_span: Span) { let tcx = ccx.tcx; - let start_t = ty::node_id_to_type(tcx, start_id); + let start_t = tcx.node_id_to_type(start_id); match start_t.sty { ty::TyBareFn(..) => { match tcx.map.find(start_id) { diff --git a/src/librustc_typeck/variance.rs b/src/librustc_typeck/variance.rs index 1f4e134365121..c1f9725fc8134 100644 --- a/src/librustc_typeck/variance.rs +++ b/src/librustc_typeck/variance.rs @@ -485,7 +485,7 @@ impl<'a, 'tcx> TermsContext<'a, 'tcx> { param_id={}, \ inf_index={:?}, \ initial_variance={:?})", - ty::item_path_str(self.tcx, ast_util::local_def(item_id)), + self.tcx.item_path_str(ast_util::local_def(item_id)), item_id, kind, space, index, param_id, inf_index, initial_variance); } @@ -603,7 +603,7 @@ impl<'a, 'tcx, 'v> Visitor<'v> for ConstraintContext<'a, 'tcx> { match item.node { ast::ItemEnum(ref enum_definition, _) => { - let scheme = ty::lookup_item_type(tcx, did); + let scheme = tcx.lookup_item_type(did); // Not entirely obvious: constraints on structs/enums do not // affect the variance of their type parameters. See discussion @@ -633,7 +633,7 @@ impl<'a, 'tcx, 'v> Visitor<'v> for ConstraintContext<'a, 'tcx> { } ast::ItemStruct(..) => { - let scheme = ty::lookup_item_type(tcx, did); + let scheme = tcx.lookup_item_type(did); // Not entirely obvious: constraints on structs/enums do not // affect the variance of their type parameters. See discussion @@ -641,16 +641,16 @@ impl<'a, 'tcx, 'v> Visitor<'v> for ConstraintContext<'a, 'tcx> { // // self.add_constraints_from_generics(&scheme.generics); - let struct_fields = ty::lookup_struct_fields(tcx, did); + let struct_fields = tcx.lookup_struct_fields(did); for field_info in &struct_fields { assert_eq!(field_info.id.krate, ast::LOCAL_CRATE); - let field_ty = ty::node_id_to_type(tcx, field_info.id.node); + let field_ty = tcx.node_id_to_type(field_info.id.node); self.add_constraints_from_ty(&scheme.generics, field_ty, self.covariant); } } ast::ItemTrait(..) => { - let trait_def = ty::lookup_trait_def(tcx, did); + let trait_def = tcx.lookup_trait_def(did); self.add_constraints_from_trait_ref(&trait_def.generics, trait_def.trait_ref, self.invariant); @@ -781,7 +781,7 @@ impl<'a, 'tcx> ConstraintContext<'a, 'tcx> { } else { // Parameter on an item defined within another crate: // variance already inferred, just look it up. - let variances = ty::item_variances(self.tcx(), item_def_id); + let variances = self.tcx().item_variances(item_def_id); let variance = match kind { TypeParam => *variances.types.get(space, index), RegionParam => *variances.regions.get(space, index), @@ -848,7 +848,7 @@ impl<'a, 'tcx> ConstraintContext<'a, 'tcx> { trait_ref, variance); - let trait_def = ty::lookup_trait_def(self.tcx(), trait_ref.def_id); + let trait_def = self.tcx().lookup_trait_def(trait_ref.def_id); self.add_constraints_from_substs( generics, @@ -904,7 +904,7 @@ impl<'a, 'tcx> ConstraintContext<'a, 'tcx> { ty::TyEnum(def_id, substs) | ty::TyStruct(def_id, substs) => { - let item_type = ty::lookup_item_type(self.tcx(), def_id); + let item_type = self.tcx().lookup_item_type(def_id); // All type parameters on enums and structs should be // in the TypeSpace. @@ -924,7 +924,7 @@ impl<'a, 'tcx> ConstraintContext<'a, 'tcx> { ty::TyProjection(ref data) => { let trait_ref = &data.trait_ref; - let trait_def = ty::lookup_trait_def(self.tcx(), trait_ref.def_id); + let trait_def = self.tcx().lookup_trait_def(trait_ref.def_id); self.add_constraints_from_substs( generics, trait_ref.def_id, @@ -1200,7 +1200,7 @@ impl<'a, 'tcx> SolveContext<'a, 'tcx> { // For unit testing: check for a special "rustc_variance" // attribute and report an error with various results if found. - if ty::has_attr(tcx, item_def_id, "rustc_variance") { + if tcx.has_attr(item_def_id, "rustc_variance") { span_err!(tcx.sess, tcx.map.span(item_id), E0208, "{:?}", item_variances); } diff --git a/src/librustdoc/clean/inline.rs b/src/librustdoc/clean/inline.rs index 53063c6247efb..e80fd360e04fd 100644 --- a/src/librustdoc/clean/inline.rs +++ b/src/librustdoc/clean/inline.rs @@ -150,9 +150,9 @@ pub fn record_extern_fqn(cx: &DocContext, did: ast::DefId, kind: clean::TypeKind pub fn build_external_trait(cx: &DocContext, tcx: &ty::ctxt, did: ast::DefId) -> clean::Trait { - let def = ty::lookup_trait_def(tcx, did); - let trait_items = ty::trait_items(tcx, did).clean(cx); - let predicates = ty::lookup_predicates(tcx, did); + let def = tcx.lookup_trait_def(did); + let trait_items = tcx.trait_items(did).clean(cx); + let predicates = tcx.lookup_predicates(did); let generics = (&def.generics, &predicates, subst::TypeSpace).clean(cx); let generics = filter_non_trait_generics(did, generics); let (generics, supertrait_bounds) = separate_supertrait_bounds(generics); @@ -165,12 +165,12 @@ pub fn build_external_trait(cx: &DocContext, tcx: &ty::ctxt, } fn build_external_function(cx: &DocContext, tcx: &ty::ctxt, did: ast::DefId) -> clean::Function { - let t = ty::lookup_item_type(tcx, did); + let t = tcx.lookup_item_type(did); let (decl, style, abi) = match t.ty.sty { ty::TyBareFn(_, ref f) => ((did, &f.sig).clean(cx), f.unsafety, f.abi), _ => panic!("bad function"), }; - let predicates = ty::lookup_predicates(tcx, did); + let predicates = tcx.lookup_predicates(did); clean::Function { decl: decl, generics: (&t.generics, &predicates, subst::FnSpace).clean(cx), @@ -183,9 +183,9 @@ fn build_external_function(cx: &DocContext, tcx: &ty::ctxt, did: ast::DefId) -> fn build_struct(cx: &DocContext, tcx: &ty::ctxt, did: ast::DefId) -> clean::Struct { use syntax::parse::token::special_idents::unnamed_field; - let t = ty::lookup_item_type(tcx, did); - let predicates = ty::lookup_predicates(tcx, did); - let fields = ty::lookup_struct_fields(tcx, did); + let t = tcx.lookup_item_type(did); + let predicates = tcx.lookup_predicates(did); + let fields = tcx.lookup_struct_fields(did); clean::Struct { struct_type: match &*fields { @@ -201,14 +201,14 @@ fn build_struct(cx: &DocContext, tcx: &ty::ctxt, did: ast::DefId) -> clean::Stru } fn build_type(cx: &DocContext, tcx: &ty::ctxt, did: ast::DefId) -> clean::ItemEnum { - let t = ty::lookup_item_type(tcx, did); - let predicates = ty::lookup_predicates(tcx, did); + let t = tcx.lookup_item_type(did); + let predicates = tcx.lookup_predicates(did); match t.ty.sty { ty::TyEnum(edid, _) if !csearch::is_typedef(&tcx.sess.cstore, did) => { return clean::EnumItem(clean::Enum { generics: (&t.generics, &predicates, subst::TypeSpace).clean(cx), variants_stripped: false, - variants: ty::enum_variants(tcx, edid).clean(cx), + variants: tcx.enum_variants(edid).clean(cx), }) } _ => {} @@ -222,7 +222,7 @@ fn build_type(cx: &DocContext, tcx: &ty::ctxt, did: ast::DefId) -> clean::ItemEn pub fn build_impls(cx: &DocContext, tcx: &ty::ctxt, did: ast::DefId) -> Vec { - ty::populate_inherent_implementations_for_type_if_necessary(tcx, did); + tcx.populate_inherent_implementations_for_type_if_necessary(did); let mut impls = Vec::new(); match tcx.inherent_impls.borrow().get(&did) { @@ -307,16 +307,16 @@ pub fn build_impl(cx: &DocContext, }); } - let predicates = ty::lookup_predicates(tcx, did); + let predicates = tcx.lookup_predicates(did); let trait_items = csearch::get_impl_items(&tcx.sess.cstore, did) .iter() .filter_map(|did| { let did = did.def_id(); - let impl_item = ty::impl_or_trait_item(tcx, did); + let impl_item = tcx.impl_or_trait_item(did); match impl_item { ty::ConstTraitItem(ref assoc_const) => { let did = assoc_const.def_id; - let type_scheme = ty::lookup_item_type(tcx, did); + let type_scheme = tcx.lookup_item_type(did); let default = match assoc_const.default { Some(_) => Some(const_eval::lookup_const_by_id(tcx, did, None) .unwrap().span.to_src(cx)), @@ -383,7 +383,7 @@ pub fn build_impl(cx: &DocContext, } }).collect::>(); let polarity = csearch::get_impl_polarity(tcx, did); - let ty = ty::lookup_item_type(tcx, did); + let ty = tcx.lookup_item_type(did); let trait_ = associated_trait.clean(cx).map(|bound| { match bound { clean::TraitBound(polyt, _) => polyt.trait_, @@ -477,7 +477,7 @@ fn build_const(cx: &DocContext, tcx: &ty::ctxt, debug!("got snippet {}", sn); clean::Constant { - type_: ty::lookup_item_type(tcx, did).ty.clean(cx), + type_: tcx.lookup_item_type(did).ty.clean(cx), expr: sn } } @@ -486,7 +486,7 @@ fn build_static(cx: &DocContext, tcx: &ty::ctxt, did: ast::DefId, mutable: bool) -> clean::Static { clean::Static { - type_: ty::lookup_item_type(tcx, did).ty.clean(cx), + type_: tcx.lookup_item_type(did).ty.clean(cx), mutability: if mutable {clean::Mutable} else {clean::Immutable}, expr: "\n\n\n".to_string(), // trigger the "[definition]" links } diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs index 8ba4470c3efbd..c25267520ccd8 100644 --- a/src/librustdoc/clean/mod.rs +++ b/src/librustdoc/clean/mod.rs @@ -1332,7 +1332,7 @@ impl<'tcx> Clean for ty::Method<'tcx> { let provided = match self.container { ty::ImplContainer(..) => false, ty::TraitContainer(did) => { - ty::provided_trait_methods(cx.tcx(), did).iter().any(|m| { + cx.tcx().provided_trait_methods(did).iter().any(|m| { m.def_id == self.def_id }) } @@ -1742,7 +1742,7 @@ impl Clean for ty::field_ty { (Some(self.name), Some(attr_map.get(&self.id.node).unwrap())) }; - let ty = ty::lookup_item_type(cx.tcx(), self.id); + let ty = cx.tcx().lookup_item_type(self.id); Item { name: name.clean(cx), @@ -2731,8 +2731,8 @@ impl<'tcx> Clean for ty::AssociatedType<'tcx> { // are actually located on the trait/impl itself, so we need to load // all of the generics from there and then look for bounds that are // applied to this associated type in question. - let def = ty::lookup_trait_def(cx.tcx(), did); - let predicates = ty::lookup_predicates(cx.tcx(), did); + let def = cx.tcx().lookup_trait_def(did); + let predicates = cx.tcx().lookup_predicates(did); let generics = (&def.generics, &predicates, subst::TypeSpace).clean(cx); generics.where_predicates.iter().filter_map(|pred| { let (name, self_type, trait_, bounds) = match *pred { diff --git a/src/librustdoc/clean/simplify.rs b/src/librustdoc/clean/simplify.rs index 2bde8d5bfb5fc..e65cdd8ff5de6 100644 --- a/src/librustdoc/clean/simplify.rs +++ b/src/librustdoc/clean/simplify.rs @@ -30,7 +30,6 @@ use std::mem; use std::collections::HashMap; use rustc::middle::subst; -use rustc::middle::ty; use syntax::ast; use clean::PathParameters as PP; @@ -154,8 +153,8 @@ fn trait_is_same_or_supertrait(cx: &DocContext, child: ast::DefId, if child == trait_ { return true } - let def = ty::lookup_trait_def(cx.tcx(), child); - let predicates = ty::lookup_predicates(cx.tcx(), child); + let def = cx.tcx().lookup_trait_def(child); + let predicates = cx.tcx().lookup_predicates(child); let generics = (&def.generics, &predicates, subst::TypeSpace).clean(cx); generics.where_predicates.iter().filter_map(|pred| { match *pred {