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};
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 check_packed(tcx, span, def_id);
1069 fn check_union<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1072 let def_id = tcx.hir.local_def_id(id);
1073 let def = tcx.adt_def(def_id);
1074 def.destructor(tcx); // force the destructor to be evaluated
1075 check_representable(tcx, span, def_id);
1078 pub fn check_item_type<'a,'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, it: &'tcx hir::Item) {
1079 debug!("check_item_type(it.id={}, it.name={})",
1081 tcx.item_path_str(tcx.hir.local_def_id(it.id)));
1082 let _indenter = indenter();
1084 // Consts can play a role in type-checking, so they are included here.
1085 hir::ItemStatic(..) |
1086 hir::ItemConst(..) => {
1087 tcx.typeck_tables_of(tcx.hir.local_def_id(it.id));
1089 hir::ItemEnum(ref enum_definition, _) => {
1092 &enum_definition.variants,
1095 hir::ItemFn(..) => {} // entirely within check_item_body
1096 hir::ItemImpl(.., ref impl_item_refs) => {
1097 debug!("ItemImpl {} with id {}", it.name, it.id);
1098 let impl_def_id = tcx.hir.local_def_id(it.id);
1099 if let Some(impl_trait_ref) = tcx.impl_trait_ref(impl_def_id) {
1100 check_impl_items_against_trait(tcx,
1105 let trait_def_id = impl_trait_ref.def_id;
1106 check_on_unimplemented(tcx, trait_def_id, it);
1109 hir::ItemTrait(..) => {
1110 let def_id = tcx.hir.local_def_id(it.id);
1111 check_on_unimplemented(tcx, def_id, it);
1113 hir::ItemStruct(..) => {
1114 check_struct(tcx, it.id, it.span);
1116 hir::ItemUnion(..) => {
1117 check_union(tcx, it.id, it.span);
1119 hir::ItemTy(_, ref generics) => {
1120 let def_id = tcx.hir.local_def_id(it.id);
1121 let pty_ty = tcx.type_of(def_id);
1122 check_bounds_are_used(tcx, generics, pty_ty);
1124 hir::ItemForeignMod(ref m) => {
1125 check_abi(tcx, it.span, m.abi);
1127 if m.abi == Abi::RustIntrinsic {
1128 for item in &m.items {
1129 intrinsic::check_intrinsic_type(tcx, item);
1131 } else if m.abi == Abi::PlatformIntrinsic {
1132 for item in &m.items {
1133 intrinsic::check_platform_intrinsic_type(tcx, item);
1136 for item in &m.items {
1137 let generics = tcx.generics_of(tcx.hir.local_def_id(item.id));
1138 if !generics.types.is_empty() {
1139 let mut err = struct_span_err!(tcx.sess, item.span, E0044,
1140 "foreign items may not have type parameters");
1141 span_help!(&mut err, item.span,
1142 "consider using specialization instead of \
1147 if let hir::ForeignItemFn(ref fn_decl, _, _) = item.node {
1148 require_c_abi_if_variadic(tcx, fn_decl, m.abi, item.span);
1153 _ => {/* nothing to do */ }
1157 fn check_on_unimplemented<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1160 let generics = tcx.generics_of(def_id);
1161 if let Some(ref attr) = item.attrs.iter().find(|a| {
1162 a.check_name("rustc_on_unimplemented")
1164 if let Some(istring) = attr.value_str() {
1165 let istring = istring.as_str();
1166 let name = tcx.item_name(def_id).as_str();
1167 let parser = Parser::new(&istring);
1168 let types = &generics.types;
1169 for token in parser {
1171 Piece::String(_) => (), // Normal string, no need to check it
1172 Piece::NextArgument(a) => match a.position {
1173 // `{Self}` is allowed
1174 Position::ArgumentNamed(s) if s == "Self" => (),
1175 // `{ThisTraitsName}` is allowed
1176 Position::ArgumentNamed(s) if s == name => (),
1177 // So is `{A}` if A is a type parameter
1178 Position::ArgumentNamed(s) => match types.iter().find(|t| {
1183 span_err!(tcx.sess, attr.span, E0230,
1184 "there is no type parameter \
1189 // `{:1}` and `{}` are not to be used
1190 Position::ArgumentIs(_) => {
1191 span_err!(tcx.sess, attr.span, E0231,
1192 "only named substitution \
1193 parameters are allowed");
1200 tcx.sess, attr.span, E0232,
1201 "this attribute must have a value")
1202 .span_label(attr.span, "attribute requires a value")
1203 .note(&format!("eg `#[rustc_on_unimplemented = \"foo\"]`"))
1209 fn report_forbidden_specialization<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1210 impl_item: &hir::ImplItem,
1213 let mut err = struct_span_err!(
1214 tcx.sess, impl_item.span, E0520,
1215 "`{}` specializes an item from a parent `impl`, but \
1216 that item is not marked `default`",
1218 err.span_label(impl_item.span, format!("cannot specialize default item `{}`",
1221 match tcx.span_of_impl(parent_impl) {
1223 err.span_label(span, "parent `impl` is here");
1224 err.note(&format!("to specialize, `{}` in the parent `impl` must be marked `default`",
1228 err.note(&format!("parent implementation is in crate `{}`", cname));
1235 fn check_specialization_validity<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1236 trait_def: &ty::TraitDef,
1238 impl_item: &hir::ImplItem)
1240 let ancestors = trait_def.ancestors(tcx, impl_id);
1242 let kind = match impl_item.node {
1243 hir::ImplItemKind::Const(..) => ty::AssociatedKind::Const,
1244 hir::ImplItemKind::Method(..) => ty::AssociatedKind::Method,
1245 hir::ImplItemKind::Type(_) => ty::AssociatedKind::Type
1247 let parent = ancestors.defs(tcx, impl_item.name, kind).skip(1).next()
1248 .map(|node_item| node_item.map(|parent| parent.defaultness));
1250 if let Some(parent) = parent {
1251 if tcx.impl_item_is_final(&parent) {
1252 report_forbidden_specialization(tcx, impl_item, parent.node.def_id());
1258 fn check_impl_items_against_trait<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1261 impl_trait_ref: ty::TraitRef<'tcx>,
1262 impl_item_refs: &[hir::ImplItemRef]) {
1263 // If the trait reference itself is erroneous (so the compilation is going
1264 // to fail), skip checking the items here -- the `impl_item` table in `tcx`
1265 // isn't populated for such impls.
1266 if impl_trait_ref.references_error() { return; }
1268 // Locate trait definition and items
1269 let trait_def = tcx.trait_def(impl_trait_ref.def_id);
1270 let mut overridden_associated_type = None;
1272 let impl_items = || impl_item_refs.iter().map(|iiref| tcx.hir.impl_item(iiref.id));
1274 // Check existing impl methods to see if they are both present in trait
1275 // and compatible with trait signature
1276 for impl_item in impl_items() {
1277 let ty_impl_item = tcx.associated_item(tcx.hir.local_def_id(impl_item.id));
1278 let ty_trait_item = tcx.associated_items(impl_trait_ref.def_id)
1279 .find(|ac| ac.name == ty_impl_item.name);
1281 // Check that impl definition matches trait definition
1282 if let Some(ty_trait_item) = ty_trait_item {
1283 match impl_item.node {
1284 hir::ImplItemKind::Const(..) => {
1285 // Find associated const definition.
1286 if ty_trait_item.kind == ty::AssociatedKind::Const {
1287 compare_const_impl(tcx,
1293 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0323,
1294 "item `{}` is an associated const, \
1295 which doesn't match its trait `{}`",
1298 err.span_label(impl_item.span, "does not match trait");
1299 // We can only get the spans from local trait definition
1300 // Same for E0324 and E0325
1301 if let Some(trait_span) = tcx.hir.span_if_local(ty_trait_item.def_id) {
1302 err.span_label(trait_span, "item in trait");
1307 hir::ImplItemKind::Method(..) => {
1308 let trait_span = tcx.hir.span_if_local(ty_trait_item.def_id);
1309 if ty_trait_item.kind == ty::AssociatedKind::Method {
1310 let err_count = tcx.sess.err_count();
1311 compare_impl_method(tcx,
1317 true); // start with old-broken-mode
1318 if err_count == tcx.sess.err_count() {
1319 // old broken mode did not report an error. Try with the new mode.
1320 compare_impl_method(tcx,
1326 false); // use the new mode
1329 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0324,
1330 "item `{}` is an associated method, \
1331 which doesn't match its trait `{}`",
1334 err.span_label(impl_item.span, "does not match trait");
1335 if let Some(trait_span) = tcx.hir.span_if_local(ty_trait_item.def_id) {
1336 err.span_label(trait_span, "item in trait");
1341 hir::ImplItemKind::Type(_) => {
1342 if ty_trait_item.kind == ty::AssociatedKind::Type {
1343 if ty_trait_item.defaultness.has_value() {
1344 overridden_associated_type = Some(impl_item);
1347 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0325,
1348 "item `{}` is an associated type, \
1349 which doesn't match its trait `{}`",
1352 err.span_label(impl_item.span, "does not match trait");
1353 if let Some(trait_span) = tcx.hir.span_if_local(ty_trait_item.def_id) {
1354 err.span_label(trait_span, "item in trait");
1362 check_specialization_validity(tcx, trait_def, impl_id, impl_item);
1365 // Check for missing items from trait
1366 let mut missing_items = Vec::new();
1367 let mut invalidated_items = Vec::new();
1368 let associated_type_overridden = overridden_associated_type.is_some();
1369 for trait_item in tcx.associated_items(impl_trait_ref.def_id) {
1370 let is_implemented = trait_def.ancestors(tcx, impl_id)
1371 .defs(tcx, trait_item.name, trait_item.kind)
1373 .map(|node_item| !node_item.node.is_from_trait())
1376 if !is_implemented {
1377 if !trait_item.defaultness.has_value() {
1378 missing_items.push(trait_item);
1379 } else if associated_type_overridden {
1380 invalidated_items.push(trait_item.name);
1385 if !missing_items.is_empty() {
1386 let mut err = struct_span_err!(tcx.sess, impl_span, E0046,
1387 "not all trait items implemented, missing: `{}`",
1388 missing_items.iter()
1389 .map(|trait_item| trait_item.name.to_string())
1390 .collect::<Vec<_>>().join("`, `"));
1391 err.span_label(impl_span, format!("missing `{}` in implementation",
1392 missing_items.iter()
1393 .map(|trait_item| trait_item.name.to_string())
1394 .collect::<Vec<_>>().join("`, `")));
1395 for trait_item in missing_items {
1396 if let Some(span) = tcx.hir.span_if_local(trait_item.def_id) {
1397 err.span_label(span, format!("`{}` from trait", trait_item.name));
1399 err.note_trait_signature(trait_item.name.to_string(),
1400 trait_item.signature(&tcx));
1406 if !invalidated_items.is_empty() {
1407 let invalidator = overridden_associated_type.unwrap();
1408 span_err!(tcx.sess, invalidator.span, E0399,
1409 "the following trait items need to be reimplemented \
1410 as `{}` was overridden: `{}`",
1412 invalidated_items.iter()
1413 .map(|name| name.to_string())
1414 .collect::<Vec<_>>().join("`, `"))
1418 /// Checks whether a type can be represented in memory. In particular, it
1419 /// identifies types that contain themselves without indirection through a
1420 /// pointer, which would mean their size is unbounded.
1421 fn check_representable<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1425 let rty = tcx.type_of(item_def_id);
1427 // Check that it is possible to represent this type. This call identifies
1428 // (1) types that contain themselves and (2) types that contain a different
1429 // recursive type. It is only necessary to throw an error on those that
1430 // contain themselves. For case 2, there must be an inner type that will be
1431 // caught by case 1.
1432 match rty.is_representable(tcx, sp) {
1433 Representability::SelfRecursive(spans) => {
1434 let mut err = tcx.recursive_type_with_infinite_size_error(item_def_id);
1436 err.span_label(span, "recursive without indirection");
1441 Representability::Representable | Representability::ContainsRecursive => (),
1446 pub fn check_simd<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, sp: Span, def_id: DefId) {
1447 let t = tcx.type_of(def_id);
1449 ty::TyAdt(def, substs) if def.is_struct() => {
1450 let fields = &def.struct_variant().fields;
1451 if fields.is_empty() {
1452 span_err!(tcx.sess, sp, E0075, "SIMD vector cannot be empty");
1455 let e = fields[0].ty(tcx, substs);
1456 if !fields.iter().all(|f| f.ty(tcx, substs) == e) {
1457 struct_span_err!(tcx.sess, sp, E0076, "SIMD vector should be homogeneous")
1458 .span_label(sp, "SIMD elements must have the same type")
1463 ty::TyParam(_) => { /* struct<T>(T, T, T, T) is ok */ }
1464 _ if e.is_machine() => { /* struct(u8, u8, u8, u8) is ok */ }
1466 span_err!(tcx.sess, sp, E0077,
1467 "SIMD vector element type should be machine type");
1476 fn check_packed<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, sp: Span, def_id: DefId) {
1477 if tcx.adt_def(def_id).repr.packed() {
1478 if tcx.adt_def(def_id).repr.align > 0 {
1479 struct_span_err!(tcx.sess, sp, E0587,
1480 "struct has conflicting packed and align representation hints").emit();
1482 else if check_packed_inner(tcx, def_id, &mut Vec::new()) {
1483 struct_span_err!(tcx.sess, sp, E0588,
1484 "packed struct cannot transitively contain a `[repr(align)]` struct").emit();
1489 fn check_packed_inner<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1491 stack: &mut Vec<DefId>) -> bool {
1492 let t = tcx.type_of(def_id);
1493 if stack.contains(&def_id) {
1494 debug!("check_packed_inner: {:?} is recursive", t);
1498 ty::TyAdt(def, substs) if def.is_struct() => {
1499 if tcx.adt_def(def.did).repr.align > 0 {
1502 // push struct def_id before checking fields
1504 for field in &def.struct_variant().fields {
1505 let f = field.ty(tcx, substs);
1507 ty::TyAdt(def, _) => {
1508 if check_packed_inner(tcx, def.did, stack) {
1515 // only need to pop if not early out
1523 #[allow(trivial_numeric_casts)]
1524 pub fn check_enum<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1526 vs: &'tcx [hir::Variant],
1528 let def_id = tcx.hir.local_def_id(id);
1529 let def = tcx.adt_def(def_id);
1530 def.destructor(tcx); // force the destructor to be evaluated
1532 if vs.is_empty() && tcx.has_attr(def_id, "repr") {
1534 tcx.sess, sp, E0084,
1535 "unsupported representation for zero-variant enum")
1536 .span_label(sp, "unsupported enum representation")
1540 let repr_type_ty = def.repr.discr_type().to_ty(tcx);
1541 if repr_type_ty == tcx.types.i128 || repr_type_ty == tcx.types.u128 {
1542 if !tcx.sess.features.borrow().i128_type {
1543 emit_feature_err(&tcx.sess.parse_sess,
1544 "i128_type", sp, GateIssue::Language, "128-bit type is unstable");
1549 if let Some(e) = v.node.disr_expr {
1550 tcx.typeck_tables_of(tcx.hir.local_def_id(e.node_id));
1554 let mut disr_vals: Vec<ConstInt> = Vec::new();
1555 for (discr, v) in def.discriminants(tcx).zip(vs) {
1556 // Check for duplicate discriminant values
1557 if let Some(i) = disr_vals.iter().position(|&x| x == discr) {
1558 let variant_i_node_id = tcx.hir.as_local_node_id(def.variants[i].did).unwrap();
1559 let variant_i = tcx.hir.expect_variant(variant_i_node_id);
1560 let i_span = match variant_i.node.disr_expr {
1561 Some(expr) => tcx.hir.span(expr.node_id),
1562 None => tcx.hir.span(variant_i_node_id)
1564 let span = match v.node.disr_expr {
1565 Some(expr) => tcx.hir.span(expr.node_id),
1568 struct_span_err!(tcx.sess, span, E0081,
1569 "discriminant value `{}` already exists", disr_vals[i])
1570 .span_label(i_span, format!("first use of `{}`", disr_vals[i]))
1571 .span_label(span , format!("enum already has `{}`", disr_vals[i]))
1574 disr_vals.push(discr);
1577 check_representable(tcx, sp, def_id);
1580 impl<'a, 'gcx, 'tcx> AstConv<'gcx, 'tcx> for FnCtxt<'a, 'gcx, 'tcx> {
1581 fn tcx<'b>(&'b self) -> TyCtxt<'b, 'gcx, 'tcx> { self.tcx }
1583 fn get_type_parameter_bounds(&self, _: Span, def_id: DefId)
1584 -> ty::GenericPredicates<'tcx>
1587 let node_id = tcx.hir.as_local_node_id(def_id).unwrap();
1588 let item_id = tcx.hir.ty_param_owner(node_id);
1589 let item_def_id = tcx.hir.local_def_id(item_id);
1590 let generics = tcx.generics_of(item_def_id);
1591 let index = generics.type_param_to_index[&def_id.index];
1592 ty::GenericPredicates {
1594 predicates: self.param_env.caller_bounds.iter().filter(|predicate| {
1596 ty::Predicate::Trait(ref data) => {
1597 data.0.self_ty().is_param(index)
1601 }).cloned().collect()
1605 fn re_infer(&self, span: Span, def: Option<&ty::RegionParameterDef>)
1606 -> Option<ty::Region<'tcx>> {
1608 Some(def) => infer::EarlyBoundRegion(span, def.name, def.issue_32330),
1609 None => infer::MiscVariable(span)
1611 Some(self.next_region_var(v))
1614 fn ty_infer(&self, span: Span) -> Ty<'tcx> {
1615 self.next_ty_var(TypeVariableOrigin::TypeInference(span))
1618 fn ty_infer_for_def(&self,
1619 ty_param_def: &ty::TypeParameterDef,
1620 substs: &[Kind<'tcx>],
1621 span: Span) -> Ty<'tcx> {
1622 self.type_var_for_def(span, ty_param_def, substs)
1625 fn projected_ty_from_poly_trait_ref(&self,
1628 poly_trait_ref: ty::PolyTraitRef<'tcx>)
1631 let item = self.tcx().associated_item(item_def_id);
1632 let (trait_ref, _) =
1633 self.replace_late_bound_regions_with_fresh_var(
1635 infer::LateBoundRegionConversionTime::AssocTypeProjection(item.name),
1638 self.tcx().mk_projection(item_def_id, trait_ref.substs)
1641 fn normalize_ty(&self, span: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
1642 if ty.has_escaping_regions() {
1643 ty // FIXME: normalization and escaping regions
1645 self.normalize_associated_types_in(span, &ty)
1649 fn set_tainted_by_errors(&self) {
1650 self.infcx.set_tainted_by_errors()
1654 /// Controls whether the arguments are tupled. This is used for the call
1657 /// Tupling means that all call-side arguments are packed into a tuple and
1658 /// passed as a single parameter. For example, if tupling is enabled, this
1661 /// fn f(x: (isize, isize))
1663 /// Can be called as:
1670 #[derive(Clone, Eq, PartialEq)]
1671 enum TupleArgumentsFlag {
1676 impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
1677 pub fn new(inh: &'a Inherited<'a, 'gcx, 'tcx>,
1678 param_env: ty::ParamEnv<'tcx>,
1679 body_id: ast::NodeId)
1680 -> FnCtxt<'a, 'gcx, 'tcx> {
1684 err_count_on_creation: inh.tcx.sess.err_count(),
1686 ps: RefCell::new(UnsafetyState::function(hir::Unsafety::Normal,
1687 ast::CRATE_NODE_ID)),
1688 diverges: Cell::new(Diverges::Maybe),
1689 has_errors: Cell::new(false),
1690 enclosing_breakables: RefCell::new(EnclosingBreakables {
1698 pub fn sess(&self) -> &Session {
1702 pub fn err_count_since_creation(&self) -> usize {
1703 self.tcx.sess.err_count() - self.err_count_on_creation
1706 /// Produce warning on the given node, if the current point in the
1707 /// function is unreachable, and there hasn't been another warning.
1708 fn warn_if_unreachable(&self, id: ast::NodeId, span: Span, kind: &str) {
1709 if self.diverges.get() == Diverges::Always {
1710 self.diverges.set(Diverges::WarnedAlways);
1712 debug!("warn_if_unreachable: id={:?} span={:?} kind={}", id, span, kind);
1714 self.tables.borrow_mut().lints.add_lint(
1715 lint::builtin::UNREACHABLE_CODE,
1717 format!("unreachable {}", kind));
1723 code: ObligationCauseCode<'tcx>)
1724 -> ObligationCause<'tcx> {
1725 ObligationCause::new(span, self.body_id, code)
1728 pub fn misc(&self, span: Span) -> ObligationCause<'tcx> {
1729 self.cause(span, ObligationCauseCode::MiscObligation)
1732 /// Resolves type variables in `ty` if possible. Unlike the infcx
1733 /// version (resolve_type_vars_if_possible), this version will
1734 /// also select obligations if it seems useful, in an effort
1735 /// to get more type information.
1736 fn resolve_type_vars_with_obligations(&self, mut ty: Ty<'tcx>) -> Ty<'tcx> {
1737 debug!("resolve_type_vars_with_obligations(ty={:?})", ty);
1739 // No TyInfer()? Nothing needs doing.
1740 if !ty.has_infer_types() {
1741 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
1745 // If `ty` is a type variable, see whether we already know what it is.
1746 ty = self.resolve_type_vars_if_possible(&ty);
1747 if !ty.has_infer_types() {
1748 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
1752 // If not, try resolving pending obligations as much as
1753 // possible. This can help substantially when there are
1754 // indirect dependencies that don't seem worth tracking
1756 self.select_obligations_where_possible();
1757 ty = self.resolve_type_vars_if_possible(&ty);
1759 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
1763 fn record_deferred_call_resolution(&self,
1764 closure_def_id: DefId,
1765 r: DeferredCallResolution<'gcx, 'tcx>) {
1766 let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
1767 deferred_call_resolutions.entry(closure_def_id).or_insert(vec![]).push(r);
1770 fn remove_deferred_call_resolutions(&self,
1771 closure_def_id: DefId)
1772 -> Vec<DeferredCallResolution<'gcx, 'tcx>>
1774 let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
1775 deferred_call_resolutions.remove(&closure_def_id).unwrap_or(vec![])
1778 pub fn tag(&self) -> String {
1779 let self_ptr: *const FnCtxt = self;
1780 format!("{:?}", self_ptr)
1783 pub fn local_ty(&self, span: Span, nid: ast::NodeId) -> Ty<'tcx> {
1784 match self.locals.borrow().get(&nid) {
1787 span_bug!(span, "no type for local variable {}",
1788 self.tcx.hir.node_to_string(nid));
1794 pub fn write_ty(&self, node_id: ast::NodeId, ty: Ty<'tcx>) {
1795 debug!("write_ty({}, {:?}) in fcx {}",
1796 node_id, self.resolve_type_vars_if_possible(&ty), self.tag());
1797 self.tables.borrow_mut().node_types.insert(node_id, ty);
1799 if ty.references_error() {
1800 self.has_errors.set(true);
1801 self.set_tainted_by_errors();
1805 pub fn write_method_call(&self, node_id: ast::NodeId, method: MethodCallee<'tcx>) {
1806 self.tables.borrow_mut().type_dependent_defs.insert(node_id, Def::Method(method.def_id));
1807 self.write_substs(node_id, method.substs);
1810 pub fn write_substs(&self, node_id: ast::NodeId, substs: &'tcx Substs<'tcx>) {
1811 if !substs.is_noop() {
1812 debug!("write_substs({}, {:?}) in fcx {}",
1817 self.tables.borrow_mut().node_substs.insert(node_id, substs);
1821 pub fn apply_adjustments(&self, expr: &hir::Expr, adj: Vec<Adjustment<'tcx>>) {
1822 debug!("apply_adjustments(expr={:?}, adj={:?})", expr, adj);
1828 match self.tables.borrow_mut().adjustments.entry(expr.id) {
1829 Entry::Vacant(entry) => { entry.insert(adj); },
1830 Entry::Occupied(mut entry) => {
1831 debug!(" - composing on top of {:?}", entry.get());
1832 match (&entry.get()[..], &adj[..]) {
1833 // Applying any adjustment on top of a NeverToAny
1834 // is a valid NeverToAny adjustment, because it can't
1836 (&[Adjustment { kind: Adjust::NeverToAny, .. }], _) => return,
1838 Adjustment { kind: Adjust::Deref(_), .. },
1839 Adjustment { kind: Adjust::Borrow(AutoBorrow::Ref(..)), .. },
1841 Adjustment { kind: Adjust::Deref(_), .. },
1842 .. // Any following adjustments are allowed.
1844 // A reborrow has no effect before a dereference.
1846 // FIXME: currently we never try to compose autoderefs
1847 // and ReifyFnPointer/UnsafeFnPointer, but we could.
1849 bug!("while adjusting {:?}, can't compose {:?} and {:?}",
1850 expr, entry.get(), adj)
1852 *entry.get_mut() = adj;
1857 /// Basically whenever we are converting from a type scheme into
1858 /// the fn body space, we always want to normalize associated
1859 /// types as well. This function combines the two.
1860 fn instantiate_type_scheme<T>(&self,
1862 substs: &Substs<'tcx>,
1865 where T : TypeFoldable<'tcx>
1867 let value = value.subst(self.tcx, substs);
1868 let result = self.normalize_associated_types_in(span, &value);
1869 debug!("instantiate_type_scheme(value={:?}, substs={:?}) = {:?}",
1876 /// As `instantiate_type_scheme`, but for the bounds found in a
1877 /// generic type scheme.
1878 fn instantiate_bounds(&self, span: Span, def_id: DefId, substs: &Substs<'tcx>)
1879 -> ty::InstantiatedPredicates<'tcx> {
1880 let bounds = self.tcx.predicates_of(def_id);
1881 let result = bounds.instantiate(self.tcx, substs);
1882 let result = self.normalize_associated_types_in(span, &result);
1883 debug!("instantiate_bounds(bounds={:?}, substs={:?}) = {:?}",
1890 /// Replace all anonymized types with fresh inference variables
1891 /// and record them for writeback.
1892 fn instantiate_anon_types<T: TypeFoldable<'tcx>>(&self, value: &T) -> T {
1893 value.fold_with(&mut BottomUpFolder { tcx: self.tcx, fldop: |ty| {
1894 if let ty::TyAnon(def_id, substs) = ty.sty {
1895 // Use the same type variable if the exact same TyAnon appears more
1896 // than once in the return type (e.g. if it's pased to a type alias).
1897 let id = self.tcx.hir.as_local_node_id(def_id).unwrap();
1898 if let Some(ty_var) = self.anon_types.borrow().get(&id) {
1901 let span = self.tcx.def_span(def_id);
1902 let ty_var = self.next_ty_var(TypeVariableOrigin::TypeInference(span));
1903 self.anon_types.borrow_mut().insert(id, ty_var);
1905 let predicates_of = self.tcx.predicates_of(def_id);
1906 let bounds = predicates_of.instantiate(self.tcx, substs);
1908 for predicate in bounds.predicates {
1909 // Change the predicate to refer to the type variable,
1910 // which will be the concrete type, instead of the TyAnon.
1911 // This also instantiates nested `impl Trait`.
1912 let predicate = self.instantiate_anon_types(&predicate);
1914 // Require that the predicate holds for the concrete type.
1915 let cause = traits::ObligationCause::new(span, self.body_id,
1916 traits::SizedReturnType);
1917 self.register_predicate(traits::Obligation::new(cause,
1929 fn normalize_associated_types_in<T>(&self, span: Span, value: &T) -> T
1930 where T : TypeFoldable<'tcx>
1932 self.inh.normalize_associated_types_in(span, self.body_id, self.param_env, value)
1935 fn normalize_associated_types_in_as_infer_ok<T>(&self, span: Span, value: &T)
1937 where T : TypeFoldable<'tcx>
1939 self.inh.normalize_associated_types_in_as_infer_ok(span,
1945 pub fn require_type_meets(&self,
1948 code: traits::ObligationCauseCode<'tcx>,
1951 self.register_bound(
1954 traits::ObligationCause::new(span, self.body_id, code));
1957 pub fn require_type_is_sized(&self,
1960 code: traits::ObligationCauseCode<'tcx>)
1962 let lang_item = self.tcx.require_lang_item(lang_items::SizedTraitLangItem);
1963 self.require_type_meets(ty, span, code, lang_item);
1966 pub fn register_bound(&self,
1969 cause: traits::ObligationCause<'tcx>)
1971 self.fulfillment_cx.borrow_mut()
1972 .register_bound(self, self.param_env, ty, def_id, cause);
1975 pub fn to_ty(&self, ast_t: &hir::Ty) -> Ty<'tcx> {
1976 let t = AstConv::ast_ty_to_ty(self, ast_t);
1977 self.register_wf_obligation(t, ast_t.span, traits::MiscObligation);
1981 pub fn node_ty(&self, id: ast::NodeId) -> Ty<'tcx> {
1982 match self.tables.borrow().node_types.get(&id) {
1984 None if self.err_count_since_creation() != 0 => self.tcx.types.err,
1986 bug!("no type for node {}: {} in fcx {}",
1987 id, self.tcx.hir.node_to_string(id),
1993 /// Registers an obligation for checking later, during regionck, that the type `ty` must
1994 /// outlive the region `r`.
1995 pub fn register_wf_obligation(&self,
1998 code: traits::ObligationCauseCode<'tcx>)
2000 // WF obligations never themselves fail, so no real need to give a detailed cause:
2001 let cause = traits::ObligationCause::new(span, self.body_id, code);
2002 self.register_predicate(traits::Obligation::new(cause,
2004 ty::Predicate::WellFormed(ty)));
2007 /// Registers obligations that all types appearing in `substs` are well-formed.
2008 pub fn add_wf_bounds(&self, substs: &Substs<'tcx>, expr: &hir::Expr)
2010 for ty in substs.types() {
2011 self.register_wf_obligation(ty, expr.span, traits::MiscObligation);
2015 /// Given a fully substituted set of bounds (`generic_bounds`), and the values with which each
2016 /// type/region parameter was instantiated (`substs`), creates and registers suitable
2017 /// trait/region obligations.
2019 /// For example, if there is a function:
2022 /// fn foo<'a,T:'a>(...)
2025 /// and a reference:
2031 /// Then we will create a fresh region variable `'$0` and a fresh type variable `$1` for `'a`
2032 /// and `T`. This routine will add a region obligation `$1:'$0` and register it locally.
2033 pub fn add_obligations_for_parameters(&self,
2034 cause: traits::ObligationCause<'tcx>,
2035 predicates: &ty::InstantiatedPredicates<'tcx>)
2037 assert!(!predicates.has_escaping_regions());
2039 debug!("add_obligations_for_parameters(predicates={:?})",
2042 for obligation in traits::predicates_for_generics(cause, self.param_env, predicates) {
2043 self.register_predicate(obligation);
2047 // FIXME(arielb1): use this instead of field.ty everywhere
2048 // Only for fields! Returns <none> for methods>
2049 // Indifferent to privacy flags
2050 pub fn field_ty(&self,
2052 field: &'tcx ty::FieldDef,
2053 substs: &Substs<'tcx>)
2056 self.normalize_associated_types_in(span,
2057 &field.ty(self.tcx, substs))
2060 fn check_casts(&self) {
2061 let mut deferred_cast_checks = self.deferred_cast_checks.borrow_mut();
2062 for cast in deferred_cast_checks.drain(..) {
2067 /// Apply "fallbacks" to some types
2068 /// unconstrained types get replaced with ! or () (depending on whether
2069 /// feature(never_type) is enabled), unconstrained ints with i32, and
2070 /// unconstrained floats with f64.
2071 fn default_type_parameters(&self) {
2072 use rustc::ty::error::UnconstrainedNumeric::Neither;
2073 use rustc::ty::error::UnconstrainedNumeric::{UnconstrainedInt, UnconstrainedFloat};
2075 // Defaulting inference variables becomes very dubious if we have
2076 // encountered type-checking errors. Therefore, if we think we saw
2077 // some errors in this function, just resolve all uninstanted type
2078 // varibles to TyError.
2079 if self.is_tainted_by_errors() {
2080 for ty in &self.unsolved_variables() {
2081 if let ty::TyInfer(_) = self.shallow_resolve(ty).sty {
2082 debug!("default_type_parameters: defaulting `{:?}` to error", ty);
2083 self.demand_eqtype(syntax_pos::DUMMY_SP, *ty, self.tcx().types.err);
2089 for ty in &self.unsolved_variables() {
2090 let resolved = self.resolve_type_vars_if_possible(ty);
2091 if self.type_var_diverges(resolved) {
2092 debug!("default_type_parameters: defaulting `{:?}` to `!` because it diverges",
2094 self.demand_eqtype(syntax_pos::DUMMY_SP, *ty,
2095 self.tcx.mk_diverging_default());
2097 match self.type_is_unconstrained_numeric(resolved) {
2098 UnconstrainedInt => {
2099 debug!("default_type_parameters: defaulting `{:?}` to `i32`",
2101 self.demand_eqtype(syntax_pos::DUMMY_SP, *ty, self.tcx.types.i32)
2103 UnconstrainedFloat => {
2104 debug!("default_type_parameters: defaulting `{:?}` to `f32`",
2106 self.demand_eqtype(syntax_pos::DUMMY_SP, *ty, self.tcx.types.f64)
2114 // Implements type inference fallback algorithm
2115 fn select_all_obligations_and_apply_defaults(&self) {
2116 self.select_obligations_where_possible();
2117 self.default_type_parameters();
2118 self.select_obligations_where_possible();
2121 fn select_all_obligations_or_error(&self) {
2122 debug!("select_all_obligations_or_error");
2124 // upvar inference should have ensured that all deferred call
2125 // resolutions are handled by now.
2126 assert!(self.deferred_call_resolutions.borrow().is_empty());
2128 self.select_all_obligations_and_apply_defaults();
2130 let mut fulfillment_cx = self.fulfillment_cx.borrow_mut();
2132 match fulfillment_cx.select_all_or_error(self) {
2134 Err(errors) => { self.report_fulfillment_errors(&errors, self.inh.body_id); }
2138 /// Select as many obligations as we can at present.
2139 fn select_obligations_where_possible(&self) {
2140 match self.fulfillment_cx.borrow_mut().select_where_possible(self) {
2142 Err(errors) => { self.report_fulfillment_errors(&errors, self.inh.body_id); }
2146 /// For the overloaded lvalue expressions (`*x`, `x[3]`), the trait
2147 /// returns a type of `&T`, but the actual type we assign to the
2148 /// *expression* is `T`. So this function just peels off the return
2149 /// type by one layer to yield `T`.
2150 fn make_overloaded_lvalue_return_type(&self,
2151 method: MethodCallee<'tcx>)
2152 -> ty::TypeAndMut<'tcx>
2154 // extract method return type, which will be &T;
2155 let ret_ty = method.sig.output();
2157 // method returns &T, but the type as visible to user is T, so deref
2158 ret_ty.builtin_deref(true, NoPreference).unwrap()
2161 fn lookup_indexing(&self,
2163 base_expr: &'gcx hir::Expr,
2166 lvalue_pref: LvaluePreference)
2167 -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)>
2169 // FIXME(#18741) -- this is almost but not quite the same as the
2170 // autoderef that normal method probing does. They could likely be
2173 let mut autoderef = self.autoderef(base_expr.span, base_ty);
2174 let mut result = None;
2175 while result.is_none() && autoderef.next().is_some() {
2176 result = self.try_index_step(expr, base_expr, &autoderef, lvalue_pref, idx_ty);
2178 autoderef.finalize();
2182 /// To type-check `base_expr[index_expr]`, we progressively autoderef
2183 /// (and otherwise adjust) `base_expr`, looking for a type which either
2184 /// supports builtin indexing or overloaded indexing.
2185 /// This loop implements one step in that search; the autoderef loop
2186 /// is implemented by `lookup_indexing`.
2187 fn try_index_step(&self,
2189 base_expr: &hir::Expr,
2190 autoderef: &Autoderef<'a, 'gcx, 'tcx>,
2191 lvalue_pref: LvaluePreference,
2193 -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)>
2195 let adjusted_ty = autoderef.unambiguous_final_ty();
2196 debug!("try_index_step(expr={:?}, base_expr={:?}, adjusted_ty={:?}, \
2204 // First, try built-in indexing.
2205 match (adjusted_ty.builtin_index(), &index_ty.sty) {
2206 (Some(ty), &ty::TyUint(ast::UintTy::Us)) | (Some(ty), &ty::TyInfer(ty::IntVar(_))) => {
2207 debug!("try_index_step: success, using built-in indexing");
2208 let adjustments = autoderef.adjust_steps(lvalue_pref);
2209 self.apply_adjustments(base_expr, adjustments);
2210 return Some((self.tcx.types.usize, ty));
2215 for &unsize in &[false, true] {
2216 let mut self_ty = adjusted_ty;
2218 // We only unsize arrays here.
2219 if let ty::TyArray(element_ty, _) = adjusted_ty.sty {
2220 self_ty = self.tcx.mk_slice(element_ty);
2226 // If some lookup succeeds, write callee into table and extract index/element
2227 // type from the method signature.
2228 // If some lookup succeeded, install method in table
2229 let input_ty = self.next_ty_var(TypeVariableOrigin::AutoDeref(base_expr.span));
2230 let method = self.try_overloaded_lvalue_op(
2231 expr.span, self_ty, &[input_ty], lvalue_pref, LvalueOp::Index);
2233 let result = method.map(|ok| {
2234 debug!("try_index_step: success, using overloaded indexing");
2235 let method = self.register_infer_ok_obligations(ok);
2237 let mut adjustments = autoderef.adjust_steps(lvalue_pref);
2238 if let ty::TyRef(region, mt) = method.sig.inputs()[0].sty {
2239 adjustments.push(Adjustment {
2240 kind: Adjust::Borrow(AutoBorrow::Ref(region, mt.mutbl)),
2241 target: self.tcx.mk_ref(region, ty::TypeAndMut {
2248 adjustments.push(Adjustment {
2249 kind: Adjust::Unsize,
2250 target: method.sig.inputs()[0]
2253 self.apply_adjustments(base_expr, adjustments);
2255 self.write_method_call(expr.id, method);
2256 (input_ty, self.make_overloaded_lvalue_return_type(method).ty)
2258 if result.is_some() {
2266 fn resolve_lvalue_op(&self, op: LvalueOp, is_mut: bool) -> (Option<DefId>, Symbol) {
2267 let (tr, name) = match (op, is_mut) {
2268 (LvalueOp::Deref, false) =>
2269 (self.tcx.lang_items.deref_trait(), "deref"),
2270 (LvalueOp::Deref, true) =>
2271 (self.tcx.lang_items.deref_mut_trait(), "deref_mut"),
2272 (LvalueOp::Index, false) =>
2273 (self.tcx.lang_items.index_trait(), "index"),
2274 (LvalueOp::Index, true) =>
2275 (self.tcx.lang_items.index_mut_trait(), "index_mut"),
2277 (tr, Symbol::intern(name))
2280 fn try_overloaded_lvalue_op(&self,
2283 arg_tys: &[Ty<'tcx>],
2284 lvalue_pref: LvaluePreference,
2286 -> Option<InferOk<'tcx, MethodCallee<'tcx>>>
2288 debug!("try_overloaded_lvalue_op({:?},{:?},{:?},{:?})",
2294 // Try Mut first, if preferred.
2295 let (mut_tr, mut_op) = self.resolve_lvalue_op(op, true);
2296 let method = match (lvalue_pref, mut_tr) {
2297 (PreferMutLvalue, Some(trait_did)) => {
2298 self.lookup_method_in_trait(span, mut_op, trait_did, base_ty, Some(arg_tys))
2303 // Otherwise, fall back to the immutable version.
2304 let (imm_tr, imm_op) = self.resolve_lvalue_op(op, false);
2305 let method = match (method, imm_tr) {
2306 (None, Some(trait_did)) => {
2307 self.lookup_method_in_trait(span, imm_op, trait_did, base_ty, Some(arg_tys))
2309 (method, _) => method,
2315 fn check_method_argument_types(&self,
2317 method: Result<MethodCallee<'tcx>, ()>,
2318 args_no_rcvr: &'gcx [hir::Expr],
2319 tuple_arguments: TupleArgumentsFlag,
2320 expected: Expectation<'tcx>)
2322 let has_error = match method {
2324 method.substs.references_error() || method.sig.references_error()
2329 let err_inputs = self.err_args(args_no_rcvr.len());
2331 let err_inputs = match tuple_arguments {
2332 DontTupleArguments => err_inputs,
2333 TupleArguments => vec![self.tcx.intern_tup(&err_inputs[..], false)],
2336 self.check_argument_types(sp, &err_inputs[..], &[], args_no_rcvr,
2337 false, tuple_arguments, None);
2338 return self.tcx.types.err;
2341 let method = method.unwrap();
2342 // HACK(eddyb) ignore self in the definition (see above).
2343 let expected_arg_tys = self.expected_inputs_for_expected_output(
2346 method.sig.output(),
2347 &method.sig.inputs()[1..]
2349 self.check_argument_types(sp, &method.sig.inputs()[1..], &expected_arg_tys[..],
2350 args_no_rcvr, method.sig.variadic, tuple_arguments,
2351 self.tcx.hir.span_if_local(method.def_id));
2355 /// Generic function that factors out common logic from function calls,
2356 /// method calls and overloaded operators.
2357 fn check_argument_types(&self,
2359 fn_inputs: &[Ty<'tcx>],
2360 expected_arg_tys: &[Ty<'tcx>],
2361 args: &'gcx [hir::Expr],
2363 tuple_arguments: TupleArgumentsFlag,
2364 def_span: Option<Span>) {
2367 // Grab the argument types, supplying fresh type variables
2368 // if the wrong number of arguments were supplied
2369 let supplied_arg_count = if tuple_arguments == DontTupleArguments {
2375 // All the input types from the fn signature must outlive the call
2376 // so as to validate implied bounds.
2377 for &fn_input_ty in fn_inputs {
2378 self.register_wf_obligation(fn_input_ty, sp, traits::MiscObligation);
2381 let mut expected_arg_tys = expected_arg_tys;
2382 let expected_arg_count = fn_inputs.len();
2384 let sp_args = if args.len() > 0 {
2385 let (first, args) = args.split_at(1);
2386 let mut sp_tmp = first[0].span;
2388 let sp_opt = self.sess().codemap().merge_spans(sp_tmp, arg.span);
2389 if ! sp_opt.is_some() {
2392 sp_tmp = sp_opt.unwrap();
2399 fn parameter_count_error<'tcx>(sess: &Session, sp: Span, expected_count: usize,
2400 arg_count: usize, error_code: &str, variadic: bool,
2401 def_span: Option<Span>) {
2402 let mut err = sess.struct_span_err_with_code(sp,
2403 &format!("this function takes {}{} parameter{} but {} parameter{} supplied",
2404 if variadic {"at least "} else {""},
2406 if expected_count == 1 {""} else {"s"},
2408 if arg_count == 1 {" was"} else {"s were"}),
2411 err.span_label(sp, format!("expected {}{} parameter{}",
2412 if variadic {"at least "} else {""},
2414 if expected_count == 1 {""} else {"s"}));
2415 if let Some(def_s) = def_span {
2416 err.span_label(def_s, "defined here");
2421 let formal_tys = if tuple_arguments == TupleArguments {
2422 let tuple_type = self.structurally_resolved_type(sp, fn_inputs[0]);
2423 match tuple_type.sty {
2424 ty::TyTuple(arg_types, _) if arg_types.len() != args.len() => {
2425 parameter_count_error(tcx.sess, sp_args, arg_types.len(), args.len(),
2426 "E0057", false, def_span);
2427 expected_arg_tys = &[];
2428 self.err_args(args.len())
2430 ty::TyTuple(arg_types, _) => {
2431 expected_arg_tys = match expected_arg_tys.get(0) {
2432 Some(&ty) => match ty.sty {
2433 ty::TyTuple(ref tys, _) => &tys,
2441 span_err!(tcx.sess, sp, E0059,
2442 "cannot use call notation; the first type parameter \
2443 for the function trait is neither a tuple nor unit");
2444 expected_arg_tys = &[];
2445 self.err_args(args.len())
2448 } else if expected_arg_count == supplied_arg_count {
2450 } else if variadic {
2451 if supplied_arg_count >= expected_arg_count {
2454 parameter_count_error(tcx.sess, sp_args, expected_arg_count,
2455 supplied_arg_count, "E0060", true, def_span);
2456 expected_arg_tys = &[];
2457 self.err_args(supplied_arg_count)
2460 parameter_count_error(tcx.sess, sp_args, expected_arg_count,
2461 supplied_arg_count, "E0061", false, def_span);
2462 expected_arg_tys = &[];
2463 self.err_args(supplied_arg_count)
2466 debug!("check_argument_types: formal_tys={:?}",
2467 formal_tys.iter().map(|t| self.ty_to_string(*t)).collect::<Vec<String>>());
2469 // Check the arguments.
2470 // We do this in a pretty awful way: first we typecheck any arguments
2471 // that are not closures, then we typecheck the closures. This is so
2472 // that we have more information about the types of arguments when we
2473 // typecheck the functions. This isn't really the right way to do this.
2474 for &check_closures in &[false, true] {
2475 debug!("check_closures={}", check_closures);
2477 // More awful hacks: before we check argument types, try to do
2478 // an "opportunistic" vtable resolution of any trait bounds on
2479 // the call. This helps coercions.
2481 self.select_obligations_where_possible();
2484 // For variadic functions, we don't have a declared type for all of
2485 // the arguments hence we only do our usual type checking with
2486 // the arguments who's types we do know.
2487 let t = if variadic {
2489 } else if tuple_arguments == TupleArguments {
2494 for (i, arg) in args.iter().take(t).enumerate() {
2495 // Warn only for the first loop (the "no closures" one).
2496 // Closure arguments themselves can't be diverging, but
2497 // a previous argument can, e.g. `foo(panic!(), || {})`.
2498 if !check_closures {
2499 self.warn_if_unreachable(arg.id, arg.span, "expression");
2502 let is_closure = match arg.node {
2503 hir::ExprClosure(..) => true,
2507 if is_closure != check_closures {
2511 debug!("checking the argument");
2512 let formal_ty = formal_tys[i];
2514 // The special-cased logic below has three functions:
2515 // 1. Provide as good of an expected type as possible.
2516 let expected = expected_arg_tys.get(i).map(|&ty| {
2517 Expectation::rvalue_hint(self, ty)
2520 let checked_ty = self.check_expr_with_expectation(
2522 expected.unwrap_or(ExpectHasType(formal_ty)));
2524 // 2. Coerce to the most detailed type that could be coerced
2525 // to, which is `expected_ty` if `rvalue_hint` returns an
2526 // `ExpectHasType(expected_ty)`, or the `formal_ty` otherwise.
2527 let coerce_ty = expected.and_then(|e| e.only_has_type(self));
2528 self.demand_coerce(&arg, checked_ty, coerce_ty.unwrap_or(formal_ty));
2530 // 3. Relate the expected type and the formal one,
2531 // if the expected type was used for the coercion.
2532 coerce_ty.map(|ty| self.demand_suptype(arg.span, formal_ty, ty));
2536 // We also need to make sure we at least write the ty of the other
2537 // arguments which we skipped above.
2539 fn variadic_error<'tcx>(s: &Session, span: Span, t: Ty<'tcx>, cast_ty: &str) {
2540 type_error_struct!(s, span, t, E0617,
2541 "can't pass `{}` to variadic function, cast to `{}`",
2545 for arg in args.iter().skip(expected_arg_count) {
2546 let arg_ty = self.check_expr(&arg);
2548 // There are a few types which get autopromoted when passed via varargs
2549 // in C but we just error out instead and require explicit casts.
2550 let arg_ty = self.structurally_resolved_type(arg.span, arg_ty);
2552 ty::TyFloat(ast::FloatTy::F32) => {
2553 variadic_error(tcx.sess, arg.span, arg_ty, "c_double");
2555 ty::TyInt(ast::IntTy::I8) | ty::TyInt(ast::IntTy::I16) | ty::TyBool => {
2556 variadic_error(tcx.sess, arg.span, arg_ty, "c_int");
2558 ty::TyUint(ast::UintTy::U8) | ty::TyUint(ast::UintTy::U16) => {
2559 variadic_error(tcx.sess, arg.span, arg_ty, "c_uint");
2561 ty::TyFnDef(..) => {
2562 let ptr_ty = self.tcx.mk_fn_ptr(arg_ty.fn_sig(self.tcx));
2563 let ptr_ty = self.resolve_type_vars_if_possible(&ptr_ty);
2564 variadic_error(tcx.sess, arg.span, arg_ty, &format!("{}", ptr_ty));
2572 fn err_args(&self, len: usize) -> Vec<Ty<'tcx>> {
2573 (0..len).map(|_| self.tcx.types.err).collect()
2576 // AST fragment checking
2579 expected: Expectation<'tcx>)
2585 ast::LitKind::Str(..) => tcx.mk_static_str(),
2586 ast::LitKind::ByteStr(ref v) => {
2587 tcx.mk_imm_ref(tcx.types.re_static,
2588 tcx.mk_array(tcx.types.u8, v.len()))
2590 ast::LitKind::Byte(_) => tcx.types.u8,
2591 ast::LitKind::Char(_) => tcx.types.char,
2592 ast::LitKind::Int(_, ast::LitIntType::Signed(t)) => tcx.mk_mach_int(t),
2593 ast::LitKind::Int(_, ast::LitIntType::Unsigned(t)) => tcx.mk_mach_uint(t),
2594 ast::LitKind::Int(_, ast::LitIntType::Unsuffixed) => {
2595 let opt_ty = expected.to_option(self).and_then(|ty| {
2597 ty::TyInt(_) | ty::TyUint(_) => Some(ty),
2598 ty::TyChar => Some(tcx.types.u8),
2599 ty::TyRawPtr(..) => Some(tcx.types.usize),
2600 ty::TyFnDef(..) | ty::TyFnPtr(_) => Some(tcx.types.usize),
2604 opt_ty.unwrap_or_else(
2605 || tcx.mk_int_var(self.next_int_var_id()))
2607 ast::LitKind::Float(_, t) => tcx.mk_mach_float(t),
2608 ast::LitKind::FloatUnsuffixed(_) => {
2609 let opt_ty = expected.to_option(self).and_then(|ty| {
2611 ty::TyFloat(_) => Some(ty),
2615 opt_ty.unwrap_or_else(
2616 || tcx.mk_float_var(self.next_float_var_id()))
2618 ast::LitKind::Bool(_) => tcx.types.bool
2622 fn check_expr_eq_type(&self,
2623 expr: &'gcx hir::Expr,
2624 expected: Ty<'tcx>) {
2625 let ty = self.check_expr_with_hint(expr, expected);
2626 self.demand_eqtype(expr.span, expected, ty);
2629 pub fn check_expr_has_type_or_error(&self,
2630 expr: &'gcx hir::Expr,
2631 expected: Ty<'tcx>) -> Ty<'tcx> {
2632 self.check_expr_meets_expectation_or_error(expr, ExpectHasType(expected))
2635 fn check_expr_meets_expectation_or_error(&self,
2636 expr: &'gcx hir::Expr,
2637 expected: Expectation<'tcx>) -> Ty<'tcx> {
2638 let expected_ty = expected.to_option(&self).unwrap_or(self.tcx.types.bool);
2639 let mut ty = self.check_expr_with_expectation(expr, expected);
2641 // While we don't allow *arbitrary* coercions here, we *do* allow
2642 // coercions from ! to `expected`.
2644 assert!(!self.tables.borrow().adjustments.contains_key(&expr.id),
2645 "expression with never type wound up being adjusted");
2646 let adj_ty = self.next_diverging_ty_var(
2647 TypeVariableOrigin::AdjustmentType(expr.span));
2648 self.apply_adjustments(expr, vec![Adjustment {
2649 kind: Adjust::NeverToAny,
2655 if let Some(mut err) = self.demand_suptype_diag(expr.span, expected_ty, ty) {
2656 // Add help to type error if this is an `if` condition with an assignment
2657 match (expected, &expr.node) {
2658 (ExpectIfCondition, &hir::ExprAssign(ref lhs, ref rhs)) => {
2659 let msg = "did you mean to compare equality?";
2660 if let (Ok(left), Ok(right)) = (
2661 self.tcx.sess.codemap().span_to_snippet(lhs.span),
2662 self.tcx.sess.codemap().span_to_snippet(rhs.span))
2664 err.span_suggestion(expr.span, msg, format!("{} == {}", left, right));
2676 fn check_expr_coercable_to_type(&self,
2677 expr: &'gcx hir::Expr,
2678 expected: Ty<'tcx>) -> Ty<'tcx> {
2679 let ty = self.check_expr_with_hint(expr, expected);
2680 self.demand_coerce(expr, ty, expected);
2684 fn check_expr_with_hint(&self, expr: &'gcx hir::Expr,
2685 expected: Ty<'tcx>) -> Ty<'tcx> {
2686 self.check_expr_with_expectation(expr, ExpectHasType(expected))
2689 fn check_expr_with_expectation(&self,
2690 expr: &'gcx hir::Expr,
2691 expected: Expectation<'tcx>) -> Ty<'tcx> {
2692 self.check_expr_with_expectation_and_lvalue_pref(expr, expected, NoPreference)
2695 fn check_expr(&self, expr: &'gcx hir::Expr) -> Ty<'tcx> {
2696 self.check_expr_with_expectation(expr, NoExpectation)
2699 fn check_expr_with_lvalue_pref(&self, expr: &'gcx hir::Expr,
2700 lvalue_pref: LvaluePreference) -> Ty<'tcx> {
2701 self.check_expr_with_expectation_and_lvalue_pref(expr, NoExpectation, lvalue_pref)
2704 // determine the `self` type, using fresh variables for all variables
2705 // declared on the impl declaration e.g., `impl<A,B> for Vec<(A,B)>`
2706 // would return ($0, $1) where $0 and $1 are freshly instantiated type
2708 pub fn impl_self_ty(&self,
2709 span: Span, // (potential) receiver for this impl
2711 -> TypeAndSubsts<'tcx> {
2712 let ity = self.tcx.type_of(did);
2713 debug!("impl_self_ty: ity={:?}", ity);
2715 let substs = self.fresh_substs_for_item(span, did);
2716 let substd_ty = self.instantiate_type_scheme(span, &substs, &ity);
2718 TypeAndSubsts { substs: substs, ty: substd_ty }
2721 /// Unifies the output type with the expected type early, for more coercions
2722 /// and forward type information on the input expressions.
2723 fn expected_inputs_for_expected_output(&self,
2725 expected_ret: Expectation<'tcx>,
2726 formal_ret: Ty<'tcx>,
2727 formal_args: &[Ty<'tcx>])
2729 let expected_args = expected_ret.only_has_type(self).and_then(|ret_ty| {
2730 self.fudge_regions_if_ok(&RegionVariableOrigin::Coercion(call_span), || {
2731 // Attempt to apply a subtyping relationship between the formal
2732 // return type (likely containing type variables if the function
2733 // is polymorphic) and the expected return type.
2734 // No argument expectations are produced if unification fails.
2735 let origin = self.misc(call_span);
2736 let ures = self.at(&origin, self.param_env).sup(ret_ty, formal_ret);
2738 // FIXME(#15760) can't use try! here, FromError doesn't default
2739 // to identity so the resulting type is not constrained.
2742 // Process any obligations locally as much as
2743 // we can. We don't care if some things turn
2744 // out unconstrained or ambiguous, as we're
2745 // just trying to get hints here.
2746 let result = self.save_and_restore_in_snapshot_flag(|_| {
2747 let mut fulfill = FulfillmentContext::new();
2748 let ok = ok; // FIXME(#30046)
2749 for obligation in ok.obligations {
2750 fulfill.register_predicate_obligation(self, obligation);
2752 fulfill.select_where_possible(self)
2757 Err(_) => return Err(()),
2760 Err(_) => return Err(()),
2763 // Record all the argument types, with the substitutions
2764 // produced from the above subtyping unification.
2765 Ok(formal_args.iter().map(|ty| {
2766 self.resolve_type_vars_if_possible(ty)
2769 }).unwrap_or(vec![]);
2770 debug!("expected_inputs_for_expected_output(formal={:?} -> {:?}, expected={:?} -> {:?})",
2771 formal_args, formal_ret,
2772 expected_args, expected_ret);
2776 // Checks a method call.
2777 fn check_method_call(&self,
2778 expr: &'gcx hir::Expr,
2779 segment: &hir::PathSegment,
2781 args: &'gcx [hir::Expr],
2782 expected: Expectation<'tcx>,
2783 lvalue_pref: LvaluePreference) -> Ty<'tcx> {
2784 let rcvr = &args[0];
2785 let rcvr_t = self.check_expr_with_lvalue_pref(&rcvr, lvalue_pref);
2786 // no need to check for bot/err -- callee does that
2787 let rcvr_t = self.structurally_resolved_type(expr.span, rcvr_t);
2789 let method = match self.lookup_method(rcvr_t,
2795 self.write_method_call(expr.id, method);
2799 if segment.name != keywords::Invalid.name() {
2800 self.report_method_error(span,
2811 // Call the generic checker.
2812 self.check_method_argument_types(span, method,
2818 fn check_return_expr(&self, return_expr: &'gcx hir::Expr) {
2822 .unwrap_or_else(|| span_bug!(return_expr.span,
2823 "check_return_expr called outside fn body"));
2825 let ret_ty = ret_coercion.borrow().expected_ty();
2826 let return_expr_ty = self.check_expr_with_hint(return_expr, ret_ty.clone());
2827 ret_coercion.borrow_mut()
2829 &self.cause(return_expr.span,
2830 ObligationCauseCode::ReturnType(return_expr.id)),
2833 self.diverges.get());
2837 // A generic function for checking the then and else in an if
2839 fn check_then_else(&self,
2840 cond_expr: &'gcx hir::Expr,
2841 then_expr: &'gcx hir::Expr,
2842 opt_else_expr: Option<&'gcx hir::Expr>,
2844 expected: Expectation<'tcx>) -> Ty<'tcx> {
2845 let cond_ty = self.check_expr_meets_expectation_or_error(cond_expr, ExpectIfCondition);
2846 let cond_diverges = self.diverges.get();
2847 self.diverges.set(Diverges::Maybe);
2849 let expected = expected.adjust_for_branches(self);
2850 let then_ty = self.check_expr_with_expectation(then_expr, expected);
2851 let then_diverges = self.diverges.get();
2852 self.diverges.set(Diverges::Maybe);
2854 // We've already taken the expected type's preferences
2855 // into account when typing the `then` branch. To figure
2856 // out the initial shot at a LUB, we thus only consider
2857 // `expected` if it represents a *hard* constraint
2858 // (`only_has_type`); otherwise, we just go with a
2859 // fresh type variable.
2860 let coerce_to_ty = expected.coercion_target_type(self, sp);
2861 let mut coerce: DynamicCoerceMany = CoerceMany::new(coerce_to_ty);
2863 let if_cause = self.cause(sp, ObligationCauseCode::IfExpression);
2864 coerce.coerce(self, &if_cause, then_expr, then_ty, then_diverges);
2866 if let Some(else_expr) = opt_else_expr {
2867 let else_ty = self.check_expr_with_expectation(else_expr, expected);
2868 let else_diverges = self.diverges.get();
2870 coerce.coerce(self, &if_cause, else_expr, else_ty, else_diverges);
2872 // We won't diverge unless both branches do (or the condition does).
2873 self.diverges.set(cond_diverges | then_diverges & else_diverges);
2875 let else_cause = self.cause(sp, ObligationCauseCode::IfExpressionWithNoElse);
2876 coerce.coerce_forced_unit(self, &else_cause, &mut |_| (), true);
2878 // If the condition is false we can't diverge.
2879 self.diverges.set(cond_diverges);
2882 let result_ty = coerce.complete(self);
2883 if cond_ty.references_error() {
2890 // Check field access expressions
2891 fn check_field(&self,
2892 expr: &'gcx hir::Expr,
2893 lvalue_pref: LvaluePreference,
2894 base: &'gcx hir::Expr,
2895 field: &Spanned<ast::Name>) -> Ty<'tcx> {
2896 let expr_t = self.check_expr_with_lvalue_pref(base, lvalue_pref);
2897 let expr_t = self.structurally_resolved_type(expr.span,
2899 let mut private_candidate = None;
2900 let mut autoderef = self.autoderef(expr.span, expr_t);
2901 while let Some((base_t, _)) = autoderef.next() {
2903 ty::TyAdt(base_def, substs) if !base_def.is_enum() => {
2904 debug!("struct named {:?}", base_t);
2905 let (ident, def_scope) =
2906 self.tcx.adjust(field.node, base_def.did, self.body_id);
2907 let fields = &base_def.struct_variant().fields;
2908 if let Some(field) = fields.iter().find(|f| f.name.to_ident() == ident) {
2909 let field_ty = self.field_ty(expr.span, field, substs);
2910 if field.vis.is_accessible_from(def_scope, self.tcx) {
2911 let adjustments = autoderef.adjust_steps(lvalue_pref);
2912 self.apply_adjustments(base, adjustments);
2913 autoderef.finalize();
2915 self.tcx.check_stability(field.did, expr.id, expr.span);
2919 private_candidate = Some((base_def.did, field_ty));
2925 autoderef.unambiguous_final_ty();
2927 if let Some((did, field_ty)) = private_candidate {
2928 let struct_path = self.tcx().item_path_str(did);
2929 let mut err = struct_span_err!(self.tcx().sess, expr.span, E0616,
2930 "field `{}` of struct `{}` is private",
2931 field.node, struct_path);
2932 // Also check if an accessible method exists, which is often what is meant.
2933 if self.method_exists(field.span, field.node, expr_t, expr.id, false) {
2934 err.note(&format!("a method `{}` also exists, perhaps you wish to call it",
2939 } else if field.node == keywords::Invalid.name() {
2940 self.tcx().types.err
2941 } else if self.method_exists(field.span, field.node, expr_t, expr.id, true) {
2942 type_error_struct!(self.tcx().sess, field.span, expr_t, E0615,
2943 "attempted to take value of method `{}` on type `{}`",
2945 .help("maybe a `()` to call it is missing? \
2946 If not, try an anonymous function")
2948 self.tcx().types.err
2950 if !expr_t.is_primitive_ty() {
2951 let mut err = self.no_such_field_err(field.span, &field.node, expr_t);
2954 ty::TyAdt(def, _) if !def.is_enum() => {
2955 if let Some(suggested_field_name) =
2956 Self::suggest_field_name(def.struct_variant(), field, vec![]) {
2957 err.span_label(field.span,
2958 format!("did you mean `{}`?", suggested_field_name));
2960 err.span_label(field.span, "unknown field");
2963 ty::TyRawPtr(..) => {
2964 err.note(&format!("`{0}` is a native pointer; perhaps you need to deref \
2966 self.tcx.hir.node_to_pretty_string(base.id),
2973 type_error_struct!(self.tcx().sess, field.span, expr_t, E0610,
2974 "`{}` is a primitive type and therefore doesn't have fields",
2977 self.tcx().types.err
2981 // Return an hint about the closest match in field names
2982 fn suggest_field_name(variant: &'tcx ty::VariantDef,
2983 field: &Spanned<ast::Name>,
2984 skip : Vec<InternedString>)
2986 let name = field.node.as_str();
2987 let names = variant.fields.iter().filter_map(|field| {
2988 // ignore already set fields and private fields from non-local crates
2989 if skip.iter().any(|x| *x == field.name.as_str()) ||
2990 (variant.did.krate != LOCAL_CRATE && field.vis != Visibility::Public) {
2997 // only find fits with at least one matching letter
2998 find_best_match_for_name(names, &name, Some(name.len()))
3001 // Check tuple index expressions
3002 fn check_tup_field(&self,
3003 expr: &'gcx hir::Expr,
3004 lvalue_pref: LvaluePreference,
3005 base: &'gcx hir::Expr,
3006 idx: codemap::Spanned<usize>) -> Ty<'tcx> {
3007 let expr_t = self.check_expr_with_lvalue_pref(base, lvalue_pref);
3008 let expr_t = self.structurally_resolved_type(expr.span,
3010 let mut private_candidate = None;
3011 let mut tuple_like = false;
3012 let mut autoderef = self.autoderef(expr.span, expr_t);
3013 while let Some((base_t, _)) = autoderef.next() {
3014 let field = match base_t.sty {
3015 ty::TyAdt(base_def, substs) if base_def.is_struct() => {
3016 tuple_like = base_def.struct_variant().ctor_kind == CtorKind::Fn;
3017 if !tuple_like { continue }
3019 debug!("tuple struct named {:?}", base_t);
3020 let ident = ast::Ident {
3021 name: Symbol::intern(&idx.node.to_string()),
3022 ctxt: idx.span.ctxt.modern(),
3024 let (ident, def_scope) =
3025 self.tcx.adjust_ident(ident, base_def.did, self.body_id);
3026 let fields = &base_def.struct_variant().fields;
3027 if let Some(field) = fields.iter().find(|f| f.name.to_ident() == ident) {
3028 let field_ty = self.field_ty(expr.span, field, substs);
3029 if field.vis.is_accessible_from(def_scope, self.tcx) {
3030 self.tcx.check_stability(field.did, expr.id, expr.span);
3033 private_candidate = Some((base_def.did, field_ty));
3040 ty::TyTuple(ref v, _) => {
3042 v.get(idx.node).cloned()
3047 if let Some(field_ty) = field {
3048 let adjustments = autoderef.adjust_steps(lvalue_pref);
3049 self.apply_adjustments(base, adjustments);
3050 autoderef.finalize();
3054 autoderef.unambiguous_final_ty();
3056 if let Some((did, field_ty)) = private_candidate {
3057 let struct_path = self.tcx().item_path_str(did);
3058 struct_span_err!(self.tcx().sess, expr.span, E0611,
3059 "field `{}` of tuple-struct `{}` is private",
3060 idx.node, struct_path).emit();
3065 type_error_struct!(self.tcx().sess, expr.span, expr_t, E0612,
3066 "attempted out-of-bounds tuple index `{}` on type `{}`",
3067 idx.node, expr_t).emit();
3069 self.no_such_field_err(expr.span, idx.node, expr_t).emit();
3072 self.tcx().types.err
3075 fn no_such_field_err<T: Display>(&self, span: Span, field: T, expr_t: &ty::TyS)
3076 -> DiagnosticBuilder {
3077 type_error_struct!(self.tcx().sess, span, expr_t, E0609,
3078 "no field `{}` on type `{}`",
3082 fn report_unknown_field(&self,
3084 variant: &'tcx ty::VariantDef,
3086 skip_fields: &[hir::Field],
3088 let mut err = self.type_error_struct_with_diag(
3090 |actual| match ty.sty {
3091 ty::TyAdt(adt, ..) if adt.is_enum() => {
3092 struct_span_err!(self.tcx.sess, field.name.span, E0559,
3093 "{} `{}::{}` has no field named `{}`",
3094 kind_name, actual, variant.name, field.name.node)
3097 struct_span_err!(self.tcx.sess, field.name.span, E0560,
3098 "{} `{}` has no field named `{}`",
3099 kind_name, actual, field.name.node)
3103 // prevent all specified fields from being suggested
3104 let skip_fields = skip_fields.iter().map(|ref x| x.name.node.as_str());
3105 if let Some(field_name) = Self::suggest_field_name(variant,
3107 skip_fields.collect()) {
3108 err.span_label(field.name.span,
3109 format!("field does not exist - did you mean `{}`?", field_name));
3112 ty::TyAdt(adt, ..) if adt.is_enum() => {
3113 err.span_label(field.name.span, format!("`{}::{}` does not have this field",
3117 err.span_label(field.name.span, format!("`{}` does not have this field", ty));
3124 fn check_expr_struct_fields(&self,
3126 expected: Expectation<'tcx>,
3127 expr_id: ast::NodeId,
3129 variant: &'tcx ty::VariantDef,
3130 ast_fields: &'gcx [hir::Field],
3131 check_completeness: bool) {
3135 self.expected_inputs_for_expected_output(span, expected, adt_ty, &[adt_ty])
3136 .get(0).cloned().unwrap_or(adt_ty);
3137 // re-link the regions that EIfEO can erase.
3138 self.demand_eqtype(span, adt_ty_hint, adt_ty);
3140 let (substs, adt_kind, kind_name) = match &adt_ty.sty{
3141 &ty::TyAdt(adt, substs) => {
3142 (substs, adt.adt_kind(), adt.variant_descr())
3144 _ => span_bug!(span, "non-ADT passed to check_expr_struct_fields")
3147 let mut remaining_fields = FxHashMap();
3148 for field in &variant.fields {
3149 remaining_fields.insert(field.name.to_ident(), field);
3152 let mut seen_fields = FxHashMap();
3154 let mut error_happened = false;
3156 // Typecheck each field.
3157 for field in ast_fields {
3158 let ident = tcx.adjust(field.name.node, variant.did, self.body_id).0;
3159 let field_type = if let Some(v_field) = remaining_fields.remove(&ident) {
3160 seen_fields.insert(field.name.node, field.span);
3162 // we don't look at stability attributes on
3163 // struct-like enums (yet...), but it's definitely not
3164 // a bug to have construct one.
3165 if adt_kind != ty::AdtKind::Enum {
3166 tcx.check_stability(v_field.did, expr_id, field.span);
3169 self.field_ty(field.span, v_field, substs)
3171 error_happened = true;
3172 if let Some(_) = variant.find_field_named(field.name.node) {
3173 let mut err = struct_span_err!(self.tcx.sess,
3176 "field `{}` specified more than once",
3179 err.span_label(field.name.span, "used more than once");
3181 if let Some(prev_span) = seen_fields.get(&field.name.node) {
3182 err.span_label(*prev_span, format!("first use of `{}`", field.name.node));
3187 self.report_unknown_field(adt_ty, variant, field, ast_fields, kind_name);
3193 // Make sure to give a type to the field even if there's
3194 // an error, so we can continue typechecking
3195 self.check_expr_coercable_to_type(&field.expr, field_type);
3198 // Make sure the programmer specified correct number of fields.
3199 if kind_name == "union" {
3200 if ast_fields.len() != 1 {
3201 tcx.sess.span_err(span, "union expressions should have exactly one field");
3203 } else if check_completeness && !error_happened && !remaining_fields.is_empty() {
3204 let len = remaining_fields.len();
3206 let mut displayable_field_names = remaining_fields
3208 .map(|ident| ident.name.as_str())
3209 .collect::<Vec<_>>();
3211 displayable_field_names.sort();
3213 let truncated_fields_error = if len <= 3 {
3216 format!(" and {} other field{}", (len - 3), if len - 3 == 1 {""} else {"s"})
3219 let remaining_fields_names = displayable_field_names.iter().take(3)
3220 .map(|n| format!("`{}`", n))
3221 .collect::<Vec<_>>()
3224 struct_span_err!(tcx.sess, span, E0063,
3225 "missing field{} {}{} in initializer of `{}`",
3226 if remaining_fields.len() == 1 { "" } else { "s" },
3227 remaining_fields_names,
3228 truncated_fields_error,
3230 .span_label(span, format!("missing {}{}",
3231 remaining_fields_names,
3232 truncated_fields_error))
3237 fn check_struct_fields_on_error(&self,
3238 fields: &'gcx [hir::Field],
3239 base_expr: &'gcx Option<P<hir::Expr>>) {
3240 for field in fields {
3241 self.check_expr(&field.expr);
3245 self.check_expr(&base);
3251 pub fn check_struct_path(&self,
3253 node_id: ast::NodeId)
3254 -> Option<(&'tcx ty::VariantDef, Ty<'tcx>)> {
3255 let path_span = match *qpath {
3256 hir::QPath::Resolved(_, ref path) => path.span,
3257 hir::QPath::TypeRelative(ref qself, _) => qself.span
3259 let (def, ty) = self.finish_resolving_struct_path(qpath, path_span, node_id);
3260 let variant = match def {
3262 self.set_tainted_by_errors();
3265 Def::Variant(..) => {
3267 ty::TyAdt(adt, substs) => {
3268 Some((adt.variant_of_def(def), adt.did, substs))
3270 _ => bug!("unexpected type: {:?}", ty.sty)
3273 Def::Struct(..) | Def::Union(..) | Def::TyAlias(..) |
3274 Def::AssociatedTy(..) | Def::SelfTy(..) => {
3276 ty::TyAdt(adt, substs) if !adt.is_enum() => {
3277 Some((adt.struct_variant(), adt.did, substs))
3282 _ => bug!("unexpected definition: {:?}", def)
3285 if let Some((variant, did, substs)) = variant {
3286 // Check bounds on type arguments used in the path.
3287 let bounds = self.instantiate_bounds(path_span, did, substs);
3288 let cause = traits::ObligationCause::new(path_span, self.body_id,
3289 traits::ItemObligation(did));
3290 self.add_obligations_for_parameters(cause, &bounds);
3294 struct_span_err!(self.tcx.sess, path_span, E0071,
3295 "expected struct, variant or union type, found {}",
3296 ty.sort_string(self.tcx))
3297 .span_label(path_span, "not a struct")
3303 fn check_expr_struct(&self,
3305 expected: Expectation<'tcx>,
3307 fields: &'gcx [hir::Field],
3308 base_expr: &'gcx Option<P<hir::Expr>>) -> Ty<'tcx>
3310 // Find the relevant variant
3311 let (variant, struct_ty) =
3312 if let Some(variant_ty) = self.check_struct_path(qpath, expr.id) {
3315 self.check_struct_fields_on_error(fields, base_expr);
3316 return self.tcx.types.err;
3319 let path_span = match *qpath {
3320 hir::QPath::Resolved(_, ref path) => path.span,
3321 hir::QPath::TypeRelative(ref qself, _) => qself.span
3324 self.check_expr_struct_fields(struct_ty, expected, expr.id, path_span, variant, fields,
3325 base_expr.is_none());
3326 if let &Some(ref base_expr) = base_expr {
3327 self.check_expr_has_type_or_error(base_expr, struct_ty);
3328 match struct_ty.sty {
3329 ty::TyAdt(adt, substs) if adt.is_struct() => {
3330 let fru_field_types = adt.struct_variant().fields.iter().map(|f| {
3331 self.normalize_associated_types_in(expr.span, &f.ty(self.tcx, substs))
3333 self.tables.borrow_mut().fru_field_types.insert(expr.id, fru_field_types);
3336 span_err!(self.tcx.sess, base_expr.span, E0436,
3337 "functional record update syntax requires a struct");
3341 self.require_type_is_sized(struct_ty, expr.span, traits::StructInitializerSized);
3347 /// If an expression has any sub-expressions that result in a type error,
3348 /// inspecting that expression's type with `ty.references_error()` will return
3349 /// true. Likewise, if an expression is known to diverge, inspecting its
3350 /// type with `ty::type_is_bot` will return true (n.b.: since Rust is
3351 /// strict, _|_ can appear in the type of an expression that does not,
3352 /// itself, diverge: for example, fn() -> _|_.)
3353 /// Note that inspecting a type's structure *directly* may expose the fact
3354 /// that there are actually multiple representations for `TyError`, so avoid
3355 /// that when err needs to be handled differently.
3356 fn check_expr_with_expectation_and_lvalue_pref(&self,
3357 expr: &'gcx hir::Expr,
3358 expected: Expectation<'tcx>,
3359 lvalue_pref: LvaluePreference) -> Ty<'tcx> {
3360 debug!(">> typechecking: expr={:?} expected={:?}",
3363 // Warn for expressions after diverging siblings.
3364 self.warn_if_unreachable(expr.id, expr.span, "expression");
3366 // Hide the outer diverging and has_errors flags.
3367 let old_diverges = self.diverges.get();
3368 let old_has_errors = self.has_errors.get();
3369 self.diverges.set(Diverges::Maybe);
3370 self.has_errors.set(false);
3372 let ty = self.check_expr_kind(expr, expected, lvalue_pref);
3374 // Warn for non-block expressions with diverging children.
3377 hir::ExprLoop(..) | hir::ExprWhile(..) |
3378 hir::ExprIf(..) | hir::ExprMatch(..) => {}
3380 _ => self.warn_if_unreachable(expr.id, expr.span, "expression")
3383 // Any expression that produces a value of type `!` must have diverged
3385 self.diverges.set(self.diverges.get() | Diverges::Always);
3388 // Record the type, which applies it effects.
3389 // We need to do this after the warning above, so that
3390 // we don't warn for the diverging expression itself.
3391 self.write_ty(expr.id, ty);
3393 // Combine the diverging and has_error flags.
3394 self.diverges.set(self.diverges.get() | old_diverges);
3395 self.has_errors.set(self.has_errors.get() | old_has_errors);
3397 debug!("type of {} is...", self.tcx.hir.node_to_string(expr.id));
3398 debug!("... {:?}, expected is {:?}", ty, expected);
3403 fn check_expr_kind(&self,
3404 expr: &'gcx hir::Expr,
3405 expected: Expectation<'tcx>,
3406 lvalue_pref: LvaluePreference) -> Ty<'tcx> {
3410 hir::ExprBox(ref subexpr) => {
3411 let expected_inner = expected.to_option(self).map_or(NoExpectation, |ty| {
3413 ty::TyAdt(def, _) if def.is_box()
3414 => Expectation::rvalue_hint(self, ty.boxed_ty()),
3418 let referent_ty = self.check_expr_with_expectation(subexpr, expected_inner);
3419 tcx.mk_box(referent_ty)
3422 hir::ExprLit(ref lit) => {
3423 self.check_lit(&lit, expected)
3425 hir::ExprBinary(op, ref lhs, ref rhs) => {
3426 self.check_binop(expr, op, lhs, rhs)
3428 hir::ExprAssignOp(op, ref lhs, ref rhs) => {
3429 self.check_binop_assign(expr, op, lhs, rhs)
3431 hir::ExprUnary(unop, ref oprnd) => {
3432 let expected_inner = match unop {
3433 hir::UnNot | hir::UnNeg => {
3440 let lvalue_pref = match unop {
3441 hir::UnDeref => lvalue_pref,
3444 let mut oprnd_t = self.check_expr_with_expectation_and_lvalue_pref(&oprnd,
3448 if !oprnd_t.references_error() {
3449 oprnd_t = self.structurally_resolved_type(expr.span, oprnd_t);
3452 if let Some(mt) = oprnd_t.builtin_deref(true, NoPreference) {
3454 } else if let Some(ok) = self.try_overloaded_deref(
3455 expr.span, oprnd_t, lvalue_pref) {
3456 let method = self.register_infer_ok_obligations(ok);
3457 if let ty::TyRef(region, mt) = method.sig.inputs()[0].sty {
3458 self.apply_adjustments(oprnd, vec![Adjustment {
3459 kind: Adjust::Borrow(AutoBorrow::Ref(region, mt.mutbl)),
3460 target: method.sig.inputs()[0]
3463 oprnd_t = self.make_overloaded_lvalue_return_type(method).ty;
3464 self.write_method_call(expr.id, method);
3466 type_error_struct!(tcx.sess, expr.span, oprnd_t, E0614,
3467 "type `{}` cannot be dereferenced",
3469 oprnd_t = tcx.types.err;
3473 let result = self.check_user_unop(expr, oprnd_t, unop);
3474 // If it's builtin, we can reuse the type, this helps inference.
3475 if !(oprnd_t.is_integral() || oprnd_t.sty == ty::TyBool) {
3480 let result = self.check_user_unop(expr, oprnd_t, unop);
3481 // If it's builtin, we can reuse the type, this helps inference.
3482 if !(oprnd_t.is_integral() || oprnd_t.is_fp()) {
3490 hir::ExprAddrOf(mutbl, ref oprnd) => {
3491 let hint = expected.only_has_type(self).map_or(NoExpectation, |ty| {
3493 ty::TyRef(_, ref mt) | ty::TyRawPtr(ref mt) => {
3494 if self.tcx.expr_is_lval(&oprnd) {
3495 // Lvalues may legitimately have unsized types.
3496 // For example, dereferences of a fat pointer and
3497 // the last field of a struct can be unsized.
3498 ExpectHasType(mt.ty)
3500 Expectation::rvalue_hint(self, mt.ty)
3506 let lvalue_pref = LvaluePreference::from_mutbl(mutbl);
3507 let ty = self.check_expr_with_expectation_and_lvalue_pref(&oprnd, hint, lvalue_pref);
3509 let tm = ty::TypeAndMut { ty: ty, mutbl: mutbl };
3510 if tm.ty.references_error() {
3513 // Note: at this point, we cannot say what the best lifetime
3514 // is to use for resulting pointer. We want to use the
3515 // shortest lifetime possible so as to avoid spurious borrowck
3516 // errors. Moreover, the longest lifetime will depend on the
3517 // precise details of the value whose address is being taken
3518 // (and how long it is valid), which we don't know yet until type
3519 // inference is complete.
3521 // Therefore, here we simply generate a region variable. The
3522 // region inferencer will then select the ultimate value.
3523 // Finally, borrowck is charged with guaranteeing that the
3524 // value whose address was taken can actually be made to live
3525 // as long as it needs to live.
3526 let region = self.next_region_var(infer::AddrOfRegion(expr.span));
3527 tcx.mk_ref(region, tm)
3530 hir::ExprPath(ref qpath) => {
3531 let (def, opt_ty, segments) = self.resolve_ty_and_def_ufcs(qpath,
3532 expr.id, expr.span);
3533 let ty = if def != Def::Err {
3534 self.instantiate_value_path(segments, opt_ty, def, expr.span, id)
3536 self.set_tainted_by_errors();
3540 // We always require that the type provided as the value for
3541 // a type parameter outlives the moment of instantiation.
3542 let substs = self.tables.borrow().node_substs(expr.id);
3543 self.add_wf_bounds(substs, expr);
3547 hir::ExprInlineAsm(_, ref outputs, ref inputs) => {
3548 for output in outputs {
3549 self.check_expr(output);
3551 for input in inputs {
3552 self.check_expr(input);
3556 hir::ExprBreak(destination, ref expr_opt) => {
3557 if let Some(target_id) = destination.target_id.opt_id() {
3558 let (e_ty, e_diverges, cause);
3559 if let Some(ref e) = *expr_opt {
3560 // If this is a break with a value, we need to type-check
3561 // the expression. Get an expected type from the loop context.
3562 let opt_coerce_to = {
3563 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
3564 enclosing_breakables.find_breakable(target_id)
3567 .map(|coerce| coerce.expected_ty())
3570 // If the loop context is not a `loop { }`, then break with
3571 // a value is illegal, and `opt_coerce_to` will be `None`.
3572 // Just set expectation to error in that case.
3573 let coerce_to = opt_coerce_to.unwrap_or(tcx.types.err);
3575 // Recurse without `enclosing_breakables` borrowed.
3576 e_ty = self.check_expr_with_hint(e, coerce_to);
3577 e_diverges = self.diverges.get();
3578 cause = self.misc(e.span);
3580 // Otherwise, this is a break *without* a value. That's
3581 // always legal, and is equivalent to `break ()`.
3582 e_ty = tcx.mk_nil();
3583 e_diverges = Diverges::Maybe;
3584 cause = self.misc(expr.span);
3587 // Now that we have type-checked `expr_opt`, borrow
3588 // the `enclosing_loops` field and let's coerce the
3589 // type of `expr_opt` into what is expected.
3590 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
3591 let ctxt = enclosing_breakables.find_breakable(target_id);
3592 if let Some(ref mut coerce) = ctxt.coerce {
3593 if let Some(ref e) = *expr_opt {
3594 coerce.coerce(self, &cause, e, e_ty, e_diverges);
3596 assert!(e_ty.is_nil());
3597 coerce.coerce_forced_unit(self, &cause, &mut |_| (), true);
3600 // If `ctxt.coerce` is `None`, we can just ignore
3601 // the type of the expresison. This is because
3602 // either this was a break *without* a value, in
3603 // which case it is always a legal type (`()`), or
3604 // else an error would have been flagged by the
3605 // `loops` pass for using break with an expression
3606 // where you are not supposed to.
3607 assert!(expr_opt.is_none() || self.tcx.sess.err_count() > 0);
3610 ctxt.may_break = true;
3612 // Otherwise, we failed to find the enclosing loop;
3613 // this can only happen if the `break` was not
3614 // inside a loop at all, which is caught by the
3615 // loop-checking pass.
3616 assert!(self.tcx.sess.err_count() > 0);
3619 // the type of a `break` is always `!`, since it diverges
3622 hir::ExprAgain(_) => { tcx.types.never }
3623 hir::ExprRet(ref expr_opt) => {
3624 if self.ret_coercion.is_none() {
3625 struct_span_err!(self.tcx.sess, expr.span, E0572,
3626 "return statement outside of function body").emit();
3627 } else if let Some(ref e) = *expr_opt {
3628 self.check_return_expr(e);
3630 let mut coercion = self.ret_coercion.as_ref().unwrap().borrow_mut();
3631 let cause = self.cause(expr.span, ObligationCauseCode::ReturnNoExpression);
3632 coercion.coerce_forced_unit(self, &cause, &mut |_| (), true);
3636 hir::ExprAssign(ref lhs, ref rhs) => {
3637 let lhs_ty = self.check_expr_with_lvalue_pref(&lhs, PreferMutLvalue);
3639 let rhs_ty = self.check_expr_coercable_to_type(&rhs, lhs_ty);
3642 ExpectIfCondition => {
3643 self.tcx.sess.delay_span_bug(lhs.span, "invalid lhs expression in if;\
3644 expected error elsehwere");
3647 // Only check this if not in an `if` condition, as the
3648 // mistyped comparison help is more appropriate.
3649 if !self.tcx.expr_is_lval(&lhs) {
3651 self.tcx.sess, expr.span, E0070,
3652 "invalid left-hand side expression")
3655 "left-hand of expression not valid")
3661 self.require_type_is_sized(lhs_ty, lhs.span, traits::AssignmentLhsSized);
3663 if lhs_ty.references_error() || rhs_ty.references_error() {
3669 hir::ExprIf(ref cond, ref then_expr, ref opt_else_expr) => {
3670 self.check_then_else(&cond, then_expr, opt_else_expr.as_ref().map(|e| &**e),
3671 expr.span, expected)
3673 hir::ExprWhile(ref cond, ref body, _) => {
3674 let ctxt = BreakableCtxt {
3675 // cannot use break with a value from a while loop
3680 self.with_breakable_ctxt(expr.id, ctxt, || {
3681 self.check_expr_has_type_or_error(&cond, tcx.types.bool);
3682 let cond_diverging = self.diverges.get();
3683 self.check_block_no_value(&body);
3685 // We may never reach the body so it diverging means nothing.
3686 self.diverges.set(cond_diverging);
3691 hir::ExprLoop(ref body, _, source) => {
3692 let coerce = match source {
3693 // you can only use break with a value from a normal `loop { }`
3694 hir::LoopSource::Loop => {
3695 let coerce_to = expected.coercion_target_type(self, body.span);
3696 Some(CoerceMany::new(coerce_to))
3699 hir::LoopSource::WhileLet |
3700 hir::LoopSource::ForLoop => {
3705 let ctxt = BreakableCtxt {
3707 may_break: false, // will get updated if/when we find a `break`
3710 let (ctxt, ()) = self.with_breakable_ctxt(expr.id, ctxt, || {
3711 self.check_block_no_value(&body);
3715 // No way to know whether it's diverging because
3716 // of a `break` or an outer `break` or `return.
3717 self.diverges.set(Diverges::Maybe);
3720 // If we permit break with a value, then result type is
3721 // the LUB of the breaks (possibly ! if none); else, it
3722 // is nil. This makes sense because infinite loops
3723 // (which would have type !) are only possible iff we
3724 // permit break with a value [1].
3725 assert!(ctxt.coerce.is_some() || ctxt.may_break); // [1]
3726 ctxt.coerce.map(|c| c.complete(self)).unwrap_or(self.tcx.mk_nil())
3728 hir::ExprMatch(ref discrim, ref arms, match_src) => {
3729 self.check_match(expr, &discrim, arms, expected, match_src)
3731 hir::ExprClosure(capture, ref decl, body_id, _) => {
3732 self.check_expr_closure(expr, capture, &decl, body_id, expected)
3734 hir::ExprBlock(ref body) => {
3735 self.check_block_with_expected(&body, expected)
3737 hir::ExprCall(ref callee, ref args) => {
3738 self.check_call(expr, &callee, args, expected)
3740 hir::ExprMethodCall(ref segment, span, ref args) => {
3741 self.check_method_call(expr, segment, span, args, expected, lvalue_pref)
3743 hir::ExprCast(ref e, ref t) => {
3744 // Find the type of `e`. Supply hints based on the type we are casting to,
3746 let t_cast = self.to_ty(t);
3747 let t_cast = self.resolve_type_vars_if_possible(&t_cast);
3748 let t_expr = self.check_expr_with_expectation(e, ExpectCastableToType(t_cast));
3749 let t_cast = self.resolve_type_vars_if_possible(&t_cast);
3750 let diverges = self.diverges.get();
3752 // Eagerly check for some obvious errors.
3753 if t_expr.references_error() || t_cast.references_error() {
3756 // Defer other checks until we're done type checking.
3757 let mut deferred_cast_checks = self.deferred_cast_checks.borrow_mut();
3758 match cast::CastCheck::new(self, e, t_expr, diverges, t_cast, t.span, expr.span) {
3760 deferred_cast_checks.push(cast_check);
3763 Err(ErrorReported) => {
3769 hir::ExprType(ref e, ref t) => {
3770 let typ = self.to_ty(&t);
3771 self.check_expr_eq_type(&e, typ);
3774 hir::ExprArray(ref args) => {
3775 let uty = expected.to_option(self).and_then(|uty| {
3777 ty::TyArray(ty, _) | ty::TySlice(ty) => Some(ty),
3782 let element_ty = if !args.is_empty() {
3783 let coerce_to = uty.unwrap_or_else(
3784 || self.next_ty_var(TypeVariableOrigin::TypeInference(expr.span)));
3785 let mut coerce = CoerceMany::with_coercion_sites(coerce_to, args);
3786 assert_eq!(self.diverges.get(), Diverges::Maybe);
3788 let e_ty = self.check_expr_with_hint(e, coerce_to);
3789 let cause = self.misc(e.span);
3790 coerce.coerce(self, &cause, e, e_ty, self.diverges.get());
3792 coerce.complete(self)
3794 self.next_ty_var(TypeVariableOrigin::TypeInference(expr.span))
3796 tcx.mk_array(element_ty, args.len())
3798 hir::ExprRepeat(ref element, count) => {
3799 let count = eval_length(self.tcx, count, "repeat count")
3802 let uty = match expected {
3803 ExpectHasType(uty) => {
3805 ty::TyArray(ty, _) | ty::TySlice(ty) => Some(ty),
3812 let (element_ty, t) = match uty {
3814 self.check_expr_coercable_to_type(&element, uty);
3818 let t: Ty = self.next_ty_var(TypeVariableOrigin::MiscVariable(element.span));
3819 let element_ty = self.check_expr_has_type_or_error(&element, t);
3825 // For [foo, ..n] where n > 1, `foo` must have
3827 let lang_item = self.tcx.require_lang_item(lang_items::CopyTraitLangItem);
3828 self.require_type_meets(t, expr.span, traits::RepeatVec, lang_item);
3831 if element_ty.references_error() {
3834 tcx.mk_array(t, count)
3837 hir::ExprTup(ref elts) => {
3838 let flds = expected.only_has_type(self).and_then(|ty| {
3840 ty::TyTuple(ref flds, _) => Some(&flds[..]),
3845 let elt_ts_iter = elts.iter().enumerate().map(|(i, e)| {
3846 let t = match flds {
3847 Some(ref fs) if i < fs.len() => {
3849 self.check_expr_coercable_to_type(&e, ety);
3853 self.check_expr_with_expectation(&e, NoExpectation)
3858 let tuple = tcx.mk_tup(elt_ts_iter, false);
3859 if tuple.references_error() {
3862 self.require_type_is_sized(tuple, expr.span, traits::TupleInitializerSized);
3866 hir::ExprStruct(ref qpath, ref fields, ref base_expr) => {
3867 self.check_expr_struct(expr, expected, qpath, fields, base_expr)
3869 hir::ExprField(ref base, ref field) => {
3870 self.check_field(expr, lvalue_pref, &base, field)
3872 hir::ExprTupField(ref base, idx) => {
3873 self.check_tup_field(expr, lvalue_pref, &base, idx)
3875 hir::ExprIndex(ref base, ref idx) => {
3876 let base_t = self.check_expr_with_lvalue_pref(&base, lvalue_pref);
3877 let idx_t = self.check_expr(&idx);
3879 if base_t.references_error() {
3881 } else if idx_t.references_error() {
3884 let base_t = self.structurally_resolved_type(expr.span, base_t);
3885 match self.lookup_indexing(expr, base, base_t, idx_t, lvalue_pref) {
3886 Some((index_ty, element_ty)) => {
3887 self.demand_coerce(idx, idx_t, index_ty);
3891 let mut err = type_error_struct!(tcx.sess, expr.span, base_t, E0608,
3892 "cannot index into a value of type `{}`",
3894 // Try to give some advice about indexing tuples.
3895 if let ty::TyTuple(..) = base_t.sty {
3896 let mut needs_note = true;
3897 // If the index is an integer, we can show the actual
3898 // fixed expression:
3899 if let hir::ExprLit(ref lit) = idx.node {
3900 if let ast::LitKind::Int(i,
3901 ast::LitIntType::Unsuffixed) = lit.node {
3902 let snip = tcx.sess.codemap().span_to_snippet(base.span);
3903 if let Ok(snip) = snip {
3904 err.span_suggestion(expr.span,
3905 "to access tuple elements, use",
3906 format!("{}.{}", snip, i));
3912 err.help("to access tuple elements, use tuple indexing \
3913 syntax (e.g. `tuple.0`)");
3925 // Finish resolving a path in a struct expression or pattern `S::A { .. }` if necessary.
3926 // The newly resolved definition is written into `type_dependent_defs`.
3927 fn finish_resolving_struct_path(&self,
3930 node_id: ast::NodeId)
3934 hir::QPath::Resolved(ref maybe_qself, ref path) => {
3935 let opt_self_ty = maybe_qself.as_ref().map(|qself| self.to_ty(qself));
3936 let ty = AstConv::def_to_ty(self, opt_self_ty, path, true);
3939 hir::QPath::TypeRelative(ref qself, ref segment) => {
3940 let ty = self.to_ty(qself);
3942 let def = if let hir::TyPath(hir::QPath::Resolved(_, ref path)) = qself.node {
3947 let (ty, def) = AstConv::associated_path_def_to_ty(self, node_id, path_span,
3950 // Write back the new resolution.
3951 self.tables.borrow_mut().type_dependent_defs.insert(node_id, def);
3958 // Resolve associated value path into a base type and associated constant or method definition.
3959 // The newly resolved definition is written into `type_dependent_defs`.
3960 pub fn resolve_ty_and_def_ufcs<'b>(&self,
3961 qpath: &'b hir::QPath,
3962 node_id: ast::NodeId,
3964 -> (Def, Option<Ty<'tcx>>, &'b [hir::PathSegment])
3966 let (ty, item_segment) = match *qpath {
3967 hir::QPath::Resolved(ref opt_qself, ref path) => {
3969 opt_qself.as_ref().map(|qself| self.to_ty(qself)),
3970 &path.segments[..]);
3972 hir::QPath::TypeRelative(ref qself, ref segment) => {
3973 (self.to_ty(qself), segment)
3976 let item_name = item_segment.name;
3977 let def = match self.resolve_ufcs(span, item_name, ty, node_id) {
3980 let def = match error {
3981 method::MethodError::PrivateMatch(def) => def,
3984 if item_name != keywords::Invalid.name() {
3985 self.report_method_error(span, ty, item_name, None, error, None);
3991 // Write back the new resolution.
3992 self.tables.borrow_mut().type_dependent_defs.insert(node_id, def);
3993 (def, Some(ty), slice::ref_slice(&**item_segment))
3996 pub fn check_decl_initializer(&self,
3997 local: &'gcx hir::Local,
3998 init: &'gcx hir::Expr) -> Ty<'tcx>
4000 let ref_bindings = local.pat.contains_ref_binding();
4002 let local_ty = self.local_ty(init.span, local.id);
4003 if let Some(m) = ref_bindings {
4004 // Somewhat subtle: if we have a `ref` binding in the pattern,
4005 // we want to avoid introducing coercions for the RHS. This is
4006 // both because it helps preserve sanity and, in the case of
4007 // ref mut, for soundness (issue #23116). In particular, in
4008 // the latter case, we need to be clear that the type of the
4009 // referent for the reference that results is *equal to* the
4010 // type of the lvalue it is referencing, and not some
4011 // supertype thereof.
4012 let init_ty = self.check_expr_with_lvalue_pref(init, LvaluePreference::from_mutbl(m));
4013 self.demand_eqtype(init.span, init_ty, local_ty);
4016 self.check_expr_coercable_to_type(init, local_ty)
4020 pub fn check_decl_local(&self, local: &'gcx hir::Local) {
4021 let t = self.local_ty(local.span, local.id);
4022 self.write_ty(local.id, t);
4024 if let Some(ref init) = local.init {
4025 let init_ty = self.check_decl_initializer(local, &init);
4026 if init_ty.references_error() {
4027 self.write_ty(local.id, init_ty);
4031 self.check_pat(&local.pat, t);
4032 let pat_ty = self.node_ty(local.pat.id);
4033 if pat_ty.references_error() {
4034 self.write_ty(local.id, pat_ty);
4038 pub fn check_stmt(&self, stmt: &'gcx hir::Stmt) {
4039 // Don't do all the complex logic below for DeclItem.
4041 hir::StmtDecl(ref decl, _) => {
4043 hir::DeclLocal(_) => {}
4044 hir::DeclItem(_) => {
4049 hir::StmtExpr(..) | hir::StmtSemi(..) => {}
4052 self.warn_if_unreachable(stmt.node.id(), stmt.span, "statement");
4054 // Hide the outer diverging and has_errors flags.
4055 let old_diverges = self.diverges.get();
4056 let old_has_errors = self.has_errors.get();
4057 self.diverges.set(Diverges::Maybe);
4058 self.has_errors.set(false);
4061 hir::StmtDecl(ref decl, _) => {
4063 hir::DeclLocal(ref l) => {
4064 self.check_decl_local(&l);
4066 hir::DeclItem(_) => {/* ignore for now */}
4069 hir::StmtExpr(ref expr, _) => {
4070 // Check with expected type of ()
4071 self.check_expr_has_type_or_error(&expr, self.tcx.mk_nil());
4073 hir::StmtSemi(ref expr, _) => {
4074 self.check_expr(&expr);
4078 // Combine the diverging and has_error flags.
4079 self.diverges.set(self.diverges.get() | old_diverges);
4080 self.has_errors.set(self.has_errors.get() | old_has_errors);
4083 pub fn check_block_no_value(&self, blk: &'gcx hir::Block) {
4084 let unit = self.tcx.mk_nil();
4085 let ty = self.check_block_with_expected(blk, ExpectHasType(unit));
4087 // if the block produces a `!` value, that can always be
4088 // (effectively) coerced to unit.
4090 self.demand_suptype(blk.span, unit, ty);
4094 fn check_block_with_expected(&self,
4095 blk: &'gcx hir::Block,
4096 expected: Expectation<'tcx>) -> Ty<'tcx> {
4098 let mut fcx_ps = self.ps.borrow_mut();
4099 let unsafety_state = fcx_ps.recurse(blk);
4100 replace(&mut *fcx_ps, unsafety_state)
4103 // In some cases, blocks have just one exit, but other blocks
4104 // can be targeted by multiple breaks. This cannot happen in
4105 // normal Rust syntax today, but it can happen when we desugar
4106 // a `do catch { ... }` expression.
4110 // 'a: { if true { break 'a Err(()); } Ok(()) }
4112 // Here we would wind up with two coercions, one from
4113 // `Err(())` and the other from the tail expression
4114 // `Ok(())`. If the tail expression is omitted, that's a
4115 // "forced unit" -- unless the block diverges, in which
4116 // case we can ignore the tail expression (e.g., `'a: {
4117 // break 'a 22; }` would not force the type of the block
4119 let tail_expr = blk.expr.as_ref();
4120 let coerce_to_ty = expected.coercion_target_type(self, blk.span);
4121 let coerce = if blk.targeted_by_break {
4122 CoerceMany::new(coerce_to_ty)
4124 let tail_expr: &[P<hir::Expr>] = match tail_expr {
4125 Some(e) => ref_slice(e),
4128 CoerceMany::with_coercion_sites(coerce_to_ty, tail_expr)
4131 let ctxt = BreakableCtxt {
4132 coerce: Some(coerce),
4136 let (ctxt, ()) = self.with_breakable_ctxt(blk.id, ctxt, || {
4137 for s in &blk.stmts {
4141 // check the tail expression **without** holding the
4142 // `enclosing_breakables` lock below.
4143 let tail_expr_ty = tail_expr.map(|t| self.check_expr_with_expectation(t, expected));
4145 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4146 let mut ctxt = enclosing_breakables.find_breakable(blk.id);
4147 let mut coerce = ctxt.coerce.as_mut().unwrap();
4148 if let Some(tail_expr_ty) = tail_expr_ty {
4149 let tail_expr = tail_expr.unwrap();
4150 let cause = self.cause(tail_expr.span,
4151 ObligationCauseCode::BlockTailExpression(blk.id));
4156 self.diverges.get());
4158 // Subtle: if there is no explicit tail expression,
4159 // that is typically equivalent to a tail expression
4160 // of `()` -- except if the block diverges. In that
4161 // case, there is no value supplied from the tail
4162 // expression (assuming there are no other breaks,
4163 // this implies that the type of the block will be
4166 // #41425 -- label the implicit `()` as being the
4167 // "found type" here, rather than the "expected type".
4168 if !self.diverges.get().always() {
4169 coerce.coerce_forced_unit(self, &self.misc(blk.span), &mut |err| {
4170 if let Some(expected_ty) = expected.only_has_type(self) {
4171 self.consider_hint_about_removing_semicolon(blk,
4180 let mut ty = ctxt.coerce.unwrap().complete(self);
4182 if self.has_errors.get() || ty.references_error() {
4183 ty = self.tcx.types.err
4186 self.write_ty(blk.id, ty);
4188 *self.ps.borrow_mut() = prev;
4192 /// Given a `NodeId`, return the `FnDecl` of the method it is enclosed by and whether it is
4193 /// `fn main` if it is a method, `None` otherwise.
4194 pub fn get_fn_decl(&self, blk_id: ast::NodeId) -> Option<(hir::FnDecl, bool)> {
4195 // Get enclosing Fn, if it is a function or a trait method, unless there's a `loop` or
4196 // `while` before reaching it, as block tail returns are not available in them.
4197 if let Some(fn_id) = self.tcx.hir.get_return_block(blk_id) {
4198 let parent = self.tcx.hir.get(fn_id);
4200 if let Node::NodeItem(&hir::Item {
4201 name, node: hir::ItemFn(ref decl, ..), ..
4203 decl.clone().and_then(|decl| {
4204 // This is less than ideal, it will not present the return type span on any
4205 // method called `main`, regardless of whether it is actually the entry point.
4206 Some((decl, name == Symbol::intern("main")))
4208 } else if let Node::NodeTraitItem(&hir::TraitItem {
4209 node: hir::TraitItemKind::Method(hir::MethodSig {
4213 decl.clone().and_then(|decl| {
4224 /// On implicit return expressions with mismatched types, provide the following suggestions:
4226 /// - Point out the method's return type as the reason for the expected type
4227 /// - Possible missing semicolon
4228 /// - Possible missing return type if the return type is the default, and not `fn main()`
4229 pub fn suggest_mismatched_types_on_tail(&self,
4230 err: &mut DiagnosticBuilder<'tcx>,
4231 expression: &'gcx hir::Expr,
4235 blk_id: ast::NodeId) {
4236 self.suggest_missing_semicolon(err, expression, expected, cause_span);
4238 if let Some((fn_decl, is_main)) = self.get_fn_decl(blk_id) {
4239 // `fn main()` must return `()`, do not suggest changing return type
4241 self.suggest_missing_return_type(err, &fn_decl, found);
4246 /// A common error is to forget to add a semicolon at the end of a block:
4250 /// bar_that_returns_u32()
4254 /// This routine checks if the return expression in a block would make sense on its own as a
4255 /// statement and the return type has been left as defaultor has been specified as `()`. If so,
4256 /// it suggests adding a semicolon.
4257 fn suggest_missing_semicolon(&self,
4258 err: &mut DiagnosticBuilder<'tcx>,
4259 expression: &'gcx hir::Expr,
4262 if expected.is_nil() {
4263 // `BlockTailExpression` only relevant if the tail expr would be
4264 // useful on its own.
4265 match expression.node {
4267 hir::ExprMethodCall(..) |
4269 hir::ExprWhile(..) |
4271 hir::ExprMatch(..) |
4272 hir::ExprBlock(..) => {
4273 let sp = cause_span.next_point();
4274 err.span_suggestion(sp,
4275 "did you mean to add a semicolon here?",
4284 /// A possible error is to forget to add a return type that is needed:
4288 /// bar_that_returns_u32()
4292 /// This routine checks if the return type is left as default, the method is not part of an
4293 /// `impl` block and that it isn't the `main` method. If so, it suggests setting the return
4295 fn suggest_missing_return_type(&self,
4296 err: &mut DiagnosticBuilder<'tcx>,
4297 fn_decl: &hir::FnDecl,
4300 // Only recommend changing the return type for methods that
4301 // haven't set a return type at all (and aren't `fn main()` or an impl).
4302 if let &hir::FnDecl {
4303 output: hir::FunctionRetTy::DefaultReturn(span), ..
4305 if ty.is_suggestable() {
4306 err.span_suggestion(span,
4307 "possibly return type missing here?",
4308 format!("-> {} ", ty));
4310 err.span_label(span, "possibly return type missing here?");
4316 /// A common error is to add an extra semicolon:
4319 /// fn foo() -> usize {
4324 /// This routine checks if the final statement in a block is an
4325 /// expression with an explicit semicolon whose type is compatible
4326 /// with `expected_ty`. If so, it suggests removing the semicolon.
4327 fn consider_hint_about_removing_semicolon(&self,
4328 blk: &'gcx hir::Block,
4329 expected_ty: Ty<'tcx>,
4330 err: &mut DiagnosticBuilder) {
4331 // Be helpful when the user wrote `{... expr;}` and
4332 // taking the `;` off is enough to fix the error.
4333 let last_stmt = match blk.stmts.last() {
4337 let last_expr = match last_stmt.node {
4338 hir::StmtSemi(ref e, _) => e,
4341 let last_expr_ty = self.node_ty(last_expr.id);
4342 if self.can_sub(self.param_env, last_expr_ty, expected_ty).is_err() {
4345 let original_span = original_sp(last_stmt.span, blk.span);
4346 let span_semi = Span {
4347 lo: original_span.hi - BytePos(1),
4348 hi: original_span.hi,
4349 ctxt: original_span.ctxt,
4351 err.span_suggestion(span_semi, "consider removing this semicolon", "".to_string());
4354 // Instantiates the given path, which must refer to an item with the given
4355 // number of type parameters and type.
4356 pub fn instantiate_value_path(&self,
4357 segments: &[hir::PathSegment],
4358 opt_self_ty: Option<Ty<'tcx>>,
4361 node_id: ast::NodeId)
4363 debug!("instantiate_value_path(path={:?}, def={:?}, node_id={})",
4368 // We need to extract the type parameters supplied by the user in
4369 // the path `path`. Due to the current setup, this is a bit of a
4370 // tricky-process; the problem is that resolve only tells us the
4371 // end-point of the path resolution, and not the intermediate steps.
4372 // Luckily, we can (at least for now) deduce the intermediate steps
4373 // just from the end-point.
4375 // There are basically four cases to consider:
4377 // 1. Reference to a constructor of enum variant or struct:
4379 // struct Foo<T>(...)
4380 // enum E<T> { Foo(...) }
4382 // In these cases, the parameters are declared in the type
4385 // 2. Reference to a fn item or a free constant:
4389 // In this case, the path will again always have the form
4390 // `a::b::foo::<T>` where only the final segment should have
4391 // type parameters. However, in this case, those parameters are
4392 // declared on a value, and hence are in the `FnSpace`.
4394 // 3. Reference to a method or an associated constant:
4396 // impl<A> SomeStruct<A> {
4400 // Here we can have a path like
4401 // `a::b::SomeStruct::<A>::foo::<B>`, in which case parameters
4402 // may appear in two places. The penultimate segment,
4403 // `SomeStruct::<A>`, contains parameters in TypeSpace, and the
4404 // final segment, `foo::<B>` contains parameters in fn space.
4406 // 4. Reference to a local variable
4408 // Local variables can't have any type parameters.
4410 // The first step then is to categorize the segments appropriately.
4412 assert!(!segments.is_empty());
4414 let mut ufcs_associated = None;
4415 let mut type_segment = None;
4416 let mut fn_segment = None;
4418 // Case 1. Reference to a struct/variant constructor.
4419 Def::StructCtor(def_id, ..) |
4420 Def::VariantCtor(def_id, ..) => {
4421 // Everything but the final segment should have no
4422 // parameters at all.
4423 let mut generics = self.tcx.generics_of(def_id);
4424 if let Some(def_id) = generics.parent {
4425 // Variant and struct constructors use the
4426 // generics of their parent type definition.
4427 generics = self.tcx.generics_of(def_id);
4429 type_segment = Some((segments.last().unwrap(), generics));
4432 // Case 2. Reference to a top-level value.
4434 Def::Const(def_id) |
4435 Def::Static(def_id, _) => {
4436 fn_segment = Some((segments.last().unwrap(),
4437 self.tcx.generics_of(def_id)));
4440 // Case 3. Reference to a method or associated const.
4441 Def::Method(def_id) |
4442 Def::AssociatedConst(def_id) => {
4443 let container = self.tcx.associated_item(def_id).container;
4445 ty::TraitContainer(trait_did) => {
4446 callee::check_legal_trait_for_method_call(self.tcx, span, trait_did)
4448 ty::ImplContainer(_) => {}
4451 let generics = self.tcx.generics_of(def_id);
4452 if segments.len() >= 2 {
4453 let parent_generics = self.tcx.generics_of(generics.parent.unwrap());
4454 type_segment = Some((&segments[segments.len() - 2], parent_generics));
4456 // `<T>::assoc` will end up here, and so can `T::assoc`.
4457 let self_ty = opt_self_ty.expect("UFCS sugared assoc missing Self");
4458 ufcs_associated = Some((container, self_ty));
4460 fn_segment = Some((segments.last().unwrap(), generics));
4463 // Case 4. Local variable, no generics.
4464 Def::Local(..) | Def::Upvar(..) => {}
4466 _ => bug!("unexpected definition: {:?}", def),
4469 debug!("type_segment={:?} fn_segment={:?}", type_segment, fn_segment);
4471 // Now that we have categorized what space the parameters for each
4472 // segment belong to, let's sort out the parameters that the user
4473 // provided (if any) into their appropriate spaces. We'll also report
4474 // errors if type parameters are provided in an inappropriate place.
4475 let poly_segments = type_segment.is_some() as usize +
4476 fn_segment.is_some() as usize;
4477 AstConv::prohibit_type_params(self, &segments[..segments.len() - poly_segments]);
4480 Def::Local(def_id) | Def::Upvar(def_id, ..) => {
4481 let nid = self.tcx.hir.as_local_node_id(def_id).unwrap();
4482 let ty = self.local_ty(span, nid);
4483 let ty = self.normalize_associated_types_in(span, &ty);
4484 self.write_ty(node_id, ty);
4490 // Now we have to compare the types that the user *actually*
4491 // provided against the types that were *expected*. If the user
4492 // did not provide any types, then we want to substitute inference
4493 // variables. If the user provided some types, we may still need
4494 // to add defaults. If the user provided *too many* types, that's
4496 self.check_path_parameter_count(span, &mut type_segment, false);
4497 self.check_path_parameter_count(span, &mut fn_segment, false);
4499 let (fn_start, has_self) = match (type_segment, fn_segment) {
4500 (_, Some((_, generics))) => {
4501 (generics.parent_count(), generics.has_self)
4503 (Some((_, generics)), None) => {
4504 (generics.own_count(), generics.has_self)
4506 (None, None) => (0, false)
4508 let substs = Substs::for_item(self.tcx, def.def_id(), |def, _| {
4509 let mut i = def.index as usize;
4511 let segment = if i < fn_start {
4512 i -= has_self as usize;
4518 let lifetimes = match segment.map(|(s, _)| &s.parameters) {
4519 Some(&hir::AngleBracketedParameters(ref data)) => &data.lifetimes[..],
4520 Some(&hir::ParenthesizedParameters(_)) => bug!(),
4524 if let Some(lifetime) = lifetimes.get(i) {
4525 AstConv::ast_region_to_region(self, lifetime, Some(def))
4527 self.re_infer(span, Some(def)).unwrap()
4530 let mut i = def.index as usize;
4532 let segment = if i < fn_start {
4533 // Handle Self first, so we can adjust the index to match the AST.
4534 if has_self && i == 0 {
4535 return opt_self_ty.unwrap_or_else(|| {
4536 self.type_var_for_def(span, def, substs)
4539 i -= has_self as usize;
4545 let (types, infer_types) = match segment.map(|(s, _)| &s.parameters) {
4546 Some(&hir::AngleBracketedParameters(ref data)) => {
4547 (&data.types[..], data.infer_types)
4549 Some(&hir::ParenthesizedParameters(_)) => bug!(),
4550 None => (&[][..], true)
4553 // Skip over the lifetimes in the same segment.
4554 if let Some((_, generics)) = segment {
4555 i -= generics.regions.len();
4558 if let Some(ast_ty) = types.get(i) {
4559 // A provided type parameter.
4561 } else if !infer_types && def.has_default {
4562 // No type parameter provided, but a default exists.
4563 let default = self.tcx.type_of(def.def_id);
4566 default.subst_spanned(self.tcx, substs, Some(span))
4569 // No type parameters were provided, we can infer all.
4570 // This can also be reached in some error cases:
4571 // We prefer to use inference variables instead of
4572 // TyError to let type inference recover somewhat.
4573 self.type_var_for_def(span, def, substs)
4577 // The things we are substituting into the type should not contain
4578 // escaping late-bound regions, and nor should the base type scheme.
4579 let ty = self.tcx.type_of(def.def_id());
4580 assert!(!substs.has_escaping_regions());
4581 assert!(!ty.has_escaping_regions());
4583 // Add all the obligations that are required, substituting and
4584 // normalized appropriately.
4585 let bounds = self.instantiate_bounds(span, def.def_id(), &substs);
4586 self.add_obligations_for_parameters(
4587 traits::ObligationCause::new(span, self.body_id, traits::ItemObligation(def.def_id())),
4590 // Substitute the values for the type parameters into the type of
4591 // the referenced item.
4592 let ty_substituted = self.instantiate_type_scheme(span, &substs, &ty);
4594 if let Some((ty::ImplContainer(impl_def_id), self_ty)) = ufcs_associated {
4595 // In the case of `Foo<T>::method` and `<Foo<T>>::method`, if `method`
4596 // is inherent, there is no `Self` parameter, instead, the impl needs
4597 // type parameters, which we can infer by unifying the provided `Self`
4598 // with the substituted impl type.
4599 let ty = self.tcx.type_of(impl_def_id);
4601 let impl_ty = self.instantiate_type_scheme(span, &substs, &ty);
4602 match self.at(&self.misc(span), self.param_env).sup(impl_ty, self_ty) {
4603 Ok(ok) => self.register_infer_ok_obligations(ok),
4606 "instantiate_value_path: (UFCS) {:?} was a subtype of {:?} but now is not?",
4613 debug!("instantiate_value_path: type of {:?} is {:?}",
4616 self.write_substs(node_id, substs);
4620 /// Report errors if the provided parameters are too few or too many.
4621 fn check_path_parameter_count(&self,
4623 segment: &mut Option<(&hir::PathSegment, &ty::Generics)>,
4624 is_method_call: bool) {
4625 let (lifetimes, types, infer_types, bindings) = {
4626 match segment.map(|(s, _)| &s.parameters) {
4627 Some(&hir::AngleBracketedParameters(ref data)) => {
4628 (&data.lifetimes[..], &data.types[..], data.infer_types, &data.bindings[..])
4630 Some(&hir::ParenthesizedParameters(_)) => {
4631 AstConv::prohibit_parenthesized_params(self, &segment.as_ref().unwrap().0,
4633 (&[][..], &[][..], true, &[][..])
4635 None => (&[][..], &[][..], true, &[][..])
4638 let infer_lifetimes = lifetimes.len() == 0;
4640 let count_lifetime_params = |n| {
4641 format!("{} lifetime parameter{}", n, if n == 1 { "" } else { "s" })
4643 let count_type_params = |n| {
4644 format!("{} type parameter{}", n, if n == 1 { "" } else { "s" })
4647 // Check provided type parameters.
4648 let type_defs = segment.map_or(&[][..], |(_, generics)| {
4649 if generics.parent.is_none() {
4650 &generics.types[generics.has_self as usize..]
4655 let required_len = type_defs.iter().take_while(|d| !d.has_default).count();
4656 if types.len() > type_defs.len() {
4657 let span = types[type_defs.len()].span;
4658 let expected_text = count_type_params(type_defs.len());
4659 let actual_text = count_type_params(types.len());
4660 struct_span_err!(self.tcx.sess, span, E0087,
4661 "too many type parameters provided: \
4662 expected at most {}, found {}",
4663 expected_text, actual_text)
4664 .span_label(span, format!("expected {}", expected_text))
4667 // To prevent derived errors to accumulate due to extra
4668 // type parameters, we force instantiate_value_path to
4669 // use inference variables instead of the provided types.
4671 } else if types.len() < required_len && !infer_types {
4672 let expected_text = count_type_params(required_len);
4673 let actual_text = count_type_params(types.len());
4674 struct_span_err!(self.tcx.sess, span, E0089,
4675 "too few type parameters provided: \
4676 expected {}, found {}",
4677 expected_text, actual_text)
4678 .span_label(span, format!("expected {}", expected_text))
4682 if !bindings.is_empty() {
4683 span_err!(self.tcx.sess, bindings[0].span, E0182,
4684 "unexpected binding of associated item in expression path \
4685 (only allowed in type paths)");
4688 // Check provided lifetime parameters.
4689 let lifetime_defs = segment.map_or(&[][..], |(_, generics)| &generics.regions);
4690 let required_len = lifetime_defs.len();
4692 // Prohibit explicit lifetime arguments if late bound lifetime parameters are present.
4693 let has_late_bound_lifetime_defs =
4694 segment.map_or(false, |(_, generics)| generics.has_late_bound_regions);
4695 if has_late_bound_lifetime_defs && !lifetimes.is_empty() {
4696 // Report this as a lint only if no error was reported previously.
4697 if !is_method_call && (lifetimes.len() > lifetime_defs.len() ||
4698 lifetimes.len() < required_len && !infer_lifetimes) {
4699 self.tcx.sess.span_err(lifetimes[0].span,
4700 "cannot specify lifetime arguments explicitly \
4701 if late bound lifetime parameters are present");
4704 self.tcx.sess.add_lint(lint::builtin::LATE_BOUND_LIFETIME_ARGUMENTS,
4705 lifetimes[0].id, lifetimes[0].span,
4706 format!("cannot specify lifetime arguments explicitly \
4707 if late bound lifetime parameters are present"));
4712 if lifetimes.len() > lifetime_defs.len() {
4713 let span = lifetimes[lifetime_defs.len()].span;
4714 let expected_text = count_lifetime_params(lifetime_defs.len());
4715 let actual_text = count_lifetime_params(lifetimes.len());
4716 struct_span_err!(self.tcx.sess, span, E0088,
4717 "too many lifetime parameters provided: \
4718 expected at most {}, found {}",
4719 expected_text, actual_text)
4720 .span_label(span, format!("expected {}", expected_text))
4722 } else if lifetimes.len() < required_len && !infer_lifetimes {
4723 let expected_text = count_lifetime_params(lifetime_defs.len());
4724 let actual_text = count_lifetime_params(lifetimes.len());
4725 struct_span_err!(self.tcx.sess, span, E0090,
4726 "too few lifetime parameters provided: \
4727 expected {}, found {}",
4728 expected_text, actual_text)
4729 .span_label(span, format!("expected {}", expected_text))
4734 fn structurally_resolve_type_or_else<F>(&self, sp: Span, ty: Ty<'tcx>, f: F)
4736 where F: Fn() -> Ty<'tcx>
4738 let mut ty = self.resolve_type_vars_with_obligations(ty);
4741 let alternative = f();
4744 if alternative.is_ty_var() || alternative.references_error() {
4745 if !self.is_tainted_by_errors() {
4746 type_error_struct!(self.tcx.sess, sp, ty, E0619,
4747 "the type of this value must be known in this context")
4750 self.demand_suptype(sp, self.tcx.types.err, ty);
4751 ty = self.tcx.types.err;
4753 self.demand_suptype(sp, alternative, ty);
4761 // Resolves `typ` by a single level if `typ` is a type variable. If no
4762 // resolution is possible, then an error is reported.
4763 pub fn structurally_resolved_type(&self, sp: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
4764 self.structurally_resolve_type_or_else(sp, ty, || {
4769 fn with_breakable_ctxt<F: FnOnce() -> R, R>(&self, id: ast::NodeId,
4770 ctxt: BreakableCtxt<'gcx, 'tcx>, f: F)
4771 -> (BreakableCtxt<'gcx, 'tcx>, R) {
4774 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4775 index = enclosing_breakables.stack.len();
4776 enclosing_breakables.by_id.insert(id, index);
4777 enclosing_breakables.stack.push(ctxt);
4781 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4782 debug_assert!(enclosing_breakables.stack.len() == index + 1);
4783 enclosing_breakables.by_id.remove(&id).expect("missing breakable context");
4784 enclosing_breakables.stack.pop().expect("missing breakable context")
4790 pub fn check_bounds_are_used<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
4791 generics: &hir::Generics,
4793 debug!("check_bounds_are_used(n_tps={}, ty={:?})",
4794 generics.ty_params.len(), ty);
4796 // make a vector of booleans initially false, set to true when used
4797 if generics.ty_params.is_empty() { return; }
4798 let mut tps_used = vec![false; generics.ty_params.len()];
4800 for leaf_ty in ty.walk() {
4801 if let ty::TyParam(ParamTy {idx, ..}) = leaf_ty.sty {
4802 debug!("Found use of ty param num {}", idx);
4803 tps_used[idx as usize - generics.lifetimes.len()] = true;
4807 for (&used, param) in tps_used.iter().zip(&generics.ty_params) {
4809 struct_span_err!(tcx.sess, param.span, E0091,
4810 "type parameter `{}` is unused",
4812 .span_label(param.span, "unused type parameter")