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.node_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::autoderef::Autoderef;
81 use self::callee::DeferredCallResolution;
82 use self::coercion::{CoerceMany, DynamicCoerceMany};
83 pub use self::compare_method::{compare_impl_method, compare_const_impl};
84 use self::method::MethodCallee;
85 use self::TupleArgumentsFlag::*;
88 use fmt_macros::{Parser, Piece, Position};
89 use hir::def::{Def, CtorKind};
90 use hir::def_id::{CrateNum, DefId, LOCAL_CRATE};
91 use rustc_back::slice::ref_slice;
92 use rustc::infer::{self, InferCtxt, InferOk, RegionVariableOrigin};
93 use rustc::infer::type_variable::{TypeVariableOrigin};
94 use rustc::middle::region::CodeExtent;
95 use rustc::ty::subst::{Kind, Subst, Substs};
96 use rustc::traits::{self, FulfillmentContext, ObligationCause, ObligationCauseCode};
97 use rustc::ty::{ParamTy, LvaluePreference, NoPreference, PreferMutLvalue};
98 use rustc::ty::{self, Ty, TyCtxt, Visibility};
99 use rustc::ty::adjustment::{Adjust, Adjustment, AutoBorrow};
100 use rustc::ty::fold::{BottomUpFolder, TypeFoldable};
101 use rustc::ty::maps::Providers;
102 use rustc::ty::util::{Representability, IntTypeExt};
103 use errors::DiagnosticBuilder;
104 use require_c_abi_if_variadic;
105 use session::{CompileIncomplete, Session};
108 use util::common::{ErrorReported, indenter};
109 use util::nodemap::{DefIdMap, FxHashMap, NodeMap};
111 use std::cell::{Cell, RefCell, Ref, RefMut};
112 use std::collections::hash_map::Entry;
114 use std::fmt::Display;
115 use std::mem::replace;
116 use std::ops::{self, Deref};
117 use syntax::abi::Abi;
119 use syntax::codemap::{self, original_sp, Spanned};
120 use syntax::feature_gate::{GateIssue, emit_feature_err};
122 use syntax::symbol::{Symbol, InternedString, keywords};
123 use syntax::util::lev_distance::find_best_match_for_name;
124 use syntax_pos::{self, BytePos, Span, MultiSpan};
126 use rustc::hir::intravisit::{self, Visitor, NestedVisitorMap};
127 use rustc::hir::itemlikevisit::ItemLikeVisitor;
128 use rustc::hir::map::Node;
129 use rustc::hir::{self, PatKind};
130 use rustc::middle::lang_items;
131 use rustc_back::slice;
132 use rustc::middle::const_val::eval_length;
133 use rustc_const_math::ConstInt;
152 /// A wrapper for InferCtxt's `in_progress_tables` field.
153 #[derive(Copy, Clone)]
154 struct MaybeInProgressTables<'a, 'tcx: 'a> {
155 maybe_tables: Option<&'a RefCell<ty::TypeckTables<'tcx>>>,
158 impl<'a, 'tcx> MaybeInProgressTables<'a, 'tcx> {
159 fn borrow(self) -> Ref<'a, ty::TypeckTables<'tcx>> {
160 match self.maybe_tables {
161 Some(tables) => tables.borrow(),
163 bug!("MaybeInProgressTables: inh/fcx.tables.borrow() with no tables")
168 fn borrow_mut(self) -> RefMut<'a, ty::TypeckTables<'tcx>> {
169 match self.maybe_tables {
170 Some(tables) => tables.borrow_mut(),
172 bug!("MaybeInProgressTables: inh/fcx.tables.borrow_mut() with no tables")
179 /// closures defined within the function. For example:
182 /// bar(move|| { ... })
185 /// Here, the function `foo()` and the closure passed to
186 /// `bar()` will each have their own `FnCtxt`, but they will
187 /// share the inherited fields.
188 pub struct Inherited<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
189 infcx: InferCtxt<'a, 'gcx, 'tcx>,
191 tables: MaybeInProgressTables<'a, 'tcx>,
193 locals: RefCell<NodeMap<Ty<'tcx>>>,
195 fulfillment_cx: RefCell<traits::FulfillmentContext<'tcx>>,
197 // When we process a call like `c()` where `c` is a closure type,
198 // we may not have decided yet whether `c` is a `Fn`, `FnMut`, or
199 // `FnOnce` closure. In that case, we defer full resolution of the
200 // call until upvar inference can kick in and make the
201 // decision. We keep these deferred resolutions grouped by the
202 // def-id of the closure, so that once we decide, we can easily go
203 // back and process them.
204 deferred_call_resolutions: RefCell<DefIdMap<Vec<DeferredCallResolution<'gcx, 'tcx>>>>,
206 deferred_cast_checks: RefCell<Vec<cast::CastCheck<'tcx>>>,
208 // Anonymized types found in explicit return types and their
209 // associated fresh inference variable. Writeback resolves these
210 // variables to get the concrete type, which can be used to
211 // deanonymize TyAnon, after typeck is done with all functions.
212 anon_types: RefCell<NodeMap<Ty<'tcx>>>,
214 /// Each type parameter has an implicit region bound that
215 /// indicates it must outlive at least the function body (the user
216 /// may specify stronger requirements). This field indicates the
217 /// region of the callee. If it is `None`, then the parameter
218 /// environment is for an item or something where the "callee" is
220 implicit_region_bound: Option<ty::Region<'tcx>>,
222 body_id: Option<hir::BodyId>,
225 impl<'a, 'gcx, 'tcx> Deref for Inherited<'a, 'gcx, 'tcx> {
226 type Target = InferCtxt<'a, 'gcx, 'tcx>;
227 fn deref(&self) -> &Self::Target {
232 /// When type-checking an expression, we propagate downward
233 /// whatever type hint we are able in the form of an `Expectation`.
234 #[derive(Copy, Clone, Debug)]
235 pub enum Expectation<'tcx> {
236 /// We know nothing about what type this expression should have.
239 /// This expression is an `if` condition, it must resolve to `bool`.
242 /// This expression should have the type given (or some subtype)
243 ExpectHasType(Ty<'tcx>),
245 /// This expression will be cast to the `Ty`
246 ExpectCastableToType(Ty<'tcx>),
248 /// This rvalue expression will be wrapped in `&` or `Box` and coerced
249 /// to `&Ty` or `Box<Ty>`, respectively. `Ty` is `[A]` or `Trait`.
250 ExpectRvalueLikeUnsized(Ty<'tcx>),
253 impl<'a, 'gcx, 'tcx> Expectation<'tcx> {
254 // Disregard "castable to" expectations because they
255 // can lead us astray. Consider for example `if cond
256 // {22} else {c} as u8` -- if we propagate the
257 // "castable to u8" constraint to 22, it will pick the
258 // type 22u8, which is overly constrained (c might not
259 // be a u8). In effect, the problem is that the
260 // "castable to" expectation is not the tightest thing
261 // we can say, so we want to drop it in this case.
262 // The tightest thing we can say is "must unify with
263 // else branch". Note that in the case of a "has type"
264 // constraint, this limitation does not hold.
266 // If the expected type is just a type variable, then don't use
267 // an expected type. Otherwise, we might write parts of the type
268 // when checking the 'then' block which are incompatible with the
270 fn adjust_for_branches(&self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) -> Expectation<'tcx> {
272 ExpectHasType(ety) => {
273 let ety = fcx.shallow_resolve(ety);
274 if !ety.is_ty_var() {
280 ExpectRvalueLikeUnsized(ety) => {
281 ExpectRvalueLikeUnsized(ety)
287 /// Provide an expectation for an rvalue expression given an *optional*
288 /// hint, which is not required for type safety (the resulting type might
289 /// be checked higher up, as is the case with `&expr` and `box expr`), but
290 /// is useful in determining the concrete type.
292 /// The primary use case is where the expected type is a fat pointer,
293 /// like `&[isize]`. For example, consider the following statement:
295 /// let x: &[isize] = &[1, 2, 3];
297 /// In this case, the expected type for the `&[1, 2, 3]` expression is
298 /// `&[isize]`. If however we were to say that `[1, 2, 3]` has the
299 /// expectation `ExpectHasType([isize])`, that would be too strong --
300 /// `[1, 2, 3]` does not have the type `[isize]` but rather `[isize; 3]`.
301 /// It is only the `&[1, 2, 3]` expression as a whole that can be coerced
302 /// to the type `&[isize]`. Therefore, we propagate this more limited hint,
303 /// which still is useful, because it informs integer literals and the like.
304 /// See the test case `test/run-pass/coerce-expect-unsized.rs` and #20169
305 /// for examples of where this comes up,.
306 fn rvalue_hint(fcx: &FnCtxt<'a, 'gcx, 'tcx>, ty: Ty<'tcx>) -> Expectation<'tcx> {
307 match fcx.tcx.struct_tail(ty).sty {
308 ty::TySlice(_) | ty::TyStr | ty::TyDynamic(..) => {
309 ExpectRvalueLikeUnsized(ty)
311 _ => ExpectHasType(ty)
315 // Resolves `expected` by a single level if it is a variable. If
316 // there is no expected type or resolution is not possible (e.g.,
317 // no constraints yet present), just returns `None`.
318 fn resolve(self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) -> Expectation<'tcx> {
320 NoExpectation => NoExpectation,
321 ExpectIfCondition => ExpectIfCondition,
322 ExpectCastableToType(t) => {
323 ExpectCastableToType(fcx.resolve_type_vars_if_possible(&t))
325 ExpectHasType(t) => {
326 ExpectHasType(fcx.resolve_type_vars_if_possible(&t))
328 ExpectRvalueLikeUnsized(t) => {
329 ExpectRvalueLikeUnsized(fcx.resolve_type_vars_if_possible(&t))
334 fn to_option(self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) -> Option<Ty<'tcx>> {
335 match self.resolve(fcx) {
336 NoExpectation => None,
337 ExpectIfCondition => Some(fcx.tcx.types.bool),
338 ExpectCastableToType(ty) |
340 ExpectRvalueLikeUnsized(ty) => Some(ty),
344 /// It sometimes happens that we want to turn an expectation into
345 /// a **hard constraint** (i.e., something that must be satisfied
346 /// for the program to type-check). `only_has_type` will return
347 /// such a constraint, if it exists.
348 fn only_has_type(self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) -> Option<Ty<'tcx>> {
349 match self.resolve(fcx) {
350 ExpectHasType(ty) => Some(ty),
351 ExpectIfCondition => Some(fcx.tcx.types.bool),
352 NoExpectation | ExpectCastableToType(_) | ExpectRvalueLikeUnsized(_) => None,
356 /// Like `only_has_type`, but instead of returning `None` if no
357 /// hard constraint exists, creates a fresh type variable.
358 fn coercion_target_type(self, fcx: &FnCtxt<'a, 'gcx, 'tcx>, span: Span) -> Ty<'tcx> {
359 self.only_has_type(fcx)
360 .unwrap_or_else(|| fcx.next_ty_var(TypeVariableOrigin::MiscVariable(span)))
364 #[derive(Copy, Clone)]
365 pub struct UnsafetyState {
366 pub def: ast::NodeId,
367 pub unsafety: hir::Unsafety,
368 pub unsafe_push_count: u32,
373 pub fn function(unsafety: hir::Unsafety, def: ast::NodeId) -> UnsafetyState {
374 UnsafetyState { def: def, unsafety: unsafety, unsafe_push_count: 0, from_fn: true }
377 pub fn recurse(&mut self, blk: &hir::Block) -> UnsafetyState {
378 match self.unsafety {
379 // If this unsafe, then if the outer function was already marked as
380 // unsafe we shouldn't attribute the unsafe'ness to the block. This
381 // way the block can be warned about instead of ignoring this
382 // extraneous block (functions are never warned about).
383 hir::Unsafety::Unsafe if self.from_fn => *self,
386 let (unsafety, def, count) = match blk.rules {
387 hir::PushUnsafeBlock(..) =>
388 (unsafety, blk.id, self.unsafe_push_count.checked_add(1).unwrap()),
389 hir::PopUnsafeBlock(..) =>
390 (unsafety, blk.id, self.unsafe_push_count.checked_sub(1).unwrap()),
391 hir::UnsafeBlock(..) =>
392 (hir::Unsafety::Unsafe, blk.id, self.unsafe_push_count),
394 (unsafety, self.def, self.unsafe_push_count),
396 UnsafetyState{ def: def,
398 unsafe_push_count: count,
405 #[derive(Debug, Copy, Clone)]
411 /// Tracks whether executing a node may exit normally (versus
412 /// return/break/panic, which "diverge", leaving dead code in their
413 /// wake). Tracked semi-automatically (through type variables marked
414 /// as diverging), with some manual adjustments for control-flow
415 /// primitives (approximating a CFG).
416 #[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
418 /// Potentially unknown, some cases converge,
419 /// others require a CFG to determine them.
422 /// Definitely known to diverge and therefore
423 /// not reach the next sibling or its parent.
426 /// Same as `Always` but with a reachability
427 /// warning already emitted
431 // Convenience impls for combinig `Diverges`.
433 impl ops::BitAnd for Diverges {
435 fn bitand(self, other: Self) -> Self {
436 cmp::min(self, other)
440 impl ops::BitOr for Diverges {
442 fn bitor(self, other: Self) -> Self {
443 cmp::max(self, other)
447 impl ops::BitAndAssign for Diverges {
448 fn bitand_assign(&mut self, other: Self) {
449 *self = *self & other;
453 impl ops::BitOrAssign for Diverges {
454 fn bitor_assign(&mut self, other: Self) {
455 *self = *self | other;
460 fn always(self) -> bool {
461 self >= Diverges::Always
465 pub struct BreakableCtxt<'gcx: 'tcx, 'tcx> {
468 // this is `null` for loops where break with a value is illegal,
469 // such as `while`, `for`, and `while let`
470 coerce: Option<DynamicCoerceMany<'gcx, 'tcx>>,
473 pub struct EnclosingBreakables<'gcx: 'tcx, 'tcx> {
474 stack: Vec<BreakableCtxt<'gcx, 'tcx>>,
475 by_id: NodeMap<usize>,
478 impl<'gcx, 'tcx> EnclosingBreakables<'gcx, 'tcx> {
479 fn find_breakable(&mut self, target_id: ast::NodeId) -> &mut BreakableCtxt<'gcx, 'tcx> {
480 let ix = *self.by_id.get(&target_id).unwrap_or_else(|| {
481 bug!("could not find enclosing breakable with id {}", target_id);
487 pub struct FnCtxt<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
488 body_id: ast::NodeId,
490 /// The parameter environment used for proving trait obligations
491 /// in this function. This can change when we descend into
492 /// closures (as they bring new things into scope), hence it is
493 /// not part of `Inherited` (as of the time of this writing,
494 /// closures do not yet change the environment, but they will
496 param_env: ty::ParamEnv<'tcx>,
498 // Number of errors that had been reported when we started
499 // checking this function. On exit, if we find that *more* errors
500 // have been reported, we will skip regionck and other work that
501 // expects the types within the function to be consistent.
502 err_count_on_creation: usize,
504 ret_coercion: Option<RefCell<DynamicCoerceMany<'gcx, 'tcx>>>,
506 ps: RefCell<UnsafetyState>,
508 /// Whether the last checked node generates a divergence (e.g.,
509 /// `return` will set this to Always). In general, when entering
510 /// an expression or other node in the tree, the initial value
511 /// indicates whether prior parts of the containing expression may
512 /// have diverged. It is then typically set to `Maybe` (and the
513 /// old value remembered) for processing the subparts of the
514 /// current expression. As each subpart is processed, they may set
515 /// the flag to `Always` etc. Finally, at the end, we take the
516 /// result and "union" it with the original value, so that when we
517 /// return the flag indicates if any subpart of the the parent
518 /// expression (up to and including this part) has diverged. So,
519 /// if you read it after evaluating a subexpression `X`, the value
520 /// you get indicates whether any subexpression that was
521 /// evaluating up to and including `X` diverged.
523 /// We use this flag for two purposes:
525 /// - To warn about unreachable code: if, after processing a
526 /// sub-expression but before we have applied the effects of the
527 /// current node, we see that the flag is set to `Always`, we
528 /// can issue a warning. This corresponds to something like
529 /// `foo(return)`; we warn on the `foo()` expression. (We then
530 /// update the flag to `WarnedAlways` to suppress duplicate
531 /// reports.) Similarly, if we traverse to a fresh statement (or
532 /// tail expression) from a `Always` setting, we will isssue a
533 /// warning. This corresponds to something like `{return;
534 /// foo();}` or `{return; 22}`, where we would warn on the
537 /// - To permit assignment into a local variable or other lvalue
538 /// (including the "return slot") of type `!`. This is allowed
539 /// if **either** the type of value being assigned is `!`, which
540 /// means the current code is dead, **or** the expression's
541 /// divering flag is true, which means that a divering value was
542 /// wrapped (e.g., `let x: ! = foo(return)`).
544 /// To repeat the last point: an expression represents dead-code
545 /// if, after checking it, **either** its type is `!` OR the
546 /// diverges flag is set to something other than `Maybe`.
547 diverges: Cell<Diverges>,
549 /// Whether any child nodes have any type errors.
550 has_errors: Cell<bool>,
552 enclosing_breakables: RefCell<EnclosingBreakables<'gcx, 'tcx>>,
554 inh: &'a Inherited<'a, 'gcx, 'tcx>,
557 impl<'a, 'gcx, 'tcx> Deref for FnCtxt<'a, 'gcx, 'tcx> {
558 type Target = Inherited<'a, 'gcx, 'tcx>;
559 fn deref(&self) -> &Self::Target {
564 /// Helper type of a temporary returned by Inherited::build(...).
565 /// Necessary because we can't write the following bound:
566 /// F: for<'b, 'tcx> where 'gcx: 'tcx FnOnce(Inherited<'b, 'gcx, 'tcx>).
567 pub struct InheritedBuilder<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
568 infcx: infer::InferCtxtBuilder<'a, 'gcx, 'tcx>,
572 impl<'a, 'gcx, 'tcx> Inherited<'a, 'gcx, 'tcx> {
573 pub fn build(tcx: TyCtxt<'a, 'gcx, 'gcx>, def_id: DefId)
574 -> InheritedBuilder<'a, 'gcx, 'tcx> {
576 infcx: tcx.infer_ctxt().with_fresh_in_progress_tables(),
582 impl<'a, 'gcx, 'tcx> InheritedBuilder<'a, 'gcx, 'tcx> {
583 fn enter<F, R>(&'tcx mut self, f: F) -> R
584 where F: for<'b> FnOnce(Inherited<'b, 'gcx, 'tcx>) -> R
586 let def_id = self.def_id;
587 self.infcx.enter(|infcx| f(Inherited::new(infcx, def_id)))
591 impl<'a, 'gcx, 'tcx> Inherited<'a, 'gcx, 'tcx> {
592 fn new(infcx: InferCtxt<'a, 'gcx, 'tcx>, def_id: DefId) -> Self {
594 let item_id = tcx.hir.as_local_node_id(def_id);
595 let body_id = item_id.and_then(|id| tcx.hir.maybe_body_owned_by(id));
596 let implicit_region_bound = body_id.map(|body| {
597 tcx.mk_region(ty::ReScope(CodeExtent::CallSiteScope(body)))
601 tables: MaybeInProgressTables {
602 maybe_tables: infcx.in_progress_tables,
605 fulfillment_cx: RefCell::new(traits::FulfillmentContext::new()),
606 locals: RefCell::new(NodeMap()),
607 deferred_call_resolutions: RefCell::new(DefIdMap()),
608 deferred_cast_checks: RefCell::new(Vec::new()),
609 anon_types: RefCell::new(NodeMap()),
610 implicit_region_bound,
615 fn register_predicate(&self, obligation: traits::PredicateObligation<'tcx>) {
616 debug!("register_predicate({:?})", obligation);
617 if obligation.has_escaping_regions() {
618 span_bug!(obligation.cause.span, "escaping regions in predicate {:?}",
623 .register_predicate_obligation(self, obligation);
626 fn register_predicates<I>(&self, obligations: I)
627 where I: IntoIterator<Item = traits::PredicateObligation<'tcx>> {
628 for obligation in obligations {
629 self.register_predicate(obligation);
633 fn register_infer_ok_obligations<T>(&self, infer_ok: InferOk<'tcx, T>) -> T {
634 self.register_predicates(infer_ok.obligations);
638 fn normalize_associated_types_in<T>(&self,
640 body_id: ast::NodeId,
641 param_env: ty::ParamEnv<'tcx>,
643 where T : TypeFoldable<'tcx>
645 let ok = self.normalize_associated_types_in_as_infer_ok(span, body_id, param_env, value);
646 self.register_infer_ok_obligations(ok)
649 fn normalize_associated_types_in_as_infer_ok<T>(&self,
651 body_id: ast::NodeId,
652 param_env: ty::ParamEnv<'tcx>,
655 where T : TypeFoldable<'tcx>
657 debug!("normalize_associated_types_in(value={:?})", value);
658 let mut selcx = traits::SelectionContext::new(self);
659 let cause = ObligationCause::misc(span, body_id);
660 let traits::Normalized { value, obligations } =
661 traits::normalize(&mut selcx, param_env, cause, value);
662 debug!("normalize_associated_types_in: result={:?} predicates={:?}",
665 InferOk { value, obligations }
668 /// Replace any late-bound regions bound in `value` with
669 /// free variants attached to `all_outlive_scope`.
670 fn liberate_late_bound_regions<T>(&self,
671 all_outlive_scope: DefId,
672 value: &ty::Binder<T>)
674 where T: TypeFoldable<'tcx>
676 self.tcx.replace_late_bound_regions(value, |br| {
677 self.tcx.mk_region(ty::ReFree(ty::FreeRegion {
678 scope: all_outlive_scope,
685 struct CheckItemTypesVisitor<'a, 'tcx: 'a> { tcx: TyCtxt<'a, 'tcx, 'tcx> }
687 impl<'a, 'tcx> ItemLikeVisitor<'tcx> for CheckItemTypesVisitor<'a, 'tcx> {
688 fn visit_item(&mut self, i: &'tcx hir::Item) {
689 check_item_type(self.tcx, i);
691 fn visit_trait_item(&mut self, _: &'tcx hir::TraitItem) { }
692 fn visit_impl_item(&mut self, _: &'tcx hir::ImplItem) { }
695 pub fn check_wf_new<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Result<(), ErrorReported> {
696 tcx.sess.track_errors(|| {
697 let mut visit = wfcheck::CheckTypeWellFormedVisitor::new(tcx);
698 tcx.hir.krate().visit_all_item_likes(&mut visit.as_deep_visitor());
702 pub fn check_item_types<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Result<(), ErrorReported> {
703 tcx.sess.track_errors(|| {
704 tcx.hir.krate().visit_all_item_likes(&mut CheckItemTypesVisitor { tcx });
708 pub fn check_item_bodies<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Result<(), CompileIncomplete> {
709 tcx.typeck_item_bodies(LOCAL_CRATE)
712 fn typeck_item_bodies<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, crate_num: CrateNum)
713 -> Result<(), CompileIncomplete>
715 debug_assert!(crate_num == LOCAL_CRATE);
716 Ok(tcx.sess.track_errors(|| {
717 for body_owner_def_id in tcx.body_owners() {
718 tcx.typeck_tables_of(body_owner_def_id);
723 pub fn provide(providers: &mut Providers) {
724 *providers = Providers {
734 fn closure_kind<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
737 let node_id = tcx.hir.as_local_node_id(def_id).unwrap();
738 tcx.typeck_tables_of(def_id).closure_kinds[&node_id].0
741 fn adt_destructor<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
743 -> Option<ty::Destructor> {
744 tcx.calculate_dtor(def_id, &mut dropck::check_drop_impl)
747 /// If this def-id is a "primary tables entry", returns `Some((body_id, decl))`
748 /// with information about it's body-id and fn-decl (if any). Otherwise,
751 /// If this function returns "some", then `typeck_tables(def_id)` will
752 /// succeed; if it returns `None`, then `typeck_tables(def_id)` may or
753 /// may not succeed. In some cases where this function returns `None`
754 /// (notably closures), `typeck_tables(def_id)` would wind up
755 /// redirecting to the owning function.
756 fn primary_body_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
758 -> Option<(hir::BodyId, Option<&'tcx hir::FnDecl>)>
760 match tcx.hir.get(id) {
761 hir::map::NodeItem(item) => {
763 hir::ItemConst(_, body) |
764 hir::ItemStatic(_, _, body) =>
766 hir::ItemFn(ref decl, .., body) =>
767 Some((body, Some(decl))),
772 hir::map::NodeTraitItem(item) => {
774 hir::TraitItemKind::Const(_, Some(body)) =>
776 hir::TraitItemKind::Method(ref sig, hir::TraitMethod::Provided(body)) =>
777 Some((body, Some(&sig.decl))),
782 hir::map::NodeImplItem(item) => {
784 hir::ImplItemKind::Const(_, body) =>
786 hir::ImplItemKind::Method(ref sig, body) =>
787 Some((body, Some(&sig.decl))),
792 hir::map::NodeExpr(expr) => {
793 // FIXME(eddyb) Closures should have separate
794 // function definition IDs and expression IDs.
795 // Type-checking should not let closures get
796 // this far in a constant position.
797 // Assume that everything other than closures
798 // is a constant "initializer" expression.
800 hir::ExprClosure(..) =>
803 Some((hir::BodyId { node_id: expr.id }, None)),
810 fn has_typeck_tables<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
813 // Closures' tables come from their outermost function,
814 // as they are part of the same "inference environment".
815 let outer_def_id = tcx.closure_base_def_id(def_id);
816 if outer_def_id != def_id {
817 return tcx.has_typeck_tables(outer_def_id);
820 let id = tcx.hir.as_local_node_id(def_id).unwrap();
821 primary_body_of(tcx, id).is_some()
824 fn typeck_tables_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
826 -> &'tcx ty::TypeckTables<'tcx> {
827 // Closures' tables come from their outermost function,
828 // as they are part of the same "inference environment".
829 let outer_def_id = tcx.closure_base_def_id(def_id);
830 if outer_def_id != def_id {
831 return tcx.typeck_tables_of(outer_def_id);
834 let id = tcx.hir.as_local_node_id(def_id).unwrap();
835 let span = tcx.hir.span(id);
837 // Figure out what primary body this item has.
838 let (body_id, fn_decl) = primary_body_of(tcx, id).unwrap_or_else(|| {
839 span_bug!(span, "can't type-check body of {:?}", def_id);
841 let body = tcx.hir.body(body_id);
843 Inherited::build(tcx, def_id).enter(|inh| {
844 let param_env = tcx.param_env(def_id);
845 let fcx = if let Some(decl) = fn_decl {
846 let fn_sig = tcx.fn_sig(def_id);
848 check_abi(tcx, span, fn_sig.abi());
850 // Compute the fty from point of view of inside fn.
852 inh.liberate_late_bound_regions(def_id, &fn_sig);
854 inh.normalize_associated_types_in(body.value.span,
859 check_fn(&inh, param_env, fn_sig, decl, id, body)
861 let fcx = FnCtxt::new(&inh, param_env, body.value.id);
862 let expected_type = tcx.type_of(def_id);
863 let expected_type = fcx.normalize_associated_types_in(body.value.span, &expected_type);
864 fcx.require_type_is_sized(expected_type, body.value.span, traits::ConstSized);
866 // Gather locals in statics (because of block expressions).
867 // This is technically unnecessary because locals in static items are forbidden,
868 // but prevents type checking from blowing up before const checking can properly
870 GatherLocalsVisitor { fcx: &fcx }.visit_body(body);
872 fcx.check_expr_coercable_to_type(&body.value, expected_type);
877 fcx.select_all_obligations_and_apply_defaults();
878 fcx.closure_analyze(body);
879 fcx.select_obligations_where_possible();
881 fcx.select_all_obligations_or_error();
883 if fn_decl.is_some() {
884 fcx.regionck_fn(id, body);
886 fcx.regionck_expr(body);
889 fcx.resolve_type_vars_in_body(body)
893 fn check_abi<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, span: Span, abi: Abi) {
894 if !tcx.sess.target.target.is_abi_supported(abi) {
895 struct_span_err!(tcx.sess, span, E0570,
896 "The ABI `{}` is not supported for the current target", abi).emit()
900 struct GatherLocalsVisitor<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
901 fcx: &'a FnCtxt<'a, 'gcx, 'tcx>
904 impl<'a, 'gcx, 'tcx> GatherLocalsVisitor<'a, 'gcx, 'tcx> {
905 fn assign(&mut self, span: Span, nid: ast::NodeId, ty_opt: Option<Ty<'tcx>>) -> Ty<'tcx> {
908 // infer the variable's type
909 let var_ty = self.fcx.next_ty_var(TypeVariableOrigin::TypeInference(span));
910 self.fcx.locals.borrow_mut().insert(nid, var_ty);
914 // take type that the user specified
915 self.fcx.locals.borrow_mut().insert(nid, typ);
922 impl<'a, 'gcx, 'tcx> Visitor<'gcx> for GatherLocalsVisitor<'a, 'gcx, 'tcx> {
923 fn nested_visit_map<'this>(&'this mut self) -> NestedVisitorMap<'this, 'gcx> {
924 NestedVisitorMap::None
927 // Add explicitly-declared locals.
928 fn visit_local(&mut self, local: &'gcx hir::Local) {
929 let o_ty = match local.ty {
930 Some(ref ty) => Some(self.fcx.to_ty(&ty)),
933 self.assign(local.span, local.id, o_ty);
934 debug!("Local variable {:?} is assigned type {}",
936 self.fcx.ty_to_string(
937 self.fcx.locals.borrow().get(&local.id).unwrap().clone()));
938 intravisit::walk_local(self, local);
941 // Add pattern bindings.
942 fn visit_pat(&mut self, p: &'gcx hir::Pat) {
943 if let PatKind::Binding(_, _, ref path1, _) = p.node {
944 let var_ty = self.assign(p.span, p.id, None);
946 self.fcx.require_type_is_sized(var_ty, p.span,
947 traits::VariableType(p.id));
949 debug!("Pattern binding {} is assigned to {} with type {:?}",
951 self.fcx.ty_to_string(
952 self.fcx.locals.borrow().get(&p.id).unwrap().clone()),
955 intravisit::walk_pat(self, p);
958 // Don't descend into the bodies of nested closures
959 fn visit_fn(&mut self, _: intravisit::FnKind<'gcx>, _: &'gcx hir::FnDecl,
960 _: hir::BodyId, _: Span, _: ast::NodeId) { }
963 /// Helper used for fns and closures. Does the grungy work of checking a function
964 /// body and returns the function context used for that purpose, since in the case of a fn item
965 /// there is still a bit more to do.
968 /// * inherited: other fields inherited from the enclosing fn (if any)
969 fn check_fn<'a, 'gcx, 'tcx>(inherited: &'a Inherited<'a, 'gcx, 'tcx>,
970 param_env: ty::ParamEnv<'tcx>,
971 fn_sig: ty::FnSig<'tcx>,
972 decl: &'gcx hir::FnDecl,
974 body: &'gcx hir::Body)
975 -> FnCtxt<'a, 'gcx, 'tcx>
977 let mut fn_sig = fn_sig.clone();
979 debug!("check_fn(sig={:?}, fn_id={}, param_env={:?})", fn_sig, fn_id, param_env);
981 // Create the function context. This is either derived from scratch or,
982 // in the case of function expressions, based on the outer context.
983 let mut fcx = FnCtxt::new(inherited, param_env, body.value.id);
984 *fcx.ps.borrow_mut() = UnsafetyState::function(fn_sig.unsafety, fn_id);
986 let ret_ty = fn_sig.output();
987 fcx.require_type_is_sized(ret_ty, decl.output.span(), traits::SizedReturnType);
988 let ret_ty = fcx.instantiate_anon_types(&ret_ty);
989 fcx.ret_coercion = Some(RefCell::new(CoerceMany::new(ret_ty)));
990 fn_sig = fcx.tcx.mk_fn_sig(
991 fn_sig.inputs().iter().cloned(),
998 GatherLocalsVisitor { fcx: &fcx, }.visit_body(body);
1000 // Add formal parameters.
1001 for (arg_ty, arg) in fn_sig.inputs().iter().zip(&body.arguments) {
1002 // Check the pattern.
1003 fcx.check_pat_arg(&arg.pat, arg_ty, true);
1005 // Check that argument is Sized.
1006 // The check for a non-trivial pattern is a hack to avoid duplicate warnings
1007 // for simple cases like `fn foo(x: Trait)`,
1008 // where we would error once on the parameter as a whole, and once on the binding `x`.
1009 if arg.pat.simple_name().is_none() {
1010 fcx.require_type_is_sized(arg_ty, decl.output.span(), traits::MiscObligation);
1013 fcx.write_ty(arg.id, arg_ty);
1016 inherited.tables.borrow_mut().liberated_fn_sigs.insert(fn_id, fn_sig);
1018 fcx.check_return_expr(&body.value);
1020 // Finalize the return check by taking the LUB of the return types
1021 // we saw and assigning it to the expected return type. This isn't
1022 // really expected to fail, since the coercions would have failed
1023 // earlier when trying to find a LUB.
1025 // However, the behavior around `!` is sort of complex. In the
1026 // event that the `actual_return_ty` comes back as `!`, that
1027 // indicates that the fn either does not return or "returns" only
1028 // values of type `!`. In this case, if there is an expected
1029 // return type that is *not* `!`, that should be ok. But if the
1030 // return type is being inferred, we want to "fallback" to `!`:
1032 // let x = move || panic!();
1034 // To allow for that, I am creating a type variable with diverging
1035 // fallback. This was deemed ever so slightly better than unifying
1036 // the return value with `!` because it allows for the caller to
1037 // make more assumptions about the return type (e.g., they could do
1039 // let y: Option<u32> = Some(x());
1041 // which would then cause this return type to become `u32`, not
1043 let coercion = fcx.ret_coercion.take().unwrap().into_inner();
1044 let mut actual_return_ty = coercion.complete(&fcx);
1045 if actual_return_ty.is_never() {
1046 actual_return_ty = fcx.next_diverging_ty_var(
1047 TypeVariableOrigin::DivergingFn(body.value.span));
1049 fcx.demand_suptype(body.value.span, ret_ty, actual_return_ty);
1054 fn check_struct<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1057 let def_id = tcx.hir.local_def_id(id);
1058 let def = tcx.adt_def(def_id);
1059 def.destructor(tcx); // force the destructor to be evaluated
1060 check_representable(tcx, span, def_id);
1062 if def.repr.simd() {
1063 check_simd(tcx, span, def_id);
1066 // if struct is packed and not aligned, check fields for alignment.
1067 // Checks for combining packed and align attrs on single struct are done elsewhere.
1068 if tcx.adt_def(def_id).repr.packed() && tcx.adt_def(def_id).repr.align == 0 {
1069 check_packed(tcx, span, def_id);
1073 fn check_union<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1076 let def_id = tcx.hir.local_def_id(id);
1077 let def = tcx.adt_def(def_id);
1078 def.destructor(tcx); // force the destructor to be evaluated
1079 check_representable(tcx, span, def_id);
1082 pub fn check_item_type<'a,'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, it: &'tcx hir::Item) {
1083 debug!("check_item_type(it.id={}, it.name={})",
1085 tcx.item_path_str(tcx.hir.local_def_id(it.id)));
1086 let _indenter = indenter();
1088 // Consts can play a role in type-checking, so they are included here.
1089 hir::ItemStatic(..) |
1090 hir::ItemConst(..) => {
1091 tcx.typeck_tables_of(tcx.hir.local_def_id(it.id));
1093 hir::ItemEnum(ref enum_definition, _) => {
1096 &enum_definition.variants,
1099 hir::ItemFn(..) => {} // entirely within check_item_body
1100 hir::ItemImpl(.., ref impl_item_refs) => {
1101 debug!("ItemImpl {} with id {}", it.name, it.id);
1102 let impl_def_id = tcx.hir.local_def_id(it.id);
1103 if let Some(impl_trait_ref) = tcx.impl_trait_ref(impl_def_id) {
1104 check_impl_items_against_trait(tcx,
1109 let trait_def_id = impl_trait_ref.def_id;
1110 check_on_unimplemented(tcx, trait_def_id, it);
1113 hir::ItemTrait(..) => {
1114 let def_id = tcx.hir.local_def_id(it.id);
1115 check_on_unimplemented(tcx, def_id, it);
1117 hir::ItemStruct(..) => {
1118 check_struct(tcx, it.id, it.span);
1120 hir::ItemUnion(..) => {
1121 check_union(tcx, it.id, it.span);
1123 hir::ItemTy(_, ref generics) => {
1124 let def_id = tcx.hir.local_def_id(it.id);
1125 let pty_ty = tcx.type_of(def_id);
1126 check_bounds_are_used(tcx, generics, pty_ty);
1128 hir::ItemForeignMod(ref m) => {
1129 check_abi(tcx, it.span, m.abi);
1131 if m.abi == Abi::RustIntrinsic {
1132 for item in &m.items {
1133 intrinsic::check_intrinsic_type(tcx, item);
1135 } else if m.abi == Abi::PlatformIntrinsic {
1136 for item in &m.items {
1137 intrinsic::check_platform_intrinsic_type(tcx, item);
1140 for item in &m.items {
1141 let generics = tcx.generics_of(tcx.hir.local_def_id(item.id));
1142 if !generics.types.is_empty() {
1143 let mut err = struct_span_err!(tcx.sess, item.span, E0044,
1144 "foreign items may not have type parameters");
1145 span_help!(&mut err, item.span,
1146 "consider using specialization instead of \
1151 if let hir::ForeignItemFn(ref fn_decl, _, _) = item.node {
1152 require_c_abi_if_variadic(tcx, fn_decl, m.abi, item.span);
1157 _ => {/* nothing to do */ }
1161 fn check_on_unimplemented<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1164 let generics = tcx.generics_of(def_id);
1165 if let Some(ref attr) = item.attrs.iter().find(|a| {
1166 a.check_name("rustc_on_unimplemented")
1168 if let Some(istring) = attr.value_str() {
1169 let istring = istring.as_str();
1170 let name = tcx.item_name(def_id).as_str();
1171 let parser = Parser::new(&istring);
1172 let types = &generics.types;
1173 for token in parser {
1175 Piece::String(_) => (), // Normal string, no need to check it
1176 Piece::NextArgument(a) => match a.position {
1177 // `{Self}` is allowed
1178 Position::ArgumentNamed(s) if s == "Self" => (),
1179 // `{ThisTraitsName}` is allowed
1180 Position::ArgumentNamed(s) if s == name => (),
1181 // So is `{A}` if A is a type parameter
1182 Position::ArgumentNamed(s) => match types.iter().find(|t| {
1187 span_err!(tcx.sess, attr.span, E0230,
1188 "there is no type parameter \
1193 // `{:1}` and `{}` are not to be used
1194 Position::ArgumentIs(_) => {
1195 span_err!(tcx.sess, attr.span, E0231,
1196 "only named substitution \
1197 parameters are allowed");
1204 tcx.sess, attr.span, E0232,
1205 "this attribute must have a value")
1206 .span_label(attr.span, "attribute requires a value")
1207 .note(&format!("eg `#[rustc_on_unimplemented = \"foo\"]`"))
1213 fn report_forbidden_specialization<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1214 impl_item: &hir::ImplItem,
1217 let mut err = struct_span_err!(
1218 tcx.sess, impl_item.span, E0520,
1219 "`{}` specializes an item from a parent `impl`, but \
1220 that item is not marked `default`",
1222 err.span_label(impl_item.span, format!("cannot specialize default item `{}`",
1225 match tcx.span_of_impl(parent_impl) {
1227 err.span_label(span, "parent `impl` is here");
1228 err.note(&format!("to specialize, `{}` in the parent `impl` must be marked `default`",
1232 err.note(&format!("parent implementation is in crate `{}`", cname));
1239 fn check_specialization_validity<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1240 trait_def: &ty::TraitDef,
1242 impl_item: &hir::ImplItem)
1244 let ancestors = trait_def.ancestors(tcx, impl_id);
1246 let kind = match impl_item.node {
1247 hir::ImplItemKind::Const(..) => ty::AssociatedKind::Const,
1248 hir::ImplItemKind::Method(..) => ty::AssociatedKind::Method,
1249 hir::ImplItemKind::Type(_) => ty::AssociatedKind::Type
1251 let parent = ancestors.defs(tcx, impl_item.name, kind).skip(1).next()
1252 .map(|node_item| node_item.map(|parent| parent.defaultness));
1254 if let Some(parent) = parent {
1255 if tcx.impl_item_is_final(&parent) {
1256 report_forbidden_specialization(tcx, impl_item, parent.node.def_id());
1262 fn check_impl_items_against_trait<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1265 impl_trait_ref: ty::TraitRef<'tcx>,
1266 impl_item_refs: &[hir::ImplItemRef]) {
1267 // If the trait reference itself is erroneous (so the compilation is going
1268 // to fail), skip checking the items here -- the `impl_item` table in `tcx`
1269 // isn't populated for such impls.
1270 if impl_trait_ref.references_error() { return; }
1272 // Locate trait definition and items
1273 let trait_def = tcx.trait_def(impl_trait_ref.def_id);
1274 let mut overridden_associated_type = None;
1276 let impl_items = || impl_item_refs.iter().map(|iiref| tcx.hir.impl_item(iiref.id));
1278 // Check existing impl methods to see if they are both present in trait
1279 // and compatible with trait signature
1280 for impl_item in impl_items() {
1281 let ty_impl_item = tcx.associated_item(tcx.hir.local_def_id(impl_item.id));
1282 let ty_trait_item = tcx.associated_items(impl_trait_ref.def_id)
1283 .find(|ac| ac.name == ty_impl_item.name);
1285 // Check that impl definition matches trait definition
1286 if let Some(ty_trait_item) = ty_trait_item {
1287 match impl_item.node {
1288 hir::ImplItemKind::Const(..) => {
1289 // Find associated const definition.
1290 if ty_trait_item.kind == ty::AssociatedKind::Const {
1291 compare_const_impl(tcx,
1297 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0323,
1298 "item `{}` is an associated const, \
1299 which doesn't match its trait `{}`",
1302 err.span_label(impl_item.span, "does not match trait");
1303 // We can only get the spans from local trait definition
1304 // Same for E0324 and E0325
1305 if let Some(trait_span) = tcx.hir.span_if_local(ty_trait_item.def_id) {
1306 err.span_label(trait_span, "item in trait");
1311 hir::ImplItemKind::Method(..) => {
1312 let trait_span = tcx.hir.span_if_local(ty_trait_item.def_id);
1313 if ty_trait_item.kind == ty::AssociatedKind::Method {
1314 let err_count = tcx.sess.err_count();
1315 compare_impl_method(tcx,
1321 true); // start with old-broken-mode
1322 if err_count == tcx.sess.err_count() {
1323 // old broken mode did not report an error. Try with the new mode.
1324 compare_impl_method(tcx,
1330 false); // use the new mode
1333 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0324,
1334 "item `{}` is an associated method, \
1335 which doesn't match its trait `{}`",
1338 err.span_label(impl_item.span, "does not match trait");
1339 if let Some(trait_span) = tcx.hir.span_if_local(ty_trait_item.def_id) {
1340 err.span_label(trait_span, "item in trait");
1345 hir::ImplItemKind::Type(_) => {
1346 if ty_trait_item.kind == ty::AssociatedKind::Type {
1347 if ty_trait_item.defaultness.has_value() {
1348 overridden_associated_type = Some(impl_item);
1351 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0325,
1352 "item `{}` is an associated type, \
1353 which doesn't match its trait `{}`",
1356 err.span_label(impl_item.span, "does not match trait");
1357 if let Some(trait_span) = tcx.hir.span_if_local(ty_trait_item.def_id) {
1358 err.span_label(trait_span, "item in trait");
1366 check_specialization_validity(tcx, trait_def, impl_id, impl_item);
1369 // Check for missing items from trait
1370 let mut missing_items = Vec::new();
1371 let mut invalidated_items = Vec::new();
1372 let associated_type_overridden = overridden_associated_type.is_some();
1373 for trait_item in tcx.associated_items(impl_trait_ref.def_id) {
1374 let is_implemented = trait_def.ancestors(tcx, impl_id)
1375 .defs(tcx, trait_item.name, trait_item.kind)
1377 .map(|node_item| !node_item.node.is_from_trait())
1380 if !is_implemented {
1381 if !trait_item.defaultness.has_value() {
1382 missing_items.push(trait_item);
1383 } else if associated_type_overridden {
1384 invalidated_items.push(trait_item.name);
1389 if !missing_items.is_empty() {
1390 let mut err = struct_span_err!(tcx.sess, impl_span, E0046,
1391 "not all trait items implemented, missing: `{}`",
1392 missing_items.iter()
1393 .map(|trait_item| trait_item.name.to_string())
1394 .collect::<Vec<_>>().join("`, `"));
1395 err.span_label(impl_span, format!("missing `{}` in implementation",
1396 missing_items.iter()
1397 .map(|trait_item| trait_item.name.to_string())
1398 .collect::<Vec<_>>().join("`, `")));
1399 for trait_item in missing_items {
1400 if let Some(span) = tcx.hir.span_if_local(trait_item.def_id) {
1401 err.span_label(span, format!("`{}` from trait", trait_item.name));
1403 err.note_trait_signature(trait_item.name.to_string(),
1404 trait_item.signature(&tcx));
1410 if !invalidated_items.is_empty() {
1411 let invalidator = overridden_associated_type.unwrap();
1412 span_err!(tcx.sess, invalidator.span, E0399,
1413 "the following trait items need to be reimplemented \
1414 as `{}` was overridden: `{}`",
1416 invalidated_items.iter()
1417 .map(|name| name.to_string())
1418 .collect::<Vec<_>>().join("`, `"))
1422 /// Checks whether a type can be represented in memory. In particular, it
1423 /// identifies types that contain themselves without indirection through a
1424 /// pointer, which would mean their size is unbounded.
1425 fn check_representable<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1429 let rty = tcx.type_of(item_def_id);
1431 // Check that it is possible to represent this type. This call identifies
1432 // (1) types that contain themselves and (2) types that contain a different
1433 // recursive type. It is only necessary to throw an error on those that
1434 // contain themselves. For case 2, there must be an inner type that will be
1435 // caught by case 1.
1436 match rty.is_representable(tcx, sp) {
1437 Representability::SelfRecursive(spans) => {
1438 let mut err = tcx.recursive_type_with_infinite_size_error(item_def_id);
1440 err.span_label(span, "recursive without indirection");
1445 Representability::Representable | Representability::ContainsRecursive => (),
1450 pub fn check_simd<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, sp: Span, def_id: DefId) {
1451 let t = tcx.type_of(def_id);
1453 ty::TyAdt(def, substs) if def.is_struct() => {
1454 let fields = &def.struct_variant().fields;
1455 if fields.is_empty() {
1456 span_err!(tcx.sess, sp, E0075, "SIMD vector cannot be empty");
1459 let e = fields[0].ty(tcx, substs);
1460 if !fields.iter().all(|f| f.ty(tcx, substs) == e) {
1461 struct_span_err!(tcx.sess, sp, E0076, "SIMD vector should be homogeneous")
1462 .span_label(sp, "SIMD elements must have the same type")
1467 ty::TyParam(_) => { /* struct<T>(T, T, T, T) is ok */ }
1468 _ if e.is_machine() => { /* struct(u8, u8, u8, u8) is ok */ }
1470 span_err!(tcx.sess, sp, E0077,
1471 "SIMD vector element type should be machine type");
1480 fn check_packed<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, sp: Span, def_id: DefId) {
1481 if check_packed_inner(tcx, def_id, &mut Vec::new()) {
1482 struct_span_err!(tcx.sess, sp, E0588,
1483 "packed struct cannot transitively contain a `[repr(align)]` struct").emit();
1487 fn check_packed_inner<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1489 stack: &mut Vec<DefId>) -> bool {
1490 let t = tcx.type_of(def_id);
1491 if stack.contains(&def_id) {
1492 debug!("check_packed_inner: {:?} is recursive", t);
1496 ty::TyAdt(def, substs) if def.is_struct() => {
1497 if tcx.adt_def(def.did).repr.align > 0 {
1500 // push struct def_id before checking fields
1502 for field in &def.struct_variant().fields {
1503 let f = field.ty(tcx, substs);
1505 ty::TyAdt(def, _) => {
1506 if check_packed_inner(tcx, def.did, stack) {
1513 // only need to pop if not early out
1521 #[allow(trivial_numeric_casts)]
1522 pub fn check_enum<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1524 vs: &'tcx [hir::Variant],
1526 let def_id = tcx.hir.local_def_id(id);
1527 let def = tcx.adt_def(def_id);
1528 def.destructor(tcx); // force the destructor to be evaluated
1530 if vs.is_empty() && tcx.has_attr(def_id, "repr") {
1532 tcx.sess, sp, E0084,
1533 "unsupported representation for zero-variant enum")
1534 .span_label(sp, "unsupported enum representation")
1538 let repr_type_ty = def.repr.discr_type().to_ty(tcx);
1539 if repr_type_ty == tcx.types.i128 || repr_type_ty == tcx.types.u128 {
1540 if !tcx.sess.features.borrow().i128_type {
1541 emit_feature_err(&tcx.sess.parse_sess,
1542 "i128_type", sp, GateIssue::Language, "128-bit type is unstable");
1547 if let Some(e) = v.node.disr_expr {
1548 tcx.typeck_tables_of(tcx.hir.local_def_id(e.node_id));
1552 let mut disr_vals: Vec<ConstInt> = Vec::new();
1553 for (discr, v) in def.discriminants(tcx).zip(vs) {
1554 // Check for duplicate discriminant values
1555 if let Some(i) = disr_vals.iter().position(|&x| x == discr) {
1556 let variant_i_node_id = tcx.hir.as_local_node_id(def.variants[i].did).unwrap();
1557 let variant_i = tcx.hir.expect_variant(variant_i_node_id);
1558 let i_span = match variant_i.node.disr_expr {
1559 Some(expr) => tcx.hir.span(expr.node_id),
1560 None => tcx.hir.span(variant_i_node_id)
1562 let span = match v.node.disr_expr {
1563 Some(expr) => tcx.hir.span(expr.node_id),
1566 struct_span_err!(tcx.sess, span, E0081,
1567 "discriminant value `{}` already exists", disr_vals[i])
1568 .span_label(i_span, format!("first use of `{}`", disr_vals[i]))
1569 .span_label(span , format!("enum already has `{}`", disr_vals[i]))
1572 disr_vals.push(discr);
1575 check_representable(tcx, sp, def_id);
1578 impl<'a, 'gcx, 'tcx> AstConv<'gcx, 'tcx> for FnCtxt<'a, 'gcx, 'tcx> {
1579 fn tcx<'b>(&'b self) -> TyCtxt<'b, 'gcx, 'tcx> { self.tcx }
1581 fn get_type_parameter_bounds(&self, _: Span, def_id: DefId)
1582 -> ty::GenericPredicates<'tcx>
1585 let node_id = tcx.hir.as_local_node_id(def_id).unwrap();
1586 let item_id = tcx.hir.ty_param_owner(node_id);
1587 let item_def_id = tcx.hir.local_def_id(item_id);
1588 let generics = tcx.generics_of(item_def_id);
1589 let index = generics.type_param_to_index[&def_id.index];
1590 ty::GenericPredicates {
1592 predicates: self.param_env.caller_bounds.iter().filter(|predicate| {
1594 ty::Predicate::Trait(ref data) => {
1595 data.0.self_ty().is_param(index)
1599 }).cloned().collect()
1603 fn re_infer(&self, span: Span, def: Option<&ty::RegionParameterDef>)
1604 -> Option<ty::Region<'tcx>> {
1606 Some(def) => infer::EarlyBoundRegion(span, def.name, def.issue_32330),
1607 None => infer::MiscVariable(span)
1609 Some(self.next_region_var(v))
1612 fn ty_infer(&self, span: Span) -> Ty<'tcx> {
1613 self.next_ty_var(TypeVariableOrigin::TypeInference(span))
1616 fn ty_infer_for_def(&self,
1617 ty_param_def: &ty::TypeParameterDef,
1618 substs: &[Kind<'tcx>],
1619 span: Span) -> Ty<'tcx> {
1620 self.type_var_for_def(span, ty_param_def, substs)
1623 fn projected_ty_from_poly_trait_ref(&self,
1626 poly_trait_ref: ty::PolyTraitRef<'tcx>)
1629 let item = self.tcx().associated_item(item_def_id);
1630 let (trait_ref, _) =
1631 self.replace_late_bound_regions_with_fresh_var(
1633 infer::LateBoundRegionConversionTime::AssocTypeProjection(item.name),
1636 self.tcx().mk_projection(item_def_id, trait_ref.substs)
1639 fn normalize_ty(&self, span: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
1640 if ty.has_escaping_regions() {
1641 ty // FIXME: normalization and escaping regions
1643 self.normalize_associated_types_in(span, &ty)
1647 fn set_tainted_by_errors(&self) {
1648 self.infcx.set_tainted_by_errors()
1652 /// Controls whether the arguments are tupled. This is used for the call
1655 /// Tupling means that all call-side arguments are packed into a tuple and
1656 /// passed as a single parameter. For example, if tupling is enabled, this
1659 /// fn f(x: (isize, isize))
1661 /// Can be called as:
1668 #[derive(Clone, Eq, PartialEq)]
1669 enum TupleArgumentsFlag {
1674 impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
1675 pub fn new(inh: &'a Inherited<'a, 'gcx, 'tcx>,
1676 param_env: ty::ParamEnv<'tcx>,
1677 body_id: ast::NodeId)
1678 -> FnCtxt<'a, 'gcx, 'tcx> {
1682 err_count_on_creation: inh.tcx.sess.err_count(),
1684 ps: RefCell::new(UnsafetyState::function(hir::Unsafety::Normal,
1685 ast::CRATE_NODE_ID)),
1686 diverges: Cell::new(Diverges::Maybe),
1687 has_errors: Cell::new(false),
1688 enclosing_breakables: RefCell::new(EnclosingBreakables {
1696 pub fn sess(&self) -> &Session {
1700 pub fn err_count_since_creation(&self) -> usize {
1701 self.tcx.sess.err_count() - self.err_count_on_creation
1704 /// Produce warning on the given node, if the current point in the
1705 /// function is unreachable, and there hasn't been another warning.
1706 fn warn_if_unreachable(&self, id: ast::NodeId, span: Span, kind: &str) {
1707 if self.diverges.get() == Diverges::Always {
1708 self.diverges.set(Diverges::WarnedAlways);
1710 debug!("warn_if_unreachable: id={:?} span={:?} kind={}", id, span, kind);
1712 self.tables.borrow_mut().lints.add_lint(
1713 lint::builtin::UNREACHABLE_CODE,
1715 format!("unreachable {}", kind));
1721 code: ObligationCauseCode<'tcx>)
1722 -> ObligationCause<'tcx> {
1723 ObligationCause::new(span, self.body_id, code)
1726 pub fn misc(&self, span: Span) -> ObligationCause<'tcx> {
1727 self.cause(span, ObligationCauseCode::MiscObligation)
1730 /// Resolves type variables in `ty` if possible. Unlike the infcx
1731 /// version (resolve_type_vars_if_possible), this version will
1732 /// also select obligations if it seems useful, in an effort
1733 /// to get more type information.
1734 fn resolve_type_vars_with_obligations(&self, mut ty: Ty<'tcx>) -> Ty<'tcx> {
1735 debug!("resolve_type_vars_with_obligations(ty={:?})", ty);
1737 // No TyInfer()? Nothing needs doing.
1738 if !ty.has_infer_types() {
1739 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
1743 // If `ty` is a type variable, see whether we already know what it is.
1744 ty = self.resolve_type_vars_if_possible(&ty);
1745 if !ty.has_infer_types() {
1746 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
1750 // If not, try resolving pending obligations as much as
1751 // possible. This can help substantially when there are
1752 // indirect dependencies that don't seem worth tracking
1754 self.select_obligations_where_possible();
1755 ty = self.resolve_type_vars_if_possible(&ty);
1757 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
1761 fn record_deferred_call_resolution(&self,
1762 closure_def_id: DefId,
1763 r: DeferredCallResolution<'gcx, 'tcx>) {
1764 let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
1765 deferred_call_resolutions.entry(closure_def_id).or_insert(vec![]).push(r);
1768 fn remove_deferred_call_resolutions(&self,
1769 closure_def_id: DefId)
1770 -> Vec<DeferredCallResolution<'gcx, 'tcx>>
1772 let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
1773 deferred_call_resolutions.remove(&closure_def_id).unwrap_or(vec![])
1776 pub fn tag(&self) -> String {
1777 let self_ptr: *const FnCtxt = self;
1778 format!("{:?}", self_ptr)
1781 pub fn local_ty(&self, span: Span, nid: ast::NodeId) -> Ty<'tcx> {
1782 match self.locals.borrow().get(&nid) {
1785 span_bug!(span, "no type for local variable {}",
1786 self.tcx.hir.node_to_string(nid));
1792 pub fn write_ty(&self, node_id: ast::NodeId, ty: Ty<'tcx>) {
1793 debug!("write_ty({}, {:?}) in fcx {}",
1794 node_id, self.resolve_type_vars_if_possible(&ty), self.tag());
1795 self.tables.borrow_mut().node_types.insert(node_id, ty);
1797 if ty.references_error() {
1798 self.has_errors.set(true);
1799 self.set_tainted_by_errors();
1803 pub fn write_method_call(&self, node_id: ast::NodeId, method: MethodCallee<'tcx>) {
1804 self.tables.borrow_mut().type_dependent_defs.insert(node_id, Def::Method(method.def_id));
1805 self.write_substs(node_id, method.substs);
1808 pub fn write_substs(&self, node_id: ast::NodeId, substs: &'tcx Substs<'tcx>) {
1809 if !substs.is_noop() {
1810 debug!("write_substs({}, {:?}) in fcx {}",
1815 self.tables.borrow_mut().node_substs.insert(node_id, substs);
1819 pub fn apply_adjustments(&self, expr: &hir::Expr, adj: Vec<Adjustment<'tcx>>) {
1820 debug!("apply_adjustments(expr={:?}, adj={:?})", expr, adj);
1826 match self.tables.borrow_mut().adjustments.entry(expr.id) {
1827 Entry::Vacant(entry) => { entry.insert(adj); },
1828 Entry::Occupied(mut entry) => {
1829 debug!(" - composing on top of {:?}", entry.get());
1830 match (&entry.get()[..], &adj[..]) {
1831 // Applying any adjustment on top of a NeverToAny
1832 // is a valid NeverToAny adjustment, because it can't
1834 (&[Adjustment { kind: Adjust::NeverToAny, .. }], _) => return,
1836 Adjustment { kind: Adjust::Deref(_), .. },
1837 Adjustment { kind: Adjust::Borrow(AutoBorrow::Ref(..)), .. },
1839 Adjustment { kind: Adjust::Deref(_), .. },
1840 .. // Any following adjustments are allowed.
1842 // A reborrow has no effect before a dereference.
1844 // FIXME: currently we never try to compose autoderefs
1845 // and ReifyFnPointer/UnsafeFnPointer, but we could.
1847 bug!("while adjusting {:?}, can't compose {:?} and {:?}",
1848 expr, entry.get(), adj)
1850 *entry.get_mut() = adj;
1855 /// Basically whenever we are converting from a type scheme into
1856 /// the fn body space, we always want to normalize associated
1857 /// types as well. This function combines the two.
1858 fn instantiate_type_scheme<T>(&self,
1860 substs: &Substs<'tcx>,
1863 where T : TypeFoldable<'tcx>
1865 let value = value.subst(self.tcx, substs);
1866 let result = self.normalize_associated_types_in(span, &value);
1867 debug!("instantiate_type_scheme(value={:?}, substs={:?}) = {:?}",
1874 /// As `instantiate_type_scheme`, but for the bounds found in a
1875 /// generic type scheme.
1876 fn instantiate_bounds(&self, span: Span, def_id: DefId, substs: &Substs<'tcx>)
1877 -> ty::InstantiatedPredicates<'tcx> {
1878 let bounds = self.tcx.predicates_of(def_id);
1879 let result = bounds.instantiate(self.tcx, substs);
1880 let result = self.normalize_associated_types_in(span, &result);
1881 debug!("instantiate_bounds(bounds={:?}, substs={:?}) = {:?}",
1888 /// Replace all anonymized types with fresh inference variables
1889 /// and record them for writeback.
1890 fn instantiate_anon_types<T: TypeFoldable<'tcx>>(&self, value: &T) -> T {
1891 value.fold_with(&mut BottomUpFolder { tcx: self.tcx, fldop: |ty| {
1892 if let ty::TyAnon(def_id, substs) = ty.sty {
1893 // Use the same type variable if the exact same TyAnon appears more
1894 // than once in the return type (e.g. if it's pased to a type alias).
1895 let id = self.tcx.hir.as_local_node_id(def_id).unwrap();
1896 if let Some(ty_var) = self.anon_types.borrow().get(&id) {
1899 let span = self.tcx.def_span(def_id);
1900 let ty_var = self.next_ty_var(TypeVariableOrigin::TypeInference(span));
1901 self.anon_types.borrow_mut().insert(id, ty_var);
1903 let predicates_of = self.tcx.predicates_of(def_id);
1904 let bounds = predicates_of.instantiate(self.tcx, substs);
1906 for predicate in bounds.predicates {
1907 // Change the predicate to refer to the type variable,
1908 // which will be the concrete type, instead of the TyAnon.
1909 // This also instantiates nested `impl Trait`.
1910 let predicate = self.instantiate_anon_types(&predicate);
1912 // Require that the predicate holds for the concrete type.
1913 let cause = traits::ObligationCause::new(span, self.body_id,
1914 traits::SizedReturnType);
1915 self.register_predicate(traits::Obligation::new(cause,
1927 fn normalize_associated_types_in<T>(&self, span: Span, value: &T) -> T
1928 where T : TypeFoldable<'tcx>
1930 self.inh.normalize_associated_types_in(span, self.body_id, self.param_env, value)
1933 fn normalize_associated_types_in_as_infer_ok<T>(&self, span: Span, value: &T)
1935 where T : TypeFoldable<'tcx>
1937 self.inh.normalize_associated_types_in_as_infer_ok(span,
1943 pub fn require_type_meets(&self,
1946 code: traits::ObligationCauseCode<'tcx>,
1949 self.register_bound(
1952 traits::ObligationCause::new(span, self.body_id, code));
1955 pub fn require_type_is_sized(&self,
1958 code: traits::ObligationCauseCode<'tcx>)
1960 let lang_item = self.tcx.require_lang_item(lang_items::SizedTraitLangItem);
1961 self.require_type_meets(ty, span, code, lang_item);
1964 pub fn register_bound(&self,
1967 cause: traits::ObligationCause<'tcx>)
1969 self.fulfillment_cx.borrow_mut()
1970 .register_bound(self, self.param_env, ty, def_id, cause);
1973 pub fn to_ty(&self, ast_t: &hir::Ty) -> Ty<'tcx> {
1974 let t = AstConv::ast_ty_to_ty(self, ast_t);
1975 self.register_wf_obligation(t, ast_t.span, traits::MiscObligation);
1979 pub fn node_ty(&self, id: ast::NodeId) -> Ty<'tcx> {
1980 match self.tables.borrow().node_types.get(&id) {
1982 None if self.err_count_since_creation() != 0 => self.tcx.types.err,
1984 bug!("no type for node {}: {} in fcx {}",
1985 id, self.tcx.hir.node_to_string(id),
1991 /// Registers an obligation for checking later, during regionck, that the type `ty` must
1992 /// outlive the region `r`.
1993 pub fn register_wf_obligation(&self,
1996 code: traits::ObligationCauseCode<'tcx>)
1998 // WF obligations never themselves fail, so no real need to give a detailed cause:
1999 let cause = traits::ObligationCause::new(span, self.body_id, code);
2000 self.register_predicate(traits::Obligation::new(cause,
2002 ty::Predicate::WellFormed(ty)));
2005 /// Registers obligations that all types appearing in `substs` are well-formed.
2006 pub fn add_wf_bounds(&self, substs: &Substs<'tcx>, expr: &hir::Expr)
2008 for ty in substs.types() {
2009 self.register_wf_obligation(ty, expr.span, traits::MiscObligation);
2013 /// Given a fully substituted set of bounds (`generic_bounds`), and the values with which each
2014 /// type/region parameter was instantiated (`substs`), creates and registers suitable
2015 /// trait/region obligations.
2017 /// For example, if there is a function:
2020 /// fn foo<'a,T:'a>(...)
2023 /// and a reference:
2029 /// Then we will create a fresh region variable `'$0` and a fresh type variable `$1` for `'a`
2030 /// and `T`. This routine will add a region obligation `$1:'$0` and register it locally.
2031 pub fn add_obligations_for_parameters(&self,
2032 cause: traits::ObligationCause<'tcx>,
2033 predicates: &ty::InstantiatedPredicates<'tcx>)
2035 assert!(!predicates.has_escaping_regions());
2037 debug!("add_obligations_for_parameters(predicates={:?})",
2040 for obligation in traits::predicates_for_generics(cause, self.param_env, predicates) {
2041 self.register_predicate(obligation);
2045 // FIXME(arielb1): use this instead of field.ty everywhere
2046 // Only for fields! Returns <none> for methods>
2047 // Indifferent to privacy flags
2048 pub fn field_ty(&self,
2050 field: &'tcx ty::FieldDef,
2051 substs: &Substs<'tcx>)
2054 self.normalize_associated_types_in(span,
2055 &field.ty(self.tcx, substs))
2058 fn check_casts(&self) {
2059 let mut deferred_cast_checks = self.deferred_cast_checks.borrow_mut();
2060 for cast in deferred_cast_checks.drain(..) {
2065 /// Apply "fallbacks" to some types
2066 /// unconstrained types get replaced with ! or () (depending on whether
2067 /// feature(never_type) is enabled), unconstrained ints with i32, and
2068 /// unconstrained floats with f64.
2069 fn default_type_parameters(&self) {
2070 use rustc::ty::error::UnconstrainedNumeric::Neither;
2071 use rustc::ty::error::UnconstrainedNumeric::{UnconstrainedInt, UnconstrainedFloat};
2073 // Defaulting inference variables becomes very dubious if we have
2074 // encountered type-checking errors. Therefore, if we think we saw
2075 // some errors in this function, just resolve all uninstanted type
2076 // varibles to TyError.
2077 if self.is_tainted_by_errors() {
2078 for ty in &self.unsolved_variables() {
2079 if let ty::TyInfer(_) = self.shallow_resolve(ty).sty {
2080 debug!("default_type_parameters: defaulting `{:?}` to error", ty);
2081 self.demand_eqtype(syntax_pos::DUMMY_SP, *ty, self.tcx().types.err);
2087 for ty in &self.unsolved_variables() {
2088 let resolved = self.resolve_type_vars_if_possible(ty);
2089 if self.type_var_diverges(resolved) {
2090 debug!("default_type_parameters: defaulting `{:?}` to `!` because it diverges",
2092 self.demand_eqtype(syntax_pos::DUMMY_SP, *ty,
2093 self.tcx.mk_diverging_default());
2095 match self.type_is_unconstrained_numeric(resolved) {
2096 UnconstrainedInt => {
2097 debug!("default_type_parameters: defaulting `{:?}` to `i32`",
2099 self.demand_eqtype(syntax_pos::DUMMY_SP, *ty, self.tcx.types.i32)
2101 UnconstrainedFloat => {
2102 debug!("default_type_parameters: defaulting `{:?}` to `f32`",
2104 self.demand_eqtype(syntax_pos::DUMMY_SP, *ty, self.tcx.types.f64)
2112 // Implements type inference fallback algorithm
2113 fn select_all_obligations_and_apply_defaults(&self) {
2114 self.select_obligations_where_possible();
2115 self.default_type_parameters();
2116 self.select_obligations_where_possible();
2119 fn select_all_obligations_or_error(&self) {
2120 debug!("select_all_obligations_or_error");
2122 // upvar inference should have ensured that all deferred call
2123 // resolutions are handled by now.
2124 assert!(self.deferred_call_resolutions.borrow().is_empty());
2126 self.select_all_obligations_and_apply_defaults();
2128 let mut fulfillment_cx = self.fulfillment_cx.borrow_mut();
2130 match fulfillment_cx.select_all_or_error(self) {
2132 Err(errors) => { self.report_fulfillment_errors(&errors, self.inh.body_id); }
2136 /// Select as many obligations as we can at present.
2137 fn select_obligations_where_possible(&self) {
2138 match self.fulfillment_cx.borrow_mut().select_where_possible(self) {
2140 Err(errors) => { self.report_fulfillment_errors(&errors, self.inh.body_id); }
2144 /// For the overloaded lvalue expressions (`*x`, `x[3]`), the trait
2145 /// returns a type of `&T`, but the actual type we assign to the
2146 /// *expression* is `T`. So this function just peels off the return
2147 /// type by one layer to yield `T`.
2148 fn make_overloaded_lvalue_return_type(&self,
2149 method: MethodCallee<'tcx>)
2150 -> ty::TypeAndMut<'tcx>
2152 // extract method return type, which will be &T;
2153 let ret_ty = method.sig.output();
2155 // method returns &T, but the type as visible to user is T, so deref
2156 ret_ty.builtin_deref(true, NoPreference).unwrap()
2159 fn lookup_indexing(&self,
2161 base_expr: &'gcx hir::Expr,
2164 lvalue_pref: LvaluePreference)
2165 -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)>
2167 // FIXME(#18741) -- this is almost but not quite the same as the
2168 // autoderef that normal method probing does. They could likely be
2171 let mut autoderef = self.autoderef(base_expr.span, base_ty);
2172 let mut result = None;
2173 while result.is_none() && autoderef.next().is_some() {
2174 result = self.try_index_step(expr, base_expr, &autoderef, lvalue_pref, idx_ty);
2176 autoderef.finalize();
2180 /// To type-check `base_expr[index_expr]`, we progressively autoderef
2181 /// (and otherwise adjust) `base_expr`, looking for a type which either
2182 /// supports builtin indexing or overloaded indexing.
2183 /// This loop implements one step in that search; the autoderef loop
2184 /// is implemented by `lookup_indexing`.
2185 fn try_index_step(&self,
2187 base_expr: &hir::Expr,
2188 autoderef: &Autoderef<'a, 'gcx, 'tcx>,
2189 lvalue_pref: LvaluePreference,
2191 -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)>
2193 let adjusted_ty = autoderef.unambiguous_final_ty();
2194 debug!("try_index_step(expr={:?}, base_expr={:?}, adjusted_ty={:?}, \
2202 // First, try built-in indexing.
2203 match (adjusted_ty.builtin_index(), &index_ty.sty) {
2204 (Some(ty), &ty::TyUint(ast::UintTy::Us)) | (Some(ty), &ty::TyInfer(ty::IntVar(_))) => {
2205 debug!("try_index_step: success, using built-in indexing");
2206 let adjustments = autoderef.adjust_steps(lvalue_pref);
2207 self.apply_adjustments(base_expr, adjustments);
2208 return Some((self.tcx.types.usize, ty));
2213 for &unsize in &[false, true] {
2214 let mut self_ty = adjusted_ty;
2216 // We only unsize arrays here.
2217 if let ty::TyArray(element_ty, _) = adjusted_ty.sty {
2218 self_ty = self.tcx.mk_slice(element_ty);
2224 // If some lookup succeeds, write callee into table and extract index/element
2225 // type from the method signature.
2226 // If some lookup succeeded, install method in table
2227 let input_ty = self.next_ty_var(TypeVariableOrigin::AutoDeref(base_expr.span));
2228 let method = self.try_overloaded_lvalue_op(
2229 expr.span, self_ty, &[input_ty], lvalue_pref, LvalueOp::Index);
2231 let result = method.map(|ok| {
2232 debug!("try_index_step: success, using overloaded indexing");
2233 let method = self.register_infer_ok_obligations(ok);
2235 let mut adjustments = autoderef.adjust_steps(lvalue_pref);
2236 if let ty::TyRef(region, mt) = method.sig.inputs()[0].sty {
2237 adjustments.push(Adjustment {
2238 kind: Adjust::Borrow(AutoBorrow::Ref(region, mt.mutbl)),
2239 target: self.tcx.mk_ref(region, ty::TypeAndMut {
2246 adjustments.push(Adjustment {
2247 kind: Adjust::Unsize,
2248 target: method.sig.inputs()[0]
2251 self.apply_adjustments(base_expr, adjustments);
2253 self.write_method_call(expr.id, method);
2254 (input_ty, self.make_overloaded_lvalue_return_type(method).ty)
2256 if result.is_some() {
2264 fn resolve_lvalue_op(&self, op: LvalueOp, is_mut: bool) -> (Option<DefId>, Symbol) {
2265 let (tr, name) = match (op, is_mut) {
2266 (LvalueOp::Deref, false) =>
2267 (self.tcx.lang_items.deref_trait(), "deref"),
2268 (LvalueOp::Deref, true) =>
2269 (self.tcx.lang_items.deref_mut_trait(), "deref_mut"),
2270 (LvalueOp::Index, false) =>
2271 (self.tcx.lang_items.index_trait(), "index"),
2272 (LvalueOp::Index, true) =>
2273 (self.tcx.lang_items.index_mut_trait(), "index_mut"),
2275 (tr, Symbol::intern(name))
2278 fn try_overloaded_lvalue_op(&self,
2281 arg_tys: &[Ty<'tcx>],
2282 lvalue_pref: LvaluePreference,
2284 -> Option<InferOk<'tcx, MethodCallee<'tcx>>>
2286 debug!("try_overloaded_lvalue_op({:?},{:?},{:?},{:?})",
2292 // Try Mut first, if preferred.
2293 let (mut_tr, mut_op) = self.resolve_lvalue_op(op, true);
2294 let method = match (lvalue_pref, mut_tr) {
2295 (PreferMutLvalue, Some(trait_did)) => {
2296 self.lookup_method_in_trait(span, mut_op, trait_did, base_ty, Some(arg_tys))
2301 // Otherwise, fall back to the immutable version.
2302 let (imm_tr, imm_op) = self.resolve_lvalue_op(op, false);
2303 let method = match (method, imm_tr) {
2304 (None, Some(trait_did)) => {
2305 self.lookup_method_in_trait(span, imm_op, trait_did, base_ty, Some(arg_tys))
2307 (method, _) => method,
2313 fn check_method_argument_types(&self,
2315 method: Result<MethodCallee<'tcx>, ()>,
2316 args_no_rcvr: &'gcx [hir::Expr],
2317 tuple_arguments: TupleArgumentsFlag,
2318 expected: Expectation<'tcx>)
2320 let has_error = match method {
2322 method.substs.references_error() || method.sig.references_error()
2327 let err_inputs = self.err_args(args_no_rcvr.len());
2329 let err_inputs = match tuple_arguments {
2330 DontTupleArguments => err_inputs,
2331 TupleArguments => vec![self.tcx.intern_tup(&err_inputs[..], false)],
2334 self.check_argument_types(sp, &err_inputs[..], &[], args_no_rcvr,
2335 false, tuple_arguments, None);
2336 return self.tcx.types.err;
2339 let method = method.unwrap();
2340 // HACK(eddyb) ignore self in the definition (see above).
2341 let expected_arg_tys = self.expected_inputs_for_expected_output(
2344 method.sig.output(),
2345 &method.sig.inputs()[1..]
2347 self.check_argument_types(sp, &method.sig.inputs()[1..], &expected_arg_tys[..],
2348 args_no_rcvr, method.sig.variadic, tuple_arguments,
2349 self.tcx.hir.span_if_local(method.def_id));
2353 /// Generic function that factors out common logic from function calls,
2354 /// method calls and overloaded operators.
2355 fn check_argument_types(&self,
2357 fn_inputs: &[Ty<'tcx>],
2358 expected_arg_tys: &[Ty<'tcx>],
2359 args: &'gcx [hir::Expr],
2361 tuple_arguments: TupleArgumentsFlag,
2362 def_span: Option<Span>) {
2365 // Grab the argument types, supplying fresh type variables
2366 // if the wrong number of arguments were supplied
2367 let supplied_arg_count = if tuple_arguments == DontTupleArguments {
2373 // All the input types from the fn signature must outlive the call
2374 // so as to validate implied bounds.
2375 for &fn_input_ty in fn_inputs {
2376 self.register_wf_obligation(fn_input_ty, sp, traits::MiscObligation);
2379 let mut expected_arg_tys = expected_arg_tys;
2380 let expected_arg_count = fn_inputs.len();
2382 let sp_args = if args.len() > 0 {
2383 let (first, args) = args.split_at(1);
2384 let mut sp_tmp = first[0].span;
2386 let sp_opt = self.sess().codemap().merge_spans(sp_tmp, arg.span);
2387 if ! sp_opt.is_some() {
2390 sp_tmp = sp_opt.unwrap();
2397 fn parameter_count_error<'tcx>(sess: &Session, sp: Span, expected_count: usize,
2398 arg_count: usize, error_code: &str, variadic: bool,
2399 def_span: Option<Span>) {
2400 let mut err = sess.struct_span_err_with_code(sp,
2401 &format!("this function takes {}{} parameter{} but {} parameter{} supplied",
2402 if variadic {"at least "} else {""},
2404 if expected_count == 1 {""} else {"s"},
2406 if arg_count == 1 {" was"} else {"s were"}),
2409 err.span_label(sp, format!("expected {}{} parameter{}",
2410 if variadic {"at least "} else {""},
2412 if expected_count == 1 {""} else {"s"}));
2413 if let Some(def_s) = def_span {
2414 err.span_label(def_s, "defined here");
2419 let formal_tys = if tuple_arguments == TupleArguments {
2420 let tuple_type = self.structurally_resolved_type(sp, fn_inputs[0]);
2421 match tuple_type.sty {
2422 ty::TyTuple(arg_types, _) if arg_types.len() != args.len() => {
2423 parameter_count_error(tcx.sess, sp_args, arg_types.len(), args.len(),
2424 "E0057", false, def_span);
2425 expected_arg_tys = &[];
2426 self.err_args(args.len())
2428 ty::TyTuple(arg_types, _) => {
2429 expected_arg_tys = match expected_arg_tys.get(0) {
2430 Some(&ty) => match ty.sty {
2431 ty::TyTuple(ref tys, _) => &tys,
2439 span_err!(tcx.sess, sp, E0059,
2440 "cannot use call notation; the first type parameter \
2441 for the function trait is neither a tuple nor unit");
2442 expected_arg_tys = &[];
2443 self.err_args(args.len())
2446 } else if expected_arg_count == supplied_arg_count {
2448 } else if variadic {
2449 if supplied_arg_count >= expected_arg_count {
2452 parameter_count_error(tcx.sess, sp_args, expected_arg_count,
2453 supplied_arg_count, "E0060", true, def_span);
2454 expected_arg_tys = &[];
2455 self.err_args(supplied_arg_count)
2458 parameter_count_error(tcx.sess, sp_args, expected_arg_count,
2459 supplied_arg_count, "E0061", false, def_span);
2460 expected_arg_tys = &[];
2461 self.err_args(supplied_arg_count)
2464 debug!("check_argument_types: formal_tys={:?}",
2465 formal_tys.iter().map(|t| self.ty_to_string(*t)).collect::<Vec<String>>());
2467 // Check the arguments.
2468 // We do this in a pretty awful way: first we typecheck any arguments
2469 // that are not closures, then we typecheck the closures. This is so
2470 // that we have more information about the types of arguments when we
2471 // typecheck the functions. This isn't really the right way to do this.
2472 for &check_closures in &[false, true] {
2473 debug!("check_closures={}", check_closures);
2475 // More awful hacks: before we check argument types, try to do
2476 // an "opportunistic" vtable resolution of any trait bounds on
2477 // the call. This helps coercions.
2479 self.select_obligations_where_possible();
2482 // For variadic functions, we don't have a declared type for all of
2483 // the arguments hence we only do our usual type checking with
2484 // the arguments who's types we do know.
2485 let t = if variadic {
2487 } else if tuple_arguments == TupleArguments {
2492 for (i, arg) in args.iter().take(t).enumerate() {
2493 // Warn only for the first loop (the "no closures" one).
2494 // Closure arguments themselves can't be diverging, but
2495 // a previous argument can, e.g. `foo(panic!(), || {})`.
2496 if !check_closures {
2497 self.warn_if_unreachable(arg.id, arg.span, "expression");
2500 let is_closure = match arg.node {
2501 hir::ExprClosure(..) => true,
2505 if is_closure != check_closures {
2509 debug!("checking the argument");
2510 let formal_ty = formal_tys[i];
2512 // The special-cased logic below has three functions:
2513 // 1. Provide as good of an expected type as possible.
2514 let expected = expected_arg_tys.get(i).map(|&ty| {
2515 Expectation::rvalue_hint(self, ty)
2518 let checked_ty = self.check_expr_with_expectation(
2520 expected.unwrap_or(ExpectHasType(formal_ty)));
2522 // 2. Coerce to the most detailed type that could be coerced
2523 // to, which is `expected_ty` if `rvalue_hint` returns an
2524 // `ExpectHasType(expected_ty)`, or the `formal_ty` otherwise.
2525 let coerce_ty = expected.and_then(|e| e.only_has_type(self));
2526 self.demand_coerce(&arg, checked_ty, coerce_ty.unwrap_or(formal_ty));
2528 // 3. Relate the expected type and the formal one,
2529 // if the expected type was used for the coercion.
2530 coerce_ty.map(|ty| self.demand_suptype(arg.span, formal_ty, ty));
2534 // We also need to make sure we at least write the ty of the other
2535 // arguments which we skipped above.
2537 fn variadic_error<'tcx>(s: &Session, span: Span, t: Ty<'tcx>, cast_ty: &str) {
2538 type_error_struct!(s, span, t, E0617,
2539 "can't pass `{}` to variadic function, cast to `{}`",
2543 for arg in args.iter().skip(expected_arg_count) {
2544 let arg_ty = self.check_expr(&arg);
2546 // There are a few types which get autopromoted when passed via varargs
2547 // in C but we just error out instead and require explicit casts.
2548 let arg_ty = self.structurally_resolved_type(arg.span, arg_ty);
2550 ty::TyFloat(ast::FloatTy::F32) => {
2551 variadic_error(tcx.sess, arg.span, arg_ty, "c_double");
2553 ty::TyInt(ast::IntTy::I8) | ty::TyInt(ast::IntTy::I16) | ty::TyBool => {
2554 variadic_error(tcx.sess, arg.span, arg_ty, "c_int");
2556 ty::TyUint(ast::UintTy::U8) | ty::TyUint(ast::UintTy::U16) => {
2557 variadic_error(tcx.sess, arg.span, arg_ty, "c_uint");
2559 ty::TyFnDef(..) => {
2560 let ptr_ty = self.tcx.mk_fn_ptr(arg_ty.fn_sig(self.tcx));
2561 let ptr_ty = self.resolve_type_vars_if_possible(&ptr_ty);
2562 variadic_error(tcx.sess, arg.span, arg_ty, &format!("{}", ptr_ty));
2570 fn err_args(&self, len: usize) -> Vec<Ty<'tcx>> {
2571 (0..len).map(|_| self.tcx.types.err).collect()
2574 // AST fragment checking
2577 expected: Expectation<'tcx>)
2583 ast::LitKind::Str(..) => tcx.mk_static_str(),
2584 ast::LitKind::ByteStr(ref v) => {
2585 tcx.mk_imm_ref(tcx.types.re_static,
2586 tcx.mk_array(tcx.types.u8, v.len()))
2588 ast::LitKind::Byte(_) => tcx.types.u8,
2589 ast::LitKind::Char(_) => tcx.types.char,
2590 ast::LitKind::Int(_, ast::LitIntType::Signed(t)) => tcx.mk_mach_int(t),
2591 ast::LitKind::Int(_, ast::LitIntType::Unsigned(t)) => tcx.mk_mach_uint(t),
2592 ast::LitKind::Int(_, ast::LitIntType::Unsuffixed) => {
2593 let opt_ty = expected.to_option(self).and_then(|ty| {
2595 ty::TyInt(_) | ty::TyUint(_) => Some(ty),
2596 ty::TyChar => Some(tcx.types.u8),
2597 ty::TyRawPtr(..) => Some(tcx.types.usize),
2598 ty::TyFnDef(..) | ty::TyFnPtr(_) => Some(tcx.types.usize),
2602 opt_ty.unwrap_or_else(
2603 || tcx.mk_int_var(self.next_int_var_id()))
2605 ast::LitKind::Float(_, t) => tcx.mk_mach_float(t),
2606 ast::LitKind::FloatUnsuffixed(_) => {
2607 let opt_ty = expected.to_option(self).and_then(|ty| {
2609 ty::TyFloat(_) => Some(ty),
2613 opt_ty.unwrap_or_else(
2614 || tcx.mk_float_var(self.next_float_var_id()))
2616 ast::LitKind::Bool(_) => tcx.types.bool
2620 fn check_expr_eq_type(&self,
2621 expr: &'gcx hir::Expr,
2622 expected: Ty<'tcx>) {
2623 let ty = self.check_expr_with_hint(expr, expected);
2624 self.demand_eqtype(expr.span, expected, ty);
2627 pub fn check_expr_has_type_or_error(&self,
2628 expr: &'gcx hir::Expr,
2629 expected: Ty<'tcx>) -> Ty<'tcx> {
2630 self.check_expr_meets_expectation_or_error(expr, ExpectHasType(expected))
2633 fn check_expr_meets_expectation_or_error(&self,
2634 expr: &'gcx hir::Expr,
2635 expected: Expectation<'tcx>) -> Ty<'tcx> {
2636 let expected_ty = expected.to_option(&self).unwrap_or(self.tcx.types.bool);
2637 let mut ty = self.check_expr_with_expectation(expr, expected);
2639 // While we don't allow *arbitrary* coercions here, we *do* allow
2640 // coercions from ! to `expected`.
2642 assert!(!self.tables.borrow().adjustments.contains_key(&expr.id),
2643 "expression with never type wound up being adjusted");
2644 let adj_ty = self.next_diverging_ty_var(
2645 TypeVariableOrigin::AdjustmentType(expr.span));
2646 self.apply_adjustments(expr, vec![Adjustment {
2647 kind: Adjust::NeverToAny,
2653 if let Some(mut err) = self.demand_suptype_diag(expr.span, expected_ty, ty) {
2654 // Add help to type error if this is an `if` condition with an assignment
2655 match (expected, &expr.node) {
2656 (ExpectIfCondition, &hir::ExprAssign(ref lhs, ref rhs)) => {
2657 let msg = "did you mean to compare equality?";
2658 if let (Ok(left), Ok(right)) = (
2659 self.tcx.sess.codemap().span_to_snippet(lhs.span),
2660 self.tcx.sess.codemap().span_to_snippet(rhs.span))
2662 err.span_suggestion(expr.span, msg, format!("{} == {}", left, right));
2674 fn check_expr_coercable_to_type(&self,
2675 expr: &'gcx hir::Expr,
2676 expected: Ty<'tcx>) -> Ty<'tcx> {
2677 let ty = self.check_expr_with_hint(expr, expected);
2678 self.demand_coerce(expr, ty, expected);
2682 fn check_expr_with_hint(&self, expr: &'gcx hir::Expr,
2683 expected: Ty<'tcx>) -> Ty<'tcx> {
2684 self.check_expr_with_expectation(expr, ExpectHasType(expected))
2687 fn check_expr_with_expectation(&self,
2688 expr: &'gcx hir::Expr,
2689 expected: Expectation<'tcx>) -> Ty<'tcx> {
2690 self.check_expr_with_expectation_and_lvalue_pref(expr, expected, NoPreference)
2693 fn check_expr(&self, expr: &'gcx hir::Expr) -> Ty<'tcx> {
2694 self.check_expr_with_expectation(expr, NoExpectation)
2697 fn check_expr_with_lvalue_pref(&self, expr: &'gcx hir::Expr,
2698 lvalue_pref: LvaluePreference) -> Ty<'tcx> {
2699 self.check_expr_with_expectation_and_lvalue_pref(expr, NoExpectation, lvalue_pref)
2702 // determine the `self` type, using fresh variables for all variables
2703 // declared on the impl declaration e.g., `impl<A,B> for Vec<(A,B)>`
2704 // would return ($0, $1) where $0 and $1 are freshly instantiated type
2706 pub fn impl_self_ty(&self,
2707 span: Span, // (potential) receiver for this impl
2709 -> TypeAndSubsts<'tcx> {
2710 let ity = self.tcx.type_of(did);
2711 debug!("impl_self_ty: ity={:?}", ity);
2713 let substs = self.fresh_substs_for_item(span, did);
2714 let substd_ty = self.instantiate_type_scheme(span, &substs, &ity);
2716 TypeAndSubsts { substs: substs, ty: substd_ty }
2719 /// Unifies the output type with the expected type early, for more coercions
2720 /// and forward type information on the input expressions.
2721 fn expected_inputs_for_expected_output(&self,
2723 expected_ret: Expectation<'tcx>,
2724 formal_ret: Ty<'tcx>,
2725 formal_args: &[Ty<'tcx>])
2727 let expected_args = expected_ret.only_has_type(self).and_then(|ret_ty| {
2728 self.fudge_regions_if_ok(&RegionVariableOrigin::Coercion(call_span), || {
2729 // Attempt to apply a subtyping relationship between the formal
2730 // return type (likely containing type variables if the function
2731 // is polymorphic) and the expected return type.
2732 // No argument expectations are produced if unification fails.
2733 let origin = self.misc(call_span);
2734 let ures = self.at(&origin, self.param_env).sup(ret_ty, formal_ret);
2736 // FIXME(#15760) can't use try! here, FromError doesn't default
2737 // to identity so the resulting type is not constrained.
2740 // Process any obligations locally as much as
2741 // we can. We don't care if some things turn
2742 // out unconstrained or ambiguous, as we're
2743 // just trying to get hints here.
2744 let result = self.save_and_restore_in_snapshot_flag(|_| {
2745 let mut fulfill = FulfillmentContext::new();
2746 let ok = ok; // FIXME(#30046)
2747 for obligation in ok.obligations {
2748 fulfill.register_predicate_obligation(self, obligation);
2750 fulfill.select_where_possible(self)
2755 Err(_) => return Err(()),
2758 Err(_) => return Err(()),
2761 // Record all the argument types, with the substitutions
2762 // produced from the above subtyping unification.
2763 Ok(formal_args.iter().map(|ty| {
2764 self.resolve_type_vars_if_possible(ty)
2767 }).unwrap_or(vec![]);
2768 debug!("expected_inputs_for_expected_output(formal={:?} -> {:?}, expected={:?} -> {:?})",
2769 formal_args, formal_ret,
2770 expected_args, expected_ret);
2774 // Checks a method call.
2775 fn check_method_call(&self,
2776 expr: &'gcx hir::Expr,
2777 segment: &hir::PathSegment,
2779 args: &'gcx [hir::Expr],
2780 expected: Expectation<'tcx>,
2781 lvalue_pref: LvaluePreference) -> Ty<'tcx> {
2782 let rcvr = &args[0];
2783 let rcvr_t = self.check_expr_with_lvalue_pref(&rcvr, lvalue_pref);
2784 // no need to check for bot/err -- callee does that
2785 let rcvr_t = self.structurally_resolved_type(expr.span, rcvr_t);
2787 let method = match self.lookup_method(rcvr_t,
2793 self.write_method_call(expr.id, method);
2797 if segment.name != keywords::Invalid.name() {
2798 self.report_method_error(span,
2809 // Call the generic checker.
2810 self.check_method_argument_types(span, method,
2816 fn check_return_expr(&self, return_expr: &'gcx hir::Expr) {
2820 .unwrap_or_else(|| span_bug!(return_expr.span,
2821 "check_return_expr called outside fn body"));
2823 let ret_ty = ret_coercion.borrow().expected_ty();
2824 let return_expr_ty = self.check_expr_with_hint(return_expr, ret_ty.clone());
2825 ret_coercion.borrow_mut()
2827 &self.cause(return_expr.span,
2828 ObligationCauseCode::ReturnType(return_expr.id)),
2831 self.diverges.get());
2835 // A generic function for checking the then and else in an if
2837 fn check_then_else(&self,
2838 cond_expr: &'gcx hir::Expr,
2839 then_expr: &'gcx hir::Expr,
2840 opt_else_expr: Option<&'gcx hir::Expr>,
2842 expected: Expectation<'tcx>) -> Ty<'tcx> {
2843 let cond_ty = self.check_expr_meets_expectation_or_error(cond_expr, ExpectIfCondition);
2844 let cond_diverges = self.diverges.get();
2845 self.diverges.set(Diverges::Maybe);
2847 let expected = expected.adjust_for_branches(self);
2848 let then_ty = self.check_expr_with_expectation(then_expr, expected);
2849 let then_diverges = self.diverges.get();
2850 self.diverges.set(Diverges::Maybe);
2852 // We've already taken the expected type's preferences
2853 // into account when typing the `then` branch. To figure
2854 // out the initial shot at a LUB, we thus only consider
2855 // `expected` if it represents a *hard* constraint
2856 // (`only_has_type`); otherwise, we just go with a
2857 // fresh type variable.
2858 let coerce_to_ty = expected.coercion_target_type(self, sp);
2859 let mut coerce: DynamicCoerceMany = CoerceMany::new(coerce_to_ty);
2861 let if_cause = self.cause(sp, ObligationCauseCode::IfExpression);
2862 coerce.coerce(self, &if_cause, then_expr, then_ty, then_diverges);
2864 if let Some(else_expr) = opt_else_expr {
2865 let else_ty = self.check_expr_with_expectation(else_expr, expected);
2866 let else_diverges = self.diverges.get();
2868 coerce.coerce(self, &if_cause, else_expr, else_ty, else_diverges);
2870 // We won't diverge unless both branches do (or the condition does).
2871 self.diverges.set(cond_diverges | then_diverges & else_diverges);
2873 let else_cause = self.cause(sp, ObligationCauseCode::IfExpressionWithNoElse);
2874 coerce.coerce_forced_unit(self, &else_cause, &mut |_| (), true);
2876 // If the condition is false we can't diverge.
2877 self.diverges.set(cond_diverges);
2880 let result_ty = coerce.complete(self);
2881 if cond_ty.references_error() {
2888 // Check field access expressions
2889 fn check_field(&self,
2890 expr: &'gcx hir::Expr,
2891 lvalue_pref: LvaluePreference,
2892 base: &'gcx hir::Expr,
2893 field: &Spanned<ast::Name>) -> Ty<'tcx> {
2894 let expr_t = self.check_expr_with_lvalue_pref(base, lvalue_pref);
2895 let expr_t = self.structurally_resolved_type(expr.span,
2897 let mut private_candidate = None;
2898 let mut autoderef = self.autoderef(expr.span, expr_t);
2899 while let Some((base_t, _)) = autoderef.next() {
2901 ty::TyAdt(base_def, substs) if !base_def.is_enum() => {
2902 debug!("struct named {:?}", base_t);
2903 let (ident, def_scope) =
2904 self.tcx.adjust(field.node, base_def.did, self.body_id);
2905 let fields = &base_def.struct_variant().fields;
2906 if let Some(field) = fields.iter().find(|f| f.name.to_ident() == ident) {
2907 let field_ty = self.field_ty(expr.span, field, substs);
2908 if field.vis.is_accessible_from(def_scope, self.tcx) {
2909 let adjustments = autoderef.adjust_steps(lvalue_pref);
2910 self.apply_adjustments(base, adjustments);
2911 autoderef.finalize();
2913 self.tcx.check_stability(field.did, expr.id, expr.span);
2917 private_candidate = Some((base_def.did, field_ty));
2923 autoderef.unambiguous_final_ty();
2925 if let Some((did, field_ty)) = private_candidate {
2926 let struct_path = self.tcx().item_path_str(did);
2927 let mut err = struct_span_err!(self.tcx().sess, expr.span, E0616,
2928 "field `{}` of struct `{}` is private",
2929 field.node, struct_path);
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 type_error_struct!(self.tcx().sess, field.span, expr_t, E0615,
2941 "attempted to take value of method `{}` on type `{}`",
2943 .help("maybe a `()` to call it is missing? \
2944 If not, try an anonymous function")
2946 self.tcx().types.err
2948 if !expr_t.is_primitive_ty() {
2949 let mut err = self.no_such_field_err(field.span, &field.node, expr_t);
2952 ty::TyAdt(def, _) if !def.is_enum() => {
2953 if let Some(suggested_field_name) =
2954 Self::suggest_field_name(def.struct_variant(), field, vec![]) {
2955 err.span_label(field.span,
2956 format!("did you mean `{}`?", suggested_field_name));
2958 err.span_label(field.span, "unknown field");
2961 ty::TyRawPtr(..) => {
2962 err.note(&format!("`{0}` is a native pointer; perhaps you need to deref \
2964 self.tcx.hir.node_to_pretty_string(base.id),
2971 type_error_struct!(self.tcx().sess, field.span, expr_t, E0610,
2972 "`{}` is a primitive type and therefore doesn't have fields",
2975 self.tcx().types.err
2979 // Return an hint about the closest match in field names
2980 fn suggest_field_name(variant: &'tcx ty::VariantDef,
2981 field: &Spanned<ast::Name>,
2982 skip : Vec<InternedString>)
2984 let name = field.node.as_str();
2985 let names = variant.fields.iter().filter_map(|field| {
2986 // ignore already set fields and private fields from non-local crates
2987 if skip.iter().any(|x| *x == field.name.as_str()) ||
2988 (variant.did.krate != LOCAL_CRATE && field.vis != Visibility::Public) {
2995 // only find fits with at least one matching letter
2996 find_best_match_for_name(names, &name, Some(name.len()))
2999 // Check tuple index expressions
3000 fn check_tup_field(&self,
3001 expr: &'gcx hir::Expr,
3002 lvalue_pref: LvaluePreference,
3003 base: &'gcx hir::Expr,
3004 idx: codemap::Spanned<usize>) -> Ty<'tcx> {
3005 let expr_t = self.check_expr_with_lvalue_pref(base, lvalue_pref);
3006 let expr_t = self.structurally_resolved_type(expr.span,
3008 let mut private_candidate = None;
3009 let mut tuple_like = false;
3010 let mut autoderef = self.autoderef(expr.span, expr_t);
3011 while let Some((base_t, _)) = autoderef.next() {
3012 let field = match base_t.sty {
3013 ty::TyAdt(base_def, substs) if base_def.is_struct() => {
3014 tuple_like = base_def.struct_variant().ctor_kind == CtorKind::Fn;
3015 if !tuple_like { continue }
3017 debug!("tuple struct named {:?}", base_t);
3018 let ident = ast::Ident {
3019 name: Symbol::intern(&idx.node.to_string()),
3020 ctxt: idx.span.ctxt.modern(),
3022 let (ident, def_scope) =
3023 self.tcx.adjust_ident(ident, base_def.did, self.body_id);
3024 let fields = &base_def.struct_variant().fields;
3025 if let Some(field) = fields.iter().find(|f| f.name.to_ident() == ident) {
3026 let field_ty = self.field_ty(expr.span, field, substs);
3027 if field.vis.is_accessible_from(def_scope, self.tcx) {
3028 self.tcx.check_stability(field.did, expr.id, expr.span);
3031 private_candidate = Some((base_def.did, field_ty));
3038 ty::TyTuple(ref v, _) => {
3040 v.get(idx.node).cloned()
3045 if let Some(field_ty) = field {
3046 let adjustments = autoderef.adjust_steps(lvalue_pref);
3047 self.apply_adjustments(base, adjustments);
3048 autoderef.finalize();
3052 autoderef.unambiguous_final_ty();
3054 if let Some((did, field_ty)) = private_candidate {
3055 let struct_path = self.tcx().item_path_str(did);
3056 struct_span_err!(self.tcx().sess, expr.span, E0611,
3057 "field `{}` of tuple-struct `{}` is private",
3058 idx.node, struct_path).emit();
3063 type_error_struct!(self.tcx().sess, expr.span, expr_t, E0612,
3064 "attempted out-of-bounds tuple index `{}` on type `{}`",
3065 idx.node, expr_t).emit();
3067 self.no_such_field_err(expr.span, idx.node, expr_t).emit();
3070 self.tcx().types.err
3073 fn no_such_field_err<T: Display>(&self, span: Span, field: T, expr_t: &ty::TyS)
3074 -> DiagnosticBuilder {
3075 type_error_struct!(self.tcx().sess, span, expr_t, E0609,
3076 "no field `{}` on type `{}`",
3080 fn report_unknown_field(&self,
3082 variant: &'tcx ty::VariantDef,
3084 skip_fields: &[hir::Field],
3086 let mut err = self.type_error_struct_with_diag(
3088 |actual| match ty.sty {
3089 ty::TyAdt(adt, ..) if adt.is_enum() => {
3090 struct_span_err!(self.tcx.sess, field.name.span, E0559,
3091 "{} `{}::{}` has no field named `{}`",
3092 kind_name, actual, variant.name, field.name.node)
3095 struct_span_err!(self.tcx.sess, field.name.span, E0560,
3096 "{} `{}` has no field named `{}`",
3097 kind_name, actual, field.name.node)
3101 // prevent all specified fields from being suggested
3102 let skip_fields = skip_fields.iter().map(|ref x| x.name.node.as_str());
3103 if let Some(field_name) = Self::suggest_field_name(variant,
3105 skip_fields.collect()) {
3106 err.span_label(field.name.span,
3107 format!("field does not exist - did you mean `{}`?", field_name));
3110 ty::TyAdt(adt, ..) if adt.is_enum() => {
3111 err.span_label(field.name.span, format!("`{}::{}` does not have this field",
3115 err.span_label(field.name.span, format!("`{}` does not have this field", ty));
3122 fn check_expr_struct_fields(&self,
3124 expected: Expectation<'tcx>,
3125 expr_id: ast::NodeId,
3127 variant: &'tcx ty::VariantDef,
3128 ast_fields: &'gcx [hir::Field],
3129 check_completeness: bool) {
3133 self.expected_inputs_for_expected_output(span, expected, adt_ty, &[adt_ty])
3134 .get(0).cloned().unwrap_or(adt_ty);
3135 // re-link the regions that EIfEO can erase.
3136 self.demand_eqtype(span, adt_ty_hint, adt_ty);
3138 let (substs, adt_kind, kind_name) = match &adt_ty.sty{
3139 &ty::TyAdt(adt, substs) => {
3140 (substs, adt.adt_kind(), adt.variant_descr())
3142 _ => span_bug!(span, "non-ADT passed to check_expr_struct_fields")
3145 let mut remaining_fields = FxHashMap();
3146 for field in &variant.fields {
3147 remaining_fields.insert(field.name.to_ident(), field);
3150 let mut seen_fields = FxHashMap();
3152 let mut error_happened = false;
3154 // Typecheck each field.
3155 for field in ast_fields {
3156 let ident = tcx.adjust(field.name.node, variant.did, self.body_id).0;
3157 let field_type = if let Some(v_field) = remaining_fields.remove(&ident) {
3158 seen_fields.insert(field.name.node, field.span);
3160 // we don't look at stability attributes on
3161 // struct-like enums (yet...), but it's definitely not
3162 // a bug to have construct one.
3163 if adt_kind != ty::AdtKind::Enum {
3164 tcx.check_stability(v_field.did, expr_id, field.span);
3167 self.field_ty(field.span, v_field, substs)
3169 error_happened = true;
3170 if let Some(_) = variant.find_field_named(field.name.node) {
3171 let mut err = struct_span_err!(self.tcx.sess,
3174 "field `{}` specified more than once",
3177 err.span_label(field.name.span, "used more than once");
3179 if let Some(prev_span) = seen_fields.get(&field.name.node) {
3180 err.span_label(*prev_span, format!("first use of `{}`", field.name.node));
3185 self.report_unknown_field(adt_ty, variant, field, ast_fields, kind_name);
3191 // Make sure to give a type to the field even if there's
3192 // an error, so we can continue typechecking
3193 self.check_expr_coercable_to_type(&field.expr, field_type);
3196 // Make sure the programmer specified correct number of fields.
3197 if kind_name == "union" {
3198 if ast_fields.len() != 1 {
3199 tcx.sess.span_err(span, "union expressions should have exactly one field");
3201 } else if check_completeness && !error_happened && !remaining_fields.is_empty() {
3202 let len = remaining_fields.len();
3204 let mut displayable_field_names = remaining_fields
3206 .map(|ident| ident.name.as_str())
3207 .collect::<Vec<_>>();
3209 displayable_field_names.sort();
3211 let truncated_fields_error = if len <= 3 {
3214 format!(" and {} other field{}", (len - 3), if len - 3 == 1 {""} else {"s"})
3217 let remaining_fields_names = displayable_field_names.iter().take(3)
3218 .map(|n| format!("`{}`", n))
3219 .collect::<Vec<_>>()
3222 struct_span_err!(tcx.sess, span, E0063,
3223 "missing field{} {}{} in initializer of `{}`",
3224 if remaining_fields.len() == 1 { "" } else { "s" },
3225 remaining_fields_names,
3226 truncated_fields_error,
3228 .span_label(span, format!("missing {}{}",
3229 remaining_fields_names,
3230 truncated_fields_error))
3235 fn check_struct_fields_on_error(&self,
3236 fields: &'gcx [hir::Field],
3237 base_expr: &'gcx Option<P<hir::Expr>>) {
3238 for field in fields {
3239 self.check_expr(&field.expr);
3243 self.check_expr(&base);
3249 pub fn check_struct_path(&self,
3251 node_id: ast::NodeId)
3252 -> Option<(&'tcx ty::VariantDef, Ty<'tcx>)> {
3253 let path_span = match *qpath {
3254 hir::QPath::Resolved(_, ref path) => path.span,
3255 hir::QPath::TypeRelative(ref qself, _) => qself.span
3257 let (def, ty) = self.finish_resolving_struct_path(qpath, path_span, node_id);
3258 let variant = match def {
3260 self.set_tainted_by_errors();
3263 Def::Variant(..) => {
3265 ty::TyAdt(adt, substs) => {
3266 Some((adt.variant_of_def(def), adt.did, substs))
3268 _ => bug!("unexpected type: {:?}", ty.sty)
3271 Def::Struct(..) | Def::Union(..) | Def::TyAlias(..) |
3272 Def::AssociatedTy(..) | Def::SelfTy(..) => {
3274 ty::TyAdt(adt, substs) if !adt.is_enum() => {
3275 Some((adt.struct_variant(), adt.did, substs))
3280 _ => bug!("unexpected definition: {:?}", def)
3283 if let Some((variant, did, substs)) = variant {
3284 // Check bounds on type arguments used in the path.
3285 let bounds = self.instantiate_bounds(path_span, did, substs);
3286 let cause = traits::ObligationCause::new(path_span, self.body_id,
3287 traits::ItemObligation(did));
3288 self.add_obligations_for_parameters(cause, &bounds);
3292 struct_span_err!(self.tcx.sess, path_span, E0071,
3293 "expected struct, variant or union type, found {}",
3294 ty.sort_string(self.tcx))
3295 .span_label(path_span, "not a struct")
3301 fn check_expr_struct(&self,
3303 expected: Expectation<'tcx>,
3305 fields: &'gcx [hir::Field],
3306 base_expr: &'gcx Option<P<hir::Expr>>) -> Ty<'tcx>
3308 // Find the relevant variant
3309 let (variant, struct_ty) =
3310 if let Some(variant_ty) = self.check_struct_path(qpath, expr.id) {
3313 self.check_struct_fields_on_error(fields, base_expr);
3314 return self.tcx.types.err;
3317 let path_span = match *qpath {
3318 hir::QPath::Resolved(_, ref path) => path.span,
3319 hir::QPath::TypeRelative(ref qself, _) => qself.span
3322 self.check_expr_struct_fields(struct_ty, expected, expr.id, path_span, variant, fields,
3323 base_expr.is_none());
3324 if let &Some(ref base_expr) = base_expr {
3325 self.check_expr_has_type_or_error(base_expr, struct_ty);
3326 match struct_ty.sty {
3327 ty::TyAdt(adt, substs) if adt.is_struct() => {
3328 let fru_field_types = adt.struct_variant().fields.iter().map(|f| {
3329 self.normalize_associated_types_in(expr.span, &f.ty(self.tcx, substs))
3331 self.tables.borrow_mut().fru_field_types.insert(expr.id, fru_field_types);
3334 span_err!(self.tcx.sess, base_expr.span, E0436,
3335 "functional record update syntax requires a struct");
3339 self.require_type_is_sized(struct_ty, expr.span, traits::StructInitializerSized);
3345 /// If an expression has any sub-expressions that result in a type error,
3346 /// inspecting that expression's type with `ty.references_error()` will return
3347 /// true. Likewise, if an expression is known to diverge, inspecting its
3348 /// type with `ty::type_is_bot` will return true (n.b.: since Rust is
3349 /// strict, _|_ can appear in the type of an expression that does not,
3350 /// itself, diverge: for example, fn() -> _|_.)
3351 /// Note that inspecting a type's structure *directly* may expose the fact
3352 /// that there are actually multiple representations for `TyError`, so avoid
3353 /// that when err needs to be handled differently.
3354 fn check_expr_with_expectation_and_lvalue_pref(&self,
3355 expr: &'gcx hir::Expr,
3356 expected: Expectation<'tcx>,
3357 lvalue_pref: LvaluePreference) -> Ty<'tcx> {
3358 debug!(">> typechecking: expr={:?} expected={:?}",
3361 // Warn for expressions after diverging siblings.
3362 self.warn_if_unreachable(expr.id, expr.span, "expression");
3364 // Hide the outer diverging and has_errors flags.
3365 let old_diverges = self.diverges.get();
3366 let old_has_errors = self.has_errors.get();
3367 self.diverges.set(Diverges::Maybe);
3368 self.has_errors.set(false);
3370 let ty = self.check_expr_kind(expr, expected, lvalue_pref);
3372 // Warn for non-block expressions with diverging children.
3375 hir::ExprLoop(..) | hir::ExprWhile(..) |
3376 hir::ExprIf(..) | hir::ExprMatch(..) => {}
3378 _ => self.warn_if_unreachable(expr.id, expr.span, "expression")
3381 // Any expression that produces a value of type `!` must have diverged
3383 self.diverges.set(self.diverges.get() | Diverges::Always);
3386 // Record the type, which applies it effects.
3387 // We need to do this after the warning above, so that
3388 // we don't warn for the diverging expression itself.
3389 self.write_ty(expr.id, ty);
3391 // Combine the diverging and has_error flags.
3392 self.diverges.set(self.diverges.get() | old_diverges);
3393 self.has_errors.set(self.has_errors.get() | old_has_errors);
3395 debug!("type of {} is...", self.tcx.hir.node_to_string(expr.id));
3396 debug!("... {:?}, expected is {:?}", ty, expected);
3401 fn check_expr_kind(&self,
3402 expr: &'gcx hir::Expr,
3403 expected: Expectation<'tcx>,
3404 lvalue_pref: LvaluePreference) -> Ty<'tcx> {
3408 hir::ExprBox(ref subexpr) => {
3409 let expected_inner = expected.to_option(self).map_or(NoExpectation, |ty| {
3411 ty::TyAdt(def, _) if def.is_box()
3412 => Expectation::rvalue_hint(self, ty.boxed_ty()),
3416 let referent_ty = self.check_expr_with_expectation(subexpr, expected_inner);
3417 tcx.mk_box(referent_ty)
3420 hir::ExprLit(ref lit) => {
3421 self.check_lit(&lit, expected)
3423 hir::ExprBinary(op, ref lhs, ref rhs) => {
3424 self.check_binop(expr, op, lhs, rhs)
3426 hir::ExprAssignOp(op, ref lhs, ref rhs) => {
3427 self.check_binop_assign(expr, op, lhs, rhs)
3429 hir::ExprUnary(unop, ref oprnd) => {
3430 let expected_inner = match unop {
3431 hir::UnNot | hir::UnNeg => {
3438 let lvalue_pref = match unop {
3439 hir::UnDeref => lvalue_pref,
3442 let mut oprnd_t = self.check_expr_with_expectation_and_lvalue_pref(&oprnd,
3446 if !oprnd_t.references_error() {
3447 oprnd_t = self.structurally_resolved_type(expr.span, oprnd_t);
3450 if let Some(mt) = oprnd_t.builtin_deref(true, NoPreference) {
3452 } else if let Some(ok) = self.try_overloaded_deref(
3453 expr.span, oprnd_t, lvalue_pref) {
3454 let method = self.register_infer_ok_obligations(ok);
3455 if let ty::TyRef(region, mt) = method.sig.inputs()[0].sty {
3456 self.apply_adjustments(oprnd, vec![Adjustment {
3457 kind: Adjust::Borrow(AutoBorrow::Ref(region, mt.mutbl)),
3458 target: method.sig.inputs()[0]
3461 oprnd_t = self.make_overloaded_lvalue_return_type(method).ty;
3462 self.write_method_call(expr.id, method);
3464 type_error_struct!(tcx.sess, expr.span, oprnd_t, E0614,
3465 "type `{}` cannot be dereferenced",
3467 oprnd_t = tcx.types.err;
3471 let result = self.check_user_unop(expr, oprnd_t, unop);
3472 // If it's builtin, we can reuse the type, this helps inference.
3473 if !(oprnd_t.is_integral() || oprnd_t.sty == ty::TyBool) {
3478 let result = self.check_user_unop(expr, oprnd_t, unop);
3479 // If it's builtin, we can reuse the type, this helps inference.
3480 if !(oprnd_t.is_integral() || oprnd_t.is_fp()) {
3488 hir::ExprAddrOf(mutbl, ref oprnd) => {
3489 let hint = expected.only_has_type(self).map_or(NoExpectation, |ty| {
3491 ty::TyRef(_, ref mt) | ty::TyRawPtr(ref mt) => {
3492 if self.tcx.expr_is_lval(&oprnd) {
3493 // Lvalues may legitimately have unsized types.
3494 // For example, dereferences of a fat pointer and
3495 // the last field of a struct can be unsized.
3496 ExpectHasType(mt.ty)
3498 Expectation::rvalue_hint(self, mt.ty)
3504 let lvalue_pref = LvaluePreference::from_mutbl(mutbl);
3505 let ty = self.check_expr_with_expectation_and_lvalue_pref(&oprnd, hint, lvalue_pref);
3507 let tm = ty::TypeAndMut { ty: ty, mutbl: mutbl };
3508 if tm.ty.references_error() {
3511 // Note: at this point, we cannot say what the best lifetime
3512 // is to use for resulting pointer. We want to use the
3513 // shortest lifetime possible so as to avoid spurious borrowck
3514 // errors. Moreover, the longest lifetime will depend on the
3515 // precise details of the value whose address is being taken
3516 // (and how long it is valid), which we don't know yet until type
3517 // inference is complete.
3519 // Therefore, here we simply generate a region variable. The
3520 // region inferencer will then select the ultimate value.
3521 // Finally, borrowck is charged with guaranteeing that the
3522 // value whose address was taken can actually be made to live
3523 // as long as it needs to live.
3524 let region = self.next_region_var(infer::AddrOfRegion(expr.span));
3525 tcx.mk_ref(region, tm)
3528 hir::ExprPath(ref qpath) => {
3529 let (def, opt_ty, segments) = self.resolve_ty_and_def_ufcs(qpath,
3530 expr.id, expr.span);
3531 let ty = if def != Def::Err {
3532 self.instantiate_value_path(segments, opt_ty, def, expr.span, id)
3534 self.set_tainted_by_errors();
3538 // We always require that the type provided as the value for
3539 // a type parameter outlives the moment of instantiation.
3540 let substs = self.tables.borrow().node_substs(expr.id);
3541 self.add_wf_bounds(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 |_| (), true);
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 |_| (), true);
3634 hir::ExprAssign(ref lhs, ref rhs) => {
3635 let lhs_ty = self.check_expr_with_lvalue_pref(&lhs, PreferMutLvalue);
3637 let rhs_ty = self.check_expr_coercable_to_type(&rhs, lhs_ty);
3640 ExpectIfCondition => {
3641 self.tcx.sess.delay_span_bug(lhs.span, "invalid lhs expression in if;\
3642 expected error elsehwere");
3645 // Only check this if not in an `if` condition, as the
3646 // mistyped comparison help is more appropriate.
3647 if !self.tcx.expr_is_lval(&lhs) {
3649 self.tcx.sess, expr.span, E0070,
3650 "invalid left-hand side expression")
3653 "left-hand of expression not valid")
3659 self.require_type_is_sized(lhs_ty, lhs.span, traits::AssignmentLhsSized);
3661 if lhs_ty.references_error() || rhs_ty.references_error() {
3667 hir::ExprIf(ref cond, ref then_expr, ref opt_else_expr) => {
3668 self.check_then_else(&cond, then_expr, opt_else_expr.as_ref().map(|e| &**e),
3669 expr.span, expected)
3671 hir::ExprWhile(ref cond, ref body, _) => {
3672 let ctxt = BreakableCtxt {
3673 // cannot use break with a value from a while loop
3678 self.with_breakable_ctxt(expr.id, ctxt, || {
3679 self.check_expr_has_type_or_error(&cond, tcx.types.bool);
3680 let cond_diverging = self.diverges.get();
3681 self.check_block_no_value(&body);
3683 // We may never reach the body so it diverging means nothing.
3684 self.diverges.set(cond_diverging);
3689 hir::ExprLoop(ref body, _, source) => {
3690 let coerce = match source {
3691 // you can only use break with a value from a normal `loop { }`
3692 hir::LoopSource::Loop => {
3693 let coerce_to = expected.coercion_target_type(self, body.span);
3694 Some(CoerceMany::new(coerce_to))
3697 hir::LoopSource::WhileLet |
3698 hir::LoopSource::ForLoop => {
3703 let ctxt = BreakableCtxt {
3705 may_break: false, // will get updated if/when we find a `break`
3708 let (ctxt, ()) = self.with_breakable_ctxt(expr.id, ctxt, || {
3709 self.check_block_no_value(&body);
3713 // No way to know whether it's diverging because
3714 // of a `break` or an outer `break` or `return.
3715 self.diverges.set(Diverges::Maybe);
3718 // If we permit break with a value, then result type is
3719 // the LUB of the breaks (possibly ! if none); else, it
3720 // is nil. This makes sense because infinite loops
3721 // (which would have type !) are only possible iff we
3722 // permit break with a value [1].
3723 assert!(ctxt.coerce.is_some() || ctxt.may_break); // [1]
3724 ctxt.coerce.map(|c| c.complete(self)).unwrap_or(self.tcx.mk_nil())
3726 hir::ExprMatch(ref discrim, ref arms, match_src) => {
3727 self.check_match(expr, &discrim, arms, expected, match_src)
3729 hir::ExprClosure(capture, ref decl, body_id, _) => {
3730 self.check_expr_closure(expr, capture, &decl, body_id, expected)
3732 hir::ExprBlock(ref body) => {
3733 self.check_block_with_expected(&body, expected)
3735 hir::ExprCall(ref callee, ref args) => {
3736 self.check_call(expr, &callee, args, expected)
3738 hir::ExprMethodCall(ref segment, span, ref args) => {
3739 self.check_method_call(expr, segment, span, args, expected, lvalue_pref)
3741 hir::ExprCast(ref e, ref t) => {
3742 // Find the type of `e`. Supply hints based on the type we are casting to,
3744 let t_cast = self.to_ty(t);
3745 let t_cast = self.resolve_type_vars_if_possible(&t_cast);
3746 let t_expr = self.check_expr_with_expectation(e, ExpectCastableToType(t_cast));
3747 let t_cast = self.resolve_type_vars_if_possible(&t_cast);
3748 let diverges = self.diverges.get();
3750 // Eagerly check for some obvious errors.
3751 if t_expr.references_error() || t_cast.references_error() {
3754 // Defer other checks until we're done type checking.
3755 let mut deferred_cast_checks = self.deferred_cast_checks.borrow_mut();
3756 match cast::CastCheck::new(self, e, t_expr, diverges, t_cast, t.span, expr.span) {
3758 deferred_cast_checks.push(cast_check);
3761 Err(ErrorReported) => {
3767 hir::ExprType(ref e, ref t) => {
3768 let typ = self.to_ty(&t);
3769 self.check_expr_eq_type(&e, typ);
3772 hir::ExprArray(ref args) => {
3773 let uty = expected.to_option(self).and_then(|uty| {
3775 ty::TyArray(ty, _) | ty::TySlice(ty) => Some(ty),
3780 let element_ty = if !args.is_empty() {
3781 let coerce_to = uty.unwrap_or_else(
3782 || self.next_ty_var(TypeVariableOrigin::TypeInference(expr.span)));
3783 let mut coerce = CoerceMany::with_coercion_sites(coerce_to, args);
3784 assert_eq!(self.diverges.get(), Diverges::Maybe);
3786 let e_ty = self.check_expr_with_hint(e, coerce_to);
3787 let cause = self.misc(e.span);
3788 coerce.coerce(self, &cause, e, e_ty, self.diverges.get());
3790 coerce.complete(self)
3792 self.next_ty_var(TypeVariableOrigin::TypeInference(expr.span))
3794 tcx.mk_array(element_ty, args.len())
3796 hir::ExprRepeat(ref element, count) => {
3797 let count = eval_length(self.tcx, count, "repeat count")
3800 let uty = match expected {
3801 ExpectHasType(uty) => {
3803 ty::TyArray(ty, _) | ty::TySlice(ty) => Some(ty),
3810 let (element_ty, t) = match uty {
3812 self.check_expr_coercable_to_type(&element, uty);
3816 let t: Ty = self.next_ty_var(TypeVariableOrigin::MiscVariable(element.span));
3817 let element_ty = self.check_expr_has_type_or_error(&element, t);
3823 // For [foo, ..n] where n > 1, `foo` must have
3825 let lang_item = self.tcx.require_lang_item(lang_items::CopyTraitLangItem);
3826 self.require_type_meets(t, expr.span, traits::RepeatVec, lang_item);
3829 if element_ty.references_error() {
3832 tcx.mk_array(t, count)
3835 hir::ExprTup(ref elts) => {
3836 let flds = expected.only_has_type(self).and_then(|ty| {
3838 ty::TyTuple(ref flds, _) => Some(&flds[..]),
3843 let elt_ts_iter = elts.iter().enumerate().map(|(i, e)| {
3844 let t = match flds {
3845 Some(ref fs) if i < fs.len() => {
3847 self.check_expr_coercable_to_type(&e, ety);
3851 self.check_expr_with_expectation(&e, NoExpectation)
3856 let tuple = tcx.mk_tup(elt_ts_iter, false);
3857 if tuple.references_error() {
3860 self.require_type_is_sized(tuple, expr.span, traits::TupleInitializerSized);
3864 hir::ExprStruct(ref qpath, ref fields, ref base_expr) => {
3865 self.check_expr_struct(expr, expected, qpath, fields, base_expr)
3867 hir::ExprField(ref base, ref field) => {
3868 self.check_field(expr, lvalue_pref, &base, field)
3870 hir::ExprTupField(ref base, idx) => {
3871 self.check_tup_field(expr, lvalue_pref, &base, idx)
3873 hir::ExprIndex(ref base, ref idx) => {
3874 let base_t = self.check_expr_with_lvalue_pref(&base, lvalue_pref);
3875 let idx_t = self.check_expr(&idx);
3877 if base_t.references_error() {
3879 } else if idx_t.references_error() {
3882 let base_t = self.structurally_resolved_type(expr.span, base_t);
3883 match self.lookup_indexing(expr, base, base_t, idx_t, lvalue_pref) {
3884 Some((index_ty, element_ty)) => {
3885 self.demand_coerce(idx, idx_t, index_ty);
3889 let mut err = type_error_struct!(tcx.sess, expr.span, base_t, E0608,
3890 "cannot index into a value of type `{}`",
3892 // Try to give some advice about indexing tuples.
3893 if let ty::TyTuple(..) = base_t.sty {
3894 let mut needs_note = true;
3895 // If the index is an integer, we can show the actual
3896 // fixed expression:
3897 if let hir::ExprLit(ref lit) = idx.node {
3898 if let ast::LitKind::Int(i,
3899 ast::LitIntType::Unsuffixed) = lit.node {
3900 let snip = tcx.sess.codemap().span_to_snippet(base.span);
3901 if let Ok(snip) = snip {
3902 err.span_suggestion(expr.span,
3903 "to access tuple elements, use",
3904 format!("{}.{}", snip, i));
3910 err.help("to access tuple elements, use tuple indexing \
3911 syntax (e.g. `tuple.0`)");
3923 // Finish resolving a path in a struct expression or pattern `S::A { .. }` if necessary.
3924 // The newly resolved definition is written into `type_dependent_defs`.
3925 fn finish_resolving_struct_path(&self,
3928 node_id: ast::NodeId)
3932 hir::QPath::Resolved(ref maybe_qself, ref path) => {
3933 let opt_self_ty = maybe_qself.as_ref().map(|qself| self.to_ty(qself));
3934 let ty = AstConv::def_to_ty(self, opt_self_ty, path, true);
3937 hir::QPath::TypeRelative(ref qself, ref segment) => {
3938 let ty = self.to_ty(qself);
3940 let def = if let hir::TyPath(hir::QPath::Resolved(_, ref path)) = qself.node {
3945 let (ty, def) = AstConv::associated_path_def_to_ty(self, node_id, path_span,
3948 // Write back the new resolution.
3949 self.tables.borrow_mut().type_dependent_defs.insert(node_id, def);
3956 // Resolve associated value path into a base type and associated constant or method definition.
3957 // The newly resolved definition is written into `type_dependent_defs`.
3958 pub fn resolve_ty_and_def_ufcs<'b>(&self,
3959 qpath: &'b hir::QPath,
3960 node_id: ast::NodeId,
3962 -> (Def, Option<Ty<'tcx>>, &'b [hir::PathSegment])
3964 let (ty, item_segment) = match *qpath {
3965 hir::QPath::Resolved(ref opt_qself, ref path) => {
3967 opt_qself.as_ref().map(|qself| self.to_ty(qself)),
3968 &path.segments[..]);
3970 hir::QPath::TypeRelative(ref qself, ref segment) => {
3971 (self.to_ty(qself), segment)
3974 let item_name = item_segment.name;
3975 let def = match self.resolve_ufcs(span, item_name, ty, node_id) {
3978 let def = match error {
3979 method::MethodError::PrivateMatch(def) => def,
3982 if item_name != keywords::Invalid.name() {
3983 self.report_method_error(span, ty, item_name, None, error, None);
3989 // Write back the new resolution.
3990 self.tables.borrow_mut().type_dependent_defs.insert(node_id, def);
3991 (def, Some(ty), slice::ref_slice(&**item_segment))
3994 pub fn check_decl_initializer(&self,
3995 local: &'gcx hir::Local,
3996 init: &'gcx hir::Expr) -> Ty<'tcx>
3998 let ref_bindings = local.pat.contains_ref_binding();
4000 let local_ty = self.local_ty(init.span, local.id);
4001 if let Some(m) = ref_bindings {
4002 // Somewhat subtle: if we have a `ref` binding in the pattern,
4003 // we want to avoid introducing coercions for the RHS. This is
4004 // both because it helps preserve sanity and, in the case of
4005 // ref mut, for soundness (issue #23116). In particular, in
4006 // the latter case, we need to be clear that the type of the
4007 // referent for the reference that results is *equal to* the
4008 // type of the lvalue it is referencing, and not some
4009 // supertype thereof.
4010 let init_ty = self.check_expr_with_lvalue_pref(init, LvaluePreference::from_mutbl(m));
4011 self.demand_eqtype(init.span, init_ty, local_ty);
4014 self.check_expr_coercable_to_type(init, local_ty)
4018 pub fn check_decl_local(&self, local: &'gcx hir::Local) {
4019 let t = self.local_ty(local.span, local.id);
4020 self.write_ty(local.id, t);
4022 if let Some(ref init) = local.init {
4023 let init_ty = self.check_decl_initializer(local, &init);
4024 if init_ty.references_error() {
4025 self.write_ty(local.id, init_ty);
4029 self.check_pat(&local.pat, t);
4030 let pat_ty = self.node_ty(local.pat.id);
4031 if pat_ty.references_error() {
4032 self.write_ty(local.id, pat_ty);
4036 pub fn check_stmt(&self, stmt: &'gcx hir::Stmt) {
4037 // Don't do all the complex logic below for DeclItem.
4039 hir::StmtDecl(ref decl, _) => {
4041 hir::DeclLocal(_) => {}
4042 hir::DeclItem(_) => {
4047 hir::StmtExpr(..) | hir::StmtSemi(..) => {}
4050 self.warn_if_unreachable(stmt.node.id(), stmt.span, "statement");
4052 // Hide the outer diverging and has_errors flags.
4053 let old_diverges = self.diverges.get();
4054 let old_has_errors = self.has_errors.get();
4055 self.diverges.set(Diverges::Maybe);
4056 self.has_errors.set(false);
4059 hir::StmtDecl(ref decl, _) => {
4061 hir::DeclLocal(ref l) => {
4062 self.check_decl_local(&l);
4064 hir::DeclItem(_) => {/* ignore for now */}
4067 hir::StmtExpr(ref expr, _) => {
4068 // Check with expected type of ()
4069 self.check_expr_has_type_or_error(&expr, self.tcx.mk_nil());
4071 hir::StmtSemi(ref expr, _) => {
4072 self.check_expr(&expr);
4076 // Combine the diverging and has_error flags.
4077 self.diverges.set(self.diverges.get() | old_diverges);
4078 self.has_errors.set(self.has_errors.get() | old_has_errors);
4081 pub fn check_block_no_value(&self, blk: &'gcx hir::Block) {
4082 let unit = self.tcx.mk_nil();
4083 let ty = self.check_block_with_expected(blk, ExpectHasType(unit));
4085 // if the block produces a `!` value, that can always be
4086 // (effectively) coerced to unit.
4088 self.demand_suptype(blk.span, unit, ty);
4092 fn check_block_with_expected(&self,
4093 blk: &'gcx hir::Block,
4094 expected: Expectation<'tcx>) -> Ty<'tcx> {
4096 let mut fcx_ps = self.ps.borrow_mut();
4097 let unsafety_state = fcx_ps.recurse(blk);
4098 replace(&mut *fcx_ps, unsafety_state)
4101 // In some cases, blocks have just one exit, but other blocks
4102 // can be targeted by multiple breaks. This cannot happen in
4103 // normal Rust syntax today, but it can happen when we desugar
4104 // a `do catch { ... }` expression.
4108 // 'a: { if true { break 'a Err(()); } Ok(()) }
4110 // Here we would wind up with two coercions, one from
4111 // `Err(())` and the other from the tail expression
4112 // `Ok(())`. If the tail expression is omitted, that's a
4113 // "forced unit" -- unless the block diverges, in which
4114 // case we can ignore the tail expression (e.g., `'a: {
4115 // break 'a 22; }` would not force the type of the block
4117 let tail_expr = blk.expr.as_ref();
4118 let coerce_to_ty = expected.coercion_target_type(self, blk.span);
4119 let coerce = if blk.targeted_by_break {
4120 CoerceMany::new(coerce_to_ty)
4122 let tail_expr: &[P<hir::Expr>] = match tail_expr {
4123 Some(e) => ref_slice(e),
4126 CoerceMany::with_coercion_sites(coerce_to_ty, tail_expr)
4129 let ctxt = BreakableCtxt {
4130 coerce: Some(coerce),
4134 let (ctxt, ()) = self.with_breakable_ctxt(blk.id, ctxt, || {
4135 for s in &blk.stmts {
4139 // check the tail expression **without** holding the
4140 // `enclosing_breakables` lock below.
4141 let tail_expr_ty = tail_expr.map(|t| self.check_expr_with_expectation(t, expected));
4143 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4144 let mut ctxt = enclosing_breakables.find_breakable(blk.id);
4145 let mut coerce = ctxt.coerce.as_mut().unwrap();
4146 if let Some(tail_expr_ty) = tail_expr_ty {
4147 let tail_expr = tail_expr.unwrap();
4148 let cause = self.cause(tail_expr.span,
4149 ObligationCauseCode::BlockTailExpression(blk.id));
4154 self.diverges.get());
4156 // Subtle: if there is no explicit tail expression,
4157 // that is typically equivalent to a tail expression
4158 // of `()` -- except if the block diverges. In that
4159 // case, there is no value supplied from the tail
4160 // expression (assuming there are no other breaks,
4161 // this implies that the type of the block will be
4164 // #41425 -- label the implicit `()` as being the
4165 // "found type" here, rather than the "expected type".
4166 if !self.diverges.get().always() {
4167 coerce.coerce_forced_unit(self, &self.misc(blk.span), &mut |err| {
4168 if let Some(expected_ty) = expected.only_has_type(self) {
4169 self.consider_hint_about_removing_semicolon(blk,
4178 let mut ty = ctxt.coerce.unwrap().complete(self);
4180 if self.has_errors.get() || ty.references_error() {
4181 ty = self.tcx.types.err
4184 self.write_ty(blk.id, ty);
4186 *self.ps.borrow_mut() = prev;
4190 /// Given a `NodeId`, return the `FnDecl` of the method it is enclosed by and whether it is
4191 /// `fn main` if it is a method, `None` otherwise.
4192 pub fn get_fn_decl(&self, blk_id: ast::NodeId) -> Option<(hir::FnDecl, bool)> {
4193 // Get enclosing Fn, if it is a function or a trait method, unless there's a `loop` or
4194 // `while` before reaching it, as block tail returns are not available in them.
4195 if let Some(fn_id) = self.tcx.hir.get_return_block(blk_id) {
4196 let parent = self.tcx.hir.get(fn_id);
4198 if let Node::NodeItem(&hir::Item {
4199 name, node: hir::ItemFn(ref decl, ..), ..
4201 decl.clone().and_then(|decl| {
4202 // This is less than ideal, it will not present the return type span on any
4203 // method called `main`, regardless of whether it is actually the entry point.
4204 Some((decl, name == Symbol::intern("main")))
4206 } else if let Node::NodeTraitItem(&hir::TraitItem {
4207 node: hir::TraitItemKind::Method(hir::MethodSig {
4211 decl.clone().and_then(|decl| {
4222 /// On implicit return expressions with mismatched types, provide the following suggestions:
4224 /// - Point out the method's return type as the reason for the expected type
4225 /// - Possible missing semicolon
4226 /// - Possible missing return type if the return type is the default, and not `fn main()`
4227 pub fn suggest_mismatched_types_on_tail(&self,
4228 err: &mut DiagnosticBuilder<'tcx>,
4229 expression: &'gcx hir::Expr,
4233 blk_id: ast::NodeId) {
4234 self.suggest_missing_semicolon(err, expression, expected, cause_span);
4236 if let Some((fn_decl, is_main)) = self.get_fn_decl(blk_id) {
4237 // `fn main()` must return `()`, do not suggest changing return type
4239 self.suggest_missing_return_type(err, &fn_decl, found);
4244 /// A common error is to forget to add a semicolon at the end of a block:
4248 /// bar_that_returns_u32()
4252 /// This routine checks if the return expression in a block would make sense on its own as a
4253 /// statement and the return type has been left as defaultor has been specified as `()`. If so,
4254 /// it suggests adding a semicolon.
4255 fn suggest_missing_semicolon(&self,
4256 err: &mut DiagnosticBuilder<'tcx>,
4257 expression: &'gcx hir::Expr,
4260 if expected.is_nil() {
4261 // `BlockTailExpression` only relevant if the tail expr would be
4262 // useful on its own.
4263 match expression.node {
4265 hir::ExprMethodCall(..) |
4267 hir::ExprWhile(..) |
4269 hir::ExprMatch(..) |
4270 hir::ExprBlock(..) => {
4271 let sp = cause_span.next_point();
4272 err.span_suggestion(sp,
4273 "did you mean to add a semicolon here?",
4282 /// A possible error is to forget to add a return type that is needed:
4286 /// bar_that_returns_u32()
4290 /// This routine checks if the return type is left as default, the method is not part of an
4291 /// `impl` block and that it isn't the `main` method. If so, it suggests setting the return
4293 fn suggest_missing_return_type(&self,
4294 err: &mut DiagnosticBuilder<'tcx>,
4295 fn_decl: &hir::FnDecl,
4298 // Only recommend changing the return type for methods that
4299 // haven't set a return type at all (and aren't `fn main()` or an impl).
4300 if let &hir::FnDecl {
4301 output: hir::FunctionRetTy::DefaultReturn(span), ..
4303 if ty.is_suggestable() {
4304 err.span_suggestion(span,
4305 "possibly return type missing here?",
4306 format!("-> {} ", ty));
4308 err.span_label(span, "possibly return type missing here?");
4314 /// A common error is to add an extra semicolon:
4317 /// fn foo() -> usize {
4322 /// This routine checks if the final statement in a block is an
4323 /// expression with an explicit semicolon whose type is compatible
4324 /// with `expected_ty`. If so, it suggests removing the semicolon.
4325 fn consider_hint_about_removing_semicolon(&self,
4326 blk: &'gcx hir::Block,
4327 expected_ty: Ty<'tcx>,
4328 err: &mut DiagnosticBuilder) {
4329 // Be helpful when the user wrote `{... expr;}` and
4330 // taking the `;` off is enough to fix the error.
4331 let last_stmt = match blk.stmts.last() {
4335 let last_expr = match last_stmt.node {
4336 hir::StmtSemi(ref e, _) => e,
4339 let last_expr_ty = self.node_ty(last_expr.id);
4340 if self.can_sub(self.param_env, last_expr_ty, expected_ty).is_err() {
4343 let original_span = original_sp(last_stmt.span, blk.span);
4344 let span_semi = Span {
4345 lo: original_span.hi - BytePos(1),
4346 hi: original_span.hi,
4347 ctxt: original_span.ctxt,
4349 err.span_suggestion(span_semi, "consider removing this semicolon", "".to_string());
4352 // Instantiates the given path, which must refer to an item with the given
4353 // number of type parameters and type.
4354 pub fn instantiate_value_path(&self,
4355 segments: &[hir::PathSegment],
4356 opt_self_ty: Option<Ty<'tcx>>,
4359 node_id: ast::NodeId)
4361 debug!("instantiate_value_path(path={:?}, def={:?}, node_id={})",
4366 // We need to extract the type parameters supplied by the user in
4367 // the path `path`. Due to the current setup, this is a bit of a
4368 // tricky-process; the problem is that resolve only tells us the
4369 // end-point of the path resolution, and not the intermediate steps.
4370 // Luckily, we can (at least for now) deduce the intermediate steps
4371 // just from the end-point.
4373 // There are basically four cases to consider:
4375 // 1. Reference to a constructor of enum variant or struct:
4377 // struct Foo<T>(...)
4378 // enum E<T> { Foo(...) }
4380 // In these cases, the parameters are declared in the type
4383 // 2. Reference to a fn item or a free constant:
4387 // In this case, the path will again always have the form
4388 // `a::b::foo::<T>` where only the final segment should have
4389 // type parameters. However, in this case, those parameters are
4390 // declared on a value, and hence are in the `FnSpace`.
4392 // 3. Reference to a method or an associated constant:
4394 // impl<A> SomeStruct<A> {
4398 // Here we can have a path like
4399 // `a::b::SomeStruct::<A>::foo::<B>`, in which case parameters
4400 // may appear in two places. The penultimate segment,
4401 // `SomeStruct::<A>`, contains parameters in TypeSpace, and the
4402 // final segment, `foo::<B>` contains parameters in fn space.
4404 // 4. Reference to a local variable
4406 // Local variables can't have any type parameters.
4408 // The first step then is to categorize the segments appropriately.
4410 assert!(!segments.is_empty());
4412 let mut ufcs_associated = None;
4413 let mut type_segment = None;
4414 let mut fn_segment = None;
4416 // Case 1. Reference to a struct/variant constructor.
4417 Def::StructCtor(def_id, ..) |
4418 Def::VariantCtor(def_id, ..) => {
4419 // Everything but the final segment should have no
4420 // parameters at all.
4421 let mut generics = self.tcx.generics_of(def_id);
4422 if let Some(def_id) = generics.parent {
4423 // Variant and struct constructors use the
4424 // generics of their parent type definition.
4425 generics = self.tcx.generics_of(def_id);
4427 type_segment = Some((segments.last().unwrap(), generics));
4430 // Case 2. Reference to a top-level value.
4432 Def::Const(def_id) |
4433 Def::Static(def_id, _) => {
4434 fn_segment = Some((segments.last().unwrap(),
4435 self.tcx.generics_of(def_id)));
4438 // Case 3. Reference to a method or associated const.
4439 Def::Method(def_id) |
4440 Def::AssociatedConst(def_id) => {
4441 let container = self.tcx.associated_item(def_id).container;
4443 ty::TraitContainer(trait_did) => {
4444 callee::check_legal_trait_for_method_call(self.tcx, span, trait_did)
4446 ty::ImplContainer(_) => {}
4449 let generics = self.tcx.generics_of(def_id);
4450 if segments.len() >= 2 {
4451 let parent_generics = self.tcx.generics_of(generics.parent.unwrap());
4452 type_segment = Some((&segments[segments.len() - 2], parent_generics));
4454 // `<T>::assoc` will end up here, and so can `T::assoc`.
4455 let self_ty = opt_self_ty.expect("UFCS sugared assoc missing Self");
4456 ufcs_associated = Some((container, self_ty));
4458 fn_segment = Some((segments.last().unwrap(), generics));
4461 // Case 4. Local variable, no generics.
4462 Def::Local(..) | Def::Upvar(..) => {}
4464 _ => bug!("unexpected definition: {:?}", def),
4467 debug!("type_segment={:?} fn_segment={:?}", type_segment, fn_segment);
4469 // Now that we have categorized what space the parameters for each
4470 // segment belong to, let's sort out the parameters that the user
4471 // provided (if any) into their appropriate spaces. We'll also report
4472 // errors if type parameters are provided in an inappropriate place.
4473 let poly_segments = type_segment.is_some() as usize +
4474 fn_segment.is_some() as usize;
4475 AstConv::prohibit_type_params(self, &segments[..segments.len() - poly_segments]);
4478 Def::Local(def_id) | Def::Upvar(def_id, ..) => {
4479 let nid = self.tcx.hir.as_local_node_id(def_id).unwrap();
4480 let ty = self.local_ty(span, nid);
4481 let ty = self.normalize_associated_types_in(span, &ty);
4482 self.write_ty(node_id, ty);
4488 // Now we have to compare the types that the user *actually*
4489 // provided against the types that were *expected*. If the user
4490 // did not provide any types, then we want to substitute inference
4491 // variables. If the user provided some types, we may still need
4492 // to add defaults. If the user provided *too many* types, that's
4494 self.check_path_parameter_count(span, &mut type_segment, false);
4495 self.check_path_parameter_count(span, &mut fn_segment, false);
4497 let (fn_start, has_self) = match (type_segment, fn_segment) {
4498 (_, Some((_, generics))) => {
4499 (generics.parent_count(), generics.has_self)
4501 (Some((_, generics)), None) => {
4502 (generics.own_count(), generics.has_self)
4504 (None, None) => (0, false)
4506 let substs = Substs::for_item(self.tcx, def.def_id(), |def, _| {
4507 let mut i = def.index as usize;
4509 let segment = if i < fn_start {
4510 i -= has_self as usize;
4516 let lifetimes = match segment.map(|(s, _)| &s.parameters) {
4517 Some(&hir::AngleBracketedParameters(ref data)) => &data.lifetimes[..],
4518 Some(&hir::ParenthesizedParameters(_)) => bug!(),
4522 if let Some(lifetime) = lifetimes.get(i) {
4523 AstConv::ast_region_to_region(self, lifetime, Some(def))
4525 self.re_infer(span, Some(def)).unwrap()
4528 let mut i = def.index as usize;
4530 let segment = if i < fn_start {
4531 // Handle Self first, so we can adjust the index to match the AST.
4532 if has_self && i == 0 {
4533 return opt_self_ty.unwrap_or_else(|| {
4534 self.type_var_for_def(span, def, substs)
4537 i -= has_self as usize;
4543 let (types, infer_types) = match segment.map(|(s, _)| &s.parameters) {
4544 Some(&hir::AngleBracketedParameters(ref data)) => {
4545 (&data.types[..], data.infer_types)
4547 Some(&hir::ParenthesizedParameters(_)) => bug!(),
4548 None => (&[][..], true)
4551 // Skip over the lifetimes in the same segment.
4552 if let Some((_, generics)) = segment {
4553 i -= generics.regions.len();
4556 if let Some(ast_ty) = types.get(i) {
4557 // A provided type parameter.
4559 } else if !infer_types && def.has_default {
4560 // No type parameter provided, but a default exists.
4561 let default = self.tcx.type_of(def.def_id);
4564 default.subst_spanned(self.tcx, substs, Some(span))
4567 // No type parameters were provided, we can infer all.
4568 // This can also be reached in some error cases:
4569 // We prefer to use inference variables instead of
4570 // TyError to let type inference recover somewhat.
4571 self.type_var_for_def(span, def, substs)
4575 // The things we are substituting into the type should not contain
4576 // escaping late-bound regions, and nor should the base type scheme.
4577 let ty = self.tcx.type_of(def.def_id());
4578 assert!(!substs.has_escaping_regions());
4579 assert!(!ty.has_escaping_regions());
4581 // Add all the obligations that are required, substituting and
4582 // normalized appropriately.
4583 let bounds = self.instantiate_bounds(span, def.def_id(), &substs);
4584 self.add_obligations_for_parameters(
4585 traits::ObligationCause::new(span, self.body_id, traits::ItemObligation(def.def_id())),
4588 // Substitute the values for the type parameters into the type of
4589 // the referenced item.
4590 let ty_substituted = self.instantiate_type_scheme(span, &substs, &ty);
4592 if let Some((ty::ImplContainer(impl_def_id), self_ty)) = ufcs_associated {
4593 // In the case of `Foo<T>::method` and `<Foo<T>>::method`, if `method`
4594 // is inherent, there is no `Self` parameter, instead, the impl needs
4595 // type parameters, which we can infer by unifying the provided `Self`
4596 // with the substituted impl type.
4597 let ty = self.tcx.type_of(impl_def_id);
4599 let impl_ty = self.instantiate_type_scheme(span, &substs, &ty);
4600 match self.at(&self.misc(span), self.param_env).sup(impl_ty, self_ty) {
4601 Ok(ok) => self.register_infer_ok_obligations(ok),
4604 "instantiate_value_path: (UFCS) {:?} was a subtype of {:?} but now is not?",
4611 debug!("instantiate_value_path: type of {:?} is {:?}",
4614 self.write_substs(node_id, substs);
4618 /// Report errors if the provided parameters are too few or too many.
4619 fn check_path_parameter_count(&self,
4621 segment: &mut Option<(&hir::PathSegment, &ty::Generics)>,
4622 is_method_call: bool) {
4623 let (lifetimes, types, infer_types, bindings) = {
4624 match segment.map(|(s, _)| &s.parameters) {
4625 Some(&hir::AngleBracketedParameters(ref data)) => {
4626 (&data.lifetimes[..], &data.types[..], data.infer_types, &data.bindings[..])
4628 Some(&hir::ParenthesizedParameters(_)) => {
4629 AstConv::prohibit_parenthesized_params(self, &segment.as_ref().unwrap().0,
4631 (&[][..], &[][..], true, &[][..])
4633 None => (&[][..], &[][..], true, &[][..])
4636 let infer_lifetimes = lifetimes.len() == 0;
4638 let count_lifetime_params = |n| {
4639 format!("{} lifetime parameter{}", n, if n == 1 { "" } else { "s" })
4641 let count_type_params = |n| {
4642 format!("{} type parameter{}", n, if n == 1 { "" } else { "s" })
4645 // Check provided type parameters.
4646 let type_defs = segment.map_or(&[][..], |(_, generics)| {
4647 if generics.parent.is_none() {
4648 &generics.types[generics.has_self as usize..]
4653 let required_len = type_defs.iter().take_while(|d| !d.has_default).count();
4654 if types.len() > type_defs.len() {
4655 let span = types[type_defs.len()].span;
4656 let expected_text = count_type_params(type_defs.len());
4657 let actual_text = count_type_params(types.len());
4658 struct_span_err!(self.tcx.sess, span, E0087,
4659 "too many type parameters provided: \
4660 expected at most {}, found {}",
4661 expected_text, actual_text)
4662 .span_label(span, format!("expected {}", expected_text))
4665 // To prevent derived errors to accumulate due to extra
4666 // type parameters, we force instantiate_value_path to
4667 // use inference variables instead of the provided types.
4669 } else if types.len() < required_len && !infer_types {
4670 let expected_text = count_type_params(required_len);
4671 let actual_text = count_type_params(types.len());
4672 struct_span_err!(self.tcx.sess, span, E0089,
4673 "too few type parameters provided: \
4674 expected {}, found {}",
4675 expected_text, actual_text)
4676 .span_label(span, format!("expected {}", expected_text))
4680 if !bindings.is_empty() {
4681 span_err!(self.tcx.sess, bindings[0].span, E0182,
4682 "unexpected binding of associated item in expression path \
4683 (only allowed in type paths)");
4686 // Check provided lifetime parameters.
4687 let lifetime_defs = segment.map_or(&[][..], |(_, generics)| &generics.regions);
4688 let required_len = lifetime_defs.len();
4690 // Prohibit explicit lifetime arguments if late bound lifetime parameters are present.
4691 let has_late_bound_lifetime_defs =
4692 segment.map_or(None, |(_, generics)| generics.has_late_bound_regions);
4693 if let (Some(span_late), false) = (has_late_bound_lifetime_defs, lifetimes.is_empty()) {
4694 // Report this as a lint only if no error was reported previously.
4695 let primary_msg = "cannot specify lifetime arguments explicitly \
4696 if late bound lifetime parameters are present";
4697 let note_msg = "the late bound lifetime parameter is introduced here";
4698 if !is_method_call && (lifetimes.len() > lifetime_defs.len() ||
4699 lifetimes.len() < required_len && !infer_lifetimes) {
4700 let mut err = self.tcx.sess.struct_span_err(lifetimes[0].span, primary_msg);
4701 err.span_note(span_late, note_msg);
4705 let mut multispan = MultiSpan::from_span(lifetimes[0].span);
4706 multispan.push_span_label(span_late, note_msg.to_string());
4707 self.tcx.sess.add_lint(lint::builtin::LATE_BOUND_LIFETIME_ARGUMENTS,
4708 lifetimes[0].id, multispan, primary_msg.to_string());
4713 if lifetimes.len() > lifetime_defs.len() {
4714 let span = lifetimes[lifetime_defs.len()].span;
4715 let expected_text = count_lifetime_params(lifetime_defs.len());
4716 let actual_text = count_lifetime_params(lifetimes.len());
4717 struct_span_err!(self.tcx.sess, span, E0088,
4718 "too many lifetime parameters provided: \
4719 expected at most {}, found {}",
4720 expected_text, actual_text)
4721 .span_label(span, format!("expected {}", expected_text))
4723 } else if lifetimes.len() < required_len && !infer_lifetimes {
4724 let expected_text = count_lifetime_params(lifetime_defs.len());
4725 let actual_text = count_lifetime_params(lifetimes.len());
4726 struct_span_err!(self.tcx.sess, span, E0090,
4727 "too few lifetime parameters provided: \
4728 expected {}, found {}",
4729 expected_text, actual_text)
4730 .span_label(span, format!("expected {}", expected_text))
4735 fn structurally_resolve_type_or_else<F>(&self, sp: Span, ty: Ty<'tcx>, f: F)
4737 where F: Fn() -> Ty<'tcx>
4739 let mut ty = self.resolve_type_vars_with_obligations(ty);
4742 let alternative = f();
4745 if alternative.is_ty_var() || alternative.references_error() {
4746 if !self.is_tainted_by_errors() {
4747 type_error_struct!(self.tcx.sess, sp, ty, E0619,
4748 "the type of this value must be known in this context")
4751 self.demand_suptype(sp, self.tcx.types.err, ty);
4752 ty = self.tcx.types.err;
4754 self.demand_suptype(sp, alternative, ty);
4762 // Resolves `typ` by a single level if `typ` is a type variable. If no
4763 // resolution is possible, then an error is reported.
4764 pub fn structurally_resolved_type(&self, sp: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
4765 self.structurally_resolve_type_or_else(sp, ty, || {
4770 fn with_breakable_ctxt<F: FnOnce() -> R, R>(&self, id: ast::NodeId,
4771 ctxt: BreakableCtxt<'gcx, 'tcx>, f: F)
4772 -> (BreakableCtxt<'gcx, 'tcx>, R) {
4775 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4776 index = enclosing_breakables.stack.len();
4777 enclosing_breakables.by_id.insert(id, index);
4778 enclosing_breakables.stack.push(ctxt);
4782 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4783 debug_assert!(enclosing_breakables.stack.len() == index + 1);
4784 enclosing_breakables.by_id.remove(&id).expect("missing breakable context");
4785 enclosing_breakables.stack.pop().expect("missing breakable context")
4791 pub fn check_bounds_are_used<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
4792 generics: &hir::Generics,
4794 debug!("check_bounds_are_used(n_tps={}, ty={:?})",
4795 generics.ty_params.len(), ty);
4797 // make a vector of booleans initially false, set to true when used
4798 if generics.ty_params.is_empty() { return; }
4799 let mut tps_used = vec![false; generics.ty_params.len()];
4801 for leaf_ty in ty.walk() {
4802 if let ty::TyParam(ParamTy {idx, ..}) = leaf_ty.sty {
4803 debug!("Found use of ty param num {}", idx);
4804 tps_used[idx as usize - generics.lifetimes.len()] = true;
4808 for (&used, param) in tps_used.iter().zip(&generics.ty_params) {
4810 struct_span_err!(tcx.sess, param.span, E0091,
4811 "type parameter `{}` is unused",
4813 .span_label(param.span, "unused type parameter")