1 // Copyright 2012-2015 The Rust Project Developers. See the COPYRIGHT
2 // file at the top-level directory of this distribution and at
3 // http://rust-lang.org/COPYRIGHT.
5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
8 // option. This file may not be copied, modified, or distributed
9 // except according to those terms.
15 Within the check phase of type check, we check each item one at a time
16 (bodies of function expressions are checked as part of the containing
17 function). Inference is used to supply types wherever they are
20 By far the most complex case is checking the body of a function. This
21 can be broken down into several distinct phases:
23 - gather: creates type variables to represent the type of each local
24 variable and pattern binding.
26 - main: the main pass does the lion's share of the work: it
27 determines the types of all expressions, resolves
28 methods, checks for most invalid conditions, and so forth. In
29 some cases, where a type is unknown, it may create a type or region
30 variable and use that as the type of an expression.
32 In the process of checking, various constraints will be placed on
33 these type variables through the subtyping relationships requested
34 through the `demand` module. The `infer` module is in charge
35 of resolving those constraints.
37 - regionck: after main is complete, the regionck pass goes over all
38 types looking for regions and making sure that they did not escape
39 into places they are not in scope. This may also influence the
40 final assignments of the various region variables if there is some
43 - vtable: find and records the impls to use for each trait bound that
44 appears on a type parameter.
46 - writeback: writes the final types within a function body, replacing
47 type variables with their final inferred types. These final types
48 are written into the `tcx.node_types` table, which should *never* contain
49 any reference to a type variable.
53 While type checking a function, the intermediate types for the
54 expressions, blocks, and so forth contained within the function are
55 stored in `fcx.node_types` and `fcx.item_substs`. These types
56 may contain unresolved type variables. After type checking is
57 complete, the functions in the writeback module are used to take the
58 types from this table, resolve them, and then write them into their
59 permanent home in the type context `tcx`.
61 This means that during inferencing you should use `fcx.write_ty()`
62 and `fcx.expr_ty()` / `fcx.node_ty()` to write/obtain the types of
63 nodes within the function.
65 The types of top-level items, which never contain unbound type
66 variables, are stored directly into the `tcx` tables.
68 n.b.: A type variable is not the same thing as a type parameter. A
69 type variable is rather an "instance" of a type parameter: that is,
70 given a generic function `fn foo<T>(t: T)`: while checking the
71 function `foo`, the type `ty_param(0)` refers to the type `T`, which
72 is treated in abstract. When `foo()` is called, however, `T` will be
73 substituted for a fresh type variable `N`. This variable will
74 eventually be resolved to some concrete type (which might itself be
79 pub use self::Expectation::*;
80 use self::coercion::{CoerceMany, DynamicCoerceMany};
81 pub use self::compare_method::{compare_impl_method, compare_const_impl};
82 use self::TupleArgumentsFlag::*;
85 use dep_graph::DepNode;
86 use fmt_macros::{Parser, Piece, Position};
87 use hir::def::{Def, CtorKind};
88 use hir::def_id::{CrateNum, DefId, LOCAL_CRATE};
89 use rustc_back::slice::ref_slice;
90 use rustc::infer::{self, InferCtxt, InferOk, RegionVariableOrigin};
91 use rustc::infer::type_variable::{self, TypeVariableOrigin};
92 use rustc::ty::subst::{Kind, Subst, Substs};
93 use rustc::traits::{self, ObligationCause, ObligationCauseCode, Reveal};
94 use rustc::ty::{ParamTy, ParameterEnvironment};
95 use rustc::ty::{LvaluePreference, NoPreference, PreferMutLvalue};
96 use rustc::ty::{self, Ty, TyCtxt, Visibility};
97 use rustc::ty::{MethodCall, MethodCallee};
98 use rustc::ty::adjustment;
99 use rustc::ty::fold::{BottomUpFolder, TypeFoldable};
100 use rustc::ty::maps::Providers;
101 use rustc::ty::util::{Representability, IntTypeExt};
102 use errors::DiagnosticBuilder;
103 use require_c_abi_if_variadic;
104 use session::{Session, CompileResult};
107 use util::common::{ErrorReported, indenter};
108 use util::nodemap::{DefIdMap, FxHashMap, FxHashSet, NodeMap};
110 use std::cell::{Cell, RefCell};
112 use std::mem::replace;
113 use std::ops::{self, Deref};
114 use syntax::abi::Abi;
116 use syntax::codemap::{self, original_sp, Spanned};
117 use syntax::feature_gate::{GateIssue, emit_feature_err};
119 use syntax::symbol::{Symbol, InternedString, keywords};
120 use syntax::util::lev_distance::find_best_match_for_name;
121 use syntax_pos::{self, BytePos, Span, DUMMY_SP};
123 use rustc::hir::intravisit::{self, Visitor, NestedVisitorMap};
124 use rustc::hir::itemlikevisit::ItemLikeVisitor;
125 use rustc::hir::{self, PatKind};
126 use rustc::middle::lang_items;
127 use rustc_back::slice;
128 use rustc_const_eval::eval_length;
129 use rustc_const_math::ConstInt;
149 /// closures defined within the function. For example:
152 /// bar(move|| { ... })
155 /// Here, the function `foo()` and the closure passed to
156 /// `bar()` will each have their own `FnCtxt`, but they will
157 /// share the inherited fields.
158 pub struct Inherited<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
159 infcx: InferCtxt<'a, 'gcx, 'tcx>,
161 locals: RefCell<NodeMap<Ty<'tcx>>>,
163 fulfillment_cx: RefCell<traits::FulfillmentContext<'tcx>>,
165 // When we process a call like `c()` where `c` is a closure type,
166 // we may not have decided yet whether `c` is a `Fn`, `FnMut`, or
167 // `FnOnce` closure. In that case, we defer full resolution of the
168 // call until upvar inference can kick in and make the
169 // decision. We keep these deferred resolutions grouped by the
170 // def-id of the closure, so that once we decide, we can easily go
171 // back and process them.
172 deferred_call_resolutions: RefCell<DefIdMap<Vec<DeferredCallResolutionHandler<'gcx, 'tcx>>>>,
174 deferred_cast_checks: RefCell<Vec<cast::CastCheck<'tcx>>>,
176 // Anonymized types found in explicit return types and their
177 // associated fresh inference variable. Writeback resolves these
178 // variables to get the concrete type, which can be used to
179 // deanonymize TyAnon, after typeck is done with all functions.
180 anon_types: RefCell<NodeMap<Ty<'tcx>>>,
183 impl<'a, 'gcx, 'tcx> Deref for Inherited<'a, 'gcx, 'tcx> {
184 type Target = InferCtxt<'a, 'gcx, 'tcx>;
185 fn deref(&self) -> &Self::Target {
190 trait DeferredCallResolution<'gcx, 'tcx> {
191 fn resolve<'a>(&mut self, fcx: &FnCtxt<'a, 'gcx, 'tcx>);
194 type DeferredCallResolutionHandler<'gcx, 'tcx> = Box<DeferredCallResolution<'gcx, 'tcx>+'tcx>;
196 /// When type-checking an expression, we propagate downward
197 /// whatever type hint we are able in the form of an `Expectation`.
198 #[derive(Copy, Clone, Debug)]
199 pub enum Expectation<'tcx> {
200 /// We know nothing about what type this expression should have.
203 /// This expression should have the type given (or some subtype)
204 ExpectHasType(Ty<'tcx>),
206 /// This expression will be cast to the `Ty`
207 ExpectCastableToType(Ty<'tcx>),
209 /// This rvalue expression will be wrapped in `&` or `Box` and coerced
210 /// to `&Ty` or `Box<Ty>`, respectively. `Ty` is `[A]` or `Trait`.
211 ExpectRvalueLikeUnsized(Ty<'tcx>),
214 impl<'a, 'gcx, 'tcx> Expectation<'tcx> {
215 // Disregard "castable to" expectations because they
216 // can lead us astray. Consider for example `if cond
217 // {22} else {c} as u8` -- if we propagate the
218 // "castable to u8" constraint to 22, it will pick the
219 // type 22u8, which is overly constrained (c might not
220 // be a u8). In effect, the problem is that the
221 // "castable to" expectation is not the tightest thing
222 // we can say, so we want to drop it in this case.
223 // The tightest thing we can say is "must unify with
224 // else branch". Note that in the case of a "has type"
225 // constraint, this limitation does not hold.
227 // If the expected type is just a type variable, then don't use
228 // an expected type. Otherwise, we might write parts of the type
229 // when checking the 'then' block which are incompatible with the
231 fn adjust_for_branches(&self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) -> Expectation<'tcx> {
233 ExpectHasType(ety) => {
234 let ety = fcx.shallow_resolve(ety);
235 if !ety.is_ty_var() {
241 ExpectRvalueLikeUnsized(ety) => {
242 ExpectRvalueLikeUnsized(ety)
248 /// Provide an expectation for an rvalue expression given an *optional*
249 /// hint, which is not required for type safety (the resulting type might
250 /// be checked higher up, as is the case with `&expr` and `box expr`), but
251 /// is useful in determining the concrete type.
253 /// The primary use case is where the expected type is a fat pointer,
254 /// like `&[isize]`. For example, consider the following statement:
256 /// let x: &[isize] = &[1, 2, 3];
258 /// In this case, the expected type for the `&[1, 2, 3]` expression is
259 /// `&[isize]`. If however we were to say that `[1, 2, 3]` has the
260 /// expectation `ExpectHasType([isize])`, that would be too strong --
261 /// `[1, 2, 3]` does not have the type `[isize]` but rather `[isize; 3]`.
262 /// It is only the `&[1, 2, 3]` expression as a whole that can be coerced
263 /// to the type `&[isize]`. Therefore, we propagate this more limited hint,
264 /// which still is useful, because it informs integer literals and the like.
265 /// See the test case `test/run-pass/coerce-expect-unsized.rs` and #20169
266 /// for examples of where this comes up,.
267 fn rvalue_hint(fcx: &FnCtxt<'a, 'gcx, 'tcx>, ty: Ty<'tcx>) -> Expectation<'tcx> {
268 match fcx.tcx.struct_tail(ty).sty {
269 ty::TySlice(_) | ty::TyStr | ty::TyDynamic(..) => {
270 ExpectRvalueLikeUnsized(ty)
272 _ => ExpectHasType(ty)
276 // Resolves `expected` by a single level if it is a variable. If
277 // there is no expected type or resolution is not possible (e.g.,
278 // no constraints yet present), just returns `None`.
279 fn resolve(self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) -> Expectation<'tcx> {
284 ExpectCastableToType(t) => {
285 ExpectCastableToType(fcx.resolve_type_vars_if_possible(&t))
287 ExpectHasType(t) => {
288 ExpectHasType(fcx.resolve_type_vars_if_possible(&t))
290 ExpectRvalueLikeUnsized(t) => {
291 ExpectRvalueLikeUnsized(fcx.resolve_type_vars_if_possible(&t))
296 fn to_option(self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) -> Option<Ty<'tcx>> {
297 match self.resolve(fcx) {
298 NoExpectation => None,
299 ExpectCastableToType(ty) |
301 ExpectRvalueLikeUnsized(ty) => Some(ty),
305 /// It sometimes happens that we want to turn an expectation into
306 /// a **hard constraint** (i.e., something that must be satisfied
307 /// for the program to type-check). `only_has_type` will return
308 /// such a constraint, if it exists.
309 fn only_has_type(self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) -> Option<Ty<'tcx>> {
310 match self.resolve(fcx) {
311 ExpectHasType(ty) => Some(ty),
316 /// Like `only_has_type`, but instead of returning `None` if no
317 /// hard constraint exists, creates a fresh type variable.
318 fn coercion_target_type(self, fcx: &FnCtxt<'a, 'gcx, 'tcx>, span: Span) -> Ty<'tcx> {
319 self.only_has_type(fcx)
320 .unwrap_or_else(|| fcx.next_ty_var(TypeVariableOrigin::MiscVariable(span)))
324 #[derive(Copy, Clone)]
325 pub struct UnsafetyState {
326 pub def: ast::NodeId,
327 pub unsafety: hir::Unsafety,
328 pub unsafe_push_count: u32,
333 pub fn function(unsafety: hir::Unsafety, def: ast::NodeId) -> UnsafetyState {
334 UnsafetyState { def: def, unsafety: unsafety, unsafe_push_count: 0, from_fn: true }
337 pub fn recurse(&mut self, blk: &hir::Block) -> UnsafetyState {
338 match self.unsafety {
339 // If this unsafe, then if the outer function was already marked as
340 // unsafe we shouldn't attribute the unsafe'ness to the block. This
341 // way the block can be warned about instead of ignoring this
342 // extraneous block (functions are never warned about).
343 hir::Unsafety::Unsafe if self.from_fn => *self,
346 let (unsafety, def, count) = match blk.rules {
347 hir::PushUnsafeBlock(..) =>
348 (unsafety, blk.id, self.unsafe_push_count.checked_add(1).unwrap()),
349 hir::PopUnsafeBlock(..) =>
350 (unsafety, blk.id, self.unsafe_push_count.checked_sub(1).unwrap()),
351 hir::UnsafeBlock(..) =>
352 (hir::Unsafety::Unsafe, blk.id, self.unsafe_push_count),
354 (unsafety, self.def, self.unsafe_push_count),
356 UnsafetyState{ def: def,
358 unsafe_push_count: count,
365 /// Tracks whether executing a node may exit normally (versus
366 /// return/break/panic, which "diverge", leaving dead code in their
367 /// wake). Tracked semi-automatically (through type variables marked
368 /// as diverging), with some manual adjustments for control-flow
369 /// primitives (approximating a CFG).
370 #[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
372 /// Potentially unknown, some cases converge,
373 /// others require a CFG to determine them.
376 /// Definitely known to diverge and therefore
377 /// not reach the next sibling or its parent.
380 /// Same as `Always` but with a reachability
381 /// warning already emitted
385 // Convenience impls for combinig `Diverges`.
387 impl ops::BitAnd for Diverges {
389 fn bitand(self, other: Self) -> Self {
390 cmp::min(self, other)
394 impl ops::BitOr for Diverges {
396 fn bitor(self, other: Self) -> Self {
397 cmp::max(self, other)
401 impl ops::BitAndAssign for Diverges {
402 fn bitand_assign(&mut self, other: Self) {
403 *self = *self & other;
407 impl ops::BitOrAssign for Diverges {
408 fn bitor_assign(&mut self, other: Self) {
409 *self = *self | other;
414 fn always(self) -> bool {
415 self >= Diverges::Always
419 pub struct BreakableCtxt<'gcx: 'tcx, 'tcx> {
422 // this is `null` for loops where break with a value is illegal,
423 // such as `while`, `for`, and `while let`
424 coerce: Option<DynamicCoerceMany<'gcx, 'tcx>>,
427 pub struct EnclosingBreakables<'gcx: 'tcx, 'tcx> {
428 stack: Vec<BreakableCtxt<'gcx, 'tcx>>,
429 by_id: NodeMap<usize>,
432 impl<'gcx, 'tcx> EnclosingBreakables<'gcx, 'tcx> {
433 fn find_breakable(&mut self, target_id: ast::NodeId) -> &mut BreakableCtxt<'gcx, 'tcx> {
434 let ix = *self.by_id.get(&target_id).unwrap_or_else(|| {
435 bug!("could not find enclosing breakable with id {}", target_id);
441 pub struct FnCtxt<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
442 ast_ty_to_ty_cache: RefCell<NodeMap<Ty<'tcx>>>,
444 body_id: ast::NodeId,
446 // Number of errors that had been reported when we started
447 // checking this function. On exit, if we find that *more* errors
448 // have been reported, we will skip regionck and other work that
449 // expects the types within the function to be consistent.
450 err_count_on_creation: usize,
452 ret_coercion: Option<RefCell<DynamicCoerceMany<'gcx, 'tcx>>>,
454 ps: RefCell<UnsafetyState>,
456 /// Whether the last checked node generates a divergence (e.g.,
457 /// `return` will set this to Always). In general, this is
458 /// typically set to *Maybe* on the way **down** the tree, and
459 /// then values are propagated **up** the tree. In a block, we
460 /// combine the results from statements and propagate the
463 /// We use this flag for two purposes:
465 /// - To warn about unreachable code: if, after processing a
466 /// sub-expression but before we have applied the effects of the
467 /// current node, we see that the flag is set to `Always`, we
468 /// can issue a warning. This corresponds to something like
469 /// `foo(return)`; we warn on the `foo()` expression. (We then
470 /// update the flag to `WarnedAlways` to suppress duplicate
471 /// reports.) Similarly, if we traverse to a fresh statement (or
472 /// tail expression) from a `Always` setting, we will isssue a
473 /// warning. This corresponds to something like `{return;
474 /// foo();}` or `{return; 22}`, where we would warn on the
477 /// - To permit assignment into a local variable or other lvalue
478 /// (including the "return slot") of type `!`. This is allowed
479 /// if **either** the type of value being assigned is `!`, which
480 /// means the current code is dead, **or** the expression's
481 /// divering flag is true, which means that a divering value was
482 /// wrapped (e.g., `let x: ! = foo(return)`).
484 /// To repeat the last point: an expression represents dead-code
485 /// if, after checking it, **either** its type is `!` OR the
486 /// diverges flag is set to something other than `Maybe`.
487 diverges: Cell<Diverges>,
489 /// Whether any child nodes have any type errors.
490 has_errors: Cell<bool>,
492 enclosing_breakables: RefCell<EnclosingBreakables<'gcx, 'tcx>>,
494 inh: &'a Inherited<'a, 'gcx, 'tcx>,
497 impl<'a, 'gcx, 'tcx> Deref for FnCtxt<'a, 'gcx, 'tcx> {
498 type Target = Inherited<'a, 'gcx, 'tcx>;
499 fn deref(&self) -> &Self::Target {
504 /// Helper type of a temporary returned by Inherited::build(...).
505 /// Necessary because we can't write the following bound:
506 /// F: for<'b, 'tcx> where 'gcx: 'tcx FnOnce(Inherited<'b, 'gcx, 'tcx>).
507 pub struct InheritedBuilder<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
508 infcx: infer::InferCtxtBuilder<'a, 'gcx, 'tcx>
511 impl<'a, 'gcx, 'tcx> Inherited<'a, 'gcx, 'tcx> {
512 pub fn build(tcx: TyCtxt<'a, 'gcx, 'gcx>, id: ast::NodeId)
513 -> InheritedBuilder<'a, 'gcx, 'tcx> {
514 let tables = ty::TypeckTables::empty();
515 let param_env = ParameterEnvironment::for_item(tcx, id);
517 infcx: tcx.infer_ctxt((tables, param_env), Reveal::UserFacing)
522 impl<'a, 'gcx, 'tcx> InheritedBuilder<'a, 'gcx, 'tcx> {
523 fn enter<F, R>(&'tcx mut self, f: F) -> R
524 where F: for<'b> FnOnce(Inherited<'b, 'gcx, 'tcx>) -> R
526 self.infcx.enter(|infcx| f(Inherited::new(infcx)))
530 impl<'a, 'gcx, 'tcx> Inherited<'a, 'gcx, 'tcx> {
531 pub fn new(infcx: InferCtxt<'a, 'gcx, 'tcx>) -> Self {
534 fulfillment_cx: RefCell::new(traits::FulfillmentContext::new()),
535 locals: RefCell::new(NodeMap()),
536 deferred_call_resolutions: RefCell::new(DefIdMap()),
537 deferred_cast_checks: RefCell::new(Vec::new()),
538 anon_types: RefCell::new(NodeMap()),
542 fn normalize_associated_types_in<T>(&self,
544 body_id: ast::NodeId,
547 where T : TypeFoldable<'tcx>
549 assoc::normalize_associated_types_in(self,
550 &mut self.fulfillment_cx.borrow_mut(),
558 struct CheckItemTypesVisitor<'a, 'tcx: 'a> { tcx: TyCtxt<'a, 'tcx, 'tcx> }
560 impl<'a, 'tcx> ItemLikeVisitor<'tcx> for CheckItemTypesVisitor<'a, 'tcx> {
561 fn visit_item(&mut self, i: &'tcx hir::Item) {
562 check_item_type(self.tcx, i);
564 fn visit_trait_item(&mut self, _: &'tcx hir::TraitItem) { }
565 fn visit_impl_item(&mut self, _: &'tcx hir::ImplItem) { }
568 pub fn check_wf_new<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) -> CompileResult {
569 tcx.sess.track_errors(|| {
570 let mut visit = wfcheck::CheckTypeWellFormedVisitor::new(tcx);
571 tcx.visit_all_item_likes_in_krate(DepNode::WfCheck, &mut visit.as_deep_visitor());
575 pub fn check_item_types<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) -> CompileResult {
576 tcx.sess.track_errors(|| {
577 tcx.visit_all_item_likes_in_krate(DepNode::TypeckItemType,
578 &mut CheckItemTypesVisitor { tcx });
582 pub fn check_item_bodies<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) -> CompileResult {
583 ty::queries::typeck_item_bodies::get(tcx, DUMMY_SP, LOCAL_CRATE)
586 fn typeck_item_bodies<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, crate_num: CrateNum) -> CompileResult {
587 debug_assert!(crate_num == LOCAL_CRATE);
588 tcx.sess.track_errors(|| {
589 tcx.visit_all_bodies_in_krate(|body_owner_def_id, _body_id| {
590 tcx.item_tables(body_owner_def_id);
595 pub fn provide(providers: &mut Providers) {
596 *providers = Providers {
606 fn closure_type<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
608 -> ty::PolyFnSig<'tcx> {
609 let node_id = tcx.hir.as_local_node_id(def_id).unwrap();
610 tcx.item_tables(def_id).closure_tys[&node_id]
613 fn closure_kind<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
616 let node_id = tcx.hir.as_local_node_id(def_id).unwrap();
617 tcx.item_tables(def_id).closure_kinds[&node_id]
620 fn adt_destructor<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
622 -> Option<ty::Destructor> {
623 tcx.calculate_dtor(def_id, &mut dropck::check_drop_impl)
626 fn typeck_tables<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
628 -> &'tcx ty::TypeckTables<'tcx> {
629 // Closures' tables come from their outermost function,
630 // as they are part of the same "inference environment".
631 let outer_def_id = tcx.closure_base_def_id(def_id);
632 if outer_def_id != def_id {
633 return tcx.item_tables(outer_def_id);
636 let id = tcx.hir.as_local_node_id(def_id).unwrap();
637 let span = tcx.hir.span(id);
638 let unsupported = || {
639 span_bug!(span, "can't type-check body of {:?}", def_id);
642 // Figure out what primary body this item has.
643 let mut fn_decl = None;
644 let body_id = match tcx.hir.get(id) {
645 hir::map::NodeItem(item) => {
647 hir::ItemConst(_, body) |
648 hir::ItemStatic(_, _, body) => body,
649 hir::ItemFn(ref decl, .., body) => {
650 fn_decl = Some(decl);
656 hir::map::NodeTraitItem(item) => {
658 hir::TraitItemKind::Const(_, Some(body)) => body,
659 hir::TraitItemKind::Method(ref sig,
660 hir::TraitMethod::Provided(body)) => {
661 fn_decl = Some(&sig.decl);
667 hir::map::NodeImplItem(item) => {
669 hir::ImplItemKind::Const(_, body) => body,
670 hir::ImplItemKind::Method(ref sig, body) => {
671 fn_decl = Some(&sig.decl);
677 hir::map::NodeExpr(expr) => {
678 // FIXME(eddyb) Closures should have separate
679 // function definition IDs and expression IDs.
680 // Type-checking should not let closures get
681 // this far in a constant position.
682 // Assume that everything other than closures
683 // is a constant "initializer" expression.
685 hir::ExprClosure(..) => {
686 // We should've bailed out above for closures.
687 span_bug!(expr.span, "unexpected closure")
689 _ => hir::BodyId { node_id: expr.id }
694 let body = tcx.hir.body(body_id);
696 Inherited::build(tcx, id).enter(|inh| {
697 let fcx = if let Some(decl) = fn_decl {
698 let fn_sig = tcx.item_type(def_id).fn_sig();
700 check_abi(tcx, span, fn_sig.abi());
702 // Compute the fty from point of view of inside fn.
703 let fn_scope = inh.tcx.region_maps.call_site_extent(id, body_id.node_id);
705 fn_sig.subst(inh.tcx, &inh.parameter_environment.free_substs);
707 inh.tcx.liberate_late_bound_regions(fn_scope, &fn_sig);
709 inh.normalize_associated_types_in(body.value.span, body_id.node_id, &fn_sig);
711 check_fn(&inh, fn_sig, decl, id, body)
713 let fcx = FnCtxt::new(&inh, body.value.id);
714 let expected_type = tcx.item_type(def_id);
715 let expected_type = fcx.normalize_associated_types_in(body.value.span, &expected_type);
716 fcx.require_type_is_sized(expected_type, body.value.span, traits::ConstSized);
718 // Gather locals in statics (because of block expressions).
719 // This is technically unnecessary because locals in static items are forbidden,
720 // but prevents type checking from blowing up before const checking can properly
722 GatherLocalsVisitor { fcx: &fcx }.visit_body(body);
724 fcx.check_expr_coercable_to_type(&body.value, expected_type);
729 fcx.select_all_obligations_and_apply_defaults();
730 fcx.closure_analyze(body);
731 fcx.select_obligations_where_possible();
733 fcx.select_all_obligations_or_error();
735 if fn_decl.is_some() {
736 fcx.regionck_fn(id, body);
738 fcx.regionck_expr(body);
741 fcx.resolve_type_vars_in_body(body)
745 fn check_abi<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, span: Span, abi: Abi) {
746 if !tcx.sess.target.target.is_abi_supported(abi) {
747 struct_span_err!(tcx.sess, span, E0570,
748 "The ABI `{}` is not supported for the current target", abi).emit()
752 struct GatherLocalsVisitor<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
753 fcx: &'a FnCtxt<'a, 'gcx, 'tcx>
756 impl<'a, 'gcx, 'tcx> GatherLocalsVisitor<'a, 'gcx, 'tcx> {
757 fn assign(&mut self, span: Span, nid: ast::NodeId, ty_opt: Option<Ty<'tcx>>) -> Ty<'tcx> {
760 // infer the variable's type
761 let var_ty = self.fcx.next_ty_var(TypeVariableOrigin::TypeInference(span));
762 self.fcx.locals.borrow_mut().insert(nid, var_ty);
766 // take type that the user specified
767 self.fcx.locals.borrow_mut().insert(nid, typ);
774 impl<'a, 'gcx, 'tcx> Visitor<'gcx> for GatherLocalsVisitor<'a, 'gcx, 'tcx> {
775 fn nested_visit_map<'this>(&'this mut self) -> NestedVisitorMap<'this, 'gcx> {
776 NestedVisitorMap::None
779 // Add explicitly-declared locals.
780 fn visit_local(&mut self, local: &'gcx hir::Local) {
781 let o_ty = match local.ty {
782 Some(ref ty) => Some(self.fcx.to_ty(&ty)),
785 self.assign(local.span, local.id, o_ty);
786 debug!("Local variable {:?} is assigned type {}",
788 self.fcx.ty_to_string(
789 self.fcx.locals.borrow().get(&local.id).unwrap().clone()));
790 intravisit::walk_local(self, local);
793 // Add pattern bindings.
794 fn visit_pat(&mut self, p: &'gcx hir::Pat) {
795 if let PatKind::Binding(_, _, ref path1, _) = p.node {
796 let var_ty = self.assign(p.span, p.id, None);
798 self.fcx.require_type_is_sized(var_ty, p.span,
799 traits::VariableType(p.id));
801 debug!("Pattern binding {} is assigned to {} with type {:?}",
803 self.fcx.ty_to_string(
804 self.fcx.locals.borrow().get(&p.id).unwrap().clone()),
807 intravisit::walk_pat(self, p);
810 // Don't descend into the bodies of nested closures
811 fn visit_fn(&mut self, _: intravisit::FnKind<'gcx>, _: &'gcx hir::FnDecl,
812 _: hir::BodyId, _: Span, _: ast::NodeId) { }
815 /// Helper used for fns and closures. Does the grungy work of checking a function
816 /// body and returns the function context used for that purpose, since in the case of a fn item
817 /// there is still a bit more to do.
820 /// * inherited: other fields inherited from the enclosing fn (if any)
821 fn check_fn<'a, 'gcx, 'tcx>(inherited: &'a Inherited<'a, 'gcx, 'tcx>,
822 fn_sig: ty::FnSig<'tcx>,
823 decl: &'gcx hir::FnDecl,
825 body: &'gcx hir::Body)
826 -> FnCtxt<'a, 'gcx, 'tcx>
828 let mut fn_sig = fn_sig.clone();
830 debug!("check_fn(sig={:?}, fn_id={})", fn_sig, fn_id);
832 // Create the function context. This is either derived from scratch or,
833 // in the case of function expressions, based on the outer context.
834 let mut fcx = FnCtxt::new(inherited, body.value.id);
835 *fcx.ps.borrow_mut() = UnsafetyState::function(fn_sig.unsafety, fn_id);
837 let ret_ty = fn_sig.output();
838 fcx.require_type_is_sized(ret_ty, decl.output.span(), traits::ReturnType);
839 let ret_ty = fcx.instantiate_anon_types(&ret_ty);
840 fcx.ret_coercion = Some(RefCell::new(CoerceMany::new(ret_ty)));
841 fn_sig = fcx.tcx.mk_fn_sig(
842 fn_sig.inputs().iter().cloned(),
849 GatherLocalsVisitor { fcx: &fcx, }.visit_body(body);
851 // Add formal parameters.
852 for (arg_ty, arg) in fn_sig.inputs().iter().zip(&body.arguments) {
853 // The type of the argument must be well-formed.
855 // NB -- this is now checked in wfcheck, but that
856 // currently only results in warnings, so we issue an
857 // old-style WF obligation here so that we still get the
858 // errors that we used to get.
859 fcx.register_old_wf_obligation(arg_ty, arg.pat.span, traits::MiscObligation);
861 // Check the pattern.
862 fcx.check_pat_arg(&arg.pat, arg_ty, true);
863 fcx.write_ty(arg.id, arg_ty);
866 inherited.tables.borrow_mut().liberated_fn_sigs.insert(fn_id, fn_sig);
868 fcx.check_return_expr(&body.value);
870 // Finalize the return check by taking the LUB of the return types
871 // we saw and assigning it to the expected return type. This isn't
872 // really expected to fail, since the coercions would have failed
873 // earlier when trying to find a LUB.
875 // However, the behavior around `!` is sort of complex. In the
876 // event that the `actual_return_ty` comes back as `!`, that
877 // indicates that the fn either does not return or "returns" only
878 // values of type `!`. In this case, if there is an expected
879 // return type that is *not* `!`, that should be ok. But if the
880 // return type is being inferred, we want to "fallback" to `!`:
882 // let x = move || panic!();
884 // To allow for that, I am creating a type variable with diverging
885 // fallback. This was deemed ever so slightly better than unifying
886 // the return value with `!` because it allows for the caller to
887 // make more assumptions about the return type (e.g., they could do
889 // let y: Option<u32> = Some(x());
891 // which would then cause this return type to become `u32`, not
893 let coercion = fcx.ret_coercion.take().unwrap().into_inner();
894 let mut actual_return_ty = coercion.complete(&fcx);
895 if actual_return_ty.is_never() {
896 actual_return_ty = fcx.next_diverging_ty_var(
897 TypeVariableOrigin::DivergingFn(body.value.span));
899 fcx.demand_suptype(body.value.span, ret_ty, actual_return_ty);
904 fn check_struct<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
907 let def_id = tcx.hir.local_def_id(id);
908 let def = tcx.lookup_adt_def(def_id);
909 def.destructor(tcx); // force the destructor to be evaluated
910 check_representable(tcx, span, def_id);
913 check_simd(tcx, span, def_id);
917 fn check_union<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
920 let def_id = tcx.hir.local_def_id(id);
921 let def = tcx.lookup_adt_def(def_id);
922 def.destructor(tcx); // force the destructor to be evaluated
923 check_representable(tcx, span, def_id);
926 pub fn check_item_type<'a,'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, it: &'tcx hir::Item) {
927 debug!("check_item_type(it.id={}, it.name={})",
929 tcx.item_path_str(tcx.hir.local_def_id(it.id)));
930 let _indenter = indenter();
932 // Consts can play a role in type-checking, so they are included here.
933 hir::ItemStatic(..) |
934 hir::ItemConst(..) => {
935 tcx.item_tables(tcx.hir.local_def_id(it.id));
937 hir::ItemEnum(ref enum_definition, _) => {
940 &enum_definition.variants,
943 hir::ItemFn(..) => {} // entirely within check_item_body
944 hir::ItemImpl(.., ref impl_item_refs) => {
945 debug!("ItemImpl {} with id {}", it.name, it.id);
946 let impl_def_id = tcx.hir.local_def_id(it.id);
947 if let Some(impl_trait_ref) = tcx.impl_trait_ref(impl_def_id) {
948 check_impl_items_against_trait(tcx,
953 let trait_def_id = impl_trait_ref.def_id;
954 check_on_unimplemented(tcx, trait_def_id, it);
957 hir::ItemTrait(..) => {
958 let def_id = tcx.hir.local_def_id(it.id);
959 check_on_unimplemented(tcx, def_id, it);
961 hir::ItemStruct(..) => {
962 check_struct(tcx, it.id, it.span);
964 hir::ItemUnion(..) => {
965 check_union(tcx, it.id, it.span);
967 hir::ItemTy(_, ref generics) => {
968 let def_id = tcx.hir.local_def_id(it.id);
969 let pty_ty = tcx.item_type(def_id);
970 check_bounds_are_used(tcx, generics, pty_ty);
972 hir::ItemForeignMod(ref m) => {
973 check_abi(tcx, it.span, m.abi);
975 if m.abi == Abi::RustIntrinsic {
976 for item in &m.items {
977 intrinsic::check_intrinsic_type(tcx, item);
979 } else if m.abi == Abi::PlatformIntrinsic {
980 for item in &m.items {
981 intrinsic::check_platform_intrinsic_type(tcx, item);
984 for item in &m.items {
985 let generics = tcx.item_generics(tcx.hir.local_def_id(item.id));
986 if !generics.types.is_empty() {
987 let mut err = struct_span_err!(tcx.sess, item.span, E0044,
988 "foreign items may not have type parameters");
989 span_help!(&mut err, item.span,
990 "consider using specialization instead of \
995 if let hir::ForeignItemFn(ref fn_decl, _, _) = item.node {
996 require_c_abi_if_variadic(tcx, fn_decl, m.abi, item.span);
1001 _ => {/* nothing to do */ }
1005 fn check_on_unimplemented<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1008 let generics = tcx.item_generics(def_id);
1009 if let Some(ref attr) = item.attrs.iter().find(|a| {
1010 a.check_name("rustc_on_unimplemented")
1012 if let Some(istring) = attr.value_str() {
1013 let istring = istring.as_str();
1014 let parser = Parser::new(&istring);
1015 let types = &generics.types;
1016 for token in parser {
1018 Piece::String(_) => (), // Normal string, no need to check it
1019 Piece::NextArgument(a) => match a.position {
1020 // `{Self}` is allowed
1021 Position::ArgumentNamed(s) if s == "Self" => (),
1022 // So is `{A}` if A is a type parameter
1023 Position::ArgumentNamed(s) => match types.iter().find(|t| {
1028 let name = tcx.item_name(def_id);
1029 span_err!(tcx.sess, attr.span, E0230,
1030 "there is no type parameter \
1035 // `{:1}` and `{}` are not to be used
1036 Position::ArgumentIs(_) => {
1037 span_err!(tcx.sess, attr.span, E0231,
1038 "only named substitution \
1039 parameters are allowed");
1046 tcx.sess, attr.span, E0232,
1047 "this attribute must have a value")
1048 .span_label(attr.span, &format!("attribute requires a value"))
1049 .note(&format!("eg `#[rustc_on_unimplemented = \"foo\"]`"))
1055 fn report_forbidden_specialization<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1056 impl_item: &hir::ImplItem,
1059 let mut err = struct_span_err!(
1060 tcx.sess, impl_item.span, E0520,
1061 "`{}` specializes an item from a parent `impl`, but \
1062 that item is not marked `default`",
1064 err.span_label(impl_item.span, &format!("cannot specialize default item `{}`",
1067 match tcx.span_of_impl(parent_impl) {
1069 err.span_label(span, &"parent `impl` is here");
1070 err.note(&format!("to specialize, `{}` in the parent `impl` must be marked `default`",
1074 err.note(&format!("parent implementation is in crate `{}`", cname));
1081 fn check_specialization_validity<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1082 trait_def: &ty::TraitDef,
1084 impl_item: &hir::ImplItem)
1086 let ancestors = trait_def.ancestors(impl_id);
1088 let kind = match impl_item.node {
1089 hir::ImplItemKind::Const(..) => ty::AssociatedKind::Const,
1090 hir::ImplItemKind::Method(..) => ty::AssociatedKind::Method,
1091 hir::ImplItemKind::Type(_) => ty::AssociatedKind::Type
1093 let parent = ancestors.defs(tcx, impl_item.name, kind).skip(1).next()
1094 .map(|node_item| node_item.map(|parent| parent.defaultness));
1096 if let Some(parent) = parent {
1097 if parent.item.is_final() {
1098 report_forbidden_specialization(tcx, impl_item, parent.node.def_id());
1104 fn check_impl_items_against_trait<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1107 impl_trait_ref: ty::TraitRef<'tcx>,
1108 impl_item_refs: &[hir::ImplItemRef]) {
1109 // If the trait reference itself is erroneous (so the compilation is going
1110 // to fail), skip checking the items here -- the `impl_item` table in `tcx`
1111 // isn't populated for such impls.
1112 if impl_trait_ref.references_error() { return; }
1114 // Locate trait definition and items
1115 let trait_def = tcx.lookup_trait_def(impl_trait_ref.def_id);
1116 let mut overridden_associated_type = None;
1118 let impl_items = || impl_item_refs.iter().map(|iiref| tcx.hir.impl_item(iiref.id));
1120 // Check existing impl methods to see if they are both present in trait
1121 // and compatible with trait signature
1122 for impl_item in impl_items() {
1123 let ty_impl_item = tcx.associated_item(tcx.hir.local_def_id(impl_item.id));
1124 let ty_trait_item = tcx.associated_items(impl_trait_ref.def_id)
1125 .find(|ac| ac.name == ty_impl_item.name);
1127 // Check that impl definition matches trait definition
1128 if let Some(ty_trait_item) = ty_trait_item {
1129 match impl_item.node {
1130 hir::ImplItemKind::Const(..) => {
1131 // Find associated const definition.
1132 if ty_trait_item.kind == ty::AssociatedKind::Const {
1133 compare_const_impl(tcx,
1139 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0323,
1140 "item `{}` is an associated const, \
1141 which doesn't match its trait `{}`",
1144 err.span_label(impl_item.span, &format!("does not match trait"));
1145 // We can only get the spans from local trait definition
1146 // Same for E0324 and E0325
1147 if let Some(trait_span) = tcx.hir.span_if_local(ty_trait_item.def_id) {
1148 err.span_label(trait_span, &format!("item in trait"));
1153 hir::ImplItemKind::Method(_, body_id) => {
1154 let trait_span = tcx.hir.span_if_local(ty_trait_item.def_id);
1155 if ty_trait_item.kind == ty::AssociatedKind::Method {
1156 let err_count = tcx.sess.err_count();
1157 compare_impl_method(tcx,
1164 true); // start with old-broken-mode
1165 if err_count == tcx.sess.err_count() {
1166 // old broken mode did not report an error. Try with the new mode.
1167 compare_impl_method(tcx,
1174 false); // use the new mode
1177 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0324,
1178 "item `{}` is an associated method, \
1179 which doesn't match its trait `{}`",
1182 err.span_label(impl_item.span, &format!("does not match trait"));
1183 if let Some(trait_span) = tcx.hir.span_if_local(ty_trait_item.def_id) {
1184 err.span_label(trait_span, &format!("item in trait"));
1189 hir::ImplItemKind::Type(_) => {
1190 if ty_trait_item.kind == ty::AssociatedKind::Type {
1191 if ty_trait_item.defaultness.has_value() {
1192 overridden_associated_type = Some(impl_item);
1195 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0325,
1196 "item `{}` is an associated type, \
1197 which doesn't match its trait `{}`",
1200 err.span_label(impl_item.span, &format!("does not match trait"));
1201 if let Some(trait_span) = tcx.hir.span_if_local(ty_trait_item.def_id) {
1202 err.span_label(trait_span, &format!("item in trait"));
1210 check_specialization_validity(tcx, trait_def, impl_id, impl_item);
1213 // Check for missing items from trait
1214 let mut missing_items = Vec::new();
1215 let mut invalidated_items = Vec::new();
1216 let associated_type_overridden = overridden_associated_type.is_some();
1217 for trait_item in tcx.associated_items(impl_trait_ref.def_id) {
1218 let is_implemented = trait_def.ancestors(impl_id)
1219 .defs(tcx, trait_item.name, trait_item.kind)
1221 .map(|node_item| !node_item.node.is_from_trait())
1224 if !is_implemented {
1225 if !trait_item.defaultness.has_value() {
1226 missing_items.push(trait_item);
1227 } else if associated_type_overridden {
1228 invalidated_items.push(trait_item.name);
1233 let signature = |item: &ty::AssociatedItem| {
1235 ty::AssociatedKind::Method => {
1236 format!("{}", tcx.item_type(item.def_id).fn_sig().0)
1238 ty::AssociatedKind::Type => format!("type {};", item.name.to_string()),
1239 ty::AssociatedKind::Const => {
1240 format!("const {}: {:?};", item.name.to_string(), tcx.item_type(item.def_id))
1245 if !missing_items.is_empty() {
1246 let mut err = struct_span_err!(tcx.sess, impl_span, E0046,
1247 "not all trait items implemented, missing: `{}`",
1248 missing_items.iter()
1249 .map(|trait_item| trait_item.name.to_string())
1250 .collect::<Vec<_>>().join("`, `"));
1251 err.span_label(impl_span, &format!("missing `{}` in implementation",
1252 missing_items.iter()
1253 .map(|trait_item| trait_item.name.to_string())
1254 .collect::<Vec<_>>().join("`, `")));
1255 for trait_item in missing_items {
1256 if let Some(span) = tcx.hir.span_if_local(trait_item.def_id) {
1257 err.span_label(span, &format!("`{}` from trait", trait_item.name));
1259 err.note(&format!("`{}` from trait: `{}`",
1261 signature(&trait_item)));
1267 if !invalidated_items.is_empty() {
1268 let invalidator = overridden_associated_type.unwrap();
1269 span_err!(tcx.sess, invalidator.span, E0399,
1270 "the following trait items need to be reimplemented \
1271 as `{}` was overridden: `{}`",
1273 invalidated_items.iter()
1274 .map(|name| name.to_string())
1275 .collect::<Vec<_>>().join("`, `"))
1279 /// Checks whether a type can be represented in memory. In particular, it
1280 /// identifies types that contain themselves without indirection through a
1281 /// pointer, which would mean their size is unbounded.
1282 fn check_representable<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1286 let rty = tcx.item_type(item_def_id);
1288 // Check that it is possible to represent this type. This call identifies
1289 // (1) types that contain themselves and (2) types that contain a different
1290 // recursive type. It is only necessary to throw an error on those that
1291 // contain themselves. For case 2, there must be an inner type that will be
1292 // caught by case 1.
1293 match rty.is_representable(tcx, sp) {
1294 Representability::SelfRecursive => {
1295 tcx.recursive_type_with_infinite_size_error(item_def_id).emit();
1298 Representability::Representable | Representability::ContainsRecursive => (),
1303 pub fn check_simd<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, sp: Span, def_id: DefId) {
1304 let t = tcx.item_type(def_id);
1306 ty::TyAdt(def, substs) if def.is_struct() => {
1307 let fields = &def.struct_variant().fields;
1308 if fields.is_empty() {
1309 span_err!(tcx.sess, sp, E0075, "SIMD vector cannot be empty");
1312 let e = fields[0].ty(tcx, substs);
1313 if !fields.iter().all(|f| f.ty(tcx, substs) == e) {
1314 struct_span_err!(tcx.sess, sp, E0076, "SIMD vector should be homogeneous")
1315 .span_label(sp, &format!("SIMD elements must have the same type"))
1320 ty::TyParam(_) => { /* struct<T>(T, T, T, T) is ok */ }
1321 _ if e.is_machine() => { /* struct(u8, u8, u8, u8) is ok */ }
1323 span_err!(tcx.sess, sp, E0077,
1324 "SIMD vector element type should be machine type");
1333 #[allow(trivial_numeric_casts)]
1334 pub fn check_enum<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1336 vs: &'tcx [hir::Variant],
1338 let def_id = tcx.hir.local_def_id(id);
1339 let def = tcx.lookup_adt_def(def_id);
1340 def.destructor(tcx); // force the destructor to be evaluated
1342 if vs.is_empty() && tcx.has_attr(def_id, "repr") {
1344 tcx.sess, sp, E0084,
1345 "unsupported representation for zero-variant enum")
1346 .span_label(sp, &format!("unsupported enum representation"))
1350 let repr_type_ty = def.repr.discr_type().to_ty(tcx);
1351 if repr_type_ty == tcx.types.i128 || repr_type_ty == tcx.types.u128 {
1352 if !tcx.sess.features.borrow().i128_type {
1353 emit_feature_err(&tcx.sess.parse_sess,
1354 "i128_type", sp, GateIssue::Language, "128-bit type is unstable");
1359 if let Some(e) = v.node.disr_expr {
1360 tcx.item_tables(tcx.hir.local_def_id(e.node_id));
1364 let mut disr_vals: Vec<ConstInt> = Vec::new();
1365 for (discr, v) in def.discriminants(tcx).zip(vs) {
1366 // Check for duplicate discriminant values
1367 if let Some(i) = disr_vals.iter().position(|&x| x == discr) {
1368 let variant_i_node_id = tcx.hir.as_local_node_id(def.variants[i].did).unwrap();
1369 let variant_i = tcx.hir.expect_variant(variant_i_node_id);
1370 let i_span = match variant_i.node.disr_expr {
1371 Some(expr) => tcx.hir.span(expr.node_id),
1372 None => tcx.hir.span(variant_i_node_id)
1374 let span = match v.node.disr_expr {
1375 Some(expr) => tcx.hir.span(expr.node_id),
1378 struct_span_err!(tcx.sess, span, E0081,
1379 "discriminant value `{}` already exists", disr_vals[i])
1380 .span_label(i_span, &format!("first use of `{}`", disr_vals[i]))
1381 .span_label(span , &format!("enum already has `{}`", disr_vals[i]))
1384 disr_vals.push(discr);
1387 check_representable(tcx, sp, def_id);
1390 impl<'a, 'gcx, 'tcx> AstConv<'gcx, 'tcx> for FnCtxt<'a, 'gcx, 'tcx> {
1391 fn tcx<'b>(&'b self) -> TyCtxt<'b, 'gcx, 'tcx> { self.tcx }
1393 fn ast_ty_to_ty_cache(&self) -> &RefCell<NodeMap<Ty<'tcx>>> {
1394 &self.ast_ty_to_ty_cache
1397 fn get_free_substs(&self) -> Option<&Substs<'tcx>> {
1398 Some(&self.parameter_environment.free_substs)
1401 fn get_type_parameter_bounds(&self, _: Span, def_id: DefId)
1402 -> ty::GenericPredicates<'tcx>
1405 let node_id = tcx.hir.as_local_node_id(def_id).unwrap();
1406 let item_id = tcx.hir.ty_param_owner(node_id);
1407 let item_def_id = tcx.hir.local_def_id(item_id);
1408 let generics = tcx.item_generics(item_def_id);
1409 let index = generics.type_param_to_index[&def_id.index];
1410 ty::GenericPredicates {
1412 predicates: self.parameter_environment.caller_bounds.iter().filter(|predicate| {
1414 ty::Predicate::Trait(ref data) => {
1415 data.0.self_ty().is_param(index)
1419 }).cloned().collect()
1423 fn re_infer(&self, span: Span, def: Option<&ty::RegionParameterDef>)
1424 -> Option<&'tcx ty::Region> {
1426 Some(def) => infer::EarlyBoundRegion(span, def.name, def.issue_32330),
1427 None => infer::MiscVariable(span)
1429 Some(self.next_region_var(v))
1432 fn ty_infer(&self, span: Span) -> Ty<'tcx> {
1433 self.next_ty_var(TypeVariableOrigin::TypeInference(span))
1436 fn ty_infer_for_def(&self,
1437 ty_param_def: &ty::TypeParameterDef,
1438 substs: &[Kind<'tcx>],
1439 span: Span) -> Ty<'tcx> {
1440 self.type_var_for_def(span, ty_param_def, substs)
1443 fn projected_ty_from_poly_trait_ref(&self,
1445 poly_trait_ref: ty::PolyTraitRef<'tcx>,
1446 item_name: ast::Name)
1449 let (trait_ref, _) =
1450 self.replace_late_bound_regions_with_fresh_var(
1452 infer::LateBoundRegionConversionTime::AssocTypeProjection(item_name),
1455 self.tcx().mk_projection(trait_ref, item_name)
1458 fn normalize_ty(&self, span: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
1459 if ty.has_escaping_regions() {
1460 ty // FIXME: normalization and escaping regions
1462 self.normalize_associated_types_in(span, &ty)
1466 fn set_tainted_by_errors(&self) {
1467 self.infcx.set_tainted_by_errors()
1471 /// Controls whether the arguments are tupled. This is used for the call
1474 /// Tupling means that all call-side arguments are packed into a tuple and
1475 /// passed as a single parameter. For example, if tupling is enabled, this
1478 /// fn f(x: (isize, isize))
1480 /// Can be called as:
1487 #[derive(Clone, Eq, PartialEq)]
1488 enum TupleArgumentsFlag {
1493 impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
1494 pub fn new(inh: &'a Inherited<'a, 'gcx, 'tcx>,
1495 body_id: ast::NodeId)
1496 -> FnCtxt<'a, 'gcx, 'tcx> {
1498 ast_ty_to_ty_cache: RefCell::new(NodeMap()),
1500 err_count_on_creation: inh.tcx.sess.err_count(),
1502 ps: RefCell::new(UnsafetyState::function(hir::Unsafety::Normal,
1503 ast::CRATE_NODE_ID)),
1504 diverges: Cell::new(Diverges::Maybe),
1505 has_errors: Cell::new(false),
1506 enclosing_breakables: RefCell::new(EnclosingBreakables {
1514 pub fn sess(&self) -> &Session {
1518 pub fn err_count_since_creation(&self) -> usize {
1519 self.tcx.sess.err_count() - self.err_count_on_creation
1522 /// Produce warning on the given node, if the current point in the
1523 /// function is unreachable, and there hasn't been another warning.
1524 fn warn_if_unreachable(&self, id: ast::NodeId, span: Span, kind: &str) {
1525 if self.diverges.get() == Diverges::Always {
1526 self.diverges.set(Diverges::WarnedAlways);
1528 debug!("warn_if_unreachable: id={:?} span={:?} kind={}", id, span, kind);
1530 self.tables.borrow_mut().lints.add_lint(
1531 lint::builtin::UNREACHABLE_CODE,
1533 format!("unreachable {}", kind));
1539 code: ObligationCauseCode<'tcx>)
1540 -> ObligationCause<'tcx> {
1541 ObligationCause::new(span, self.body_id, code)
1544 pub fn misc(&self, span: Span) -> ObligationCause<'tcx> {
1545 self.cause(span, ObligationCauseCode::MiscObligation)
1548 /// Resolves type variables in `ty` if possible. Unlike the infcx
1549 /// version (resolve_type_vars_if_possible), this version will
1550 /// also select obligations if it seems useful, in an effort
1551 /// to get more type information.
1552 fn resolve_type_vars_with_obligations(&self, mut ty: Ty<'tcx>) -> Ty<'tcx> {
1553 debug!("resolve_type_vars_with_obligations(ty={:?})", ty);
1555 // No TyInfer()? Nothing needs doing.
1556 if !ty.has_infer_types() {
1557 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
1561 // If `ty` is a type variable, see whether we already know what it is.
1562 ty = self.resolve_type_vars_if_possible(&ty);
1563 if !ty.has_infer_types() {
1564 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
1568 // If not, try resolving pending obligations as much as
1569 // possible. This can help substantially when there are
1570 // indirect dependencies that don't seem worth tracking
1572 self.select_obligations_where_possible();
1573 ty = self.resolve_type_vars_if_possible(&ty);
1575 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
1579 fn record_deferred_call_resolution(&self,
1580 closure_def_id: DefId,
1581 r: DeferredCallResolutionHandler<'gcx, 'tcx>) {
1582 let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
1583 deferred_call_resolutions.entry(closure_def_id).or_insert(vec![]).push(r);
1586 fn remove_deferred_call_resolutions(&self,
1587 closure_def_id: DefId)
1588 -> Vec<DeferredCallResolutionHandler<'gcx, 'tcx>>
1590 let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
1591 deferred_call_resolutions.remove(&closure_def_id).unwrap_or(Vec::new())
1594 pub fn tag(&self) -> String {
1595 let self_ptr: *const FnCtxt = self;
1596 format!("{:?}", self_ptr)
1599 pub fn local_ty(&self, span: Span, nid: ast::NodeId) -> Ty<'tcx> {
1600 match self.locals.borrow().get(&nid) {
1603 span_bug!(span, "no type for local variable {}",
1604 self.tcx.hir.node_to_string(nid));
1610 pub fn write_ty(&self, node_id: ast::NodeId, ty: Ty<'tcx>) {
1611 debug!("write_ty({}, {:?}) in fcx {}",
1612 node_id, self.resolve_type_vars_if_possible(&ty), self.tag());
1613 self.tables.borrow_mut().node_types.insert(node_id, ty);
1615 if ty.references_error() {
1616 self.has_errors.set(true);
1617 self.set_tainted_by_errors();
1621 pub fn write_substs(&self, node_id: ast::NodeId, substs: ty::ItemSubsts<'tcx>) {
1622 if !substs.substs.is_noop() {
1623 debug!("write_substs({}, {:?}) in fcx {}",
1628 self.tables.borrow_mut().item_substs.insert(node_id, substs);
1632 pub fn write_autoderef_adjustment(&self,
1633 node_id: ast::NodeId,
1635 adjusted_ty: Ty<'tcx>) {
1636 self.write_adjustment(node_id, adjustment::Adjustment {
1637 kind: adjustment::Adjust::DerefRef {
1646 pub fn write_adjustment(&self,
1647 node_id: ast::NodeId,
1648 adj: adjustment::Adjustment<'tcx>) {
1649 debug!("write_adjustment(node_id={}, adj={:?})", node_id, adj);
1651 if adj.is_identity() {
1655 self.tables.borrow_mut().adjustments.insert(node_id, adj);
1658 /// Basically whenever we are converting from a type scheme into
1659 /// the fn body space, we always want to normalize associated
1660 /// types as well. This function combines the two.
1661 fn instantiate_type_scheme<T>(&self,
1663 substs: &Substs<'tcx>,
1666 where T : TypeFoldable<'tcx>
1668 let value = value.subst(self.tcx, substs);
1669 let result = self.normalize_associated_types_in(span, &value);
1670 debug!("instantiate_type_scheme(value={:?}, substs={:?}) = {:?}",
1677 /// As `instantiate_type_scheme`, but for the bounds found in a
1678 /// generic type scheme.
1679 fn instantiate_bounds(&self, span: Span, def_id: DefId, substs: &Substs<'tcx>)
1680 -> ty::InstantiatedPredicates<'tcx> {
1681 let bounds = self.tcx.item_predicates(def_id);
1682 let result = bounds.instantiate(self.tcx, substs);
1683 let result = self.normalize_associated_types_in(span, &result.predicates);
1684 debug!("instantiate_bounds(bounds={:?}, substs={:?}) = {:?}",
1688 ty::InstantiatedPredicates {
1693 /// Replace all anonymized types with fresh inference variables
1694 /// and record them for writeback.
1695 fn instantiate_anon_types<T: TypeFoldable<'tcx>>(&self, value: &T) -> T {
1696 value.fold_with(&mut BottomUpFolder { tcx: self.tcx, fldop: |ty| {
1697 if let ty::TyAnon(def_id, substs) = ty.sty {
1698 // Use the same type variable if the exact same TyAnon appears more
1699 // than once in the return type (e.g. if it's pased to a type alias).
1700 let id = self.tcx.hir.as_local_node_id(def_id).unwrap();
1701 if let Some(ty_var) = self.anon_types.borrow().get(&id) {
1704 let span = self.tcx.def_span(def_id);
1705 let ty_var = self.next_ty_var(TypeVariableOrigin::TypeInference(span));
1706 self.anon_types.borrow_mut().insert(id, ty_var);
1708 let item_predicates = self.tcx.item_predicates(def_id);
1709 let bounds = item_predicates.instantiate(self.tcx, substs);
1711 for predicate in bounds.predicates {
1712 // Change the predicate to refer to the type variable,
1713 // which will be the concrete type, instead of the TyAnon.
1714 // This also instantiates nested `impl Trait`.
1715 let predicate = self.instantiate_anon_types(&predicate);
1717 // Require that the predicate holds for the concrete type.
1718 let cause = traits::ObligationCause::new(span, self.body_id,
1719 traits::ReturnType);
1720 self.register_predicate(traits::Obligation::new(cause, predicate));
1730 fn normalize_associated_types_in<T>(&self, span: Span, value: &T) -> T
1731 where T : TypeFoldable<'tcx>
1733 self.inh.normalize_associated_types_in(span, self.body_id, value)
1736 pub fn write_nil(&self, node_id: ast::NodeId) {
1737 self.write_ty(node_id, self.tcx.mk_nil());
1740 pub fn write_error(&self, node_id: ast::NodeId) {
1741 self.write_ty(node_id, self.tcx.types.err);
1744 pub fn require_type_meets(&self,
1747 code: traits::ObligationCauseCode<'tcx>,
1750 self.register_bound(
1753 traits::ObligationCause::new(span, self.body_id, code));
1756 pub fn require_type_is_sized(&self,
1759 code: traits::ObligationCauseCode<'tcx>)
1761 let lang_item = self.tcx.require_lang_item(lang_items::SizedTraitLangItem);
1762 self.require_type_meets(ty, span, code, lang_item);
1765 pub fn register_bound(&self,
1768 cause: traits::ObligationCause<'tcx>)
1770 self.fulfillment_cx.borrow_mut()
1771 .register_bound(self, ty, def_id, cause);
1774 pub fn register_predicate(&self,
1775 obligation: traits::PredicateObligation<'tcx>)
1777 debug!("register_predicate({:?})", obligation);
1778 if obligation.has_escaping_regions() {
1779 span_bug!(obligation.cause.span, "escaping regions in predicate {:?}",
1784 .register_predicate_obligation(self, obligation);
1787 pub fn register_predicates(&self,
1788 obligations: Vec<traits::PredicateObligation<'tcx>>)
1790 for obligation in obligations {
1791 self.register_predicate(obligation);
1795 pub fn register_infer_ok_obligations<T>(&self, infer_ok: InferOk<'tcx, T>) -> T {
1796 self.register_predicates(infer_ok.obligations);
1800 pub fn to_ty(&self, ast_t: &hir::Ty) -> Ty<'tcx> {
1801 let t = AstConv::ast_ty_to_ty(self, ast_t);
1802 self.register_wf_obligation(t, ast_t.span, traits::MiscObligation);
1806 pub fn node_ty(&self, id: ast::NodeId) -> Ty<'tcx> {
1807 match self.tables.borrow().node_types.get(&id) {
1809 None if self.err_count_since_creation() != 0 => self.tcx.types.err,
1811 bug!("no type for node {}: {} in fcx {}",
1812 id, self.tcx.hir.node_to_string(id),
1818 pub fn opt_node_ty_substs<F>(&self,
1821 F: FnOnce(&ty::ItemSubsts<'tcx>),
1823 if let Some(s) = self.tables.borrow().item_substs.get(&id) {
1828 /// Registers an obligation for checking later, during regionck, that the type `ty` must
1829 /// outlive the region `r`.
1830 pub fn register_region_obligation(&self,
1832 region: &'tcx ty::Region,
1833 cause: traits::ObligationCause<'tcx>)
1835 let mut fulfillment_cx = self.fulfillment_cx.borrow_mut();
1836 fulfillment_cx.register_region_obligation(ty, region, cause);
1839 /// Registers an obligation for checking later, during regionck, that the type `ty` must
1840 /// outlive the region `r`.
1841 pub fn register_wf_obligation(&self,
1844 code: traits::ObligationCauseCode<'tcx>)
1846 // WF obligations never themselves fail, so no real need to give a detailed cause:
1847 let cause = traits::ObligationCause::new(span, self.body_id, code);
1848 self.register_predicate(traits::Obligation::new(cause, ty::Predicate::WellFormed(ty)));
1851 pub fn register_old_wf_obligation(&self,
1854 code: traits::ObligationCauseCode<'tcx>)
1856 // Registers an "old-style" WF obligation that uses the
1857 // implicator code. This is basically a buggy version of
1858 // `register_wf_obligation` that is being kept around
1859 // temporarily just to help with phasing in the newer rules.
1861 // FIXME(#27579) all uses of this should be migrated to register_wf_obligation eventually
1862 let cause = traits::ObligationCause::new(span, self.body_id, code);
1863 self.register_region_obligation(ty, self.tcx.mk_region(ty::ReEmpty), cause);
1866 /// Registers obligations that all types appearing in `substs` are well-formed.
1867 pub fn add_wf_bounds(&self, substs: &Substs<'tcx>, expr: &hir::Expr)
1869 for ty in substs.types() {
1870 self.register_wf_obligation(ty, expr.span, traits::MiscObligation);
1874 /// Given a fully substituted set of bounds (`generic_bounds`), and the values with which each
1875 /// type/region parameter was instantiated (`substs`), creates and registers suitable
1876 /// trait/region obligations.
1878 /// For example, if there is a function:
1881 /// fn foo<'a,T:'a>(...)
1884 /// and a reference:
1890 /// Then we will create a fresh region variable `'$0` and a fresh type variable `$1` for `'a`
1891 /// and `T`. This routine will add a region obligation `$1:'$0` and register it locally.
1892 pub fn add_obligations_for_parameters(&self,
1893 cause: traits::ObligationCause<'tcx>,
1894 predicates: &ty::InstantiatedPredicates<'tcx>)
1896 assert!(!predicates.has_escaping_regions());
1898 debug!("add_obligations_for_parameters(predicates={:?})",
1901 for obligation in traits::predicates_for_generics(cause, predicates) {
1902 self.register_predicate(obligation);
1906 // FIXME(arielb1): use this instead of field.ty everywhere
1907 // Only for fields! Returns <none> for methods>
1908 // Indifferent to privacy flags
1909 pub fn field_ty(&self,
1911 field: &'tcx ty::FieldDef,
1912 substs: &Substs<'tcx>)
1915 self.normalize_associated_types_in(span,
1916 &field.ty(self.tcx, substs))
1919 fn check_casts(&self) {
1920 let mut deferred_cast_checks = self.deferred_cast_checks.borrow_mut();
1921 for cast in deferred_cast_checks.drain(..) {
1926 /// Apply "fallbacks" to some types
1927 /// unconstrained types get replaced with ! or () (depending on whether
1928 /// feature(never_type) is enabled), unconstrained ints with i32, and
1929 /// unconstrained floats with f64.
1930 fn default_type_parameters(&self) {
1931 use rustc::ty::error::UnconstrainedNumeric::Neither;
1932 use rustc::ty::error::UnconstrainedNumeric::{UnconstrainedInt, UnconstrainedFloat};
1934 // Defaulting inference variables becomes very dubious if we have
1935 // encountered type-checking errors. Therefore, if we think we saw
1936 // some errors in this function, just resolve all uninstanted type
1937 // varibles to TyError.
1938 if self.is_tainted_by_errors() {
1939 for ty in &self.unsolved_variables() {
1940 if let ty::TyInfer(_) = self.shallow_resolve(ty).sty {
1941 debug!("default_type_parameters: defaulting `{:?}` to error", ty);
1942 self.demand_eqtype(syntax_pos::DUMMY_SP, *ty, self.tcx().types.err);
1948 for ty in &self.unsolved_variables() {
1949 let resolved = self.resolve_type_vars_if_possible(ty);
1950 if self.type_var_diverges(resolved) {
1951 debug!("default_type_parameters: defaulting `{:?}` to `!` because it diverges",
1953 self.demand_eqtype(syntax_pos::DUMMY_SP, *ty,
1954 self.tcx.mk_diverging_default());
1956 match self.type_is_unconstrained_numeric(resolved) {
1957 UnconstrainedInt => {
1958 debug!("default_type_parameters: defaulting `{:?}` to `i32`",
1960 self.demand_eqtype(syntax_pos::DUMMY_SP, *ty, self.tcx.types.i32)
1962 UnconstrainedFloat => {
1963 debug!("default_type_parameters: defaulting `{:?}` to `f32`",
1965 self.demand_eqtype(syntax_pos::DUMMY_SP, *ty, self.tcx.types.f64)
1973 fn select_all_obligations_and_apply_defaults(&self) {
1974 if self.tcx.sess.features.borrow().default_type_parameter_fallback {
1975 self.new_select_all_obligations_and_apply_defaults();
1977 self.old_select_all_obligations_and_apply_defaults();
1981 // Implements old type inference fallback algorithm
1982 fn old_select_all_obligations_and_apply_defaults(&self) {
1983 self.select_obligations_where_possible();
1984 self.default_type_parameters();
1985 self.select_obligations_where_possible();
1988 fn new_select_all_obligations_and_apply_defaults(&self) {
1989 use rustc::ty::error::UnconstrainedNumeric::Neither;
1990 use rustc::ty::error::UnconstrainedNumeric::{UnconstrainedInt, UnconstrainedFloat};
1992 // For the time being this errs on the side of being memory wasteful but provides better
1994 // let type_variables = self.type_variables.clone();
1996 // There is a possibility that this algorithm will have to run an arbitrary number of times
1997 // to terminate so we bound it by the compiler's recursion limit.
1998 for _ in 0..self.tcx.sess.recursion_limit.get() {
1999 // First we try to solve all obligations, it is possible that the last iteration
2000 // has made it possible to make more progress.
2001 self.select_obligations_where_possible();
2003 let mut conflicts = Vec::new();
2005 // Collect all unsolved type, integral and floating point variables.
2006 let unsolved_variables = self.unsolved_variables();
2008 // We must collect the defaults *before* we do any unification. Because we have
2009 // directly attached defaults to the type variables any unification that occurs
2010 // will erase defaults causing conflicting defaults to be completely ignored.
2011 let default_map: FxHashMap<Ty<'tcx>, _> =
2014 .filter_map(|t| self.default(t).map(|d| (*t, d)))
2017 let mut unbound_tyvars = FxHashSet();
2019 debug!("select_all_obligations_and_apply_defaults: defaults={:?}", default_map);
2021 // We loop over the unsolved variables, resolving them and if they are
2022 // and unconstrainted numeric type we add them to the set of unbound
2023 // variables. We do this so we only apply literal fallback to type
2024 // variables without defaults.
2025 for ty in &unsolved_variables {
2026 let resolved = self.resolve_type_vars_if_possible(ty);
2027 if self.type_var_diverges(resolved) {
2028 self.demand_eqtype(syntax_pos::DUMMY_SP, *ty,
2029 self.tcx.mk_diverging_default());
2031 match self.type_is_unconstrained_numeric(resolved) {
2032 UnconstrainedInt | UnconstrainedFloat => {
2033 unbound_tyvars.insert(resolved);
2040 // We now remove any numeric types that also have defaults, and instead insert
2041 // the type variable with a defined fallback.
2042 for ty in &unsolved_variables {
2043 if let Some(_default) = default_map.get(ty) {
2044 let resolved = self.resolve_type_vars_if_possible(ty);
2046 debug!("select_all_obligations_and_apply_defaults: \
2047 ty: {:?} with default: {:?}",
2050 match resolved.sty {
2051 ty::TyInfer(ty::TyVar(_)) => {
2052 unbound_tyvars.insert(ty);
2055 ty::TyInfer(ty::IntVar(_)) | ty::TyInfer(ty::FloatVar(_)) => {
2056 unbound_tyvars.insert(ty);
2057 if unbound_tyvars.contains(resolved) {
2058 unbound_tyvars.remove(resolved);
2067 // If there are no more fallbacks to apply at this point we have applied all possible
2068 // defaults and type inference will proceed as normal.
2069 if unbound_tyvars.is_empty() {
2073 // Finally we go through each of the unbound type variables and unify them with
2074 // the proper fallback, reporting a conflicting default error if any of the
2075 // unifications fail. We know it must be a conflicting default because the
2076 // variable would only be in `unbound_tyvars` and have a concrete value if
2077 // it had been solved by previously applying a default.
2079 // We wrap this in a transaction for error reporting, if we detect a conflict
2080 // we will rollback the inference context to its prior state so we can probe
2081 // for conflicts and correctly report them.
2083 let _ = self.commit_if_ok(|_: &infer::CombinedSnapshot| {
2085 self.apply_defaults_and_return_conflicts(&unbound_tyvars, &default_map, None)
2088 // If there are conflicts we rollback, otherwise commit
2089 if conflicts.len() > 0 {
2096 // Loop through each conflicting default, figuring out the default that caused
2097 // a unification failure and then report an error for each.
2098 for (conflict, default) in conflicts {
2099 let conflicting_default =
2100 self.apply_defaults_and_return_conflicts(
2107 .unwrap_or(type_variable::Default {
2108 ty: self.next_ty_var(
2109 TypeVariableOrigin::MiscVariable(syntax_pos::DUMMY_SP)),
2110 origin_span: syntax_pos::DUMMY_SP,
2111 // what do I put here?
2112 def_id: self.tcx.hir.local_def_id(ast::CRATE_NODE_ID)
2115 // This is to ensure that we elimnate any non-determinism from the error
2116 // reporting by fixing an order, it doesn't matter what order we choose
2117 // just that it is consistent.
2118 let (first_default, second_default) =
2119 if default.def_id < conflicting_default.def_id {
2120 (default, conflicting_default)
2122 (conflicting_default, default)
2126 self.report_conflicting_default_types(
2127 first_default.origin_span,
2134 self.select_obligations_where_possible();
2137 // For use in error handling related to default type parameter fallback. We explicitly
2138 // apply the default that caused conflict first to a local version of the type variable
2139 // table then apply defaults until we find a conflict. That default must be the one
2140 // that caused conflict earlier.
2141 fn apply_defaults_and_return_conflicts<'b>(
2143 unbound_vars: &'b FxHashSet<Ty<'tcx>>,
2144 default_map: &'b FxHashMap<Ty<'tcx>, type_variable::Default<'tcx>>,
2145 conflict: Option<Ty<'tcx>>,
2146 ) -> impl Iterator<Item=(Ty<'tcx>, type_variable::Default<'tcx>)> + 'b {
2147 use rustc::ty::error::UnconstrainedNumeric::Neither;
2148 use rustc::ty::error::UnconstrainedNumeric::{UnconstrainedInt, UnconstrainedFloat};
2150 conflict.into_iter().chain(unbound_vars.iter().cloned()).flat_map(move |ty| {
2151 if self.type_var_diverges(ty) {
2152 self.demand_eqtype(syntax_pos::DUMMY_SP, ty,
2153 self.tcx.mk_diverging_default());
2155 match self.type_is_unconstrained_numeric(ty) {
2156 UnconstrainedInt => {
2157 self.demand_eqtype(syntax_pos::DUMMY_SP, ty, self.tcx.types.i32)
2159 UnconstrainedFloat => {
2160 self.demand_eqtype(syntax_pos::DUMMY_SP, ty, self.tcx.types.f64)
2163 if let Some(default) = default_map.get(ty) {
2164 let default = default.clone();
2165 let default_ty = self.normalize_associated_types_in(
2166 default.origin_span, &default.ty);
2167 match self.eq_types(false,
2168 &self.misc(default.origin_span),
2171 Ok(ok) => self.register_infer_ok_obligations(ok),
2173 return Some((ty, default));
2185 fn select_all_obligations_or_error(&self) {
2186 debug!("select_all_obligations_or_error");
2188 // upvar inference should have ensured that all deferred call
2189 // resolutions are handled by now.
2190 assert!(self.deferred_call_resolutions.borrow().is_empty());
2192 self.select_all_obligations_and_apply_defaults();
2194 let mut fulfillment_cx = self.fulfillment_cx.borrow_mut();
2196 match fulfillment_cx.select_all_or_error(self) {
2198 Err(errors) => { self.report_fulfillment_errors(&errors); }
2202 /// Select as many obligations as we can at present.
2203 fn select_obligations_where_possible(&self) {
2204 match self.fulfillment_cx.borrow_mut().select_where_possible(self) {
2206 Err(errors) => { self.report_fulfillment_errors(&errors); }
2210 /// For the overloaded lvalue expressions (`*x`, `x[3]`), the trait
2211 /// returns a type of `&T`, but the actual type we assign to the
2212 /// *expression* is `T`. So this function just peels off the return
2213 /// type by one layer to yield `T`.
2214 fn make_overloaded_lvalue_return_type(&self,
2215 method: MethodCallee<'tcx>)
2216 -> ty::TypeAndMut<'tcx>
2218 // extract method return type, which will be &T;
2219 // all LB regions should have been instantiated during method lookup
2220 let ret_ty = method.ty.fn_ret();
2221 let ret_ty = self.tcx.no_late_bound_regions(&ret_ty).unwrap();
2223 // method returns &T, but the type as visible to user is T, so deref
2224 ret_ty.builtin_deref(true, NoPreference).unwrap()
2227 fn lookup_indexing(&self,
2229 base_expr: &'gcx hir::Expr,
2232 lvalue_pref: LvaluePreference)
2233 -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)>
2235 // FIXME(#18741) -- this is almost but not quite the same as the
2236 // autoderef that normal method probing does. They could likely be
2239 let mut autoderef = self.autoderef(base_expr.span, base_ty);
2241 while let Some((adj_ty, autoderefs)) = autoderef.next() {
2242 if let Some(final_mt) = self.try_index_step(
2243 MethodCall::expr(expr.id),
2244 expr, base_expr, adj_ty, autoderefs,
2245 false, lvalue_pref, idx_ty)
2247 autoderef.finalize(lvalue_pref, &[base_expr]);
2248 return Some(final_mt);
2251 if let ty::TyArray(element_ty, _) = adj_ty.sty {
2252 autoderef.finalize(lvalue_pref, &[base_expr]);
2253 let adjusted_ty = self.tcx.mk_slice(element_ty);
2254 return self.try_index_step(
2255 MethodCall::expr(expr.id), expr, base_expr,
2256 adjusted_ty, autoderefs, true, lvalue_pref, idx_ty);
2259 autoderef.unambiguous_final_ty();
2263 /// To type-check `base_expr[index_expr]`, we progressively autoderef
2264 /// (and otherwise adjust) `base_expr`, looking for a type which either
2265 /// supports builtin indexing or overloaded indexing.
2266 /// This loop implements one step in that search; the autoderef loop
2267 /// is implemented by `lookup_indexing`.
2268 fn try_index_step(&self,
2269 method_call: MethodCall,
2271 base_expr: &'gcx hir::Expr,
2272 adjusted_ty: Ty<'tcx>,
2275 lvalue_pref: LvaluePreference,
2277 -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)>
2280 debug!("try_index_step(expr={:?}, base_expr.id={:?}, adjusted_ty={:?}, \
2281 autoderefs={}, unsize={}, index_ty={:?})",
2289 let input_ty = self.next_ty_var(TypeVariableOrigin::AutoDeref(base_expr.span));
2291 // First, try built-in indexing.
2292 match (adjusted_ty.builtin_index(), &index_ty.sty) {
2293 (Some(ty), &ty::TyUint(ast::UintTy::Us)) | (Some(ty), &ty::TyInfer(ty::IntVar(_))) => {
2294 debug!("try_index_step: success, using built-in indexing");
2295 // If we had `[T; N]`, we should've caught it before unsizing to `[T]`.
2297 self.write_autoderef_adjustment(base_expr.id, autoderefs, adjusted_ty);
2298 return Some((tcx.types.usize, ty));
2303 // Try `IndexMut` first, if preferred.
2304 let method = match (lvalue_pref, tcx.lang_items.index_mut_trait()) {
2305 (PreferMutLvalue, Some(trait_did)) => {
2306 self.lookup_method_in_trait_adjusted(expr.span,
2308 Symbol::intern("index_mut"),
2313 Some(vec![input_ty]))
2318 // Otherwise, fall back to `Index`.
2319 let method = match (method, tcx.lang_items.index_trait()) {
2320 (None, Some(trait_did)) => {
2321 self.lookup_method_in_trait_adjusted(expr.span,
2323 Symbol::intern("index"),
2328 Some(vec![input_ty]))
2330 (method, _) => method,
2333 // If some lookup succeeds, write callee into table and extract index/element
2334 // type from the method signature.
2335 // If some lookup succeeded, install method in table
2336 method.map(|method| {
2337 debug!("try_index_step: success, using overloaded indexing");
2338 self.tables.borrow_mut().method_map.insert(method_call, method);
2339 (input_ty, self.make_overloaded_lvalue_return_type(method).ty)
2343 fn check_method_argument_types(&self,
2345 method_fn_ty: Ty<'tcx>,
2346 callee_expr: &'gcx hir::Expr,
2347 args_no_rcvr: &'gcx [hir::Expr],
2348 tuple_arguments: TupleArgumentsFlag,
2349 expected: Expectation<'tcx>)
2351 if method_fn_ty.references_error() {
2352 let err_inputs = self.err_args(args_no_rcvr.len());
2354 let err_inputs = match tuple_arguments {
2355 DontTupleArguments => err_inputs,
2356 TupleArguments => vec![self.tcx.intern_tup(&err_inputs[..], false)],
2359 self.check_argument_types(sp, &err_inputs[..], &[], args_no_rcvr,
2360 false, tuple_arguments, None);
2363 match method_fn_ty.sty {
2364 ty::TyFnDef(def_id, .., ref fty) => {
2365 // HACK(eddyb) ignore self in the definition (see above).
2366 let expected_arg_tys = self.expected_inputs_for_expected_output(
2370 &fty.0.inputs()[1..]
2372 self.check_argument_types(sp, &fty.0.inputs()[1..], &expected_arg_tys[..],
2373 args_no_rcvr, fty.0.variadic, tuple_arguments,
2374 self.tcx.hir.span_if_local(def_id));
2378 span_bug!(callee_expr.span, "method without bare fn type");
2384 /// Generic function that factors out common logic from function calls,
2385 /// method calls and overloaded operators.
2386 fn check_argument_types(&self,
2388 fn_inputs: &[Ty<'tcx>],
2389 expected_arg_tys: &[Ty<'tcx>],
2390 args: &'gcx [hir::Expr],
2392 tuple_arguments: TupleArgumentsFlag,
2393 def_span: Option<Span>) {
2396 // Grab the argument types, supplying fresh type variables
2397 // if the wrong number of arguments were supplied
2398 let supplied_arg_count = if tuple_arguments == DontTupleArguments {
2404 // All the input types from the fn signature must outlive the call
2405 // so as to validate implied bounds.
2406 for &fn_input_ty in fn_inputs {
2407 self.register_wf_obligation(fn_input_ty, sp, traits::MiscObligation);
2410 let mut expected_arg_tys = expected_arg_tys;
2411 let expected_arg_count = fn_inputs.len();
2413 let sp_args = if args.len() > 0 {
2414 let (first, args) = args.split_at(1);
2415 let mut sp_tmp = first[0].span;
2417 let sp_opt = self.sess().codemap().merge_spans(sp_tmp, arg.span);
2418 if ! sp_opt.is_some() {
2421 sp_tmp = sp_opt.unwrap();
2428 fn parameter_count_error<'tcx>(sess: &Session, sp: Span, expected_count: usize,
2429 arg_count: usize, error_code: &str, variadic: bool,
2430 def_span: Option<Span>) {
2431 let mut err = sess.struct_span_err_with_code(sp,
2432 &format!("this function takes {}{} parameter{} but {} parameter{} supplied",
2433 if variadic {"at least "} else {""},
2435 if expected_count == 1 {""} else {"s"},
2437 if arg_count == 1 {" was"} else {"s were"}),
2440 err.span_label(sp, &format!("expected {}{} parameter{}",
2441 if variadic {"at least "} else {""},
2443 if expected_count == 1 {""} else {"s"}));
2444 if let Some(def_s) = def_span {
2445 err.span_label(def_s, &format!("defined here"));
2450 let formal_tys = if tuple_arguments == TupleArguments {
2451 let tuple_type = self.structurally_resolved_type(sp, fn_inputs[0]);
2452 match tuple_type.sty {
2453 ty::TyTuple(arg_types, _) if arg_types.len() != args.len() => {
2454 parameter_count_error(tcx.sess, sp_args, arg_types.len(), args.len(),
2455 "E0057", false, def_span);
2456 expected_arg_tys = &[];
2457 self.err_args(args.len())
2459 ty::TyTuple(arg_types, _) => {
2460 expected_arg_tys = match expected_arg_tys.get(0) {
2461 Some(&ty) => match ty.sty {
2462 ty::TyTuple(ref tys, _) => &tys,
2470 span_err!(tcx.sess, sp, E0059,
2471 "cannot use call notation; the first type parameter \
2472 for the function trait is neither a tuple nor unit");
2473 expected_arg_tys = &[];
2474 self.err_args(args.len())
2477 } else if expected_arg_count == supplied_arg_count {
2479 } else if variadic {
2480 if supplied_arg_count >= expected_arg_count {
2483 parameter_count_error(tcx.sess, sp_args, expected_arg_count,
2484 supplied_arg_count, "E0060", true, def_span);
2485 expected_arg_tys = &[];
2486 self.err_args(supplied_arg_count)
2489 parameter_count_error(tcx.sess, sp_args, expected_arg_count,
2490 supplied_arg_count, "E0061", false, def_span);
2491 expected_arg_tys = &[];
2492 self.err_args(supplied_arg_count)
2495 debug!("check_argument_types: formal_tys={:?}",
2496 formal_tys.iter().map(|t| self.ty_to_string(*t)).collect::<Vec<String>>());
2498 // Check the arguments.
2499 // We do this in a pretty awful way: first we typecheck any arguments
2500 // that are not closures, then we typecheck the closures. This is so
2501 // that we have more information about the types of arguments when we
2502 // typecheck the functions. This isn't really the right way to do this.
2503 for &check_closures in &[false, true] {
2504 debug!("check_closures={}", check_closures);
2506 // More awful hacks: before we check argument types, try to do
2507 // an "opportunistic" vtable resolution of any trait bounds on
2508 // the call. This helps coercions.
2510 self.select_obligations_where_possible();
2513 // For variadic functions, we don't have a declared type for all of
2514 // the arguments hence we only do our usual type checking with
2515 // the arguments who's types we do know.
2516 let t = if variadic {
2518 } else if tuple_arguments == TupleArguments {
2523 for (i, arg) in args.iter().take(t).enumerate() {
2524 // Warn only for the first loop (the "no closures" one).
2525 // Closure arguments themselves can't be diverging, but
2526 // a previous argument can, e.g. `foo(panic!(), || {})`.
2527 if !check_closures {
2528 self.warn_if_unreachable(arg.id, arg.span, "expression");
2531 let is_closure = match arg.node {
2532 hir::ExprClosure(..) => true,
2536 if is_closure != check_closures {
2540 debug!("checking the argument");
2541 let formal_ty = formal_tys[i];
2543 // The special-cased logic below has three functions:
2544 // 1. Provide as good of an expected type as possible.
2545 let expected = expected_arg_tys.get(i).map(|&ty| {
2546 Expectation::rvalue_hint(self, ty)
2549 let checked_ty = self.check_expr_with_expectation(
2551 expected.unwrap_or(ExpectHasType(formal_ty)));
2553 // 2. Coerce to the most detailed type that could be coerced
2554 // to, which is `expected_ty` if `rvalue_hint` returns an
2555 // `ExpectHasType(expected_ty)`, or the `formal_ty` otherwise.
2556 let coerce_ty = expected.and_then(|e| e.only_has_type(self));
2557 self.demand_coerce(&arg, checked_ty, coerce_ty.unwrap_or(formal_ty));
2559 // 3. Relate the expected type and the formal one,
2560 // if the expected type was used for the coercion.
2561 coerce_ty.map(|ty| self.demand_suptype(arg.span, formal_ty, ty));
2565 // We also need to make sure we at least write the ty of the other
2566 // arguments which we skipped above.
2568 for arg in args.iter().skip(expected_arg_count) {
2569 let arg_ty = self.check_expr(&arg);
2571 // There are a few types which get autopromoted when passed via varargs
2572 // in C but we just error out instead and require explicit casts.
2573 let arg_ty = self.structurally_resolved_type(arg.span,
2576 ty::TyFloat(ast::FloatTy::F32) => {
2577 self.type_error_message(arg.span, |t| {
2578 format!("can't pass an `{}` to variadic \
2579 function, cast to `c_double`", t)
2582 ty::TyInt(ast::IntTy::I8) | ty::TyInt(ast::IntTy::I16) | ty::TyBool => {
2583 self.type_error_message(arg.span, |t| {
2584 format!("can't pass `{}` to variadic \
2585 function, cast to `c_int`",
2589 ty::TyUint(ast::UintTy::U8) | ty::TyUint(ast::UintTy::U16) => {
2590 self.type_error_message(arg.span, |t| {
2591 format!("can't pass `{}` to variadic \
2592 function, cast to `c_uint`",
2596 ty::TyFnDef(.., f) => {
2597 let ptr_ty = self.tcx.mk_fn_ptr(f);
2598 let ptr_ty = self.resolve_type_vars_if_possible(&ptr_ty);
2599 self.type_error_message(arg.span,
2601 format!("can't pass `{}` to variadic \
2602 function, cast to `{}`", t, ptr_ty)
2611 fn err_args(&self, len: usize) -> Vec<Ty<'tcx>> {
2612 (0..len).map(|_| self.tcx.types.err).collect()
2615 // AST fragment checking
2618 expected: Expectation<'tcx>)
2624 ast::LitKind::Str(..) => tcx.mk_static_str(),
2625 ast::LitKind::ByteStr(ref v) => {
2626 tcx.mk_imm_ref(tcx.mk_region(ty::ReStatic),
2627 tcx.mk_array(tcx.types.u8, v.len()))
2629 ast::LitKind::Byte(_) => tcx.types.u8,
2630 ast::LitKind::Char(_) => tcx.types.char,
2631 ast::LitKind::Int(_, ast::LitIntType::Signed(t)) => tcx.mk_mach_int(t),
2632 ast::LitKind::Int(_, ast::LitIntType::Unsigned(t)) => tcx.mk_mach_uint(t),
2633 ast::LitKind::Int(_, ast::LitIntType::Unsuffixed) => {
2634 let opt_ty = expected.to_option(self).and_then(|ty| {
2636 ty::TyInt(_) | ty::TyUint(_) => Some(ty),
2637 ty::TyChar => Some(tcx.types.u8),
2638 ty::TyRawPtr(..) => Some(tcx.types.usize),
2639 ty::TyFnDef(..) | ty::TyFnPtr(_) => Some(tcx.types.usize),
2643 opt_ty.unwrap_or_else(
2644 || tcx.mk_int_var(self.next_int_var_id()))
2646 ast::LitKind::Float(_, t) => tcx.mk_mach_float(t),
2647 ast::LitKind::FloatUnsuffixed(_) => {
2648 let opt_ty = expected.to_option(self).and_then(|ty| {
2650 ty::TyFloat(_) => Some(ty),
2654 opt_ty.unwrap_or_else(
2655 || tcx.mk_float_var(self.next_float_var_id()))
2657 ast::LitKind::Bool(_) => tcx.types.bool
2661 fn check_expr_eq_type(&self,
2662 expr: &'gcx hir::Expr,
2663 expected: Ty<'tcx>) {
2664 let ty = self.check_expr_with_hint(expr, expected);
2665 self.demand_eqtype(expr.span, expected, ty);
2668 pub fn check_expr_has_type(&self,
2669 expr: &'gcx hir::Expr,
2670 expected: Ty<'tcx>) -> Ty<'tcx> {
2671 let mut ty = self.check_expr_with_hint(expr, expected);
2673 // While we don't allow *arbitrary* coercions here, we *do* allow
2674 // coercions from ! to `expected`.
2676 assert!(!self.tables.borrow().adjustments.contains_key(&expr.id),
2677 "expression with never type wound up being adjusted");
2678 let adj_ty = self.next_diverging_ty_var(
2679 TypeVariableOrigin::AdjustmentType(expr.span));
2680 self.write_adjustment(expr.id, adjustment::Adjustment {
2681 kind: adjustment::Adjust::NeverToAny,
2687 self.demand_suptype(expr.span, expected, ty);
2691 fn check_expr_coercable_to_type(&self,
2692 expr: &'gcx hir::Expr,
2693 expected: Ty<'tcx>) -> Ty<'tcx> {
2694 let ty = self.check_expr_with_hint(expr, expected);
2695 self.demand_coerce(expr, ty, expected);
2699 fn check_expr_with_hint(&self, expr: &'gcx hir::Expr,
2700 expected: Ty<'tcx>) -> Ty<'tcx> {
2701 self.check_expr_with_expectation(expr, ExpectHasType(expected))
2704 fn check_expr_with_expectation(&self,
2705 expr: &'gcx hir::Expr,
2706 expected: Expectation<'tcx>) -> Ty<'tcx> {
2707 self.check_expr_with_expectation_and_lvalue_pref(expr, expected, NoPreference)
2710 fn check_expr(&self, expr: &'gcx hir::Expr) -> Ty<'tcx> {
2711 self.check_expr_with_expectation(expr, NoExpectation)
2714 fn check_expr_with_lvalue_pref(&self, expr: &'gcx hir::Expr,
2715 lvalue_pref: LvaluePreference) -> Ty<'tcx> {
2716 self.check_expr_with_expectation_and_lvalue_pref(expr, NoExpectation, lvalue_pref)
2719 // determine the `self` type, using fresh variables for all variables
2720 // declared on the impl declaration e.g., `impl<A,B> for Vec<(A,B)>`
2721 // would return ($0, $1) where $0 and $1 are freshly instantiated type
2723 pub fn impl_self_ty(&self,
2724 span: Span, // (potential) receiver for this impl
2726 -> TypeAndSubsts<'tcx> {
2727 let ity = self.tcx.item_type(did);
2728 debug!("impl_self_ty: ity={:?}", ity);
2730 let substs = self.fresh_substs_for_item(span, did);
2731 let substd_ty = self.instantiate_type_scheme(span, &substs, &ity);
2733 TypeAndSubsts { substs: substs, ty: substd_ty }
2736 /// Unifies the output type with the expected type early, for more coercions
2737 /// and forward type information on the input expressions.
2738 fn expected_inputs_for_expected_output(&self,
2740 expected_ret: Expectation<'tcx>,
2741 formal_ret: Ty<'tcx>,
2742 formal_args: &[Ty<'tcx>])
2744 let expected_args = expected_ret.only_has_type(self).and_then(|ret_ty| {
2745 self.fudge_regions_if_ok(&RegionVariableOrigin::Coercion(call_span), || {
2746 // Attempt to apply a subtyping relationship between the formal
2747 // return type (likely containing type variables if the function
2748 // is polymorphic) and the expected return type.
2749 // No argument expectations are produced if unification fails.
2750 let origin = self.misc(call_span);
2751 let ures = self.sub_types(false, &origin, formal_ret, ret_ty);
2752 // FIXME(#15760) can't use try! here, FromError doesn't default
2753 // to identity so the resulting type is not constrained.
2755 Ok(ok) => self.register_infer_ok_obligations(ok),
2756 Err(e) => return Err(e),
2759 // Record all the argument types, with the substitutions
2760 // produced from the above subtyping unification.
2761 Ok(formal_args.iter().map(|ty| {
2762 self.resolve_type_vars_if_possible(ty)
2765 }).unwrap_or(vec![]);
2766 debug!("expected_inputs_for_expected_output(formal={:?} -> {:?}, expected={:?} -> {:?})",
2767 formal_args, formal_ret,
2768 expected_args, expected_ret);
2772 // Checks a method call.
2773 fn check_method_call(&self,
2774 expr: &'gcx hir::Expr,
2775 method_name: Spanned<ast::Name>,
2776 args: &'gcx [hir::Expr],
2778 expected: Expectation<'tcx>,
2779 lvalue_pref: LvaluePreference) -> Ty<'tcx> {
2780 let rcvr = &args[0];
2781 let rcvr_t = self.check_expr_with_lvalue_pref(&rcvr, lvalue_pref);
2783 // no need to check for bot/err -- callee does that
2784 let expr_t = self.structurally_resolved_type(expr.span, rcvr_t);
2786 let tps = tps.iter().map(|ast_ty| self.to_ty(&ast_ty)).collect::<Vec<_>>();
2787 let fn_ty = match self.lookup_method(method_name.span,
2794 let method_ty = method.ty;
2795 let method_call = MethodCall::expr(expr.id);
2796 self.tables.borrow_mut().method_map.insert(method_call, method);
2800 if method_name.node != keywords::Invalid.name() {
2801 self.report_method_error(method_name.span,
2808 self.write_error(expr.id);
2813 // Call the generic checker.
2814 let ret_ty = self.check_method_argument_types(method_name.span, fn_ty,
2822 fn check_return_expr(&self, return_expr: &'gcx hir::Expr) {
2826 .unwrap_or_else(|| span_bug!(return_expr.span,
2827 "check_return_expr called outside fn body"));
2829 let ret_ty = ret_coercion.borrow().expected_ty();
2830 let return_expr_ty = self.check_expr_with_hint(return_expr, ret_ty);
2831 ret_coercion.borrow_mut()
2833 &self.misc(return_expr.span),
2836 self.diverges.get());
2840 // A generic function for checking the then and else in an if
2842 fn check_then_else(&self,
2843 cond_expr: &'gcx hir::Expr,
2844 then_expr: &'gcx hir::Expr,
2845 opt_else_expr: Option<&'gcx hir::Expr>,
2847 expected: Expectation<'tcx>) -> Ty<'tcx> {
2848 let cond_ty = self.check_expr_has_type(cond_expr, self.tcx.types.bool);
2849 let cond_diverges = self.diverges.get();
2850 self.diverges.set(Diverges::Maybe);
2852 let expected = expected.adjust_for_branches(self);
2853 let then_ty = self.check_expr_with_expectation(then_expr, expected);
2854 let then_diverges = self.diverges.get();
2855 self.diverges.set(Diverges::Maybe);
2857 // We've already taken the expected type's preferences
2858 // into account when typing the `then` branch. To figure
2859 // out the initial shot at a LUB, we thus only consider
2860 // `expected` if it represents a *hard* constraint
2861 // (`only_has_type`); otherwise, we just go with a
2862 // fresh type variable.
2863 let coerce_to_ty = expected.coercion_target_type(self, sp);
2864 let mut coerce: DynamicCoerceMany = CoerceMany::new(coerce_to_ty);
2866 let if_cause = self.cause(sp, ObligationCauseCode::IfExpression);
2867 coerce.coerce(self, &if_cause, then_expr, then_ty, then_diverges);
2869 if let Some(else_expr) = opt_else_expr {
2870 let else_ty = self.check_expr_with_expectation(else_expr, expected);
2871 let else_diverges = self.diverges.get();
2873 coerce.coerce(self, &if_cause, else_expr, else_ty, else_diverges);
2875 // We won't diverge unless both branches do (or the condition does).
2876 self.diverges.set(cond_diverges | then_diverges & else_diverges);
2878 let else_cause = self.cause(sp, ObligationCauseCode::IfExpressionWithNoElse);
2879 coerce.coerce_forced_unit(self, &else_cause, &mut |_| ());
2881 // If the condition is false we can't diverge.
2882 self.diverges.set(cond_diverges);
2885 let result_ty = coerce.complete(self);
2886 if cond_ty.references_error() {
2893 // Check field access expressions
2894 fn check_field(&self,
2895 expr: &'gcx hir::Expr,
2896 lvalue_pref: LvaluePreference,
2897 base: &'gcx hir::Expr,
2898 field: &Spanned<ast::Name>) -> Ty<'tcx> {
2899 let expr_t = self.check_expr_with_lvalue_pref(base, lvalue_pref);
2900 let expr_t = self.structurally_resolved_type(expr.span,
2902 let mut private_candidate = None;
2903 let mut autoderef = self.autoderef(expr.span, expr_t);
2904 while let Some((base_t, autoderefs)) = autoderef.next() {
2906 ty::TyAdt(base_def, substs) if !base_def.is_enum() => {
2907 debug!("struct named {:?}", base_t);
2908 if let Some(field) = base_def.struct_variant().find_field_named(field.node) {
2909 let field_ty = self.field_ty(expr.span, field, substs);
2910 if self.tcx.vis_is_accessible_from(field.vis, self.body_id) {
2911 autoderef.finalize(lvalue_pref, &[base]);
2912 self.write_autoderef_adjustment(base.id, autoderefs, base_t);
2914 self.tcx.check_stability(field.did, expr.id, expr.span);
2918 private_candidate = Some((base_def.did, field_ty));
2924 autoderef.unambiguous_final_ty();
2926 if let Some((did, field_ty)) = private_candidate {
2927 let struct_path = self.tcx().item_path_str(did);
2928 let msg = format!("field `{}` of struct `{}` is private", field.node, struct_path);
2929 let mut err = self.tcx().sess.struct_span_err(expr.span, &msg);
2930 // Also check if an accessible method exists, which is often what is meant.
2931 if self.method_exists(field.span, field.node, expr_t, expr.id, false) {
2932 err.note(&format!("a method `{}` also exists, perhaps you wish to call it",
2937 } else if field.node == keywords::Invalid.name() {
2938 self.tcx().types.err
2939 } else if self.method_exists(field.span, field.node, expr_t, expr.id, true) {
2940 self.type_error_struct(field.span, |actual| {
2941 format!("attempted to take value of method `{}` on type \
2942 `{}`", field.node, actual)
2944 .help("maybe a `()` to call it is missing? \
2945 If not, try an anonymous function")
2947 self.tcx().types.err
2949 let mut err = self.type_error_struct(field.span, |actual| {
2950 format!("no field `{}` on type `{}`",
2954 ty::TyAdt(def, _) if !def.is_enum() => {
2955 if let Some(suggested_field_name) =
2956 Self::suggest_field_name(def.struct_variant(), field, vec![]) {
2957 err.span_label(field.span,
2958 &format!("did you mean `{}`?", suggested_field_name));
2960 err.span_label(field.span,
2961 &format!("unknown field"));
2964 ty::TyRawPtr(..) => {
2965 err.note(&format!("`{0}` is a native pointer; perhaps you need to deref with \
2967 self.tcx.hir.node_to_pretty_string(base.id),
2973 self.tcx().types.err
2977 // Return an hint about the closest match in field names
2978 fn suggest_field_name(variant: &'tcx ty::VariantDef,
2979 field: &Spanned<ast::Name>,
2980 skip : Vec<InternedString>)
2982 let name = field.node.as_str();
2983 let names = variant.fields.iter().filter_map(|field| {
2984 // ignore already set fields and private fields from non-local crates
2985 if skip.iter().any(|x| *x == field.name.as_str()) ||
2986 (variant.did.krate != LOCAL_CRATE && field.vis != Visibility::Public) {
2993 // only find fits with at least one matching letter
2994 find_best_match_for_name(names, &name, Some(name.len()))
2997 // Check tuple index expressions
2998 fn check_tup_field(&self,
2999 expr: &'gcx hir::Expr,
3000 lvalue_pref: LvaluePreference,
3001 base: &'gcx hir::Expr,
3002 idx: codemap::Spanned<usize>) -> Ty<'tcx> {
3003 let expr_t = self.check_expr_with_lvalue_pref(base, lvalue_pref);
3004 let expr_t = self.structurally_resolved_type(expr.span,
3006 let mut private_candidate = None;
3007 let mut tuple_like = false;
3008 let mut autoderef = self.autoderef(expr.span, expr_t);
3009 while let Some((base_t, autoderefs)) = autoderef.next() {
3010 let field = match base_t.sty {
3011 ty::TyAdt(base_def, substs) if base_def.is_struct() => {
3012 tuple_like = base_def.struct_variant().ctor_kind == CtorKind::Fn;
3013 if !tuple_like { continue }
3015 debug!("tuple struct named {:?}", base_t);
3016 base_def.struct_variant().fields.get(idx.node).and_then(|field| {
3017 let field_ty = self.field_ty(expr.span, field, substs);
3018 private_candidate = Some((base_def.did, field_ty));
3019 if self.tcx.vis_is_accessible_from(field.vis, self.body_id) {
3020 self.tcx.check_stability(field.did, expr.id, expr.span);
3027 ty::TyTuple(ref v, _) => {
3029 v.get(idx.node).cloned()
3034 if let Some(field_ty) = field {
3035 autoderef.finalize(lvalue_pref, &[base]);
3036 self.write_autoderef_adjustment(base.id, autoderefs, base_t);
3040 autoderef.unambiguous_final_ty();
3042 if let Some((did, field_ty)) = private_candidate {
3043 let struct_path = self.tcx().item_path_str(did);
3044 let msg = format!("field `{}` of struct `{}` is private", idx.node, struct_path);
3045 self.tcx().sess.span_err(expr.span, &msg);
3049 self.type_error_message(
3053 format!("attempted out-of-bounds tuple index `{}` on \
3058 format!("attempted tuple index `{}` on type `{}`, but the \
3059 type was not a tuple or tuple struct",
3066 self.tcx().types.err
3069 fn report_unknown_field(&self,
3071 variant: &'tcx ty::VariantDef,
3073 skip_fields: &[hir::Field],
3075 let mut err = self.type_error_struct_with_diag(
3077 |actual| match ty.sty {
3078 ty::TyAdt(adt, ..) if adt.is_enum() => {
3079 struct_span_err!(self.tcx.sess, field.name.span, E0559,
3080 "{} `{}::{}` has no field named `{}`",
3081 kind_name, actual, variant.name, field.name.node)
3084 struct_span_err!(self.tcx.sess, field.name.span, E0560,
3085 "{} `{}` has no field named `{}`",
3086 kind_name, actual, field.name.node)
3090 // prevent all specified fields from being suggested
3091 let skip_fields = skip_fields.iter().map(|ref x| x.name.node.as_str());
3092 if let Some(field_name) = Self::suggest_field_name(variant,
3094 skip_fields.collect()) {
3095 err.span_label(field.name.span,
3096 &format!("field does not exist - did you mean `{}`?", field_name));
3099 ty::TyAdt(adt, ..) if adt.is_enum() => {
3100 err.span_label(field.name.span, &format!("`{}::{}` does not have this field",
3104 err.span_label(field.name.span, &format!("`{}` does not have this field", ty));
3111 fn check_expr_struct_fields(&self,
3113 expected: Expectation<'tcx>,
3114 expr_id: ast::NodeId,
3116 variant: &'tcx ty::VariantDef,
3117 ast_fields: &'gcx [hir::Field],
3118 check_completeness: bool) {
3122 self.expected_inputs_for_expected_output(span, expected, adt_ty, &[adt_ty])
3123 .get(0).cloned().unwrap_or(adt_ty);
3125 let (substs, hint_substs, adt_kind, kind_name) = match (&adt_ty.sty, &adt_ty_hint.sty) {
3126 (&ty::TyAdt(adt, substs), &ty::TyAdt(_, hint_substs)) => {
3127 (substs, hint_substs, adt.adt_kind(), adt.variant_descr())
3129 _ => span_bug!(span, "non-ADT passed to check_expr_struct_fields")
3132 let mut remaining_fields = FxHashMap();
3133 for field in &variant.fields {
3134 remaining_fields.insert(field.name, field);
3137 let mut seen_fields = FxHashMap();
3139 let mut error_happened = false;
3141 // Typecheck each field.
3142 for field in ast_fields {
3143 let final_field_type;
3144 let field_type_hint;
3146 if let Some(v_field) = remaining_fields.remove(&field.name.node) {
3147 final_field_type = self.field_ty(field.span, v_field, substs);
3148 field_type_hint = self.field_ty(field.span, v_field, hint_substs);
3150 seen_fields.insert(field.name.node, field.span);
3152 // we don't look at stability attributes on
3153 // struct-like enums (yet...), but it's definitely not
3154 // a bug to have construct one.
3155 if adt_kind != ty::AdtKind::Enum {
3156 tcx.check_stability(v_field.did, expr_id, field.span);
3159 error_happened = true;
3160 final_field_type = tcx.types.err;
3161 field_type_hint = tcx.types.err;
3162 if let Some(_) = variant.find_field_named(field.name.node) {
3163 let mut err = struct_span_err!(self.tcx.sess,
3166 "field `{}` specified more than once",
3169 err.span_label(field.name.span, &format!("used more than once"));
3171 if let Some(prev_span) = seen_fields.get(&field.name.node) {
3172 err.span_label(*prev_span, &format!("first use of `{}`", field.name.node));
3177 self.report_unknown_field(adt_ty, variant, field, ast_fields, kind_name);
3181 // Make sure to give a type to the field even if there's
3182 // an error, so we can continue typechecking
3183 let ty = self.check_expr_with_hint(&field.expr, field_type_hint);
3184 self.demand_coerce(&field.expr, ty, final_field_type);
3187 // Make sure the programmer specified correct number of fields.
3188 if kind_name == "union" {
3189 if ast_fields.len() != 1 {
3190 tcx.sess.span_err(span, "union expressions should have exactly one field");
3192 } else if check_completeness && !error_happened && !remaining_fields.is_empty() {
3193 let len = remaining_fields.len();
3195 let mut displayable_field_names = remaining_fields
3197 .map(|x| x.as_str())
3198 .collect::<Vec<_>>();
3200 displayable_field_names.sort();
3202 let truncated_fields_error = if len <= 3 {
3205 format!(" and {} other field{}", (len - 3), if len - 3 == 1 {""} else {"s"})
3208 let remaining_fields_names = displayable_field_names.iter().take(3)
3209 .map(|n| format!("`{}`", n))
3210 .collect::<Vec<_>>()
3213 struct_span_err!(tcx.sess, span, E0063,
3214 "missing field{} {}{} in initializer of `{}`",
3215 if remaining_fields.len() == 1 {""} else {"s"},
3216 remaining_fields_names,
3217 truncated_fields_error,
3219 .span_label(span, &format!("missing {}{}",
3220 remaining_fields_names,
3221 truncated_fields_error))
3226 fn check_struct_fields_on_error(&self,
3227 fields: &'gcx [hir::Field],
3228 base_expr: &'gcx Option<P<hir::Expr>>) {
3229 for field in fields {
3230 self.check_expr(&field.expr);
3234 self.check_expr(&base);
3240 pub fn check_struct_path(&self,
3242 node_id: ast::NodeId)
3243 -> Option<(&'tcx ty::VariantDef, Ty<'tcx>)> {
3244 let path_span = match *qpath {
3245 hir::QPath::Resolved(_, ref path) => path.span,
3246 hir::QPath::TypeRelative(ref qself, _) => qself.span
3248 let (def, ty) = self.finish_resolving_struct_path(qpath, path_span, node_id);
3249 let variant = match def {
3251 self.set_tainted_by_errors();
3254 Def::Variant(..) => {
3256 ty::TyAdt(adt, substs) => {
3257 Some((adt.variant_of_def(def), adt.did, substs))
3259 _ => bug!("unexpected type: {:?}", ty.sty)
3262 Def::Struct(..) | Def::Union(..) | Def::TyAlias(..) |
3263 Def::AssociatedTy(..) | Def::SelfTy(..) => {
3265 ty::TyAdt(adt, substs) if !adt.is_enum() => {
3266 Some((adt.struct_variant(), adt.did, substs))
3271 _ => bug!("unexpected definition: {:?}", def)
3274 if let Some((variant, did, substs)) = variant {
3275 // Check bounds on type arguments used in the path.
3276 let bounds = self.instantiate_bounds(path_span, did, substs);
3277 let cause = traits::ObligationCause::new(path_span, self.body_id,
3278 traits::ItemObligation(did));
3279 self.add_obligations_for_parameters(cause, &bounds);
3283 struct_span_err!(self.tcx.sess, path_span, E0071,
3284 "expected struct, variant or union type, found {}",
3285 ty.sort_string(self.tcx))
3286 .span_label(path_span, &format!("not a struct"))
3292 fn check_expr_struct(&self,
3294 expected: Expectation<'tcx>,
3296 fields: &'gcx [hir::Field],
3297 base_expr: &'gcx Option<P<hir::Expr>>) -> Ty<'tcx>
3299 // Find the relevant variant
3300 let (variant, struct_ty) =
3301 if let Some(variant_ty) = self.check_struct_path(qpath, expr.id) {
3304 self.check_struct_fields_on_error(fields, base_expr);
3305 return self.tcx.types.err;
3308 let path_span = match *qpath {
3309 hir::QPath::Resolved(_, ref path) => path.span,
3310 hir::QPath::TypeRelative(ref qself, _) => qself.span
3313 self.check_expr_struct_fields(struct_ty, expected, expr.id, path_span, variant, fields,
3314 base_expr.is_none());
3315 if let &Some(ref base_expr) = base_expr {
3316 self.check_expr_has_type(base_expr, struct_ty);
3317 match struct_ty.sty {
3318 ty::TyAdt(adt, substs) if adt.is_struct() => {
3319 self.tables.borrow_mut().fru_field_types.insert(
3321 adt.struct_variant().fields.iter().map(|f| {
3322 self.normalize_associated_types_in(
3323 expr.span, &f.ty(self.tcx, substs)
3329 span_err!(self.tcx.sess, base_expr.span, E0436,
3330 "functional record update syntax requires a struct");
3334 self.require_type_is_sized(struct_ty, expr.span, traits::StructInitializerSized);
3340 /// If an expression has any sub-expressions that result in a type error,
3341 /// inspecting that expression's type with `ty.references_error()` will return
3342 /// true. Likewise, if an expression is known to diverge, inspecting its
3343 /// type with `ty::type_is_bot` will return true (n.b.: since Rust is
3344 /// strict, _|_ can appear in the type of an expression that does not,
3345 /// itself, diverge: for example, fn() -> _|_.)
3346 /// Note that inspecting a type's structure *directly* may expose the fact
3347 /// that there are actually multiple representations for `TyError`, so avoid
3348 /// that when err needs to be handled differently.
3349 fn check_expr_with_expectation_and_lvalue_pref(&self,
3350 expr: &'gcx hir::Expr,
3351 expected: Expectation<'tcx>,
3352 lvalue_pref: LvaluePreference) -> Ty<'tcx> {
3353 debug!(">> typechecking: expr={:?} expected={:?}",
3356 // Warn for expressions after diverging siblings.
3357 self.warn_if_unreachable(expr.id, expr.span, "expression");
3359 // Hide the outer diverging and has_errors flags.
3360 let old_diverges = self.diverges.get();
3361 let old_has_errors = self.has_errors.get();
3362 self.diverges.set(Diverges::Maybe);
3363 self.has_errors.set(false);
3365 let ty = self.check_expr_kind(expr, expected, lvalue_pref);
3367 // Warn for non-block expressions with diverging children.
3370 hir::ExprLoop(..) | hir::ExprWhile(..) |
3371 hir::ExprIf(..) | hir::ExprMatch(..) => {}
3373 _ => self.warn_if_unreachable(expr.id, expr.span, "expression")
3376 // Any expression that produces a value of type `!` must have diverged
3378 self.diverges.set(self.diverges.get() | Diverges::Always);
3381 // Record the type, which applies it effects.
3382 // We need to do this after the warning above, so that
3383 // we don't warn for the diverging expression itself.
3384 self.write_ty(expr.id, ty);
3386 // Combine the diverging and has_error flags.
3387 self.diverges.set(self.diverges.get() | old_diverges);
3388 self.has_errors.set(self.has_errors.get() | old_has_errors);
3390 debug!("type of {} is...", self.tcx.hir.node_to_string(expr.id));
3391 debug!("... {:?}, expected is {:?}", ty, expected);
3396 fn check_expr_kind(&self,
3397 expr: &'gcx hir::Expr,
3398 expected: Expectation<'tcx>,
3399 lvalue_pref: LvaluePreference) -> Ty<'tcx> {
3403 hir::ExprBox(ref subexpr) => {
3404 let expected_inner = expected.to_option(self).map_or(NoExpectation, |ty| {
3406 ty::TyAdt(def, _) if def.is_box()
3407 => Expectation::rvalue_hint(self, ty.boxed_ty()),
3411 let referent_ty = self.check_expr_with_expectation(subexpr, expected_inner);
3412 tcx.mk_box(referent_ty)
3415 hir::ExprLit(ref lit) => {
3416 self.check_lit(&lit, expected)
3418 hir::ExprBinary(op, ref lhs, ref rhs) => {
3419 self.check_binop(expr, op, lhs, rhs)
3421 hir::ExprAssignOp(op, ref lhs, ref rhs) => {
3422 self.check_binop_assign(expr, op, lhs, rhs)
3424 hir::ExprUnary(unop, ref oprnd) => {
3425 let expected_inner = match unop {
3426 hir::UnNot | hir::UnNeg => {
3433 let lvalue_pref = match unop {
3434 hir::UnDeref => lvalue_pref,
3437 let mut oprnd_t = self.check_expr_with_expectation_and_lvalue_pref(&oprnd,
3441 if !oprnd_t.references_error() {
3444 oprnd_t = self.structurally_resolved_type(expr.span, oprnd_t);
3446 if let Some(mt) = oprnd_t.builtin_deref(true, NoPreference) {
3448 } else if let Some(method) = self.try_overloaded_deref(
3449 expr.span, Some(&oprnd), oprnd_t, lvalue_pref) {
3450 oprnd_t = self.make_overloaded_lvalue_return_type(method).ty;
3451 self.tables.borrow_mut().method_map.insert(MethodCall::expr(expr.id),
3454 self.type_error_message(expr.span, |actual| {
3455 format!("type `{}` cannot be \
3456 dereferenced", actual)
3458 oprnd_t = tcx.types.err;
3462 oprnd_t = self.structurally_resolved_type(oprnd.span,
3464 let result = self.check_user_unop("!", "not",
3465 tcx.lang_items.not_trait(),
3466 expr, &oprnd, oprnd_t, unop);
3467 // If it's builtin, we can reuse the type, this helps inference.
3468 if !(oprnd_t.is_integral() || oprnd_t.sty == ty::TyBool) {
3473 oprnd_t = self.structurally_resolved_type(oprnd.span,
3475 let result = self.check_user_unop("-", "neg",
3476 tcx.lang_items.neg_trait(),
3477 expr, &oprnd, oprnd_t, unop);
3478 // If it's builtin, we can reuse the type, this helps inference.
3479 if !(oprnd_t.is_integral() || oprnd_t.is_fp()) {
3487 hir::ExprAddrOf(mutbl, ref oprnd) => {
3488 let hint = expected.only_has_type(self).map_or(NoExpectation, |ty| {
3490 ty::TyRef(_, ref mt) | ty::TyRawPtr(ref mt) => {
3491 if self.tcx.expr_is_lval(&oprnd) {
3492 // Lvalues may legitimately have unsized types.
3493 // For example, dereferences of a fat pointer and
3494 // the last field of a struct can be unsized.
3495 ExpectHasType(mt.ty)
3497 Expectation::rvalue_hint(self, mt.ty)
3503 let lvalue_pref = LvaluePreference::from_mutbl(mutbl);
3504 let ty = self.check_expr_with_expectation_and_lvalue_pref(&oprnd, hint, lvalue_pref);
3506 let tm = ty::TypeAndMut { ty: ty, mutbl: mutbl };
3507 if tm.ty.references_error() {
3510 // Note: at this point, we cannot say what the best lifetime
3511 // is to use for resulting pointer. We want to use the
3512 // shortest lifetime possible so as to avoid spurious borrowck
3513 // errors. Moreover, the longest lifetime will depend on the
3514 // precise details of the value whose address is being taken
3515 // (and how long it is valid), which we don't know yet until type
3516 // inference is complete.
3518 // Therefore, here we simply generate a region variable. The
3519 // region inferencer will then select the ultimate value.
3520 // Finally, borrowck is charged with guaranteeing that the
3521 // value whose address was taken can actually be made to live
3522 // as long as it needs to live.
3523 let region = self.next_region_var(infer::AddrOfRegion(expr.span));
3524 tcx.mk_ref(region, tm)
3527 hir::ExprPath(ref qpath) => {
3528 let (def, opt_ty, segments) = self.resolve_ty_and_def_ufcs(qpath,
3529 expr.id, expr.span);
3530 let ty = if def != Def::Err {
3531 self.instantiate_value_path(segments, opt_ty, def, expr.span, id)
3533 self.set_tainted_by_errors();
3537 // We always require that the type provided as the value for
3538 // a type parameter outlives the moment of instantiation.
3539 self.opt_node_ty_substs(expr.id, |item_substs| {
3540 self.add_wf_bounds(&item_substs.substs, expr);
3545 hir::ExprInlineAsm(_, ref outputs, ref inputs) => {
3546 for output in outputs {
3547 self.check_expr(output);
3549 for input in inputs {
3550 self.check_expr(input);
3554 hir::ExprBreak(destination, ref expr_opt) => {
3555 if let Some(target_id) = destination.target_id.opt_id() {
3556 let (e_ty, e_diverges, cause);
3557 if let Some(ref e) = *expr_opt {
3558 // If this is a break with a value, we need to type-check
3559 // the expression. Get an expected type from the loop context.
3560 let opt_coerce_to = {
3561 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
3562 enclosing_breakables.find_breakable(target_id)
3565 .map(|coerce| coerce.expected_ty())
3568 // If the loop context is not a `loop { }`, then break with
3569 // a value is illegal, and `opt_coerce_to` will be `None`.
3570 // Just set expectation to error in that case.
3571 let coerce_to = opt_coerce_to.unwrap_or(tcx.types.err);
3573 // Recurse without `enclosing_breakables` borrowed.
3574 e_ty = self.check_expr_with_hint(e, coerce_to);
3575 e_diverges = self.diverges.get();
3576 cause = self.misc(e.span);
3578 // Otherwise, this is a break *without* a value. That's
3579 // always legal, and is equivalent to `break ()`.
3580 e_ty = tcx.mk_nil();
3581 e_diverges = Diverges::Maybe;
3582 cause = self.misc(expr.span);
3585 // Now that we have type-checked `expr_opt`, borrow
3586 // the `enclosing_loops` field and let's coerce the
3587 // type of `expr_opt` into what is expected.
3588 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
3589 let ctxt = enclosing_breakables.find_breakable(target_id);
3590 if let Some(ref mut coerce) = ctxt.coerce {
3591 if let Some(ref e) = *expr_opt {
3592 coerce.coerce(self, &cause, e, e_ty, e_diverges);
3594 assert!(e_ty.is_nil());
3595 coerce.coerce_forced_unit(self, &cause, &mut |_| ());
3598 // If `ctxt.coerce` is `None`, we can just ignore
3599 // the type of the expresison. This is because
3600 // either this was a break *without* a value, in
3601 // which case it is always a legal type (`()`), or
3602 // else an error would have been flagged by the
3603 // `loops` pass for using break with an expression
3604 // where you are not supposed to.
3605 assert!(expr_opt.is_none() || self.tcx.sess.err_count() > 0);
3608 ctxt.may_break = true;
3610 // Otherwise, we failed to find the enclosing loop;
3611 // this can only happen if the `break` was not
3612 // inside a loop at all, which is caught by the
3613 // loop-checking pass.
3614 assert!(self.tcx.sess.err_count() > 0);
3617 // the type of a `break` is always `!`, since it diverges
3620 hir::ExprAgain(_) => { tcx.types.never }
3621 hir::ExprRet(ref expr_opt) => {
3622 if self.ret_coercion.is_none() {
3623 struct_span_err!(self.tcx.sess, expr.span, E0572,
3624 "return statement outside of function body").emit();
3625 } else if let Some(ref e) = *expr_opt {
3626 self.check_return_expr(e);
3628 let mut coercion = self.ret_coercion.as_ref().unwrap().borrow_mut();
3629 let cause = self.cause(expr.span, ObligationCauseCode::ReturnNoExpression);
3630 coercion.coerce_forced_unit(self, &cause, &mut |_| ());
3634 hir::ExprAssign(ref lhs, ref rhs) => {
3635 let lhs_ty = self.check_expr_with_lvalue_pref(&lhs, PreferMutLvalue);
3638 if !tcx.expr_is_lval(&lhs) {
3640 tcx.sess, expr.span, E0070,
3641 "invalid left-hand side expression")
3644 &format!("left-hand of expression not valid"))
3648 let rhs_ty = self.check_expr_coercable_to_type(&rhs, lhs_ty);
3650 self.require_type_is_sized(lhs_ty, lhs.span, traits::AssignmentLhsSized);
3652 if lhs_ty.references_error() || rhs_ty.references_error() {
3658 hir::ExprIf(ref cond, ref then_expr, ref opt_else_expr) => {
3659 self.check_then_else(&cond, then_expr, opt_else_expr.as_ref().map(|e| &**e),
3660 expr.span, expected)
3662 hir::ExprWhile(ref cond, ref body, _) => {
3663 let ctxt = BreakableCtxt {
3664 // cannot use break with a value from a while loop
3669 self.with_breakable_ctxt(expr.id, ctxt, || {
3670 self.check_expr_has_type(&cond, tcx.types.bool);
3671 let cond_diverging = self.diverges.get();
3672 self.check_block_no_value(&body);
3674 // We may never reach the body so it diverging means nothing.
3675 self.diverges.set(cond_diverging);
3680 hir::ExprLoop(ref body, _, source) => {
3681 let coerce = match source {
3682 // you can only use break with a value from a normal `loop { }`
3683 hir::LoopSource::Loop => {
3684 let coerce_to = expected.coercion_target_type(self, body.span);
3685 Some(CoerceMany::new(coerce_to))
3688 hir::LoopSource::WhileLet |
3689 hir::LoopSource::ForLoop => {
3694 let ctxt = BreakableCtxt {
3696 may_break: false, // will get updated if/when we find a `break`
3699 let (ctxt, ()) = self.with_breakable_ctxt(expr.id, ctxt, || {
3700 self.check_block_no_value(&body);
3704 // No way to know whether it's diverging because
3705 // of a `break` or an outer `break` or `return.
3706 self.diverges.set(Diverges::Maybe);
3709 // If we permit break with a value, then result type is
3710 // the LUB of the breaks (possibly ! if none); else, it
3711 // is nil. This makes sense because infinite loops
3712 // (which would have type !) are only possible iff we
3713 // permit break with a value [1].
3714 assert!(ctxt.coerce.is_some() || ctxt.may_break); // [1]
3715 ctxt.coerce.map(|c| c.complete(self)).unwrap_or(self.tcx.mk_nil())
3717 hir::ExprMatch(ref discrim, ref arms, match_src) => {
3718 self.check_match(expr, &discrim, arms, expected, match_src)
3720 hir::ExprClosure(capture, ref decl, body_id, _) => {
3721 self.check_expr_closure(expr, capture, &decl, body_id, expected)
3723 hir::ExprBlock(ref body) => {
3724 self.check_block_with_expected(&body, expected)
3726 hir::ExprCall(ref callee, ref args) => {
3727 self.check_call(expr, &callee, args, expected)
3729 hir::ExprMethodCall(name, ref tps, ref args) => {
3730 self.check_method_call(expr, name, args, &tps[..], expected, lvalue_pref)
3732 hir::ExprCast(ref e, ref t) => {
3733 // Find the type of `e`. Supply hints based on the type we are casting to,
3735 let t_cast = self.to_ty(t);
3736 let t_cast = self.resolve_type_vars_if_possible(&t_cast);
3737 let t_expr = self.check_expr_with_expectation(e, ExpectCastableToType(t_cast));
3738 let t_cast = self.resolve_type_vars_if_possible(&t_cast);
3739 let diverges = self.diverges.get();
3741 // Eagerly check for some obvious errors.
3742 if t_expr.references_error() || t_cast.references_error() {
3745 // Defer other checks until we're done type checking.
3746 let mut deferred_cast_checks = self.deferred_cast_checks.borrow_mut();
3747 match cast::CastCheck::new(self, e, t_expr, diverges, t_cast, t.span, expr.span) {
3749 deferred_cast_checks.push(cast_check);
3752 Err(ErrorReported) => {
3758 hir::ExprType(ref e, ref t) => {
3759 let typ = self.to_ty(&t);
3760 self.check_expr_eq_type(&e, typ);
3763 hir::ExprArray(ref args) => {
3764 let uty = expected.to_option(self).and_then(|uty| {
3766 ty::TyArray(ty, _) | ty::TySlice(ty) => Some(ty),
3771 let element_ty = if !args.is_empty() {
3772 let coerce_to = uty.unwrap_or_else(
3773 || self.next_ty_var(TypeVariableOrigin::TypeInference(expr.span)));
3774 let mut coerce = CoerceMany::with_coercion_sites(coerce_to, args);
3775 assert_eq!(self.diverges.get(), Diverges::Maybe);
3777 let e_ty = self.check_expr_with_hint(e, coerce_to);
3778 let cause = self.misc(e.span);
3779 coerce.coerce(self, &cause, e, e_ty, self.diverges.get());
3781 coerce.complete(self)
3783 self.next_ty_var(TypeVariableOrigin::TypeInference(expr.span))
3785 tcx.mk_array(element_ty, args.len())
3787 hir::ExprRepeat(ref element, count) => {
3788 let count = eval_length(self.tcx.global_tcx(), count, "repeat count")
3791 let uty = match expected {
3792 ExpectHasType(uty) => {
3794 ty::TyArray(ty, _) | ty::TySlice(ty) => Some(ty),
3801 let (element_ty, t) = match uty {
3803 self.check_expr_coercable_to_type(&element, uty);
3807 let t: Ty = self.next_ty_var(TypeVariableOrigin::MiscVariable(element.span));
3808 let element_ty = self.check_expr_has_type(&element, t);
3814 // For [foo, ..n] where n > 1, `foo` must have
3816 let lang_item = self.tcx.require_lang_item(lang_items::CopyTraitLangItem);
3817 self.require_type_meets(t, expr.span, traits::RepeatVec, lang_item);
3820 if element_ty.references_error() {
3823 tcx.mk_array(t, count)
3826 hir::ExprTup(ref elts) => {
3827 let flds = expected.only_has_type(self).and_then(|ty| {
3829 ty::TyTuple(ref flds, _) => Some(&flds[..]),
3834 let elt_ts_iter = elts.iter().enumerate().map(|(i, e)| {
3835 let t = match flds {
3836 Some(ref fs) if i < fs.len() => {
3838 self.check_expr_coercable_to_type(&e, ety);
3842 self.check_expr_with_expectation(&e, NoExpectation)
3847 let tuple = tcx.mk_tup(elt_ts_iter, false);
3848 if tuple.references_error() {
3854 hir::ExprStruct(ref qpath, ref fields, ref base_expr) => {
3855 self.check_expr_struct(expr, expected, qpath, fields, base_expr)
3857 hir::ExprField(ref base, ref field) => {
3858 self.check_field(expr, lvalue_pref, &base, field)
3860 hir::ExprTupField(ref base, idx) => {
3861 self.check_tup_field(expr, lvalue_pref, &base, idx)
3863 hir::ExprIndex(ref base, ref idx) => {
3864 let base_t = self.check_expr_with_lvalue_pref(&base, lvalue_pref);
3865 let idx_t = self.check_expr(&idx);
3867 if base_t.references_error() {
3869 } else if idx_t.references_error() {
3872 let base_t = self.structurally_resolved_type(expr.span, base_t);
3873 match self.lookup_indexing(expr, base, base_t, idx_t, lvalue_pref) {
3874 Some((index_ty, element_ty)) => {
3875 self.demand_coerce(idx, idx_t, index_ty);
3879 self.check_expr_has_type(&idx, self.tcx.types.err);
3880 let mut err = self.type_error_struct(
3883 format!("cannot index a value of type `{}`",
3887 // Try to give some advice about indexing tuples.
3888 if let ty::TyTuple(..) = base_t.sty {
3889 let mut needs_note = true;
3890 // If the index is an integer, we can show the actual
3891 // fixed expression:
3892 if let hir::ExprLit(ref lit) = idx.node {
3893 if let ast::LitKind::Int(i,
3894 ast::LitIntType::Unsuffixed) = lit.node {
3895 let snip = tcx.sess.codemap().span_to_snippet(base.span);
3896 if let Ok(snip) = snip {
3897 err.span_suggestion(expr.span,
3898 "to access tuple elements, \
3899 use tuple indexing syntax \
3901 format!("{}.{}", snip, i));
3907 err.help("to access tuple elements, use tuple indexing \
3908 syntax (e.g. `tuple.0`)");
3920 // Finish resolving a path in a struct expression or pattern `S::A { .. }` if necessary.
3921 // The newly resolved definition is written into `type_relative_path_defs`.
3922 fn finish_resolving_struct_path(&self,
3925 node_id: ast::NodeId)
3929 hir::QPath::Resolved(ref maybe_qself, ref path) => {
3930 let opt_self_ty = maybe_qself.as_ref().map(|qself| self.to_ty(qself));
3931 let ty = AstConv::def_to_ty(self, opt_self_ty, path, true);
3934 hir::QPath::TypeRelative(ref qself, ref segment) => {
3935 let ty = self.to_ty(qself);
3937 let def = if let hir::TyPath(hir::QPath::Resolved(_, ref path)) = qself.node {
3942 let (ty, def) = AstConv::associated_path_def_to_ty(self, node_id, path_span,
3945 // Write back the new resolution.
3946 self.tables.borrow_mut().type_relative_path_defs.insert(node_id, def);
3953 // Resolve associated value path into a base type and associated constant or method definition.
3954 // The newly resolved definition is written into `type_relative_path_defs`.
3955 pub fn resolve_ty_and_def_ufcs<'b>(&self,
3956 qpath: &'b hir::QPath,
3957 node_id: ast::NodeId,
3959 -> (Def, Option<Ty<'tcx>>, &'b [hir::PathSegment])
3961 let (ty, item_segment) = match *qpath {
3962 hir::QPath::Resolved(ref opt_qself, ref path) => {
3964 opt_qself.as_ref().map(|qself| self.to_ty(qself)),
3965 &path.segments[..]);
3967 hir::QPath::TypeRelative(ref qself, ref segment) => {
3968 (self.to_ty(qself), segment)
3971 let item_name = item_segment.name;
3972 let def = match self.resolve_ufcs(span, item_name, ty, node_id) {
3975 let def = match error {
3976 method::MethodError::PrivateMatch(def) => def,
3979 if item_name != keywords::Invalid.name() {
3980 self.report_method_error(span, ty, item_name, None, error, None);
3986 // Write back the new resolution.
3987 self.tables.borrow_mut().type_relative_path_defs.insert(node_id, def);
3988 (def, Some(ty), slice::ref_slice(&**item_segment))
3991 pub fn check_decl_initializer(&self,
3992 local: &'gcx hir::Local,
3993 init: &'gcx hir::Expr) -> Ty<'tcx>
3995 let ref_bindings = local.pat.contains_ref_binding();
3997 let local_ty = self.local_ty(init.span, local.id);
3998 if let Some(m) = ref_bindings {
3999 // Somewhat subtle: if we have a `ref` binding in the pattern,
4000 // we want to avoid introducing coercions for the RHS. This is
4001 // both because it helps preserve sanity and, in the case of
4002 // ref mut, for soundness (issue #23116). In particular, in
4003 // the latter case, we need to be clear that the type of the
4004 // referent for the reference that results is *equal to* the
4005 // type of the lvalue it is referencing, and not some
4006 // supertype thereof.
4007 let init_ty = self.check_expr_with_lvalue_pref(init, LvaluePreference::from_mutbl(m));
4008 self.demand_eqtype(init.span, init_ty, local_ty);
4011 self.check_expr_coercable_to_type(init, local_ty)
4015 pub fn check_decl_local(&self, local: &'gcx hir::Local) {
4016 let t = self.local_ty(local.span, local.id);
4017 self.write_ty(local.id, t);
4019 if let Some(ref init) = local.init {
4020 let init_ty = self.check_decl_initializer(local, &init);
4021 if init_ty.references_error() {
4022 self.write_ty(local.id, init_ty);
4026 self.check_pat(&local.pat, t);
4027 let pat_ty = self.node_ty(local.pat.id);
4028 if pat_ty.references_error() {
4029 self.write_ty(local.id, pat_ty);
4033 pub fn check_stmt(&self, stmt: &'gcx hir::Stmt) {
4034 // Don't do all the complex logic below for DeclItem.
4036 hir::StmtDecl(ref decl, id) => {
4038 hir::DeclLocal(_) => {}
4039 hir::DeclItem(_) => {
4045 hir::StmtExpr(..) | hir::StmtSemi(..) => {}
4048 self.warn_if_unreachable(stmt.node.id(), stmt.span, "statement");
4050 // Hide the outer diverging and has_errors flags.
4051 let old_diverges = self.diverges.get();
4052 let old_has_errors = self.has_errors.get();
4053 self.diverges.set(Diverges::Maybe);
4054 self.has_errors.set(false);
4056 let (node_id, _span) = match stmt.node {
4057 hir::StmtDecl(ref decl, id) => {
4058 let span = match decl.node {
4059 hir::DeclLocal(ref l) => {
4060 self.check_decl_local(&l);
4063 hir::DeclItem(_) => {/* ignore for now */
4069 hir::StmtExpr(ref expr, id) => {
4070 // Check with expected type of ()
4071 self.check_expr_has_type(&expr, self.tcx.mk_nil());
4074 hir::StmtSemi(ref expr, id) => {
4075 self.check_expr(&expr);
4080 if self.has_errors.get() {
4081 self.write_error(node_id);
4083 self.write_nil(node_id);
4086 // Combine the diverging and has_error flags.
4087 self.diverges.set(self.diverges.get() | old_diverges);
4088 self.has_errors.set(self.has_errors.get() | old_has_errors);
4091 pub fn check_block_no_value(&self, blk: &'gcx hir::Block) {
4092 let unit = self.tcx.mk_nil();
4093 let ty = self.check_block_with_expected(blk, ExpectHasType(unit));
4095 // if the block produces a `!` value, that can always be
4096 // (effectively) coerced to unit.
4098 self.demand_suptype(blk.span, unit, ty);
4102 fn check_block_with_expected(&self,
4103 blk: &'gcx hir::Block,
4104 expected: Expectation<'tcx>) -> Ty<'tcx> {
4106 let mut fcx_ps = self.ps.borrow_mut();
4107 let unsafety_state = fcx_ps.recurse(blk);
4108 replace(&mut *fcx_ps, unsafety_state)
4111 // In some cases, blocks have just one exit, but other blocks
4112 // can be targeted by multiple breaks. This cannot happen in
4113 // normal Rust syntax today, but it can happen when we desugar
4114 // a `do catch { ... }` expression.
4118 // 'a: { if true { break 'a Err(()); } Ok(()) }
4120 // Here we would wind up with two coercions, one from
4121 // `Err(())` and the other from the tail expression
4122 // `Ok(())`. If the tail expression is omitted, that's a
4123 // "forced unit" -- unless the block diverges, in which
4124 // case we can ignore the tail expression (e.g., `'a: {
4125 // break 'a 22; }` would not force the type of the block
4127 let tail_expr = blk.expr.as_ref();
4128 let coerce_to_ty = expected.coercion_target_type(self, blk.span);
4129 let coerce = if blk.targeted_by_break {
4130 CoerceMany::new(coerce_to_ty)
4132 let tail_expr: &[P<hir::Expr>] = match tail_expr {
4133 Some(e) => ref_slice(e),
4136 CoerceMany::with_coercion_sites(coerce_to_ty, tail_expr)
4139 let ctxt = BreakableCtxt {
4140 coerce: Some(coerce),
4144 let (ctxt, ()) = self.with_breakable_ctxt(blk.id, ctxt, || {
4145 for s in &blk.stmts {
4149 // check the tail expression **without** holding the
4150 // `enclosing_breakables` lock below.
4151 let tail_expr_ty = tail_expr.map(|t| self.check_expr_with_expectation(t, expected));
4153 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4154 let mut ctxt = enclosing_breakables.find_breakable(blk.id);
4155 let mut coerce = ctxt.coerce.as_mut().unwrap();
4156 if let Some(tail_expr_ty) = tail_expr_ty {
4157 let tail_expr = tail_expr.unwrap();
4159 &self.misc(tail_expr.span),
4162 self.diverges.get());
4164 // Subtle: if there is no explicit tail expression,
4165 // that is typically equivalent to a tail expression
4166 // of `()` -- except if the block diverges. In that
4167 // case, there is no value supplied from the tail
4168 // expression (assuming there are no other breaks,
4169 // this implies that the type of the block will be
4171 if !self.diverges.get().always() {
4172 coerce.coerce_forced_unit(self, &self.misc(blk.span), &mut |err| {
4173 if let Some(expected_ty) = expected.only_has_type(self) {
4174 self.consider_hint_about_removing_semicolon(blk,
4183 let mut ty = ctxt.coerce.unwrap().complete(self);
4185 if self.has_errors.get() || ty.references_error() {
4186 ty = self.tcx.types.err
4189 self.write_ty(blk.id, ty);
4191 *self.ps.borrow_mut() = prev;
4195 /// A common error is to add an extra semicolon:
4198 /// fn foo() -> usize {
4203 /// This routine checks if the final statement in a block is an
4204 /// expression with an explicit semicolon whose type is compatible
4205 /// with `expected_ty`. If so, it suggests removing the semicolon.
4206 fn consider_hint_about_removing_semicolon(&self,
4207 blk: &'gcx hir::Block,
4208 expected_ty: Ty<'tcx>,
4209 err: &mut DiagnosticBuilder) {
4210 // Be helpful when the user wrote `{... expr;}` and
4211 // taking the `;` off is enough to fix the error.
4212 let last_stmt = match blk.stmts.last() {
4216 let last_expr = match last_stmt.node {
4217 hir::StmtSemi(ref e, _) => e,
4220 let last_expr_ty = self.expr_ty(last_expr);
4221 if self.can_sub_types(last_expr_ty, expected_ty).is_err() {
4224 let original_span = original_sp(last_stmt.span, blk.span);
4225 let span_semi = Span {
4226 lo: original_span.hi - BytePos(1),
4227 hi: original_span.hi,
4228 ctxt: original_span.ctxt,
4230 err.span_help(span_semi, "consider removing this semicolon:");
4233 // Instantiates the given path, which must refer to an item with the given
4234 // number of type parameters and type.
4235 pub fn instantiate_value_path(&self,
4236 segments: &[hir::PathSegment],
4237 opt_self_ty: Option<Ty<'tcx>>,
4240 node_id: ast::NodeId)
4242 debug!("instantiate_value_path(path={:?}, def={:?}, node_id={})",
4247 // We need to extract the type parameters supplied by the user in
4248 // the path `path`. Due to the current setup, this is a bit of a
4249 // tricky-process; the problem is that resolve only tells us the
4250 // end-point of the path resolution, and not the intermediate steps.
4251 // Luckily, we can (at least for now) deduce the intermediate steps
4252 // just from the end-point.
4254 // There are basically four cases to consider:
4256 // 1. Reference to a constructor of enum variant or struct:
4258 // struct Foo<T>(...)
4259 // enum E<T> { Foo(...) }
4261 // In these cases, the parameters are declared in the type
4264 // 2. Reference to a fn item or a free constant:
4268 // In this case, the path will again always have the form
4269 // `a::b::foo::<T>` where only the final segment should have
4270 // type parameters. However, in this case, those parameters are
4271 // declared on a value, and hence are in the `FnSpace`.
4273 // 3. Reference to a method or an associated constant:
4275 // impl<A> SomeStruct<A> {
4279 // Here we can have a path like
4280 // `a::b::SomeStruct::<A>::foo::<B>`, in which case parameters
4281 // may appear in two places. The penultimate segment,
4282 // `SomeStruct::<A>`, contains parameters in TypeSpace, and the
4283 // final segment, `foo::<B>` contains parameters in fn space.
4285 // 4. Reference to a local variable
4287 // Local variables can't have any type parameters.
4289 // The first step then is to categorize the segments appropriately.
4291 assert!(!segments.is_empty());
4293 let mut ufcs_associated = None;
4294 let mut type_segment = None;
4295 let mut fn_segment = None;
4297 // Case 1. Reference to a struct/variant constructor.
4298 Def::StructCtor(def_id, ..) |
4299 Def::VariantCtor(def_id, ..) => {
4300 // Everything but the final segment should have no
4301 // parameters at all.
4302 let mut generics = self.tcx.item_generics(def_id);
4303 if let Some(def_id) = generics.parent {
4304 // Variant and struct constructors use the
4305 // generics of their parent type definition.
4306 generics = self.tcx.item_generics(def_id);
4308 type_segment = Some((segments.last().unwrap(), generics));
4311 // Case 2. Reference to a top-level value.
4313 Def::Const(def_id) |
4314 Def::Static(def_id, _) => {
4315 fn_segment = Some((segments.last().unwrap(),
4316 self.tcx.item_generics(def_id)));
4319 // Case 3. Reference to a method or associated const.
4320 Def::Method(def_id) |
4321 Def::AssociatedConst(def_id) => {
4322 let container = self.tcx.associated_item(def_id).container;
4324 ty::TraitContainer(trait_did) => {
4325 callee::check_legal_trait_for_method_call(self.tcx, span, trait_did)
4327 ty::ImplContainer(_) => {}
4330 let generics = self.tcx.item_generics(def_id);
4331 if segments.len() >= 2 {
4332 let parent_generics = self.tcx.item_generics(generics.parent.unwrap());
4333 type_segment = Some((&segments[segments.len() - 2], parent_generics));
4335 // `<T>::assoc` will end up here, and so can `T::assoc`.
4336 let self_ty = opt_self_ty.expect("UFCS sugared assoc missing Self");
4337 ufcs_associated = Some((container, self_ty));
4339 fn_segment = Some((segments.last().unwrap(), generics));
4342 // Case 4. Local variable, no generics.
4343 Def::Local(..) | Def::Upvar(..) => {}
4345 _ => bug!("unexpected definition: {:?}", def),
4348 debug!("type_segment={:?} fn_segment={:?}", type_segment, fn_segment);
4350 // Now that we have categorized what space the parameters for each
4351 // segment belong to, let's sort out the parameters that the user
4352 // provided (if any) into their appropriate spaces. We'll also report
4353 // errors if type parameters are provided in an inappropriate place.
4354 let poly_segments = type_segment.is_some() as usize +
4355 fn_segment.is_some() as usize;
4356 AstConv::prohibit_type_params(self, &segments[..segments.len() - poly_segments]);
4359 Def::Local(def_id) | Def::Upvar(def_id, ..) => {
4360 let nid = self.tcx.hir.as_local_node_id(def_id).unwrap();
4361 let ty = self.local_ty(span, nid);
4362 let ty = self.normalize_associated_types_in(span, &ty);
4363 self.write_ty(node_id, ty);
4364 self.write_substs(node_id, ty::ItemSubsts {
4365 substs: self.tcx.intern_substs(&[])
4372 // Now we have to compare the types that the user *actually*
4373 // provided against the types that were *expected*. If the user
4374 // did not provide any types, then we want to substitute inference
4375 // variables. If the user provided some types, we may still need
4376 // to add defaults. If the user provided *too many* types, that's
4378 self.check_path_parameter_count(span, &mut type_segment);
4379 self.check_path_parameter_count(span, &mut fn_segment);
4381 let (fn_start, has_self) = match (type_segment, fn_segment) {
4382 (_, Some((_, generics))) => {
4383 (generics.parent_count(), generics.has_self)
4385 (Some((_, generics)), None) => {
4386 (generics.own_count(), generics.has_self)
4388 (None, None) => (0, false)
4390 let substs = Substs::for_item(self.tcx, def.def_id(), |def, _| {
4391 let mut i = def.index as usize;
4393 let segment = if i < fn_start {
4394 i -= has_self as usize;
4400 let lifetimes = match segment.map(|(s, _)| &s.parameters) {
4401 Some(&hir::AngleBracketedParameters(ref data)) => &data.lifetimes[..],
4402 Some(&hir::ParenthesizedParameters(_)) => bug!(),
4406 if let Some(lifetime) = lifetimes.get(i) {
4407 AstConv::ast_region_to_region(self, lifetime, Some(def))
4409 self.re_infer(span, Some(def)).unwrap()
4412 let mut i = def.index as usize;
4414 let segment = if i < fn_start {
4415 // Handle Self first, so we can adjust the index to match the AST.
4416 if has_self && i == 0 {
4417 return opt_self_ty.unwrap_or_else(|| {
4418 self.type_var_for_def(span, def, substs)
4421 i -= has_self as usize;
4427 let (types, infer_types) = match segment.map(|(s, _)| &s.parameters) {
4428 Some(&hir::AngleBracketedParameters(ref data)) => {
4429 (&data.types[..], data.infer_types)
4431 Some(&hir::ParenthesizedParameters(_)) => bug!(),
4432 None => (&[][..], true)
4435 // Skip over the lifetimes in the same segment.
4436 if let Some((_, generics)) = segment {
4437 i -= generics.regions.len();
4440 if let Some(ast_ty) = types.get(i) {
4441 // A provided type parameter.
4443 } else if !infer_types && def.has_default {
4444 // No type parameter provided, but a default exists.
4445 let default = self.tcx.item_type(def.def_id);
4448 default.subst_spanned(self.tcx, substs, Some(span))
4451 // No type parameters were provided, we can infer all.
4452 // This can also be reached in some error cases:
4453 // We prefer to use inference variables instead of
4454 // TyError to let type inference recover somewhat.
4455 self.type_var_for_def(span, def, substs)
4459 // The things we are substituting into the type should not contain
4460 // escaping late-bound regions, and nor should the base type scheme.
4461 let ty = self.tcx.item_type(def.def_id());
4462 assert!(!substs.has_escaping_regions());
4463 assert!(!ty.has_escaping_regions());
4465 // Add all the obligations that are required, substituting and
4466 // normalized appropriately.
4467 let bounds = self.instantiate_bounds(span, def.def_id(), &substs);
4468 self.add_obligations_for_parameters(
4469 traits::ObligationCause::new(span, self.body_id, traits::ItemObligation(def.def_id())),
4472 // Substitute the values for the type parameters into the type of
4473 // the referenced item.
4474 let ty_substituted = self.instantiate_type_scheme(span, &substs, &ty);
4476 if let Some((ty::ImplContainer(impl_def_id), self_ty)) = ufcs_associated {
4477 // In the case of `Foo<T>::method` and `<Foo<T>>::method`, if `method`
4478 // is inherent, there is no `Self` parameter, instead, the impl needs
4479 // type parameters, which we can infer by unifying the provided `Self`
4480 // with the substituted impl type.
4481 let ty = self.tcx.item_type(impl_def_id);
4483 let impl_ty = self.instantiate_type_scheme(span, &substs, &ty);
4484 match self.sub_types(false, &self.misc(span), self_ty, impl_ty) {
4485 Ok(ok) => self.register_infer_ok_obligations(ok),
4488 "instantiate_value_path: (UFCS) {:?} was a subtype of {:?} but now is not?",
4495 debug!("instantiate_value_path: type of {:?} is {:?}",
4498 self.write_substs(node_id, ty::ItemSubsts {
4504 /// Report errors if the provided parameters are too few or too many.
4505 fn check_path_parameter_count(&self,
4507 segment: &mut Option<(&hir::PathSegment, &ty::Generics)>) {
4508 let (lifetimes, types, infer_types, bindings) = {
4509 match segment.map(|(s, _)| &s.parameters) {
4510 Some(&hir::AngleBracketedParameters(ref data)) => {
4511 (&data.lifetimes[..], &data.types[..], data.infer_types, &data.bindings[..])
4513 Some(&hir::ParenthesizedParameters(_)) => {
4514 span_bug!(span, "parenthesized parameters cannot appear in ExprPath");
4516 None => (&[][..], &[][..], true, &[][..])
4520 let count_lifetime_params = |n| {
4521 format!("{} lifetime parameter{}", n, if n == 1 { "" } else { "s" })
4523 let count_type_params = |n| {
4524 format!("{} type parameter{}", n, if n == 1 { "" } else { "s" })
4527 // Check provided lifetime parameters.
4528 let lifetime_defs = segment.map_or(&[][..], |(_, generics)| &generics.regions);
4529 if lifetimes.len() > lifetime_defs.len() {
4530 let expected_text = count_lifetime_params(lifetime_defs.len());
4531 let actual_text = count_lifetime_params(lifetimes.len());
4532 struct_span_err!(self.tcx.sess, span, E0088,
4533 "too many lifetime parameters provided: \
4534 expected at most {}, found {}",
4535 expected_text, actual_text)
4536 .span_label(span, &format!("expected {}", expected_text))
4538 } else if lifetimes.len() > 0 && lifetimes.len() < lifetime_defs.len() {
4539 let expected_text = count_lifetime_params(lifetime_defs.len());
4540 let actual_text = count_lifetime_params(lifetimes.len());
4541 struct_span_err!(self.tcx.sess, span, E0090,
4542 "too few lifetime parameters provided: \
4543 expected {}, found {}",
4544 expected_text, actual_text)
4545 .span_label(span, &format!("expected {}", expected_text))
4549 // The case where there is not enough lifetime parameters is not checked,
4550 // because this is not possible - a function never takes lifetime parameters.
4551 // See discussion for Pull Request 36208.
4553 // Check provided type parameters.
4554 let type_defs = segment.map_or(&[][..], |(_, generics)| {
4555 if generics.parent.is_none() {
4556 &generics.types[generics.has_self as usize..]
4561 let required_len = type_defs.iter().take_while(|d| !d.has_default).count();
4562 if types.len() > type_defs.len() {
4563 let span = types[type_defs.len()].span;
4564 let expected_text = count_type_params(type_defs.len());
4565 let actual_text = count_type_params(types.len());
4566 struct_span_err!(self.tcx.sess, span, E0087,
4567 "too many type parameters provided: \
4568 expected at most {}, found {}",
4569 expected_text, actual_text)
4570 .span_label(span, &format!("expected {}", expected_text))
4573 // To prevent derived errors to accumulate due to extra
4574 // type parameters, we force instantiate_value_path to
4575 // use inference variables instead of the provided types.
4577 } else if !infer_types && types.len() < required_len {
4578 let expected_text = count_type_params(required_len);
4579 let actual_text = count_type_params(types.len());
4580 struct_span_err!(self.tcx.sess, span, E0089,
4581 "too few type parameters provided: \
4582 expected {}, found {}",
4583 expected_text, actual_text)
4584 .span_label(span, &format!("expected {}", expected_text))
4588 if !bindings.is_empty() {
4589 span_err!(self.tcx.sess, bindings[0].span, E0182,
4590 "unexpected binding of associated item in expression path \
4591 (only allowed in type paths)");
4595 fn structurally_resolve_type_or_else<F>(&self, sp: Span, ty: Ty<'tcx>, f: F)
4597 where F: Fn() -> Ty<'tcx>
4599 let mut ty = self.resolve_type_vars_with_obligations(ty);
4602 let alternative = f();
4605 if alternative.is_ty_var() || alternative.references_error() {
4606 if !self.is_tainted_by_errors() {
4607 self.type_error_message(sp, |_actual| {
4608 "the type of this value must be known in this context".to_string()
4611 self.demand_suptype(sp, self.tcx.types.err, ty);
4612 ty = self.tcx.types.err;
4614 self.demand_suptype(sp, alternative, ty);
4622 // Resolves `typ` by a single level if `typ` is a type variable. If no
4623 // resolution is possible, then an error is reported.
4624 pub fn structurally_resolved_type(&self, sp: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
4625 self.structurally_resolve_type_or_else(sp, ty, || {
4630 fn with_breakable_ctxt<F: FnOnce() -> R, R>(&self, id: ast::NodeId,
4631 ctxt: BreakableCtxt<'gcx, 'tcx>, f: F)
4632 -> (BreakableCtxt<'gcx, 'tcx>, R) {
4635 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4636 index = enclosing_breakables.stack.len();
4637 enclosing_breakables.by_id.insert(id, index);
4638 enclosing_breakables.stack.push(ctxt);
4642 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4643 debug_assert!(enclosing_breakables.stack.len() == index + 1);
4644 enclosing_breakables.by_id.remove(&id).expect("missing breakable context");
4645 enclosing_breakables.stack.pop().expect("missing breakable context")
4651 pub fn check_bounds_are_used<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
4652 generics: &hir::Generics,
4654 debug!("check_bounds_are_used(n_tps={}, ty={:?})",
4655 generics.ty_params.len(), ty);
4657 // make a vector of booleans initially false, set to true when used
4658 if generics.ty_params.is_empty() { return; }
4659 let mut tps_used = vec![false; generics.ty_params.len()];
4661 for leaf_ty in ty.walk() {
4662 if let ty::TyParam(ParamTy {idx, ..}) = leaf_ty.sty {
4663 debug!("Found use of ty param num {}", idx);
4664 tps_used[idx as usize - generics.lifetimes.len()] = true;
4668 for (&used, param) in tps_used.iter().zip(&generics.ty_params) {
4670 struct_span_err!(tcx.sess, param.span, E0091,
4671 "type parameter `{}` is unused",
4673 .span_label(param.span, &format!("unused type parameter"))