1 // Copyright 2012-2015 The Rust Project Developers. See the COPYRIGHT
2 // file at the top-level directory of this distribution and at
3 // http://rust-lang.org/COPYRIGHT.
5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
8 // option. This file may not be copied, modified, or distributed
9 // except according to those terms.
15 Within the check phase of type check, we check each item one at a time
16 (bodies of function expressions are checked as part of the containing
17 function). Inference is used to supply types wherever they are
20 By far the most complex case is checking the body of a function. This
21 can be broken down into several distinct phases:
23 - gather: creates type variables to represent the type of each local
24 variable and pattern binding.
26 - main: the main pass does the lion's share of the work: it
27 determines the types of all expressions, resolves
28 methods, checks for most invalid conditions, and so forth. In
29 some cases, where a type is unknown, it may create a type or region
30 variable and use that as the type of an expression.
32 In the process of checking, various constraints will be placed on
33 these type variables through the subtyping relationships requested
34 through the `demand` module. The `infer` module is in charge
35 of resolving those constraints.
37 - regionck: after main is complete, the regionck pass goes over all
38 types looking for regions and making sure that they did not escape
39 into places they are not in scope. This may also influence the
40 final assignments of the various region variables if there is some
43 - vtable: find and records the impls to use for each trait bound that
44 appears on a type parameter.
46 - writeback: writes the final types within a function body, replacing
47 type variables with their final inferred types. These final types
48 are written into the `tcx.node_types` table, which should *never* contain
49 any reference to a type variable.
53 While type checking a function, the intermediate types for the
54 expressions, blocks, and so forth contained within the function are
55 stored in `fcx.node_types` and `fcx.node_substs`. These types
56 may contain unresolved type variables. After type checking is
57 complete, the functions in the writeback module are used to take the
58 types from this table, resolve them, and then write them into their
59 permanent home in the type context `tcx`.
61 This means that during inferencing you should use `fcx.write_ty()`
62 and `fcx.expr_ty()` / `fcx.node_ty()` to write/obtain the types of
63 nodes within the function.
65 The types of top-level items, which never contain unbound type
66 variables, are stored directly into the `tcx` tables.
68 n.b.: A type variable is not the same thing as a type parameter. A
69 type variable is rather an "instance" of a type parameter: that is,
70 given a generic function `fn foo<T>(t: T)`: while checking the
71 function `foo`, the type `ty_param(0)` refers to the type `T`, which
72 is treated in abstract. When `foo()` is called, however, `T` will be
73 substituted for a fresh type variable `N`. This variable will
74 eventually be resolved to some concrete type (which might itself be
79 pub use self::Expectation::*;
80 use self::autoderef::Autoderef;
81 use self::callee::DeferredCallResolution;
82 use self::coercion::{CoerceMany, DynamicCoerceMany};
83 pub use self::compare_method::{compare_impl_method, compare_const_impl};
84 use self::method::MethodCallee;
85 use self::TupleArgumentsFlag::*;
88 use fmt_macros::{Parser, Piece, Position};
89 use hir::def::{Def, CtorKind};
90 use hir::def_id::{CrateNum, DefId, LOCAL_CRATE};
91 use rustc_back::slice::ref_slice;
92 use rustc::infer::{self, InferCtxt, InferOk, RegionVariableOrigin};
93 use rustc::infer::type_variable::{TypeVariableOrigin};
94 use rustc::middle::region::CodeExtent;
95 use rustc::ty::subst::{Kind, Subst, Substs};
96 use rustc::traits::{self, FulfillmentContext, ObligationCause, ObligationCauseCode};
97 use rustc::ty::{ParamTy, LvaluePreference, NoPreference, PreferMutLvalue};
98 use rustc::ty::{self, Ty, TyCtxt, Visibility};
99 use rustc::ty::adjustment::{Adjust, Adjustment, AutoBorrow};
100 use rustc::ty::fold::{BottomUpFolder, TypeFoldable};
101 use rustc::ty::maps::Providers;
102 use rustc::ty::util::{Representability, IntTypeExt};
103 use errors::DiagnosticBuilder;
104 use require_c_abi_if_variadic;
105 use session::{CompileIncomplete, Session};
108 use util::common::{ErrorReported, indenter};
109 use util::nodemap::{DefIdMap, FxHashMap, NodeMap};
111 use std::cell::{Cell, RefCell, Ref, RefMut};
112 use std::collections::hash_map::Entry;
114 use std::fmt::Display;
115 use std::mem::replace;
116 use std::ops::{self, Deref};
117 use syntax::abi::Abi;
119 use syntax::codemap::{self, original_sp, Spanned};
120 use syntax::feature_gate::{GateIssue, emit_feature_err};
122 use syntax::symbol::{Symbol, InternedString, keywords};
123 use syntax::util::lev_distance::find_best_match_for_name;
124 use syntax_pos::{self, BytePos, Span, MultiSpan};
126 use rustc::hir::intravisit::{self, Visitor, NestedVisitorMap};
127 use rustc::hir::itemlikevisit::ItemLikeVisitor;
128 use rustc::hir::map::Node;
129 use rustc::hir::{self, PatKind};
130 use rustc::middle::lang_items;
131 use rustc_back::slice;
132 use rustc::middle::const_val::eval_length;
133 use rustc_const_math::ConstInt;
152 /// A wrapper for InferCtxt's `in_progress_tables` field.
153 #[derive(Copy, Clone)]
154 struct MaybeInProgressTables<'a, 'tcx: 'a> {
155 maybe_tables: Option<&'a RefCell<ty::TypeckTables<'tcx>>>,
158 impl<'a, 'tcx> MaybeInProgressTables<'a, 'tcx> {
159 fn borrow(self) -> Ref<'a, ty::TypeckTables<'tcx>> {
160 match self.maybe_tables {
161 Some(tables) => tables.borrow(),
163 bug!("MaybeInProgressTables: inh/fcx.tables.borrow() with no tables")
168 fn borrow_mut(self) -> RefMut<'a, ty::TypeckTables<'tcx>> {
169 match self.maybe_tables {
170 Some(tables) => tables.borrow_mut(),
172 bug!("MaybeInProgressTables: inh/fcx.tables.borrow_mut() with no tables")
179 /// closures defined within the function. For example:
182 /// bar(move|| { ... })
185 /// Here, the function `foo()` and the closure passed to
186 /// `bar()` will each have their own `FnCtxt`, but they will
187 /// share the inherited fields.
188 pub struct Inherited<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
189 infcx: InferCtxt<'a, 'gcx, 'tcx>,
191 tables: MaybeInProgressTables<'a, 'tcx>,
193 locals: RefCell<NodeMap<Ty<'tcx>>>,
195 fulfillment_cx: RefCell<traits::FulfillmentContext<'tcx>>,
197 // When we process a call like `c()` where `c` is a closure type,
198 // we may not have decided yet whether `c` is a `Fn`, `FnMut`, or
199 // `FnOnce` closure. In that case, we defer full resolution of the
200 // call until upvar inference can kick in and make the
201 // decision. We keep these deferred resolutions grouped by the
202 // def-id of the closure, so that once we decide, we can easily go
203 // back and process them.
204 deferred_call_resolutions: RefCell<DefIdMap<Vec<DeferredCallResolution<'gcx, 'tcx>>>>,
206 deferred_cast_checks: RefCell<Vec<cast::CastCheck<'tcx>>>,
208 // Anonymized types found in explicit return types and their
209 // associated fresh inference variable. Writeback resolves these
210 // variables to get the concrete type, which can be used to
211 // deanonymize TyAnon, after typeck is done with all functions.
212 anon_types: RefCell<NodeMap<Ty<'tcx>>>,
214 /// Each type parameter has an implicit region bound that
215 /// indicates it must outlive at least the function body (the user
216 /// may specify stronger requirements). This field indicates the
217 /// region of the callee. If it is `None`, then the parameter
218 /// environment is for an item or something where the "callee" is
220 implicit_region_bound: Option<ty::Region<'tcx>>,
222 body_id: Option<hir::BodyId>,
225 impl<'a, 'gcx, 'tcx> Deref for Inherited<'a, 'gcx, 'tcx> {
226 type Target = InferCtxt<'a, 'gcx, 'tcx>;
227 fn deref(&self) -> &Self::Target {
232 /// When type-checking an expression, we propagate downward
233 /// whatever type hint we are able in the form of an `Expectation`.
234 #[derive(Copy, Clone, Debug)]
235 pub enum Expectation<'tcx> {
236 /// We know nothing about what type this expression should have.
239 /// This expression is an `if` condition, it must resolve to `bool`.
242 /// This expression should have the type given (or some subtype)
243 ExpectHasType(Ty<'tcx>),
245 /// This expression will be cast to the `Ty`
246 ExpectCastableToType(Ty<'tcx>),
248 /// This rvalue expression will be wrapped in `&` or `Box` and coerced
249 /// to `&Ty` or `Box<Ty>`, respectively. `Ty` is `[A]` or `Trait`.
250 ExpectRvalueLikeUnsized(Ty<'tcx>),
253 impl<'a, 'gcx, 'tcx> Expectation<'tcx> {
254 // Disregard "castable to" expectations because they
255 // can lead us astray. Consider for example `if cond
256 // {22} else {c} as u8` -- if we propagate the
257 // "castable to u8" constraint to 22, it will pick the
258 // type 22u8, which is overly constrained (c might not
259 // be a u8). In effect, the problem is that the
260 // "castable to" expectation is not the tightest thing
261 // we can say, so we want to drop it in this case.
262 // The tightest thing we can say is "must unify with
263 // else branch". Note that in the case of a "has type"
264 // constraint, this limitation does not hold.
266 // If the expected type is just a type variable, then don't use
267 // an expected type. Otherwise, we might write parts of the type
268 // when checking the 'then' block which are incompatible with the
270 fn adjust_for_branches(&self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) -> Expectation<'tcx> {
272 ExpectHasType(ety) => {
273 let ety = fcx.shallow_resolve(ety);
274 if !ety.is_ty_var() {
280 ExpectRvalueLikeUnsized(ety) => {
281 ExpectRvalueLikeUnsized(ety)
287 /// Provide an expectation for an rvalue expression given an *optional*
288 /// hint, which is not required for type safety (the resulting type might
289 /// be checked higher up, as is the case with `&expr` and `box expr`), but
290 /// is useful in determining the concrete type.
292 /// The primary use case is where the expected type is a fat pointer,
293 /// like `&[isize]`. For example, consider the following statement:
295 /// let x: &[isize] = &[1, 2, 3];
297 /// In this case, the expected type for the `&[1, 2, 3]` expression is
298 /// `&[isize]`. If however we were to say that `[1, 2, 3]` has the
299 /// expectation `ExpectHasType([isize])`, that would be too strong --
300 /// `[1, 2, 3]` does not have the type `[isize]` but rather `[isize; 3]`.
301 /// It is only the `&[1, 2, 3]` expression as a whole that can be coerced
302 /// to the type `&[isize]`. Therefore, we propagate this more limited hint,
303 /// which still is useful, because it informs integer literals and the like.
304 /// See the test case `test/run-pass/coerce-expect-unsized.rs` and #20169
305 /// for examples of where this comes up,.
306 fn rvalue_hint(fcx: &FnCtxt<'a, 'gcx, 'tcx>, ty: Ty<'tcx>) -> Expectation<'tcx> {
307 match fcx.tcx.struct_tail(ty).sty {
308 ty::TySlice(_) | ty::TyStr | ty::TyDynamic(..) => {
309 ExpectRvalueLikeUnsized(ty)
311 _ => ExpectHasType(ty)
315 // Resolves `expected` by a single level if it is a variable. If
316 // there is no expected type or resolution is not possible (e.g.,
317 // no constraints yet present), just returns `None`.
318 fn resolve(self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) -> Expectation<'tcx> {
320 NoExpectation => NoExpectation,
321 ExpectIfCondition => ExpectIfCondition,
322 ExpectCastableToType(t) => {
323 ExpectCastableToType(fcx.resolve_type_vars_if_possible(&t))
325 ExpectHasType(t) => {
326 ExpectHasType(fcx.resolve_type_vars_if_possible(&t))
328 ExpectRvalueLikeUnsized(t) => {
329 ExpectRvalueLikeUnsized(fcx.resolve_type_vars_if_possible(&t))
334 fn to_option(self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) -> Option<Ty<'tcx>> {
335 match self.resolve(fcx) {
336 NoExpectation => None,
337 ExpectIfCondition => Some(fcx.tcx.types.bool),
338 ExpectCastableToType(ty) |
340 ExpectRvalueLikeUnsized(ty) => Some(ty),
344 /// It sometimes happens that we want to turn an expectation into
345 /// a **hard constraint** (i.e., something that must be satisfied
346 /// for the program to type-check). `only_has_type` will return
347 /// such a constraint, if it exists.
348 fn only_has_type(self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) -> Option<Ty<'tcx>> {
349 match self.resolve(fcx) {
350 ExpectHasType(ty) => Some(ty),
351 ExpectIfCondition => Some(fcx.tcx.types.bool),
352 NoExpectation | ExpectCastableToType(_) | ExpectRvalueLikeUnsized(_) => None,
356 /// Like `only_has_type`, but instead of returning `None` if no
357 /// hard constraint exists, creates a fresh type variable.
358 fn coercion_target_type(self, fcx: &FnCtxt<'a, 'gcx, 'tcx>, span: Span) -> Ty<'tcx> {
359 self.only_has_type(fcx)
360 .unwrap_or_else(|| fcx.next_ty_var(TypeVariableOrigin::MiscVariable(span)))
364 #[derive(Copy, Clone)]
365 pub struct UnsafetyState {
366 pub def: ast::NodeId,
367 pub unsafety: hir::Unsafety,
368 pub unsafe_push_count: u32,
373 pub fn function(unsafety: hir::Unsafety, def: ast::NodeId) -> UnsafetyState {
374 UnsafetyState { def: def, unsafety: unsafety, unsafe_push_count: 0, from_fn: true }
377 pub fn recurse(&mut self, blk: &hir::Block) -> UnsafetyState {
378 match self.unsafety {
379 // If this unsafe, then if the outer function was already marked as
380 // unsafe we shouldn't attribute the unsafe'ness to the block. This
381 // way the block can be warned about instead of ignoring this
382 // extraneous block (functions are never warned about).
383 hir::Unsafety::Unsafe if self.from_fn => *self,
386 let (unsafety, def, count) = match blk.rules {
387 hir::PushUnsafeBlock(..) =>
388 (unsafety, blk.id, self.unsafe_push_count.checked_add(1).unwrap()),
389 hir::PopUnsafeBlock(..) =>
390 (unsafety, blk.id, self.unsafe_push_count.checked_sub(1).unwrap()),
391 hir::UnsafeBlock(..) =>
392 (hir::Unsafety::Unsafe, blk.id, self.unsafe_push_count),
394 (unsafety, self.def, self.unsafe_push_count),
396 UnsafetyState{ def: def,
398 unsafe_push_count: count,
405 #[derive(Debug, Copy, Clone)]
411 /// Tracks whether executing a node may exit normally (versus
412 /// return/break/panic, which "diverge", leaving dead code in their
413 /// wake). Tracked semi-automatically (through type variables marked
414 /// as diverging), with some manual adjustments for control-flow
415 /// primitives (approximating a CFG).
416 #[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
418 /// Potentially unknown, some cases converge,
419 /// others require a CFG to determine them.
422 /// Definitely known to diverge and therefore
423 /// not reach the next sibling or its parent.
426 /// Same as `Always` but with a reachability
427 /// warning already emitted
431 // Convenience impls for combinig `Diverges`.
433 impl ops::BitAnd for Diverges {
435 fn bitand(self, other: Self) -> Self {
436 cmp::min(self, other)
440 impl ops::BitOr for Diverges {
442 fn bitor(self, other: Self) -> Self {
443 cmp::max(self, other)
447 impl ops::BitAndAssign for Diverges {
448 fn bitand_assign(&mut self, other: Self) {
449 *self = *self & other;
453 impl ops::BitOrAssign for Diverges {
454 fn bitor_assign(&mut self, other: Self) {
455 *self = *self | other;
460 fn always(self) -> bool {
461 self >= Diverges::Always
465 pub struct BreakableCtxt<'gcx: 'tcx, 'tcx> {
468 // this is `null` for loops where break with a value is illegal,
469 // such as `while`, `for`, and `while let`
470 coerce: Option<DynamicCoerceMany<'gcx, 'tcx>>,
473 pub struct EnclosingBreakables<'gcx: 'tcx, 'tcx> {
474 stack: Vec<BreakableCtxt<'gcx, 'tcx>>,
475 by_id: NodeMap<usize>,
478 impl<'gcx, 'tcx> EnclosingBreakables<'gcx, 'tcx> {
479 fn find_breakable(&mut self, target_id: ast::NodeId) -> &mut BreakableCtxt<'gcx, 'tcx> {
480 let ix = *self.by_id.get(&target_id).unwrap_or_else(|| {
481 bug!("could not find enclosing breakable with id {}", target_id);
487 pub struct FnCtxt<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
488 body_id: ast::NodeId,
490 /// The parameter environment used for proving trait obligations
491 /// in this function. This can change when we descend into
492 /// closures (as they bring new things into scope), hence it is
493 /// not part of `Inherited` (as of the time of this writing,
494 /// closures do not yet change the environment, but they will
496 param_env: ty::ParamEnv<'tcx>,
498 // Number of errors that had been reported when we started
499 // checking this function. On exit, if we find that *more* errors
500 // have been reported, we will skip regionck and other work that
501 // expects the types within the function to be consistent.
502 err_count_on_creation: usize,
504 ret_coercion: Option<RefCell<DynamicCoerceMany<'gcx, 'tcx>>>,
506 ps: RefCell<UnsafetyState>,
508 /// Whether the last checked node generates a divergence (e.g.,
509 /// `return` will set this to Always). In general, when entering
510 /// an expression or other node in the tree, the initial value
511 /// indicates whether prior parts of the containing expression may
512 /// have diverged. It is then typically set to `Maybe` (and the
513 /// old value remembered) for processing the subparts of the
514 /// current expression. As each subpart is processed, they may set
515 /// the flag to `Always` etc. Finally, at the end, we take the
516 /// result and "union" it with the original value, so that when we
517 /// return the flag indicates if any subpart of the the parent
518 /// expression (up to and including this part) has diverged. So,
519 /// if you read it after evaluating a subexpression `X`, the value
520 /// you get indicates whether any subexpression that was
521 /// evaluating up to and including `X` diverged.
523 /// We use this flag for two purposes:
525 /// - To warn about unreachable code: if, after processing a
526 /// sub-expression but before we have applied the effects of the
527 /// current node, we see that the flag is set to `Always`, we
528 /// can issue a warning. This corresponds to something like
529 /// `foo(return)`; we warn on the `foo()` expression. (We then
530 /// update the flag to `WarnedAlways` to suppress duplicate
531 /// reports.) Similarly, if we traverse to a fresh statement (or
532 /// tail expression) from a `Always` setting, we will isssue a
533 /// warning. This corresponds to something like `{return;
534 /// foo();}` or `{return; 22}`, where we would warn on the
537 /// - To permit assignment into a local variable or other lvalue
538 /// (including the "return slot") of type `!`. This is allowed
539 /// if **either** the type of value being assigned is `!`, which
540 /// means the current code is dead, **or** the expression's
541 /// divering flag is true, which means that a divering value was
542 /// wrapped (e.g., `let x: ! = foo(return)`).
544 /// To repeat the last point: an expression represents dead-code
545 /// if, after checking it, **either** its type is `!` OR the
546 /// diverges flag is set to something other than `Maybe`.
547 diverges: Cell<Diverges>,
549 /// Whether any child nodes have any type errors.
550 has_errors: Cell<bool>,
552 enclosing_breakables: RefCell<EnclosingBreakables<'gcx, 'tcx>>,
554 inh: &'a Inherited<'a, 'gcx, 'tcx>,
557 impl<'a, 'gcx, 'tcx> Deref for FnCtxt<'a, 'gcx, 'tcx> {
558 type Target = Inherited<'a, 'gcx, 'tcx>;
559 fn deref(&self) -> &Self::Target {
564 /// Helper type of a temporary returned by Inherited::build(...).
565 /// Necessary because we can't write the following bound:
566 /// F: for<'b, 'tcx> where 'gcx: 'tcx FnOnce(Inherited<'b, 'gcx, 'tcx>).
567 pub struct InheritedBuilder<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
568 infcx: infer::InferCtxtBuilder<'a, 'gcx, 'tcx>,
572 impl<'a, 'gcx, 'tcx> Inherited<'a, 'gcx, 'tcx> {
573 pub fn build(tcx: TyCtxt<'a, 'gcx, 'gcx>, def_id: DefId)
574 -> InheritedBuilder<'a, 'gcx, 'tcx> {
576 infcx: tcx.infer_ctxt().with_fresh_in_progress_tables(),
582 impl<'a, 'gcx, 'tcx> InheritedBuilder<'a, 'gcx, 'tcx> {
583 fn enter<F, R>(&'tcx mut self, f: F) -> R
584 where F: for<'b> FnOnce(Inherited<'b, 'gcx, 'tcx>) -> R
586 let def_id = self.def_id;
587 self.infcx.enter(|infcx| f(Inherited::new(infcx, def_id)))
591 impl<'a, 'gcx, 'tcx> Inherited<'a, 'gcx, 'tcx> {
592 fn new(infcx: InferCtxt<'a, 'gcx, 'tcx>, def_id: DefId) -> Self {
594 let item_id = tcx.hir.as_local_node_id(def_id);
595 let body_id = item_id.and_then(|id| tcx.hir.maybe_body_owned_by(id));
596 let implicit_region_bound = body_id.map(|body| {
597 tcx.mk_region(ty::ReScope(CodeExtent::CallSiteScope(body)))
601 tables: MaybeInProgressTables {
602 maybe_tables: infcx.in_progress_tables,
605 fulfillment_cx: RefCell::new(traits::FulfillmentContext::new()),
606 locals: RefCell::new(NodeMap()),
607 deferred_call_resolutions: RefCell::new(DefIdMap()),
608 deferred_cast_checks: RefCell::new(Vec::new()),
609 anon_types: RefCell::new(NodeMap()),
610 implicit_region_bound,
615 fn register_predicate(&self, obligation: traits::PredicateObligation<'tcx>) {
616 debug!("register_predicate({:?})", obligation);
617 if obligation.has_escaping_regions() {
618 span_bug!(obligation.cause.span, "escaping regions in predicate {:?}",
623 .register_predicate_obligation(self, obligation);
626 fn register_predicates<I>(&self, obligations: I)
627 where I: IntoIterator<Item = traits::PredicateObligation<'tcx>> {
628 for obligation in obligations {
629 self.register_predicate(obligation);
633 fn register_infer_ok_obligations<T>(&self, infer_ok: InferOk<'tcx, T>) -> T {
634 self.register_predicates(infer_ok.obligations);
638 fn normalize_associated_types_in<T>(&self,
640 body_id: ast::NodeId,
641 param_env: ty::ParamEnv<'tcx>,
643 where T : TypeFoldable<'tcx>
645 let ok = self.normalize_associated_types_in_as_infer_ok(span, body_id, param_env, value);
646 self.register_infer_ok_obligations(ok)
649 fn normalize_associated_types_in_as_infer_ok<T>(&self,
651 body_id: ast::NodeId,
652 param_env: ty::ParamEnv<'tcx>,
655 where T : TypeFoldable<'tcx>
657 debug!("normalize_associated_types_in(value={:?})", value);
658 let mut selcx = traits::SelectionContext::new(self);
659 let cause = ObligationCause::misc(span, body_id);
660 let traits::Normalized { value, obligations } =
661 traits::normalize(&mut selcx, param_env, cause, value);
662 debug!("normalize_associated_types_in: result={:?} predicates={:?}",
665 InferOk { value, obligations }
668 /// Replace any late-bound regions bound in `value` with
669 /// free variants attached to `all_outlive_scope`.
670 fn liberate_late_bound_regions<T>(&self,
671 all_outlive_scope: DefId,
672 value: &ty::Binder<T>)
674 where T: TypeFoldable<'tcx>
676 self.tcx.replace_late_bound_regions(value, |br| {
677 self.tcx.mk_region(ty::ReFree(ty::FreeRegion {
678 scope: all_outlive_scope,
685 struct CheckItemTypesVisitor<'a, 'tcx: 'a> { tcx: TyCtxt<'a, 'tcx, 'tcx> }
687 impl<'a, 'tcx> ItemLikeVisitor<'tcx> for CheckItemTypesVisitor<'a, 'tcx> {
688 fn visit_item(&mut self, i: &'tcx hir::Item) {
689 check_item_type(self.tcx, i);
691 fn visit_trait_item(&mut self, _: &'tcx hir::TraitItem) { }
692 fn visit_impl_item(&mut self, _: &'tcx hir::ImplItem) { }
695 pub fn check_wf_new<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Result<(), ErrorReported> {
696 tcx.sess.track_errors(|| {
697 let mut visit = wfcheck::CheckTypeWellFormedVisitor::new(tcx);
698 tcx.hir.krate().visit_all_item_likes(&mut visit.as_deep_visitor());
702 pub fn check_item_types<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Result<(), ErrorReported> {
703 tcx.sess.track_errors(|| {
704 tcx.hir.krate().visit_all_item_likes(&mut CheckItemTypesVisitor { tcx });
708 pub fn check_item_bodies<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Result<(), CompileIncomplete> {
709 tcx.typeck_item_bodies(LOCAL_CRATE)
712 fn typeck_item_bodies<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, crate_num: CrateNum)
713 -> Result<(), CompileIncomplete>
715 debug_assert!(crate_num == LOCAL_CRATE);
716 Ok(tcx.sess.track_errors(|| {
717 for body_owner_def_id in tcx.body_owners() {
718 tcx.typeck_tables_of(body_owner_def_id);
723 pub fn provide(providers: &mut Providers) {
724 *providers = Providers {
734 fn closure_kind<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
737 let node_id = tcx.hir.as_local_node_id(def_id).unwrap();
738 tcx.typeck_tables_of(def_id).closure_kinds[&node_id].0
741 fn adt_destructor<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
743 -> Option<ty::Destructor> {
744 tcx.calculate_dtor(def_id, &mut dropck::check_drop_impl)
747 /// If this def-id is a "primary tables entry", returns `Some((body_id, decl))`
748 /// with information about it's body-id and fn-decl (if any). Otherwise,
751 /// If this function returns "some", then `typeck_tables(def_id)` will
752 /// succeed; if it returns `None`, then `typeck_tables(def_id)` may or
753 /// may not succeed. In some cases where this function returns `None`
754 /// (notably closures), `typeck_tables(def_id)` would wind up
755 /// redirecting to the owning function.
756 fn primary_body_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
758 -> Option<(hir::BodyId, Option<&'tcx hir::FnDecl>)>
760 match tcx.hir.get(id) {
761 hir::map::NodeItem(item) => {
763 hir::ItemConst(_, body) |
764 hir::ItemStatic(_, _, body) =>
766 hir::ItemFn(ref decl, .., body) =>
767 Some((body, Some(decl))),
772 hir::map::NodeTraitItem(item) => {
774 hir::TraitItemKind::Const(_, Some(body)) =>
776 hir::TraitItemKind::Method(ref sig, hir::TraitMethod::Provided(body)) =>
777 Some((body, Some(&sig.decl))),
782 hir::map::NodeImplItem(item) => {
784 hir::ImplItemKind::Const(_, body) =>
786 hir::ImplItemKind::Method(ref sig, body) =>
787 Some((body, Some(&sig.decl))),
792 hir::map::NodeExpr(expr) => {
793 // FIXME(eddyb) Closures should have separate
794 // function definition IDs and expression IDs.
795 // Type-checking should not let closures get
796 // this far in a constant position.
797 // Assume that everything other than closures
798 // is a constant "initializer" expression.
800 hir::ExprClosure(..) =>
803 Some((hir::BodyId { node_id: expr.id }, None)),
810 fn has_typeck_tables<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
813 // Closures' tables come from their outermost function,
814 // as they are part of the same "inference environment".
815 let outer_def_id = tcx.closure_base_def_id(def_id);
816 if outer_def_id != def_id {
817 return tcx.has_typeck_tables(outer_def_id);
820 let id = tcx.hir.as_local_node_id(def_id).unwrap();
821 primary_body_of(tcx, id).is_some()
824 fn typeck_tables_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
826 -> &'tcx ty::TypeckTables<'tcx> {
827 // Closures' tables come from their outermost function,
828 // as they are part of the same "inference environment".
829 let outer_def_id = tcx.closure_base_def_id(def_id);
830 if outer_def_id != def_id {
831 return tcx.typeck_tables_of(outer_def_id);
834 let id = tcx.hir.as_local_node_id(def_id).unwrap();
835 let span = tcx.hir.span(id);
837 // Figure out what primary body this item has.
838 let (body_id, fn_decl) = primary_body_of(tcx, id).unwrap_or_else(|| {
839 span_bug!(span, "can't type-check body of {:?}", def_id);
841 let body = tcx.hir.body(body_id);
843 Inherited::build(tcx, def_id).enter(|inh| {
844 let param_env = tcx.param_env(def_id);
845 let fcx = if let Some(decl) = fn_decl {
846 let fn_sig = tcx.fn_sig(def_id);
848 check_abi(tcx, span, fn_sig.abi());
850 // Compute the fty from point of view of inside fn.
852 inh.liberate_late_bound_regions(def_id, &fn_sig);
854 inh.normalize_associated_types_in(body.value.span,
859 check_fn(&inh, param_env, fn_sig, decl, id, body)
861 let fcx = FnCtxt::new(&inh, param_env, body.value.id);
862 let expected_type = tcx.type_of(def_id);
863 let expected_type = fcx.normalize_associated_types_in(body.value.span, &expected_type);
864 fcx.require_type_is_sized(expected_type, body.value.span, traits::ConstSized);
866 // Gather locals in statics (because of block expressions).
867 // This is technically unnecessary because locals in static items are forbidden,
868 // but prevents type checking from blowing up before const checking can properly
870 GatherLocalsVisitor { fcx: &fcx }.visit_body(body);
872 fcx.check_expr_coercable_to_type(&body.value, expected_type);
877 fcx.select_all_obligations_and_apply_defaults();
878 fcx.closure_analyze(body);
879 fcx.select_obligations_where_possible();
881 fcx.select_all_obligations_or_error();
883 if fn_decl.is_some() {
884 fcx.regionck_fn(id, body);
886 fcx.regionck_expr(body);
889 fcx.resolve_type_vars_in_body(body)
893 fn check_abi<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, span: Span, abi: Abi) {
894 if !tcx.sess.target.target.is_abi_supported(abi) {
895 struct_span_err!(tcx.sess, span, E0570,
896 "The ABI `{}` is not supported for the current target", abi).emit()
900 struct GatherLocalsVisitor<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
901 fcx: &'a FnCtxt<'a, 'gcx, 'tcx>
904 impl<'a, 'gcx, 'tcx> GatherLocalsVisitor<'a, 'gcx, 'tcx> {
905 fn assign(&mut self, span: Span, nid: ast::NodeId, ty_opt: Option<Ty<'tcx>>) -> Ty<'tcx> {
908 // infer the variable's type
909 let var_ty = self.fcx.next_ty_var(TypeVariableOrigin::TypeInference(span));
910 self.fcx.locals.borrow_mut().insert(nid, var_ty);
914 // take type that the user specified
915 self.fcx.locals.borrow_mut().insert(nid, typ);
922 impl<'a, 'gcx, 'tcx> Visitor<'gcx> for GatherLocalsVisitor<'a, 'gcx, 'tcx> {
923 fn nested_visit_map<'this>(&'this mut self) -> NestedVisitorMap<'this, 'gcx> {
924 NestedVisitorMap::None
927 // Add explicitly-declared locals.
928 fn visit_local(&mut self, local: &'gcx hir::Local) {
929 let o_ty = match local.ty {
930 Some(ref ty) => Some(self.fcx.to_ty(&ty)),
933 self.assign(local.span, local.id, o_ty);
934 debug!("Local variable {:?} is assigned type {}",
936 self.fcx.ty_to_string(
937 self.fcx.locals.borrow().get(&local.id).unwrap().clone()));
938 intravisit::walk_local(self, local);
941 // Add pattern bindings.
942 fn visit_pat(&mut self, p: &'gcx hir::Pat) {
943 if let PatKind::Binding(_, _, ref path1, _) = p.node {
944 let var_ty = self.assign(p.span, p.id, None);
946 self.fcx.require_type_is_sized(var_ty, p.span,
947 traits::VariableType(p.id));
949 debug!("Pattern binding {} is assigned to {} with type {:?}",
951 self.fcx.ty_to_string(
952 self.fcx.locals.borrow().get(&p.id).unwrap().clone()),
955 intravisit::walk_pat(self, p);
958 // Don't descend into the bodies of nested closures
959 fn visit_fn(&mut self, _: intravisit::FnKind<'gcx>, _: &'gcx hir::FnDecl,
960 _: hir::BodyId, _: Span, _: ast::NodeId) { }
963 /// Helper used for fns and closures. Does the grungy work of checking a function
964 /// body and returns the function context used for that purpose, since in the case of a fn item
965 /// there is still a bit more to do.
968 /// * inherited: other fields inherited from the enclosing fn (if any)
969 fn check_fn<'a, 'gcx, 'tcx>(inherited: &'a Inherited<'a, 'gcx, 'tcx>,
970 param_env: ty::ParamEnv<'tcx>,
971 fn_sig: ty::FnSig<'tcx>,
972 decl: &'gcx hir::FnDecl,
974 body: &'gcx hir::Body)
975 -> FnCtxt<'a, 'gcx, 'tcx>
977 let mut fn_sig = fn_sig.clone();
979 debug!("check_fn(sig={:?}, fn_id={}, param_env={:?})", fn_sig, fn_id, param_env);
981 // Create the function context. This is either derived from scratch or,
982 // in the case of function expressions, based on the outer context.
983 let mut fcx = FnCtxt::new(inherited, param_env, body.value.id);
984 *fcx.ps.borrow_mut() = UnsafetyState::function(fn_sig.unsafety, fn_id);
986 let ret_ty = fn_sig.output();
987 fcx.require_type_is_sized(ret_ty, decl.output.span(), traits::SizedReturnType);
988 let ret_ty = fcx.instantiate_anon_types(&ret_ty);
989 fcx.ret_coercion = Some(RefCell::new(CoerceMany::new(ret_ty)));
990 fn_sig = fcx.tcx.mk_fn_sig(
991 fn_sig.inputs().iter().cloned(),
998 GatherLocalsVisitor { fcx: &fcx, }.visit_body(body);
1000 // Add formal parameters.
1001 for (arg_ty, arg) in fn_sig.inputs().iter().zip(&body.arguments) {
1002 // Check the pattern.
1003 fcx.check_pat_arg(&arg.pat, arg_ty, true);
1005 // Check that argument is Sized.
1006 // The check for a non-trivial pattern is a hack to avoid duplicate warnings
1007 // for simple cases like `fn foo(x: Trait)`,
1008 // where we would error once on the parameter as a whole, and once on the binding `x`.
1009 if arg.pat.simple_name().is_none() {
1010 fcx.require_type_is_sized(arg_ty, decl.output.span(), traits::MiscObligation);
1013 fcx.write_ty(arg.id, arg_ty);
1016 inherited.tables.borrow_mut().liberated_fn_sigs.insert(fn_id, fn_sig);
1018 fcx.check_return_expr(&body.value);
1020 // Finalize the return check by taking the LUB of the return types
1021 // we saw and assigning it to the expected return type. This isn't
1022 // really expected to fail, since the coercions would have failed
1023 // earlier when trying to find a LUB.
1025 // However, the behavior around `!` is sort of complex. In the
1026 // event that the `actual_return_ty` comes back as `!`, that
1027 // indicates that the fn either does not return or "returns" only
1028 // values of type `!`. In this case, if there is an expected
1029 // return type that is *not* `!`, that should be ok. But if the
1030 // return type is being inferred, we want to "fallback" to `!`:
1032 // let x = move || panic!();
1034 // To allow for that, I am creating a type variable with diverging
1035 // fallback. This was deemed ever so slightly better than unifying
1036 // the return value with `!` because it allows for the caller to
1037 // make more assumptions about the return type (e.g., they could do
1039 // let y: Option<u32> = Some(x());
1041 // which would then cause this return type to become `u32`, not
1043 let coercion = fcx.ret_coercion.take().unwrap().into_inner();
1044 let mut actual_return_ty = coercion.complete(&fcx);
1045 if actual_return_ty.is_never() {
1046 actual_return_ty = fcx.next_diverging_ty_var(
1047 TypeVariableOrigin::DivergingFn(body.value.span));
1049 fcx.demand_suptype(body.value.span, ret_ty, actual_return_ty);
1054 fn check_struct<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1057 let def_id = tcx.hir.local_def_id(id);
1058 let def = tcx.adt_def(def_id);
1059 def.destructor(tcx); // force the destructor to be evaluated
1060 check_representable(tcx, span, def_id);
1062 if def.repr.simd() {
1063 check_simd(tcx, span, def_id);
1066 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);
1077 check_packed(tcx, span, def_id);
1080 pub fn check_item_type<'a,'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, it: &'tcx hir::Item) {
1081 debug!("check_item_type(it.id={}, it.name={})",
1083 tcx.item_path_str(tcx.hir.local_def_id(it.id)));
1084 let _indenter = indenter();
1086 // Consts can play a role in type-checking, so they are included here.
1087 hir::ItemStatic(..) |
1088 hir::ItemConst(..) => {
1089 tcx.typeck_tables_of(tcx.hir.local_def_id(it.id));
1091 hir::ItemEnum(ref enum_definition, _) => {
1094 &enum_definition.variants,
1097 hir::ItemFn(..) => {} // entirely within check_item_body
1098 hir::ItemImpl(.., ref impl_item_refs) => {
1099 debug!("ItemImpl {} with id {}", it.name, it.id);
1100 let impl_def_id = tcx.hir.local_def_id(it.id);
1101 if let Some(impl_trait_ref) = tcx.impl_trait_ref(impl_def_id) {
1102 check_impl_items_against_trait(tcx,
1107 let trait_def_id = impl_trait_ref.def_id;
1108 check_on_unimplemented(tcx, trait_def_id, it);
1111 hir::ItemTrait(..) => {
1112 let def_id = tcx.hir.local_def_id(it.id);
1113 check_on_unimplemented(tcx, def_id, it);
1115 hir::ItemStruct(..) => {
1116 check_struct(tcx, it.id, it.span);
1118 hir::ItemUnion(..) => {
1119 check_union(tcx, it.id, it.span);
1121 hir::ItemTy(_, ref generics) => {
1122 let def_id = tcx.hir.local_def_id(it.id);
1123 let pty_ty = tcx.type_of(def_id);
1124 check_bounds_are_used(tcx, generics, pty_ty);
1126 hir::ItemForeignMod(ref m) => {
1127 check_abi(tcx, it.span, m.abi);
1129 if m.abi == Abi::RustIntrinsic {
1130 for item in &m.items {
1131 intrinsic::check_intrinsic_type(tcx, item);
1133 } else if m.abi == Abi::PlatformIntrinsic {
1134 for item in &m.items {
1135 intrinsic::check_platform_intrinsic_type(tcx, item);
1138 for item in &m.items {
1139 let generics = tcx.generics_of(tcx.hir.local_def_id(item.id));
1140 if !generics.types.is_empty() {
1141 let mut err = struct_span_err!(tcx.sess, item.span, E0044,
1142 "foreign items may not have type parameters");
1143 span_help!(&mut err, item.span,
1144 "consider using specialization instead of \
1149 if let hir::ForeignItemFn(ref fn_decl, _, _) = item.node {
1150 require_c_abi_if_variadic(tcx, fn_decl, m.abi, item.span);
1155 _ => {/* nothing to do */ }
1159 fn check_on_unimplemented<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1162 let generics = tcx.generics_of(def_id);
1163 if let Some(ref attr) = item.attrs.iter().find(|a| {
1164 a.check_name("rustc_on_unimplemented")
1166 if let Some(istring) = attr.value_str() {
1167 let istring = istring.as_str();
1168 let name = tcx.item_name(def_id).as_str();
1169 let parser = Parser::new(&istring);
1170 let types = &generics.types;
1171 for token in parser {
1173 Piece::String(_) => (), // Normal string, no need to check it
1174 Piece::NextArgument(a) => match a.position {
1175 // `{Self}` is allowed
1176 Position::ArgumentNamed(s) if s == "Self" => (),
1177 // `{ThisTraitsName}` is allowed
1178 Position::ArgumentNamed(s) if s == name => (),
1179 // So is `{A}` if A is a type parameter
1180 Position::ArgumentNamed(s) => match types.iter().find(|t| {
1185 span_err!(tcx.sess, attr.span, E0230,
1186 "there is no type parameter \
1191 // `{:1}` and `{}` are not to be used
1192 Position::ArgumentIs(_) => {
1193 span_err!(tcx.sess, attr.span, E0231,
1194 "only named substitution \
1195 parameters are allowed");
1202 tcx.sess, attr.span, E0232,
1203 "this attribute must have a value")
1204 .span_label(attr.span, "attribute requires a value")
1205 .note(&format!("eg `#[rustc_on_unimplemented = \"foo\"]`"))
1211 fn report_forbidden_specialization<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1212 impl_item: &hir::ImplItem,
1215 let mut err = struct_span_err!(
1216 tcx.sess, impl_item.span, E0520,
1217 "`{}` specializes an item from a parent `impl`, but \
1218 that item is not marked `default`",
1220 err.span_label(impl_item.span, format!("cannot specialize default item `{}`",
1223 match tcx.span_of_impl(parent_impl) {
1225 err.span_label(span, "parent `impl` is here");
1226 err.note(&format!("to specialize, `{}` in the parent `impl` must be marked `default`",
1230 err.note(&format!("parent implementation is in crate `{}`", cname));
1237 fn check_specialization_validity<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1238 trait_def: &ty::TraitDef,
1240 impl_item: &hir::ImplItem)
1242 let ancestors = trait_def.ancestors(tcx, impl_id);
1244 let kind = match impl_item.node {
1245 hir::ImplItemKind::Const(..) => ty::AssociatedKind::Const,
1246 hir::ImplItemKind::Method(..) => ty::AssociatedKind::Method,
1247 hir::ImplItemKind::Type(_) => ty::AssociatedKind::Type
1249 let parent = ancestors.defs(tcx, impl_item.name, kind).skip(1).next()
1250 .map(|node_item| node_item.map(|parent| parent.defaultness));
1252 if let Some(parent) = parent {
1253 if tcx.impl_item_is_final(&parent) {
1254 report_forbidden_specialization(tcx, impl_item, parent.node.def_id());
1260 fn check_impl_items_against_trait<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1263 impl_trait_ref: ty::TraitRef<'tcx>,
1264 impl_item_refs: &[hir::ImplItemRef]) {
1265 // If the trait reference itself is erroneous (so the compilation is going
1266 // to fail), skip checking the items here -- the `impl_item` table in `tcx`
1267 // isn't populated for such impls.
1268 if impl_trait_ref.references_error() { return; }
1270 // Locate trait definition and items
1271 let trait_def = tcx.trait_def(impl_trait_ref.def_id);
1272 let mut overridden_associated_type = None;
1274 let impl_items = || impl_item_refs.iter().map(|iiref| tcx.hir.impl_item(iiref.id));
1276 // Check existing impl methods to see if they are both present in trait
1277 // and compatible with trait signature
1278 for impl_item in impl_items() {
1279 let ty_impl_item = tcx.associated_item(tcx.hir.local_def_id(impl_item.id));
1280 let ty_trait_item = tcx.associated_items(impl_trait_ref.def_id)
1281 .find(|ac| ac.name == ty_impl_item.name);
1283 // Check that impl definition matches trait definition
1284 if let Some(ty_trait_item) = ty_trait_item {
1285 match impl_item.node {
1286 hir::ImplItemKind::Const(..) => {
1287 // Find associated const definition.
1288 if ty_trait_item.kind == ty::AssociatedKind::Const {
1289 compare_const_impl(tcx,
1295 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0323,
1296 "item `{}` is an associated const, \
1297 which doesn't match its trait `{}`",
1300 err.span_label(impl_item.span, "does not match trait");
1301 // We can only get the spans from local trait definition
1302 // Same for E0324 and E0325
1303 if let Some(trait_span) = tcx.hir.span_if_local(ty_trait_item.def_id) {
1304 err.span_label(trait_span, "item in trait");
1309 hir::ImplItemKind::Method(..) => {
1310 let trait_span = tcx.hir.span_if_local(ty_trait_item.def_id);
1311 if ty_trait_item.kind == ty::AssociatedKind::Method {
1312 let err_count = tcx.sess.err_count();
1313 compare_impl_method(tcx,
1319 true); // start with old-broken-mode
1320 if err_count == tcx.sess.err_count() {
1321 // old broken mode did not report an error. Try with the new mode.
1322 compare_impl_method(tcx,
1328 false); // use the new mode
1331 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0324,
1332 "item `{}` is an associated method, \
1333 which doesn't match its trait `{}`",
1336 err.span_label(impl_item.span, "does not match trait");
1337 if let Some(trait_span) = tcx.hir.span_if_local(ty_trait_item.def_id) {
1338 err.span_label(trait_span, "item in trait");
1343 hir::ImplItemKind::Type(_) => {
1344 if ty_trait_item.kind == ty::AssociatedKind::Type {
1345 if ty_trait_item.defaultness.has_value() {
1346 overridden_associated_type = Some(impl_item);
1349 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0325,
1350 "item `{}` is an associated type, \
1351 which doesn't match its trait `{}`",
1354 err.span_label(impl_item.span, "does not match trait");
1355 if let Some(trait_span) = tcx.hir.span_if_local(ty_trait_item.def_id) {
1356 err.span_label(trait_span, "item in trait");
1364 check_specialization_validity(tcx, trait_def, impl_id, impl_item);
1367 // Check for missing items from trait
1368 let mut missing_items = Vec::new();
1369 let mut invalidated_items = Vec::new();
1370 let associated_type_overridden = overridden_associated_type.is_some();
1371 for trait_item in tcx.associated_items(impl_trait_ref.def_id) {
1372 let is_implemented = trait_def.ancestors(tcx, impl_id)
1373 .defs(tcx, trait_item.name, trait_item.kind)
1375 .map(|node_item| !node_item.node.is_from_trait())
1378 if !is_implemented {
1379 if !trait_item.defaultness.has_value() {
1380 missing_items.push(trait_item);
1381 } else if associated_type_overridden {
1382 invalidated_items.push(trait_item.name);
1387 if !missing_items.is_empty() {
1388 let mut err = struct_span_err!(tcx.sess, impl_span, E0046,
1389 "not all trait items implemented, missing: `{}`",
1390 missing_items.iter()
1391 .map(|trait_item| trait_item.name.to_string())
1392 .collect::<Vec<_>>().join("`, `"));
1393 err.span_label(impl_span, format!("missing `{}` in implementation",
1394 missing_items.iter()
1395 .map(|trait_item| trait_item.name.to_string())
1396 .collect::<Vec<_>>().join("`, `")));
1397 for trait_item in missing_items {
1398 if let Some(span) = tcx.hir.span_if_local(trait_item.def_id) {
1399 err.span_label(span, format!("`{}` from trait", trait_item.name));
1401 err.note_trait_signature(trait_item.name.to_string(),
1402 trait_item.signature(&tcx));
1408 if !invalidated_items.is_empty() {
1409 let invalidator = overridden_associated_type.unwrap();
1410 span_err!(tcx.sess, invalidator.span, E0399,
1411 "the following trait items need to be reimplemented \
1412 as `{}` was overridden: `{}`",
1414 invalidated_items.iter()
1415 .map(|name| name.to_string())
1416 .collect::<Vec<_>>().join("`, `"))
1420 /// Checks whether a type can be represented in memory. In particular, it
1421 /// identifies types that contain themselves without indirection through a
1422 /// pointer, which would mean their size is unbounded.
1423 fn check_representable<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1427 let rty = tcx.type_of(item_def_id);
1429 // Check that it is possible to represent this type. This call identifies
1430 // (1) types that contain themselves and (2) types that contain a different
1431 // recursive type. It is only necessary to throw an error on those that
1432 // contain themselves. For case 2, there must be an inner type that will be
1433 // caught by case 1.
1434 match rty.is_representable(tcx, sp) {
1435 Representability::SelfRecursive(spans) => {
1436 let mut err = tcx.recursive_type_with_infinite_size_error(item_def_id);
1438 err.span_label(span, "recursive without indirection");
1443 Representability::Representable | Representability::ContainsRecursive => (),
1448 pub fn check_simd<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, sp: Span, def_id: DefId) {
1449 let t = tcx.type_of(def_id);
1451 ty::TyAdt(def, substs) if def.is_struct() => {
1452 let fields = &def.struct_variant().fields;
1453 if fields.is_empty() {
1454 span_err!(tcx.sess, sp, E0075, "SIMD vector cannot be empty");
1457 let e = fields[0].ty(tcx, substs);
1458 if !fields.iter().all(|f| f.ty(tcx, substs) == e) {
1459 struct_span_err!(tcx.sess, sp, E0076, "SIMD vector should be homogeneous")
1460 .span_label(sp, "SIMD elements must have the same type")
1465 ty::TyParam(_) => { /* struct<T>(T, T, T, T) is ok */ }
1466 _ if e.is_machine() => { /* struct(u8, u8, u8, u8) is ok */ }
1468 span_err!(tcx.sess, sp, E0077,
1469 "SIMD vector element type should be machine type");
1478 fn check_packed<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, sp: Span, def_id: DefId) {
1479 if tcx.adt_def(def_id).repr.packed() {
1480 if tcx.adt_def(def_id).repr.align > 0 {
1481 struct_span_err!(tcx.sess, sp, E0587,
1482 "type has conflicting packed and align representation hints").emit();
1484 else if check_packed_inner(tcx, def_id, &mut Vec::new()) {
1485 struct_span_err!(tcx.sess, sp, E0588,
1486 "packed type cannot transitively contain a `[repr(align)]` type").emit();
1491 fn check_packed_inner<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1493 stack: &mut Vec<DefId>) -> bool {
1494 let t = tcx.type_of(def_id);
1495 if stack.contains(&def_id) {
1496 debug!("check_packed_inner: {:?} is recursive", t);
1500 ty::TyAdt(def, substs) if def.is_struct() || def.is_union() => {
1501 if tcx.adt_def(def.did).repr.align > 0 {
1504 // push struct def_id before checking fields
1506 for field in &def.struct_variant().fields {
1507 let f = field.ty(tcx, substs);
1509 ty::TyAdt(def, _) => {
1510 if check_packed_inner(tcx, def.did, stack) {
1517 // only need to pop if not early out
1525 #[allow(trivial_numeric_casts)]
1526 pub fn check_enum<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1528 vs: &'tcx [hir::Variant],
1530 let def_id = tcx.hir.local_def_id(id);
1531 let def = tcx.adt_def(def_id);
1532 def.destructor(tcx); // force the destructor to be evaluated
1534 if vs.is_empty() && tcx.has_attr(def_id, "repr") {
1536 tcx.sess, sp, E0084,
1537 "unsupported representation for zero-variant enum")
1538 .span_label(sp, "unsupported enum representation")
1542 let repr_type_ty = def.repr.discr_type().to_ty(tcx);
1543 if repr_type_ty == tcx.types.i128 || repr_type_ty == tcx.types.u128 {
1544 if !tcx.sess.features.borrow().i128_type {
1545 emit_feature_err(&tcx.sess.parse_sess,
1546 "i128_type", sp, GateIssue::Language, "128-bit type is unstable");
1551 if let Some(e) = v.node.disr_expr {
1552 tcx.typeck_tables_of(tcx.hir.local_def_id(e.node_id));
1556 let mut disr_vals: Vec<ConstInt> = Vec::new();
1557 for (discr, v) in def.discriminants(tcx).zip(vs) {
1558 // Check for duplicate discriminant values
1559 if let Some(i) = disr_vals.iter().position(|&x| x == discr) {
1560 let variant_i_node_id = tcx.hir.as_local_node_id(def.variants[i].did).unwrap();
1561 let variant_i = tcx.hir.expect_variant(variant_i_node_id);
1562 let i_span = match variant_i.node.disr_expr {
1563 Some(expr) => tcx.hir.span(expr.node_id),
1564 None => tcx.hir.span(variant_i_node_id)
1566 let span = match v.node.disr_expr {
1567 Some(expr) => tcx.hir.span(expr.node_id),
1570 struct_span_err!(tcx.sess, span, E0081,
1571 "discriminant value `{}` already exists", disr_vals[i])
1572 .span_label(i_span, format!("first use of `{}`", disr_vals[i]))
1573 .span_label(span , format!("enum already has `{}`", disr_vals[i]))
1576 disr_vals.push(discr);
1579 check_representable(tcx, sp, def_id);
1582 impl<'a, 'gcx, 'tcx> AstConv<'gcx, 'tcx> for FnCtxt<'a, 'gcx, 'tcx> {
1583 fn tcx<'b>(&'b self) -> TyCtxt<'b, 'gcx, 'tcx> { self.tcx }
1585 fn get_type_parameter_bounds(&self, _: Span, def_id: DefId)
1586 -> ty::GenericPredicates<'tcx>
1589 let node_id = tcx.hir.as_local_node_id(def_id).unwrap();
1590 let item_id = tcx.hir.ty_param_owner(node_id);
1591 let item_def_id = tcx.hir.local_def_id(item_id);
1592 let generics = tcx.generics_of(item_def_id);
1593 let index = generics.type_param_to_index[&def_id.index];
1594 ty::GenericPredicates {
1596 predicates: self.param_env.caller_bounds.iter().filter(|predicate| {
1598 ty::Predicate::Trait(ref data) => {
1599 data.0.self_ty().is_param(index)
1603 }).cloned().collect()
1607 fn re_infer(&self, span: Span, def: Option<&ty::RegionParameterDef>)
1608 -> Option<ty::Region<'tcx>> {
1610 Some(def) => infer::EarlyBoundRegion(span, def.name),
1611 None => infer::MiscVariable(span)
1613 Some(self.next_region_var(v))
1616 fn ty_infer(&self, span: Span) -> Ty<'tcx> {
1617 self.next_ty_var(TypeVariableOrigin::TypeInference(span))
1620 fn ty_infer_for_def(&self,
1621 ty_param_def: &ty::TypeParameterDef,
1622 substs: &[Kind<'tcx>],
1623 span: Span) -> Ty<'tcx> {
1624 self.type_var_for_def(span, ty_param_def, substs)
1627 fn projected_ty_from_poly_trait_ref(&self,
1630 poly_trait_ref: ty::PolyTraitRef<'tcx>)
1633 let item = self.tcx().associated_item(item_def_id);
1634 let (trait_ref, _) =
1635 self.replace_late_bound_regions_with_fresh_var(
1637 infer::LateBoundRegionConversionTime::AssocTypeProjection(item.name),
1640 self.tcx().mk_projection(item_def_id, trait_ref.substs)
1643 fn normalize_ty(&self, span: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
1644 if ty.has_escaping_regions() {
1645 ty // FIXME: normalization and escaping regions
1647 self.normalize_associated_types_in(span, &ty)
1651 fn set_tainted_by_errors(&self) {
1652 self.infcx.set_tainted_by_errors()
1656 /// Controls whether the arguments are tupled. This is used for the call
1659 /// Tupling means that all call-side arguments are packed into a tuple and
1660 /// passed as a single parameter. For example, if tupling is enabled, this
1663 /// fn f(x: (isize, isize))
1665 /// Can be called as:
1672 #[derive(Clone, Eq, PartialEq)]
1673 enum TupleArgumentsFlag {
1678 impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
1679 pub fn new(inh: &'a Inherited<'a, 'gcx, 'tcx>,
1680 param_env: ty::ParamEnv<'tcx>,
1681 body_id: ast::NodeId)
1682 -> FnCtxt<'a, 'gcx, 'tcx> {
1686 err_count_on_creation: inh.tcx.sess.err_count(),
1688 ps: RefCell::new(UnsafetyState::function(hir::Unsafety::Normal,
1689 ast::CRATE_NODE_ID)),
1690 diverges: Cell::new(Diverges::Maybe),
1691 has_errors: Cell::new(false),
1692 enclosing_breakables: RefCell::new(EnclosingBreakables {
1700 pub fn sess(&self) -> &Session {
1704 pub fn err_count_since_creation(&self) -> usize {
1705 self.tcx.sess.err_count() - self.err_count_on_creation
1708 /// Produce warning on the given node, if the current point in the
1709 /// function is unreachable, and there hasn't been another warning.
1710 fn warn_if_unreachable(&self, id: ast::NodeId, span: Span, kind: &str) {
1711 if self.diverges.get() == Diverges::Always {
1712 self.diverges.set(Diverges::WarnedAlways);
1714 debug!("warn_if_unreachable: id={:?} span={:?} kind={}", id, span, kind);
1716 self.tables.borrow_mut().lints.add_lint(
1717 lint::builtin::UNREACHABLE_CODE,
1719 format!("unreachable {}", kind));
1725 code: ObligationCauseCode<'tcx>)
1726 -> ObligationCause<'tcx> {
1727 ObligationCause::new(span, self.body_id, code)
1730 pub fn misc(&self, span: Span) -> ObligationCause<'tcx> {
1731 self.cause(span, ObligationCauseCode::MiscObligation)
1734 /// Resolves type variables in `ty` if possible. Unlike the infcx
1735 /// version (resolve_type_vars_if_possible), this version will
1736 /// also select obligations if it seems useful, in an effort
1737 /// to get more type information.
1738 fn resolve_type_vars_with_obligations(&self, mut ty: Ty<'tcx>) -> Ty<'tcx> {
1739 debug!("resolve_type_vars_with_obligations(ty={:?})", ty);
1741 // No TyInfer()? Nothing needs doing.
1742 if !ty.has_infer_types() {
1743 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
1747 // If `ty` is a type variable, see whether we already know what it is.
1748 ty = self.resolve_type_vars_if_possible(&ty);
1749 if !ty.has_infer_types() {
1750 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
1754 // If not, try resolving pending obligations as much as
1755 // possible. This can help substantially when there are
1756 // indirect dependencies that don't seem worth tracking
1758 self.select_obligations_where_possible();
1759 ty = self.resolve_type_vars_if_possible(&ty);
1761 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
1765 fn record_deferred_call_resolution(&self,
1766 closure_def_id: DefId,
1767 r: DeferredCallResolution<'gcx, 'tcx>) {
1768 let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
1769 deferred_call_resolutions.entry(closure_def_id).or_insert(vec![]).push(r);
1772 fn remove_deferred_call_resolutions(&self,
1773 closure_def_id: DefId)
1774 -> Vec<DeferredCallResolution<'gcx, 'tcx>>
1776 let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
1777 deferred_call_resolutions.remove(&closure_def_id).unwrap_or(vec![])
1780 pub fn tag(&self) -> String {
1781 let self_ptr: *const FnCtxt = self;
1782 format!("{:?}", self_ptr)
1785 pub fn local_ty(&self, span: Span, nid: ast::NodeId) -> Ty<'tcx> {
1786 match self.locals.borrow().get(&nid) {
1789 span_bug!(span, "no type for local variable {}",
1790 self.tcx.hir.node_to_string(nid));
1796 pub fn write_ty(&self, node_id: ast::NodeId, ty: Ty<'tcx>) {
1797 debug!("write_ty({}, {:?}) in fcx {}",
1798 node_id, self.resolve_type_vars_if_possible(&ty), self.tag());
1799 self.tables.borrow_mut().node_types.insert(node_id, ty);
1801 if ty.references_error() {
1802 self.has_errors.set(true);
1803 self.set_tainted_by_errors();
1807 pub fn write_method_call(&self, node_id: ast::NodeId, method: MethodCallee<'tcx>) {
1808 self.tables.borrow_mut().type_dependent_defs.insert(node_id, Def::Method(method.def_id));
1809 self.write_substs(node_id, method.substs);
1812 pub fn write_substs(&self, node_id: ast::NodeId, substs: &'tcx Substs<'tcx>) {
1813 if !substs.is_noop() {
1814 debug!("write_substs({}, {:?}) in fcx {}",
1819 self.tables.borrow_mut().node_substs.insert(node_id, substs);
1823 pub fn apply_adjustments(&self, expr: &hir::Expr, adj: Vec<Adjustment<'tcx>>) {
1824 debug!("apply_adjustments(expr={:?}, adj={:?})", expr, adj);
1830 match self.tables.borrow_mut().adjustments.entry(expr.id) {
1831 Entry::Vacant(entry) => { entry.insert(adj); },
1832 Entry::Occupied(mut entry) => {
1833 debug!(" - composing on top of {:?}", entry.get());
1834 match (&entry.get()[..], &adj[..]) {
1835 // Applying any adjustment on top of a NeverToAny
1836 // is a valid NeverToAny adjustment, because it can't
1838 (&[Adjustment { kind: Adjust::NeverToAny, .. }], _) => return,
1840 Adjustment { kind: Adjust::Deref(_), .. },
1841 Adjustment { kind: Adjust::Borrow(AutoBorrow::Ref(..)), .. },
1843 Adjustment { kind: Adjust::Deref(_), .. },
1844 .. // Any following adjustments are allowed.
1846 // A reborrow has no effect before a dereference.
1848 // FIXME: currently we never try to compose autoderefs
1849 // and ReifyFnPointer/UnsafeFnPointer, but we could.
1851 bug!("while adjusting {:?}, can't compose {:?} and {:?}",
1852 expr, entry.get(), adj)
1854 *entry.get_mut() = adj;
1859 /// Basically whenever we are converting from a type scheme into
1860 /// the fn body space, we always want to normalize associated
1861 /// types as well. This function combines the two.
1862 fn instantiate_type_scheme<T>(&self,
1864 substs: &Substs<'tcx>,
1867 where T : TypeFoldable<'tcx>
1869 let value = value.subst(self.tcx, substs);
1870 let result = self.normalize_associated_types_in(span, &value);
1871 debug!("instantiate_type_scheme(value={:?}, substs={:?}) = {:?}",
1878 /// As `instantiate_type_scheme`, but for the bounds found in a
1879 /// generic type scheme.
1880 fn instantiate_bounds(&self, span: Span, def_id: DefId, substs: &Substs<'tcx>)
1881 -> ty::InstantiatedPredicates<'tcx> {
1882 let bounds = self.tcx.predicates_of(def_id);
1883 let result = bounds.instantiate(self.tcx, substs);
1884 let result = self.normalize_associated_types_in(span, &result);
1885 debug!("instantiate_bounds(bounds={:?}, substs={:?}) = {:?}",
1892 /// Replace all anonymized types with fresh inference variables
1893 /// and record them for writeback.
1894 fn instantiate_anon_types<T: TypeFoldable<'tcx>>(&self, value: &T) -> T {
1895 value.fold_with(&mut BottomUpFolder { tcx: self.tcx, fldop: |ty| {
1896 if let ty::TyAnon(def_id, substs) = ty.sty {
1897 // Use the same type variable if the exact same TyAnon appears more
1898 // than once in the return type (e.g. if it's pased to a type alias).
1899 let id = self.tcx.hir.as_local_node_id(def_id).unwrap();
1900 if let Some(ty_var) = self.anon_types.borrow().get(&id) {
1903 let span = self.tcx.def_span(def_id);
1904 let ty_var = self.next_ty_var(TypeVariableOrigin::TypeInference(span));
1905 self.anon_types.borrow_mut().insert(id, ty_var);
1907 let predicates_of = self.tcx.predicates_of(def_id);
1908 let bounds = predicates_of.instantiate(self.tcx, substs);
1910 for predicate in bounds.predicates {
1911 // Change the predicate to refer to the type variable,
1912 // which will be the concrete type, instead of the TyAnon.
1913 // This also instantiates nested `impl Trait`.
1914 let predicate = self.instantiate_anon_types(&predicate);
1916 // Require that the predicate holds for the concrete type.
1917 let cause = traits::ObligationCause::new(span, self.body_id,
1918 traits::SizedReturnType);
1919 self.register_predicate(traits::Obligation::new(cause,
1931 fn normalize_associated_types_in<T>(&self, span: Span, value: &T) -> T
1932 where T : TypeFoldable<'tcx>
1934 self.inh.normalize_associated_types_in(span, self.body_id, self.param_env, value)
1937 fn normalize_associated_types_in_as_infer_ok<T>(&self, span: Span, value: &T)
1939 where T : TypeFoldable<'tcx>
1941 self.inh.normalize_associated_types_in_as_infer_ok(span,
1947 pub fn require_type_meets(&self,
1950 code: traits::ObligationCauseCode<'tcx>,
1953 self.register_bound(
1956 traits::ObligationCause::new(span, self.body_id, code));
1959 pub fn require_type_is_sized(&self,
1962 code: traits::ObligationCauseCode<'tcx>)
1964 let lang_item = self.tcx.require_lang_item(lang_items::SizedTraitLangItem);
1965 self.require_type_meets(ty, span, code, lang_item);
1968 pub fn register_bound(&self,
1971 cause: traits::ObligationCause<'tcx>)
1973 self.fulfillment_cx.borrow_mut()
1974 .register_bound(self, self.param_env, ty, def_id, cause);
1977 pub fn to_ty(&self, ast_t: &hir::Ty) -> Ty<'tcx> {
1978 let t = AstConv::ast_ty_to_ty(self, ast_t);
1979 self.register_wf_obligation(t, ast_t.span, traits::MiscObligation);
1983 pub fn node_ty(&self, id: ast::NodeId) -> Ty<'tcx> {
1984 match self.tables.borrow().node_types.get(&id) {
1986 None if self.err_count_since_creation() != 0 => self.tcx.types.err,
1988 bug!("no type for node {}: {} in fcx {}",
1989 id, self.tcx.hir.node_to_string(id),
1995 /// Registers an obligation for checking later, during regionck, that the type `ty` must
1996 /// outlive the region `r`.
1997 pub fn register_wf_obligation(&self,
2000 code: traits::ObligationCauseCode<'tcx>)
2002 // WF obligations never themselves fail, so no real need to give a detailed cause:
2003 let cause = traits::ObligationCause::new(span, self.body_id, code);
2004 self.register_predicate(traits::Obligation::new(cause,
2006 ty::Predicate::WellFormed(ty)));
2009 /// Registers obligations that all types appearing in `substs` are well-formed.
2010 pub fn add_wf_bounds(&self, substs: &Substs<'tcx>, expr: &hir::Expr)
2012 for ty in substs.types() {
2013 self.register_wf_obligation(ty, expr.span, traits::MiscObligation);
2017 /// Given a fully substituted set of bounds (`generic_bounds`), and the values with which each
2018 /// type/region parameter was instantiated (`substs`), creates and registers suitable
2019 /// trait/region obligations.
2021 /// For example, if there is a function:
2024 /// fn foo<'a,T:'a>(...)
2027 /// and a reference:
2033 /// Then we will create a fresh region variable `'$0` and a fresh type variable `$1` for `'a`
2034 /// and `T`. This routine will add a region obligation `$1:'$0` and register it locally.
2035 pub fn add_obligations_for_parameters(&self,
2036 cause: traits::ObligationCause<'tcx>,
2037 predicates: &ty::InstantiatedPredicates<'tcx>)
2039 assert!(!predicates.has_escaping_regions());
2041 debug!("add_obligations_for_parameters(predicates={:?})",
2044 for obligation in traits::predicates_for_generics(cause, self.param_env, predicates) {
2045 self.register_predicate(obligation);
2049 // FIXME(arielb1): use this instead of field.ty everywhere
2050 // Only for fields! Returns <none> for methods>
2051 // Indifferent to privacy flags
2052 pub fn field_ty(&self,
2054 field: &'tcx ty::FieldDef,
2055 substs: &Substs<'tcx>)
2058 self.normalize_associated_types_in(span,
2059 &field.ty(self.tcx, substs))
2062 fn check_casts(&self) {
2063 let mut deferred_cast_checks = self.deferred_cast_checks.borrow_mut();
2064 for cast in deferred_cast_checks.drain(..) {
2069 /// Apply "fallbacks" to some types
2070 /// unconstrained types get replaced with ! or () (depending on whether
2071 /// feature(never_type) is enabled), unconstrained ints with i32, and
2072 /// unconstrained floats with f64.
2073 fn default_type_parameters(&self) {
2074 use rustc::ty::error::UnconstrainedNumeric::Neither;
2075 use rustc::ty::error::UnconstrainedNumeric::{UnconstrainedInt, UnconstrainedFloat};
2077 // Defaulting inference variables becomes very dubious if we have
2078 // encountered type-checking errors. Therefore, if we think we saw
2079 // some errors in this function, just resolve all uninstanted type
2080 // varibles to TyError.
2081 if self.is_tainted_by_errors() {
2082 for ty in &self.unsolved_variables() {
2083 if let ty::TyInfer(_) = self.shallow_resolve(ty).sty {
2084 debug!("default_type_parameters: defaulting `{:?}` to error", ty);
2085 self.demand_eqtype(syntax_pos::DUMMY_SP, *ty, self.tcx().types.err);
2091 for ty in &self.unsolved_variables() {
2092 let resolved = self.resolve_type_vars_if_possible(ty);
2093 if self.type_var_diverges(resolved) {
2094 debug!("default_type_parameters: defaulting `{:?}` to `!` because it diverges",
2096 self.demand_eqtype(syntax_pos::DUMMY_SP, *ty,
2097 self.tcx.mk_diverging_default());
2099 match self.type_is_unconstrained_numeric(resolved) {
2100 UnconstrainedInt => {
2101 debug!("default_type_parameters: defaulting `{:?}` to `i32`",
2103 self.demand_eqtype(syntax_pos::DUMMY_SP, *ty, self.tcx.types.i32)
2105 UnconstrainedFloat => {
2106 debug!("default_type_parameters: defaulting `{:?}` to `f32`",
2108 self.demand_eqtype(syntax_pos::DUMMY_SP, *ty, self.tcx.types.f64)
2116 // Implements type inference fallback algorithm
2117 fn select_all_obligations_and_apply_defaults(&self) {
2118 self.select_obligations_where_possible();
2119 self.default_type_parameters();
2120 self.select_obligations_where_possible();
2123 fn select_all_obligations_or_error(&self) {
2124 debug!("select_all_obligations_or_error");
2126 // upvar inference should have ensured that all deferred call
2127 // resolutions are handled by now.
2128 assert!(self.deferred_call_resolutions.borrow().is_empty());
2130 self.select_all_obligations_and_apply_defaults();
2132 let mut fulfillment_cx = self.fulfillment_cx.borrow_mut();
2134 match fulfillment_cx.select_all_or_error(self) {
2136 Err(errors) => { self.report_fulfillment_errors(&errors, self.inh.body_id); }
2140 /// Select as many obligations as we can at present.
2141 fn select_obligations_where_possible(&self) {
2142 match self.fulfillment_cx.borrow_mut().select_where_possible(self) {
2144 Err(errors) => { self.report_fulfillment_errors(&errors, self.inh.body_id); }
2148 /// For the overloaded lvalue expressions (`*x`, `x[3]`), the trait
2149 /// returns a type of `&T`, but the actual type we assign to the
2150 /// *expression* is `T`. So this function just peels off the return
2151 /// type by one layer to yield `T`.
2152 fn make_overloaded_lvalue_return_type(&self,
2153 method: MethodCallee<'tcx>)
2154 -> ty::TypeAndMut<'tcx>
2156 // extract method return type, which will be &T;
2157 let ret_ty = method.sig.output();
2159 // method returns &T, but the type as visible to user is T, so deref
2160 ret_ty.builtin_deref(true, NoPreference).unwrap()
2163 fn lookup_indexing(&self,
2165 base_expr: &'gcx hir::Expr,
2168 lvalue_pref: LvaluePreference)
2169 -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)>
2171 // FIXME(#18741) -- this is almost but not quite the same as the
2172 // autoderef that normal method probing does. They could likely be
2175 let mut autoderef = self.autoderef(base_expr.span, base_ty);
2176 let mut result = None;
2177 while result.is_none() && autoderef.next().is_some() {
2178 result = self.try_index_step(expr, base_expr, &autoderef, lvalue_pref, idx_ty);
2180 autoderef.finalize();
2184 /// To type-check `base_expr[index_expr]`, we progressively autoderef
2185 /// (and otherwise adjust) `base_expr`, looking for a type which either
2186 /// supports builtin indexing or overloaded indexing.
2187 /// This loop implements one step in that search; the autoderef loop
2188 /// is implemented by `lookup_indexing`.
2189 fn try_index_step(&self,
2191 base_expr: &hir::Expr,
2192 autoderef: &Autoderef<'a, 'gcx, 'tcx>,
2193 lvalue_pref: LvaluePreference,
2195 -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)>
2197 let adjusted_ty = autoderef.unambiguous_final_ty();
2198 debug!("try_index_step(expr={:?}, base_expr={:?}, adjusted_ty={:?}, \
2206 // First, try built-in indexing.
2207 match (adjusted_ty.builtin_index(), &index_ty.sty) {
2208 (Some(ty), &ty::TyUint(ast::UintTy::Us)) | (Some(ty), &ty::TyInfer(ty::IntVar(_))) => {
2209 debug!("try_index_step: success, using built-in indexing");
2210 let adjustments = autoderef.adjust_steps(lvalue_pref);
2211 self.apply_adjustments(base_expr, adjustments);
2212 return Some((self.tcx.types.usize, ty));
2217 for &unsize in &[false, true] {
2218 let mut self_ty = adjusted_ty;
2220 // We only unsize arrays here.
2221 if let ty::TyArray(element_ty, _) = adjusted_ty.sty {
2222 self_ty = self.tcx.mk_slice(element_ty);
2228 // If some lookup succeeds, write callee into table and extract index/element
2229 // type from the method signature.
2230 // If some lookup succeeded, install method in table
2231 let input_ty = self.next_ty_var(TypeVariableOrigin::AutoDeref(base_expr.span));
2232 let method = self.try_overloaded_lvalue_op(
2233 expr.span, self_ty, &[input_ty], lvalue_pref, LvalueOp::Index);
2235 let result = method.map(|ok| {
2236 debug!("try_index_step: success, using overloaded indexing");
2237 let method = self.register_infer_ok_obligations(ok);
2239 let mut adjustments = autoderef.adjust_steps(lvalue_pref);
2240 if let ty::TyRef(region, mt) = method.sig.inputs()[0].sty {
2241 adjustments.push(Adjustment {
2242 kind: Adjust::Borrow(AutoBorrow::Ref(region, mt.mutbl)),
2243 target: self.tcx.mk_ref(region, ty::TypeAndMut {
2250 adjustments.push(Adjustment {
2251 kind: Adjust::Unsize,
2252 target: method.sig.inputs()[0]
2255 self.apply_adjustments(base_expr, adjustments);
2257 self.write_method_call(expr.id, method);
2258 (input_ty, self.make_overloaded_lvalue_return_type(method).ty)
2260 if result.is_some() {
2268 fn resolve_lvalue_op(&self, op: LvalueOp, is_mut: bool) -> (Option<DefId>, Symbol) {
2269 let (tr, name) = match (op, is_mut) {
2270 (LvalueOp::Deref, false) =>
2271 (self.tcx.lang_items.deref_trait(), "deref"),
2272 (LvalueOp::Deref, true) =>
2273 (self.tcx.lang_items.deref_mut_trait(), "deref_mut"),
2274 (LvalueOp::Index, false) =>
2275 (self.tcx.lang_items.index_trait(), "index"),
2276 (LvalueOp::Index, true) =>
2277 (self.tcx.lang_items.index_mut_trait(), "index_mut"),
2279 (tr, Symbol::intern(name))
2282 fn try_overloaded_lvalue_op(&self,
2285 arg_tys: &[Ty<'tcx>],
2286 lvalue_pref: LvaluePreference,
2288 -> Option<InferOk<'tcx, MethodCallee<'tcx>>>
2290 debug!("try_overloaded_lvalue_op({:?},{:?},{:?},{:?})",
2296 // Try Mut first, if preferred.
2297 let (mut_tr, mut_op) = self.resolve_lvalue_op(op, true);
2298 let method = match (lvalue_pref, mut_tr) {
2299 (PreferMutLvalue, Some(trait_did)) => {
2300 self.lookup_method_in_trait(span, mut_op, trait_did, base_ty, Some(arg_tys))
2305 // Otherwise, fall back to the immutable version.
2306 let (imm_tr, imm_op) = self.resolve_lvalue_op(op, false);
2307 let method = match (method, imm_tr) {
2308 (None, Some(trait_did)) => {
2309 self.lookup_method_in_trait(span, imm_op, trait_did, base_ty, Some(arg_tys))
2311 (method, _) => method,
2317 fn check_method_argument_types(&self,
2319 method: Result<MethodCallee<'tcx>, ()>,
2320 args_no_rcvr: &'gcx [hir::Expr],
2321 tuple_arguments: TupleArgumentsFlag,
2322 expected: Expectation<'tcx>)
2324 let has_error = match method {
2326 method.substs.references_error() || method.sig.references_error()
2331 let err_inputs = self.err_args(args_no_rcvr.len());
2333 let err_inputs = match tuple_arguments {
2334 DontTupleArguments => err_inputs,
2335 TupleArguments => vec![self.tcx.intern_tup(&err_inputs[..], false)],
2338 self.check_argument_types(sp, &err_inputs[..], &[], args_no_rcvr,
2339 false, tuple_arguments, None);
2340 return self.tcx.types.err;
2343 let method = method.unwrap();
2344 // HACK(eddyb) ignore self in the definition (see above).
2345 let expected_arg_tys = self.expected_inputs_for_expected_output(
2348 method.sig.output(),
2349 &method.sig.inputs()[1..]
2351 self.check_argument_types(sp, &method.sig.inputs()[1..], &expected_arg_tys[..],
2352 args_no_rcvr, method.sig.variadic, tuple_arguments,
2353 self.tcx.hir.span_if_local(method.def_id));
2357 /// Generic function that factors out common logic from function calls,
2358 /// method calls and overloaded operators.
2359 fn check_argument_types(&self,
2361 fn_inputs: &[Ty<'tcx>],
2362 expected_arg_tys: &[Ty<'tcx>],
2363 args: &'gcx [hir::Expr],
2365 tuple_arguments: TupleArgumentsFlag,
2366 def_span: Option<Span>) {
2369 // Grab the argument types, supplying fresh type variables
2370 // if the wrong number of arguments were supplied
2371 let supplied_arg_count = if tuple_arguments == DontTupleArguments {
2377 // All the input types from the fn signature must outlive the call
2378 // so as to validate implied bounds.
2379 for &fn_input_ty in fn_inputs {
2380 self.register_wf_obligation(fn_input_ty, sp, traits::MiscObligation);
2383 let mut expected_arg_tys = expected_arg_tys;
2384 let expected_arg_count = fn_inputs.len();
2386 let sp_args = if args.len() > 0 {
2387 let (first, args) = args.split_at(1);
2388 let mut sp_tmp = first[0].span;
2390 let sp_opt = self.sess().codemap().merge_spans(sp_tmp, arg.span);
2391 if ! sp_opt.is_some() {
2394 sp_tmp = sp_opt.unwrap();
2401 fn parameter_count_error<'tcx>(sess: &Session, sp: Span, expected_count: usize,
2402 arg_count: usize, error_code: &str, variadic: bool,
2403 def_span: Option<Span>) {
2404 let mut err = sess.struct_span_err_with_code(sp,
2405 &format!("this function takes {}{} parameter{} but {} parameter{} supplied",
2406 if variadic {"at least "} else {""},
2408 if expected_count == 1 {""} else {"s"},
2410 if arg_count == 1 {" was"} else {"s were"}),
2413 err.span_label(sp, format!("expected {}{} parameter{}",
2414 if variadic {"at least "} else {""},
2416 if expected_count == 1 {""} else {"s"}));
2417 if let Some(def_s) = def_span {
2418 err.span_label(def_s, "defined here");
2423 let formal_tys = if tuple_arguments == TupleArguments {
2424 let tuple_type = self.structurally_resolved_type(sp, fn_inputs[0]);
2425 match tuple_type.sty {
2426 ty::TyTuple(arg_types, _) if arg_types.len() != args.len() => {
2427 parameter_count_error(tcx.sess, sp_args, arg_types.len(), args.len(),
2428 "E0057", false, def_span);
2429 expected_arg_tys = &[];
2430 self.err_args(args.len())
2432 ty::TyTuple(arg_types, _) => {
2433 expected_arg_tys = match expected_arg_tys.get(0) {
2434 Some(&ty) => match ty.sty {
2435 ty::TyTuple(ref tys, _) => &tys,
2443 span_err!(tcx.sess, sp, E0059,
2444 "cannot use call notation; the first type parameter \
2445 for the function trait is neither a tuple nor unit");
2446 expected_arg_tys = &[];
2447 self.err_args(args.len())
2450 } else if expected_arg_count == supplied_arg_count {
2452 } else if variadic {
2453 if supplied_arg_count >= expected_arg_count {
2456 parameter_count_error(tcx.sess, sp_args, expected_arg_count,
2457 supplied_arg_count, "E0060", true, def_span);
2458 expected_arg_tys = &[];
2459 self.err_args(supplied_arg_count)
2462 parameter_count_error(tcx.sess, sp_args, expected_arg_count,
2463 supplied_arg_count, "E0061", false, def_span);
2464 expected_arg_tys = &[];
2465 self.err_args(supplied_arg_count)
2468 debug!("check_argument_types: formal_tys={:?}",
2469 formal_tys.iter().map(|t| self.ty_to_string(*t)).collect::<Vec<String>>());
2471 // Check the arguments.
2472 // We do this in a pretty awful way: first we typecheck any arguments
2473 // that are not closures, then we typecheck the closures. This is so
2474 // that we have more information about the types of arguments when we
2475 // typecheck the functions. This isn't really the right way to do this.
2476 for &check_closures in &[false, true] {
2477 debug!("check_closures={}", check_closures);
2479 // More awful hacks: before we check argument types, try to do
2480 // an "opportunistic" vtable resolution of any trait bounds on
2481 // the call. This helps coercions.
2483 self.select_obligations_where_possible();
2486 // For variadic functions, we don't have a declared type for all of
2487 // the arguments hence we only do our usual type checking with
2488 // the arguments who's types we do know.
2489 let t = if variadic {
2491 } else if tuple_arguments == TupleArguments {
2496 for (i, arg) in args.iter().take(t).enumerate() {
2497 // Warn only for the first loop (the "no closures" one).
2498 // Closure arguments themselves can't be diverging, but
2499 // a previous argument can, e.g. `foo(panic!(), || {})`.
2500 if !check_closures {
2501 self.warn_if_unreachable(arg.id, arg.span, "expression");
2504 let is_closure = match arg.node {
2505 hir::ExprClosure(..) => true,
2509 if is_closure != check_closures {
2513 debug!("checking the argument");
2514 let formal_ty = formal_tys[i];
2516 // The special-cased logic below has three functions:
2517 // 1. Provide as good of an expected type as possible.
2518 let expected = expected_arg_tys.get(i).map(|&ty| {
2519 Expectation::rvalue_hint(self, ty)
2522 let checked_ty = self.check_expr_with_expectation(
2524 expected.unwrap_or(ExpectHasType(formal_ty)));
2526 // 2. Coerce to the most detailed type that could be coerced
2527 // to, which is `expected_ty` if `rvalue_hint` returns an
2528 // `ExpectHasType(expected_ty)`, or the `formal_ty` otherwise.
2529 let coerce_ty = expected.and_then(|e| e.only_has_type(self));
2530 self.demand_coerce(&arg, checked_ty, coerce_ty.unwrap_or(formal_ty));
2532 // 3. Relate the expected type and the formal one,
2533 // if the expected type was used for the coercion.
2534 coerce_ty.map(|ty| self.demand_suptype(arg.span, formal_ty, ty));
2538 // We also need to make sure we at least write the ty of the other
2539 // arguments which we skipped above.
2541 fn variadic_error<'tcx>(s: &Session, span: Span, t: Ty<'tcx>, cast_ty: &str) {
2542 type_error_struct!(s, span, t, E0617,
2543 "can't pass `{}` to variadic function, cast to `{}`",
2547 for arg in args.iter().skip(expected_arg_count) {
2548 let arg_ty = self.check_expr(&arg);
2550 // There are a few types which get autopromoted when passed via varargs
2551 // in C but we just error out instead and require explicit casts.
2552 let arg_ty = self.structurally_resolved_type(arg.span, arg_ty);
2554 ty::TyFloat(ast::FloatTy::F32) => {
2555 variadic_error(tcx.sess, arg.span, arg_ty, "c_double");
2557 ty::TyInt(ast::IntTy::I8) | ty::TyInt(ast::IntTy::I16) | ty::TyBool => {
2558 variadic_error(tcx.sess, arg.span, arg_ty, "c_int");
2560 ty::TyUint(ast::UintTy::U8) | ty::TyUint(ast::UintTy::U16) => {
2561 variadic_error(tcx.sess, arg.span, arg_ty, "c_uint");
2563 ty::TyFnDef(..) => {
2564 let ptr_ty = self.tcx.mk_fn_ptr(arg_ty.fn_sig(self.tcx));
2565 let ptr_ty = self.resolve_type_vars_if_possible(&ptr_ty);
2566 variadic_error(tcx.sess, arg.span, arg_ty, &format!("{}", ptr_ty));
2574 fn err_args(&self, len: usize) -> Vec<Ty<'tcx>> {
2575 (0..len).map(|_| self.tcx.types.err).collect()
2578 // AST fragment checking
2581 expected: Expectation<'tcx>)
2587 ast::LitKind::Str(..) => tcx.mk_static_str(),
2588 ast::LitKind::ByteStr(ref v) => {
2589 tcx.mk_imm_ref(tcx.types.re_static,
2590 tcx.mk_array(tcx.types.u8, v.len()))
2592 ast::LitKind::Byte(_) => tcx.types.u8,
2593 ast::LitKind::Char(_) => tcx.types.char,
2594 ast::LitKind::Int(_, ast::LitIntType::Signed(t)) => tcx.mk_mach_int(t),
2595 ast::LitKind::Int(_, ast::LitIntType::Unsigned(t)) => tcx.mk_mach_uint(t),
2596 ast::LitKind::Int(_, ast::LitIntType::Unsuffixed) => {
2597 let opt_ty = expected.to_option(self).and_then(|ty| {
2599 ty::TyInt(_) | ty::TyUint(_) => Some(ty),
2600 ty::TyChar => Some(tcx.types.u8),
2601 ty::TyRawPtr(..) => Some(tcx.types.usize),
2602 ty::TyFnDef(..) | ty::TyFnPtr(_) => Some(tcx.types.usize),
2606 opt_ty.unwrap_or_else(
2607 || tcx.mk_int_var(self.next_int_var_id()))
2609 ast::LitKind::Float(_, t) => tcx.mk_mach_float(t),
2610 ast::LitKind::FloatUnsuffixed(_) => {
2611 let opt_ty = expected.to_option(self).and_then(|ty| {
2613 ty::TyFloat(_) => Some(ty),
2617 opt_ty.unwrap_or_else(
2618 || tcx.mk_float_var(self.next_float_var_id()))
2620 ast::LitKind::Bool(_) => tcx.types.bool
2624 fn check_expr_eq_type(&self,
2625 expr: &'gcx hir::Expr,
2626 expected: Ty<'tcx>) {
2627 let ty = self.check_expr_with_hint(expr, expected);
2628 self.demand_eqtype(expr.span, expected, ty);
2631 pub fn check_expr_has_type_or_error(&self,
2632 expr: &'gcx hir::Expr,
2633 expected: Ty<'tcx>) -> Ty<'tcx> {
2634 self.check_expr_meets_expectation_or_error(expr, ExpectHasType(expected))
2637 fn check_expr_meets_expectation_or_error(&self,
2638 expr: &'gcx hir::Expr,
2639 expected: Expectation<'tcx>) -> Ty<'tcx> {
2640 let expected_ty = expected.to_option(&self).unwrap_or(self.tcx.types.bool);
2641 let mut ty = self.check_expr_with_expectation(expr, expected);
2643 // While we don't allow *arbitrary* coercions here, we *do* allow
2644 // coercions from ! to `expected`.
2646 assert!(!self.tables.borrow().adjustments.contains_key(&expr.id),
2647 "expression with never type wound up being adjusted");
2648 let adj_ty = self.next_diverging_ty_var(
2649 TypeVariableOrigin::AdjustmentType(expr.span));
2650 self.apply_adjustments(expr, vec![Adjustment {
2651 kind: Adjust::NeverToAny,
2657 if let Some(mut err) = self.demand_suptype_diag(expr.span, expected_ty, ty) {
2658 // Add help to type error if this is an `if` condition with an assignment
2659 match (expected, &expr.node) {
2660 (ExpectIfCondition, &hir::ExprAssign(ref lhs, ref rhs)) => {
2661 let msg = "try comparing for equality";
2662 if let (Ok(left), Ok(right)) = (
2663 self.tcx.sess.codemap().span_to_snippet(lhs.span),
2664 self.tcx.sess.codemap().span_to_snippet(rhs.span))
2666 err.span_suggestion(expr.span, msg, format!("{} == {}", left, right));
2678 fn check_expr_coercable_to_type(&self,
2679 expr: &'gcx hir::Expr,
2680 expected: Ty<'tcx>) -> Ty<'tcx> {
2681 let ty = self.check_expr_with_hint(expr, expected);
2682 self.demand_coerce(expr, ty, expected);
2686 fn check_expr_with_hint(&self, expr: &'gcx hir::Expr,
2687 expected: Ty<'tcx>) -> Ty<'tcx> {
2688 self.check_expr_with_expectation(expr, ExpectHasType(expected))
2691 fn check_expr_with_expectation(&self,
2692 expr: &'gcx hir::Expr,
2693 expected: Expectation<'tcx>) -> Ty<'tcx> {
2694 self.check_expr_with_expectation_and_lvalue_pref(expr, expected, NoPreference)
2697 fn check_expr(&self, expr: &'gcx hir::Expr) -> Ty<'tcx> {
2698 self.check_expr_with_expectation(expr, NoExpectation)
2701 fn check_expr_with_lvalue_pref(&self, expr: &'gcx hir::Expr,
2702 lvalue_pref: LvaluePreference) -> Ty<'tcx> {
2703 self.check_expr_with_expectation_and_lvalue_pref(expr, NoExpectation, lvalue_pref)
2706 // determine the `self` type, using fresh variables for all variables
2707 // declared on the impl declaration e.g., `impl<A,B> for Vec<(A,B)>`
2708 // would return ($0, $1) where $0 and $1 are freshly instantiated type
2710 pub fn impl_self_ty(&self,
2711 span: Span, // (potential) receiver for this impl
2713 -> TypeAndSubsts<'tcx> {
2714 let ity = self.tcx.type_of(did);
2715 debug!("impl_self_ty: ity={:?}", ity);
2717 let substs = self.fresh_substs_for_item(span, did);
2718 let substd_ty = self.instantiate_type_scheme(span, &substs, &ity);
2720 TypeAndSubsts { substs: substs, ty: substd_ty }
2723 /// Unifies the output type with the expected type early, for more coercions
2724 /// and forward type information on the input expressions.
2725 fn expected_inputs_for_expected_output(&self,
2727 expected_ret: Expectation<'tcx>,
2728 formal_ret: Ty<'tcx>,
2729 formal_args: &[Ty<'tcx>])
2731 let expected_args = expected_ret.only_has_type(self).and_then(|ret_ty| {
2732 self.fudge_regions_if_ok(&RegionVariableOrigin::Coercion(call_span), || {
2733 // Attempt to apply a subtyping relationship between the formal
2734 // return type (likely containing type variables if the function
2735 // is polymorphic) and the expected return type.
2736 // No argument expectations are produced if unification fails.
2737 let origin = self.misc(call_span);
2738 let ures = self.at(&origin, self.param_env).sup(ret_ty, formal_ret);
2740 // FIXME(#15760) can't use try! here, FromError doesn't default
2741 // to identity so the resulting type is not constrained.
2744 // Process any obligations locally as much as
2745 // we can. We don't care if some things turn
2746 // out unconstrained or ambiguous, as we're
2747 // just trying to get hints here.
2748 let result = self.save_and_restore_in_snapshot_flag(|_| {
2749 let mut fulfill = FulfillmentContext::new();
2750 let ok = ok; // FIXME(#30046)
2751 for obligation in ok.obligations {
2752 fulfill.register_predicate_obligation(self, obligation);
2754 fulfill.select_where_possible(self)
2759 Err(_) => return Err(()),
2762 Err(_) => return Err(()),
2765 // Record all the argument types, with the substitutions
2766 // produced from the above subtyping unification.
2767 Ok(formal_args.iter().map(|ty| {
2768 self.resolve_type_vars_if_possible(ty)
2771 }).unwrap_or(vec![]);
2772 debug!("expected_inputs_for_expected_output(formal={:?} -> {:?}, expected={:?} -> {:?})",
2773 formal_args, formal_ret,
2774 expected_args, expected_ret);
2778 // Checks a method call.
2779 fn check_method_call(&self,
2780 expr: &'gcx hir::Expr,
2781 segment: &hir::PathSegment,
2783 args: &'gcx [hir::Expr],
2784 expected: Expectation<'tcx>,
2785 lvalue_pref: LvaluePreference) -> Ty<'tcx> {
2786 let rcvr = &args[0];
2787 let rcvr_t = self.check_expr_with_lvalue_pref(&rcvr, lvalue_pref);
2788 // no need to check for bot/err -- callee does that
2789 let rcvr_t = self.structurally_resolved_type(expr.span, rcvr_t);
2791 let method = match self.lookup_method(rcvr_t,
2797 self.write_method_call(expr.id, method);
2801 if segment.name != keywords::Invalid.name() {
2802 self.report_method_error(span,
2813 // Call the generic checker.
2814 self.check_method_argument_types(span, method,
2820 fn check_return_expr(&self, return_expr: &'gcx hir::Expr) {
2824 .unwrap_or_else(|| span_bug!(return_expr.span,
2825 "check_return_expr called outside fn body"));
2827 let ret_ty = ret_coercion.borrow().expected_ty();
2828 let return_expr_ty = self.check_expr_with_hint(return_expr, ret_ty.clone());
2829 ret_coercion.borrow_mut()
2831 &self.cause(return_expr.span,
2832 ObligationCauseCode::ReturnType(return_expr.id)),
2835 self.diverges.get());
2839 // A generic function for checking the then and else in an if
2841 fn check_then_else(&self,
2842 cond_expr: &'gcx hir::Expr,
2843 then_expr: &'gcx hir::Expr,
2844 opt_else_expr: Option<&'gcx hir::Expr>,
2846 expected: Expectation<'tcx>) -> Ty<'tcx> {
2847 let cond_ty = self.check_expr_meets_expectation_or_error(cond_expr, ExpectIfCondition);
2848 let cond_diverges = self.diverges.get();
2849 self.diverges.set(Diverges::Maybe);
2851 let expected = expected.adjust_for_branches(self);
2852 let then_ty = self.check_expr_with_expectation(then_expr, expected);
2853 let then_diverges = self.diverges.get();
2854 self.diverges.set(Diverges::Maybe);
2856 // We've already taken the expected type's preferences
2857 // into account when typing the `then` branch. To figure
2858 // out the initial shot at a LUB, we thus only consider
2859 // `expected` if it represents a *hard* constraint
2860 // (`only_has_type`); otherwise, we just go with a
2861 // fresh type variable.
2862 let coerce_to_ty = expected.coercion_target_type(self, sp);
2863 let mut coerce: DynamicCoerceMany = CoerceMany::new(coerce_to_ty);
2865 let if_cause = self.cause(sp, ObligationCauseCode::IfExpression);
2866 coerce.coerce(self, &if_cause, then_expr, then_ty, then_diverges);
2868 if let Some(else_expr) = opt_else_expr {
2869 let else_ty = self.check_expr_with_expectation(else_expr, expected);
2870 let else_diverges = self.diverges.get();
2872 coerce.coerce(self, &if_cause, else_expr, else_ty, else_diverges);
2874 // We won't diverge unless both branches do (or the condition does).
2875 self.diverges.set(cond_diverges | then_diverges & else_diverges);
2877 let else_cause = self.cause(sp, ObligationCauseCode::IfExpressionWithNoElse);
2878 coerce.coerce_forced_unit(self, &else_cause, &mut |_| (), true);
2880 // If the condition is false we can't diverge.
2881 self.diverges.set(cond_diverges);
2884 let result_ty = coerce.complete(self);
2885 if cond_ty.references_error() {
2892 // Check field access expressions
2893 fn check_field(&self,
2894 expr: &'gcx hir::Expr,
2895 lvalue_pref: LvaluePreference,
2896 base: &'gcx hir::Expr,
2897 field: &Spanned<ast::Name>) -> Ty<'tcx> {
2898 let expr_t = self.check_expr_with_lvalue_pref(base, lvalue_pref);
2899 let expr_t = self.structurally_resolved_type(expr.span,
2901 let mut private_candidate = None;
2902 let mut autoderef = self.autoderef(expr.span, expr_t);
2903 while let Some((base_t, _)) = autoderef.next() {
2905 ty::TyAdt(base_def, substs) if !base_def.is_enum() => {
2906 debug!("struct named {:?}", base_t);
2907 let (ident, def_scope) =
2908 self.tcx.adjust(field.node, base_def.did, self.body_id);
2909 let fields = &base_def.struct_variant().fields;
2910 if let Some(field) = fields.iter().find(|f| f.name.to_ident() == ident) {
2911 let field_ty = self.field_ty(expr.span, field, substs);
2912 if field.vis.is_accessible_from(def_scope, self.tcx) {
2913 let adjustments = autoderef.adjust_steps(lvalue_pref);
2914 self.apply_adjustments(base, adjustments);
2915 autoderef.finalize();
2917 self.tcx.check_stability(field.did, expr.id, expr.span);
2921 private_candidate = Some((base_def.did, field_ty));
2927 autoderef.unambiguous_final_ty();
2929 if let Some((did, field_ty)) = private_candidate {
2930 let struct_path = self.tcx().item_path_str(did);
2931 let mut err = struct_span_err!(self.tcx().sess, expr.span, E0616,
2932 "field `{}` of struct `{}` is private",
2933 field.node, struct_path);
2934 // Also check if an accessible method exists, which is often what is meant.
2935 if self.method_exists(field.span, field.node, expr_t, expr.id, false) {
2936 err.note(&format!("a method `{}` also exists, perhaps you wish to call it",
2941 } else if field.node == keywords::Invalid.name() {
2942 self.tcx().types.err
2943 } else if self.method_exists(field.span, field.node, expr_t, expr.id, true) {
2944 type_error_struct!(self.tcx().sess, field.span, expr_t, E0615,
2945 "attempted to take value of method `{}` on type `{}`",
2947 .help("maybe a `()` to call it is missing? \
2948 If not, try an anonymous function")
2950 self.tcx().types.err
2952 if !expr_t.is_primitive_ty() {
2953 let mut err = self.no_such_field_err(field.span, &field.node, expr_t);
2956 ty::TyAdt(def, _) if !def.is_enum() => {
2957 if let Some(suggested_field_name) =
2958 Self::suggest_field_name(def.struct_variant(), field, vec![]) {
2959 err.span_label(field.span,
2960 format!("did you mean `{}`?", suggested_field_name));
2962 err.span_label(field.span, "unknown field");
2963 let struct_variant_def = def.struct_variant();
2964 let field_names = self.available_field_names(struct_variant_def);
2965 if !field_names.is_empty() {
2966 err.note(&format!("available fields are: {}",
2967 self.name_series_display(field_names)));
2971 ty::TyRawPtr(..) => {
2972 err.note(&format!("`{0}` is a native pointer; perhaps you need to deref \
2974 self.tcx.hir.node_to_pretty_string(base.id),
2981 type_error_struct!(self.tcx().sess, field.span, expr_t, E0610,
2982 "`{}` is a primitive type and therefore doesn't have fields",
2985 self.tcx().types.err
2989 // Return an hint about the closest match in field names
2990 fn suggest_field_name(variant: &'tcx ty::VariantDef,
2991 field: &Spanned<ast::Name>,
2992 skip: Vec<InternedString>)
2994 let name = field.node.as_str();
2995 let names = variant.fields.iter().filter_map(|field| {
2996 // ignore already set fields and private fields from non-local crates
2997 if skip.iter().any(|x| *x == field.name.as_str()) ||
2998 (variant.did.krate != LOCAL_CRATE && field.vis != Visibility::Public) {
3005 find_best_match_for_name(names, &name, None)
3008 fn available_field_names(&self, variant: &'tcx ty::VariantDef) -> Vec<ast::Name> {
3009 let mut available = Vec::new();
3010 for field in variant.fields.iter() {
3011 let (_, def_scope) = self.tcx.adjust(field.name, variant.did, self.body_id);
3012 if field.vis.is_accessible_from(def_scope, self.tcx) {
3013 available.push(field.name);
3019 fn name_series_display(&self, names: Vec<ast::Name>) -> String {
3020 // dynamic limit, to never omit just one field
3021 let limit = if names.len() == 6 { 6 } else { 5 };
3022 let mut display = names.iter().take(limit)
3023 .map(|n| format!("`{}`", n)).collect::<Vec<_>>().join(", ");
3024 if names.len() > limit {
3025 display = format!("{} ... and {} others", display, names.len() - limit);
3030 // Check tuple index expressions
3031 fn check_tup_field(&self,
3032 expr: &'gcx hir::Expr,
3033 lvalue_pref: LvaluePreference,
3034 base: &'gcx hir::Expr,
3035 idx: codemap::Spanned<usize>) -> Ty<'tcx> {
3036 let expr_t = self.check_expr_with_lvalue_pref(base, lvalue_pref);
3037 let expr_t = self.structurally_resolved_type(expr.span,
3039 let mut private_candidate = None;
3040 let mut tuple_like = false;
3041 let mut autoderef = self.autoderef(expr.span, expr_t);
3042 while let Some((base_t, _)) = autoderef.next() {
3043 let field = match base_t.sty {
3044 ty::TyAdt(base_def, substs) if base_def.is_struct() => {
3045 tuple_like = base_def.struct_variant().ctor_kind == CtorKind::Fn;
3046 if !tuple_like { continue }
3048 debug!("tuple struct named {:?}", base_t);
3049 let ident = ast::Ident {
3050 name: Symbol::intern(&idx.node.to_string()),
3051 ctxt: idx.span.ctxt.modern(),
3053 let (ident, def_scope) =
3054 self.tcx.adjust_ident(ident, base_def.did, self.body_id);
3055 let fields = &base_def.struct_variant().fields;
3056 if let Some(field) = fields.iter().find(|f| f.name.to_ident() == ident) {
3057 let field_ty = self.field_ty(expr.span, field, substs);
3058 if field.vis.is_accessible_from(def_scope, self.tcx) {
3059 self.tcx.check_stability(field.did, expr.id, expr.span);
3062 private_candidate = Some((base_def.did, field_ty));
3069 ty::TyTuple(ref v, _) => {
3071 v.get(idx.node).cloned()
3076 if let Some(field_ty) = field {
3077 let adjustments = autoderef.adjust_steps(lvalue_pref);
3078 self.apply_adjustments(base, adjustments);
3079 autoderef.finalize();
3083 autoderef.unambiguous_final_ty();
3085 if let Some((did, field_ty)) = private_candidate {
3086 let struct_path = self.tcx().item_path_str(did);
3087 struct_span_err!(self.tcx().sess, expr.span, E0611,
3088 "field `{}` of tuple-struct `{}` is private",
3089 idx.node, struct_path).emit();
3094 type_error_struct!(self.tcx().sess, expr.span, expr_t, E0612,
3095 "attempted out-of-bounds tuple index `{}` on type `{}`",
3096 idx.node, expr_t).emit();
3098 self.no_such_field_err(expr.span, idx.node, expr_t).emit();
3101 self.tcx().types.err
3104 fn no_such_field_err<T: Display>(&self, span: Span, field: T, expr_t: &ty::TyS)
3105 -> DiagnosticBuilder {
3106 type_error_struct!(self.tcx().sess, span, expr_t, E0609,
3107 "no field `{}` on type `{}`",
3111 fn report_unknown_field(&self,
3113 variant: &'tcx ty::VariantDef,
3115 skip_fields: &[hir::Field],
3117 let mut err = self.type_error_struct_with_diag(
3119 |actual| match ty.sty {
3120 ty::TyAdt(adt, ..) if adt.is_enum() => {
3121 struct_span_err!(self.tcx.sess, field.name.span, E0559,
3122 "{} `{}::{}` has no field named `{}`",
3123 kind_name, actual, variant.name, field.name.node)
3126 struct_span_err!(self.tcx.sess, field.name.span, E0560,
3127 "{} `{}` has no field named `{}`",
3128 kind_name, actual, field.name.node)
3132 // prevent all specified fields from being suggested
3133 let skip_fields = skip_fields.iter().map(|ref x| x.name.node.as_str());
3134 if let Some(field_name) = Self::suggest_field_name(variant,
3136 skip_fields.collect()) {
3137 err.span_label(field.name.span,
3138 format!("field does not exist - did you mean `{}`?", field_name));
3141 ty::TyAdt(adt, ..) => {
3143 err.span_label(field.name.span,
3144 format!("`{}::{}` does not have this field",
3147 err.span_label(field.name.span,
3148 format!("`{}` does not have this field", ty));
3150 let available_field_names = self.available_field_names(variant);
3151 if !available_field_names.is_empty() {
3152 err.note(&format!("available fields are: {}",
3153 self.name_series_display(available_field_names)));
3156 _ => bug!("non-ADT passed to report_unknown_field")
3162 fn check_expr_struct_fields(&self,
3164 expected: Expectation<'tcx>,
3165 expr_id: ast::NodeId,
3167 variant: &'tcx ty::VariantDef,
3168 ast_fields: &'gcx [hir::Field],
3169 check_completeness: bool) {
3173 self.expected_inputs_for_expected_output(span, expected, adt_ty, &[adt_ty])
3174 .get(0).cloned().unwrap_or(adt_ty);
3175 // re-link the regions that EIfEO can erase.
3176 self.demand_eqtype(span, adt_ty_hint, adt_ty);
3178 let (substs, adt_kind, kind_name) = match &adt_ty.sty{
3179 &ty::TyAdt(adt, substs) => {
3180 (substs, adt.adt_kind(), adt.variant_descr())
3182 _ => span_bug!(span, "non-ADT passed to check_expr_struct_fields")
3185 let mut remaining_fields = FxHashMap();
3186 for field in &variant.fields {
3187 remaining_fields.insert(field.name.to_ident(), field);
3190 let mut seen_fields = FxHashMap();
3192 let mut error_happened = false;
3194 // Typecheck each field.
3195 for field in ast_fields {
3196 let ident = tcx.adjust(field.name.node, variant.did, self.body_id).0;
3197 let field_type = if let Some(v_field) = remaining_fields.remove(&ident) {
3198 seen_fields.insert(field.name.node, field.span);
3200 // we don't look at stability attributes on
3201 // struct-like enums (yet...), but it's definitely not
3202 // a bug to have construct one.
3203 if adt_kind != ty::AdtKind::Enum {
3204 tcx.check_stability(v_field.did, expr_id, field.span);
3207 self.field_ty(field.span, v_field, substs)
3209 error_happened = true;
3210 if let Some(_) = variant.find_field_named(field.name.node) {
3211 let mut err = struct_span_err!(self.tcx.sess,
3214 "field `{}` specified more than once",
3217 err.span_label(field.name.span, "used more than once");
3219 if let Some(prev_span) = seen_fields.get(&field.name.node) {
3220 err.span_label(*prev_span, format!("first use of `{}`", field.name.node));
3225 self.report_unknown_field(adt_ty, variant, field, ast_fields, kind_name);
3231 // Make sure to give a type to the field even if there's
3232 // an error, so we can continue typechecking
3233 self.check_expr_coercable_to_type(&field.expr, field_type);
3236 // Make sure the programmer specified correct number of fields.
3237 if kind_name == "union" {
3238 if ast_fields.len() != 1 {
3239 tcx.sess.span_err(span, "union expressions should have exactly one field");
3241 } else if check_completeness && !error_happened && !remaining_fields.is_empty() {
3242 let len = remaining_fields.len();
3244 let mut displayable_field_names = remaining_fields
3246 .map(|ident| ident.name.as_str())
3247 .collect::<Vec<_>>();
3249 displayable_field_names.sort();
3251 let truncated_fields_error = if len <= 3 {
3254 format!(" and {} other field{}", (len - 3), if len - 3 == 1 {""} else {"s"})
3257 let remaining_fields_names = displayable_field_names.iter().take(3)
3258 .map(|n| format!("`{}`", n))
3259 .collect::<Vec<_>>()
3262 struct_span_err!(tcx.sess, span, E0063,
3263 "missing field{} {}{} in initializer of `{}`",
3264 if remaining_fields.len() == 1 { "" } else { "s" },
3265 remaining_fields_names,
3266 truncated_fields_error,
3268 .span_label(span, format!("missing {}{}",
3269 remaining_fields_names,
3270 truncated_fields_error))
3275 fn check_struct_fields_on_error(&self,
3276 fields: &'gcx [hir::Field],
3277 base_expr: &'gcx Option<P<hir::Expr>>) {
3278 for field in fields {
3279 self.check_expr(&field.expr);
3283 self.check_expr(&base);
3289 pub fn check_struct_path(&self,
3291 node_id: ast::NodeId)
3292 -> Option<(&'tcx ty::VariantDef, Ty<'tcx>)> {
3293 let path_span = match *qpath {
3294 hir::QPath::Resolved(_, ref path) => path.span,
3295 hir::QPath::TypeRelative(ref qself, _) => qself.span
3297 let (def, ty) = self.finish_resolving_struct_path(qpath, path_span, node_id);
3298 let variant = match def {
3300 self.set_tainted_by_errors();
3303 Def::Variant(..) => {
3305 ty::TyAdt(adt, substs) => {
3306 Some((adt.variant_of_def(def), adt.did, substs))
3308 _ => bug!("unexpected type: {:?}", ty.sty)
3311 Def::Struct(..) | Def::Union(..) | Def::TyAlias(..) |
3312 Def::AssociatedTy(..) | Def::SelfTy(..) => {
3314 ty::TyAdt(adt, substs) if !adt.is_enum() => {
3315 Some((adt.struct_variant(), adt.did, substs))
3320 _ => bug!("unexpected definition: {:?}", def)
3323 if let Some((variant, did, substs)) = variant {
3324 // Check bounds on type arguments used in the path.
3325 let bounds = self.instantiate_bounds(path_span, did, substs);
3326 let cause = traits::ObligationCause::new(path_span, self.body_id,
3327 traits::ItemObligation(did));
3328 self.add_obligations_for_parameters(cause, &bounds);
3332 struct_span_err!(self.tcx.sess, path_span, E0071,
3333 "expected struct, variant or union type, found {}",
3334 ty.sort_string(self.tcx))
3335 .span_label(path_span, "not a struct")
3341 fn check_expr_struct(&self,
3343 expected: Expectation<'tcx>,
3345 fields: &'gcx [hir::Field],
3346 base_expr: &'gcx Option<P<hir::Expr>>) -> Ty<'tcx>
3348 // Find the relevant variant
3349 let (variant, struct_ty) =
3350 if let Some(variant_ty) = self.check_struct_path(qpath, expr.id) {
3353 self.check_struct_fields_on_error(fields, base_expr);
3354 return self.tcx.types.err;
3357 let path_span = match *qpath {
3358 hir::QPath::Resolved(_, ref path) => path.span,
3359 hir::QPath::TypeRelative(ref qself, _) => qself.span
3362 self.check_expr_struct_fields(struct_ty, expected, expr.id, path_span, variant, fields,
3363 base_expr.is_none());
3364 if let &Some(ref base_expr) = base_expr {
3365 self.check_expr_has_type_or_error(base_expr, struct_ty);
3366 match struct_ty.sty {
3367 ty::TyAdt(adt, substs) if adt.is_struct() => {
3368 let fru_field_types = adt.struct_variant().fields.iter().map(|f| {
3369 self.normalize_associated_types_in(expr.span, &f.ty(self.tcx, substs))
3371 self.tables.borrow_mut().fru_field_types.insert(expr.id, fru_field_types);
3374 span_err!(self.tcx.sess, base_expr.span, E0436,
3375 "functional record update syntax requires a struct");
3379 self.require_type_is_sized(struct_ty, expr.span, traits::StructInitializerSized);
3385 /// If an expression has any sub-expressions that result in a type error,
3386 /// inspecting that expression's type with `ty.references_error()` will return
3387 /// true. Likewise, if an expression is known to diverge, inspecting its
3388 /// type with `ty::type_is_bot` will return true (n.b.: since Rust is
3389 /// strict, _|_ can appear in the type of an expression that does not,
3390 /// itself, diverge: for example, fn() -> _|_.)
3391 /// Note that inspecting a type's structure *directly* may expose the fact
3392 /// that there are actually multiple representations for `TyError`, so avoid
3393 /// that when err needs to be handled differently.
3394 fn check_expr_with_expectation_and_lvalue_pref(&self,
3395 expr: &'gcx hir::Expr,
3396 expected: Expectation<'tcx>,
3397 lvalue_pref: LvaluePreference) -> Ty<'tcx> {
3398 debug!(">> typechecking: expr={:?} expected={:?}",
3401 // Warn for expressions after diverging siblings.
3402 self.warn_if_unreachable(expr.id, expr.span, "expression");
3404 // Hide the outer diverging and has_errors flags.
3405 let old_diverges = self.diverges.get();
3406 let old_has_errors = self.has_errors.get();
3407 self.diverges.set(Diverges::Maybe);
3408 self.has_errors.set(false);
3410 let ty = self.check_expr_kind(expr, expected, lvalue_pref);
3412 // Warn for non-block expressions with diverging children.
3415 hir::ExprLoop(..) | hir::ExprWhile(..) |
3416 hir::ExprIf(..) | hir::ExprMatch(..) => {}
3418 _ => self.warn_if_unreachable(expr.id, expr.span, "expression")
3421 // Any expression that produces a value of type `!` must have diverged
3423 self.diverges.set(self.diverges.get() | Diverges::Always);
3426 // Record the type, which applies it effects.
3427 // We need to do this after the warning above, so that
3428 // we don't warn for the diverging expression itself.
3429 self.write_ty(expr.id, ty);
3431 // Combine the diverging and has_error flags.
3432 self.diverges.set(self.diverges.get() | old_diverges);
3433 self.has_errors.set(self.has_errors.get() | old_has_errors);
3435 debug!("type of {} is...", self.tcx.hir.node_to_string(expr.id));
3436 debug!("... {:?}, expected is {:?}", ty, expected);
3441 fn check_expr_kind(&self,
3442 expr: &'gcx hir::Expr,
3443 expected: Expectation<'tcx>,
3444 lvalue_pref: LvaluePreference) -> Ty<'tcx> {
3448 hir::ExprBox(ref subexpr) => {
3449 let expected_inner = expected.to_option(self).map_or(NoExpectation, |ty| {
3451 ty::TyAdt(def, _) if def.is_box()
3452 => Expectation::rvalue_hint(self, ty.boxed_ty()),
3456 let referent_ty = self.check_expr_with_expectation(subexpr, expected_inner);
3457 tcx.mk_box(referent_ty)
3460 hir::ExprLit(ref lit) => {
3461 self.check_lit(&lit, expected)
3463 hir::ExprBinary(op, ref lhs, ref rhs) => {
3464 self.check_binop(expr, op, lhs, rhs)
3466 hir::ExprAssignOp(op, ref lhs, ref rhs) => {
3467 self.check_binop_assign(expr, op, lhs, rhs)
3469 hir::ExprUnary(unop, ref oprnd) => {
3470 let expected_inner = match unop {
3471 hir::UnNot | hir::UnNeg => {
3478 let lvalue_pref = match unop {
3479 hir::UnDeref => lvalue_pref,
3482 let mut oprnd_t = self.check_expr_with_expectation_and_lvalue_pref(&oprnd,
3486 if !oprnd_t.references_error() {
3487 oprnd_t = self.structurally_resolved_type(expr.span, oprnd_t);
3490 if let Some(mt) = oprnd_t.builtin_deref(true, NoPreference) {
3492 } else if let Some(ok) = self.try_overloaded_deref(
3493 expr.span, oprnd_t, lvalue_pref) {
3494 let method = self.register_infer_ok_obligations(ok);
3495 if let ty::TyRef(region, mt) = method.sig.inputs()[0].sty {
3496 self.apply_adjustments(oprnd, vec![Adjustment {
3497 kind: Adjust::Borrow(AutoBorrow::Ref(region, mt.mutbl)),
3498 target: method.sig.inputs()[0]
3501 oprnd_t = self.make_overloaded_lvalue_return_type(method).ty;
3502 self.write_method_call(expr.id, method);
3504 type_error_struct!(tcx.sess, expr.span, oprnd_t, E0614,
3505 "type `{}` cannot be dereferenced",
3507 oprnd_t = tcx.types.err;
3511 let result = self.check_user_unop(expr, oprnd_t, unop);
3512 // If it's builtin, we can reuse the type, this helps inference.
3513 if !(oprnd_t.is_integral() || oprnd_t.sty == ty::TyBool) {
3518 let result = self.check_user_unop(expr, oprnd_t, unop);
3519 // If it's builtin, we can reuse the type, this helps inference.
3520 if !(oprnd_t.is_integral() || oprnd_t.is_fp()) {
3528 hir::ExprAddrOf(mutbl, ref oprnd) => {
3529 let hint = expected.only_has_type(self).map_or(NoExpectation, |ty| {
3531 ty::TyRef(_, ref mt) | ty::TyRawPtr(ref mt) => {
3532 if self.tcx.expr_is_lval(&oprnd) {
3533 // Lvalues may legitimately have unsized types.
3534 // For example, dereferences of a fat pointer and
3535 // the last field of a struct can be unsized.
3536 ExpectHasType(mt.ty)
3538 Expectation::rvalue_hint(self, mt.ty)
3544 let lvalue_pref = LvaluePreference::from_mutbl(mutbl);
3545 let ty = self.check_expr_with_expectation_and_lvalue_pref(&oprnd, hint, lvalue_pref);
3547 let tm = ty::TypeAndMut { ty: ty, mutbl: mutbl };
3548 if tm.ty.references_error() {
3551 // Note: at this point, we cannot say what the best lifetime
3552 // is to use for resulting pointer. We want to use the
3553 // shortest lifetime possible so as to avoid spurious borrowck
3554 // errors. Moreover, the longest lifetime will depend on the
3555 // precise details of the value whose address is being taken
3556 // (and how long it is valid), which we don't know yet until type
3557 // inference is complete.
3559 // Therefore, here we simply generate a region variable. The
3560 // region inferencer will then select the ultimate value.
3561 // Finally, borrowck is charged with guaranteeing that the
3562 // value whose address was taken can actually be made to live
3563 // as long as it needs to live.
3564 let region = self.next_region_var(infer::AddrOfRegion(expr.span));
3565 tcx.mk_ref(region, tm)
3568 hir::ExprPath(ref qpath) => {
3569 let (def, opt_ty, segments) = self.resolve_ty_and_def_ufcs(qpath,
3570 expr.id, expr.span);
3571 let ty = if def != Def::Err {
3572 self.instantiate_value_path(segments, opt_ty, def, expr.span, id)
3574 self.set_tainted_by_errors();
3578 // We always require that the type provided as the value for
3579 // a type parameter outlives the moment of instantiation.
3580 let substs = self.tables.borrow().node_substs(expr.id);
3581 self.add_wf_bounds(substs, expr);
3585 hir::ExprInlineAsm(_, ref outputs, ref inputs) => {
3586 for output in outputs {
3587 self.check_expr(output);
3589 for input in inputs {
3590 self.check_expr(input);
3594 hir::ExprBreak(destination, ref expr_opt) => {
3595 if let Some(target_id) = destination.target_id.opt_id() {
3596 let (e_ty, e_diverges, cause);
3597 if let Some(ref e) = *expr_opt {
3598 // If this is a break with a value, we need to type-check
3599 // the expression. Get an expected type from the loop context.
3600 let opt_coerce_to = {
3601 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
3602 enclosing_breakables.find_breakable(target_id)
3605 .map(|coerce| coerce.expected_ty())
3608 // If the loop context is not a `loop { }`, then break with
3609 // a value is illegal, and `opt_coerce_to` will be `None`.
3610 // Just set expectation to error in that case.
3611 let coerce_to = opt_coerce_to.unwrap_or(tcx.types.err);
3613 // Recurse without `enclosing_breakables` borrowed.
3614 e_ty = self.check_expr_with_hint(e, coerce_to);
3615 e_diverges = self.diverges.get();
3616 cause = self.misc(e.span);
3618 // Otherwise, this is a break *without* a value. That's
3619 // always legal, and is equivalent to `break ()`.
3620 e_ty = tcx.mk_nil();
3621 e_diverges = Diverges::Maybe;
3622 cause = self.misc(expr.span);
3625 // Now that we have type-checked `expr_opt`, borrow
3626 // the `enclosing_loops` field and let's coerce the
3627 // type of `expr_opt` into what is expected.
3628 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
3629 let ctxt = enclosing_breakables.find_breakable(target_id);
3630 if let Some(ref mut coerce) = ctxt.coerce {
3631 if let Some(ref e) = *expr_opt {
3632 coerce.coerce(self, &cause, e, e_ty, e_diverges);
3634 assert!(e_ty.is_nil());
3635 coerce.coerce_forced_unit(self, &cause, &mut |_| (), true);
3638 // If `ctxt.coerce` is `None`, we can just ignore
3639 // the type of the expresison. This is because
3640 // either this was a break *without* a value, in
3641 // which case it is always a legal type (`()`), or
3642 // else an error would have been flagged by the
3643 // `loops` pass for using break with an expression
3644 // where you are not supposed to.
3645 assert!(expr_opt.is_none() || self.tcx.sess.err_count() > 0);
3648 ctxt.may_break = true;
3650 // Otherwise, we failed to find the enclosing loop;
3651 // this can only happen if the `break` was not
3652 // inside a loop at all, which is caught by the
3653 // loop-checking pass.
3654 assert!(self.tcx.sess.err_count() > 0);
3657 // the type of a `break` is always `!`, since it diverges
3660 hir::ExprAgain(_) => { tcx.types.never }
3661 hir::ExprRet(ref expr_opt) => {
3662 if self.ret_coercion.is_none() {
3663 struct_span_err!(self.tcx.sess, expr.span, E0572,
3664 "return statement outside of function body").emit();
3665 } else if let Some(ref e) = *expr_opt {
3666 self.check_return_expr(e);
3668 let mut coercion = self.ret_coercion.as_ref().unwrap().borrow_mut();
3669 let cause = self.cause(expr.span, ObligationCauseCode::ReturnNoExpression);
3670 coercion.coerce_forced_unit(self, &cause, &mut |_| (), true);
3674 hir::ExprAssign(ref lhs, ref rhs) => {
3675 let lhs_ty = self.check_expr_with_lvalue_pref(&lhs, PreferMutLvalue);
3677 let rhs_ty = self.check_expr_coercable_to_type(&rhs, lhs_ty);
3680 ExpectIfCondition => {
3681 self.tcx.sess.delay_span_bug(lhs.span, "invalid lhs expression in if;\
3682 expected error elsehwere");
3685 // Only check this if not in an `if` condition, as the
3686 // mistyped comparison help is more appropriate.
3687 if !self.tcx.expr_is_lval(&lhs) {
3689 self.tcx.sess, expr.span, E0070,
3690 "invalid left-hand side expression")
3693 "left-hand of expression not valid")
3699 self.require_type_is_sized(lhs_ty, lhs.span, traits::AssignmentLhsSized);
3701 if lhs_ty.references_error() || rhs_ty.references_error() {
3707 hir::ExprIf(ref cond, ref then_expr, ref opt_else_expr) => {
3708 self.check_then_else(&cond, then_expr, opt_else_expr.as_ref().map(|e| &**e),
3709 expr.span, expected)
3711 hir::ExprWhile(ref cond, ref body, _) => {
3712 let ctxt = BreakableCtxt {
3713 // cannot use break with a value from a while loop
3718 self.with_breakable_ctxt(expr.id, ctxt, || {
3719 self.check_expr_has_type_or_error(&cond, tcx.types.bool);
3720 let cond_diverging = self.diverges.get();
3721 self.check_block_no_value(&body);
3723 // We may never reach the body so it diverging means nothing.
3724 self.diverges.set(cond_diverging);
3729 hir::ExprLoop(ref body, _, source) => {
3730 let coerce = match source {
3731 // you can only use break with a value from a normal `loop { }`
3732 hir::LoopSource::Loop => {
3733 let coerce_to = expected.coercion_target_type(self, body.span);
3734 Some(CoerceMany::new(coerce_to))
3737 hir::LoopSource::WhileLet |
3738 hir::LoopSource::ForLoop => {
3743 let ctxt = BreakableCtxt {
3745 may_break: false, // will get updated if/when we find a `break`
3748 let (ctxt, ()) = self.with_breakable_ctxt(expr.id, ctxt, || {
3749 self.check_block_no_value(&body);
3753 // No way to know whether it's diverging because
3754 // of a `break` or an outer `break` or `return.
3755 self.diverges.set(Diverges::Maybe);
3758 // If we permit break with a value, then result type is
3759 // the LUB of the breaks (possibly ! if none); else, it
3760 // is nil. This makes sense because infinite loops
3761 // (which would have type !) are only possible iff we
3762 // permit break with a value [1].
3763 assert!(ctxt.coerce.is_some() || ctxt.may_break); // [1]
3764 ctxt.coerce.map(|c| c.complete(self)).unwrap_or(self.tcx.mk_nil())
3766 hir::ExprMatch(ref discrim, ref arms, match_src) => {
3767 self.check_match(expr, &discrim, arms, expected, match_src)
3769 hir::ExprClosure(capture, ref decl, body_id, _) => {
3770 self.check_expr_closure(expr, capture, &decl, body_id, expected)
3772 hir::ExprBlock(ref body) => {
3773 self.check_block_with_expected(&body, expected)
3775 hir::ExprCall(ref callee, ref args) => {
3776 self.check_call(expr, &callee, args, expected)
3778 hir::ExprMethodCall(ref segment, span, ref args) => {
3779 self.check_method_call(expr, segment, span, args, expected, lvalue_pref)
3781 hir::ExprCast(ref e, ref t) => {
3782 // Find the type of `e`. Supply hints based on the type we are casting to,
3784 let t_cast = self.to_ty(t);
3785 let t_cast = self.resolve_type_vars_if_possible(&t_cast);
3786 let t_expr = self.check_expr_with_expectation(e, ExpectCastableToType(t_cast));
3787 let t_cast = self.resolve_type_vars_if_possible(&t_cast);
3788 let diverges = self.diverges.get();
3790 // Eagerly check for some obvious errors.
3791 if t_expr.references_error() || t_cast.references_error() {
3794 // Defer other checks until we're done type checking.
3795 let mut deferred_cast_checks = self.deferred_cast_checks.borrow_mut();
3796 match cast::CastCheck::new(self, e, t_expr, diverges, t_cast, t.span, expr.span) {
3798 deferred_cast_checks.push(cast_check);
3801 Err(ErrorReported) => {
3807 hir::ExprType(ref e, ref t) => {
3808 let typ = self.to_ty(&t);
3809 self.check_expr_eq_type(&e, typ);
3812 hir::ExprArray(ref args) => {
3813 let uty = expected.to_option(self).and_then(|uty| {
3815 ty::TyArray(ty, _) | ty::TySlice(ty) => Some(ty),
3820 let element_ty = if !args.is_empty() {
3821 let coerce_to = uty.unwrap_or_else(
3822 || self.next_ty_var(TypeVariableOrigin::TypeInference(expr.span)));
3823 let mut coerce = CoerceMany::with_coercion_sites(coerce_to, args);
3824 assert_eq!(self.diverges.get(), Diverges::Maybe);
3826 let e_ty = self.check_expr_with_hint(e, coerce_to);
3827 let cause = self.misc(e.span);
3828 coerce.coerce(self, &cause, e, e_ty, self.diverges.get());
3830 coerce.complete(self)
3832 self.next_ty_var(TypeVariableOrigin::TypeInference(expr.span))
3834 tcx.mk_array(element_ty, args.len())
3836 hir::ExprRepeat(ref element, count) => {
3837 let count = eval_length(self.tcx, count, "repeat count")
3840 let uty = match expected {
3841 ExpectHasType(uty) => {
3843 ty::TyArray(ty, _) | ty::TySlice(ty) => Some(ty),
3850 let (element_ty, t) = match uty {
3852 self.check_expr_coercable_to_type(&element, uty);
3856 let t: Ty = self.next_ty_var(TypeVariableOrigin::MiscVariable(element.span));
3857 let element_ty = self.check_expr_has_type_or_error(&element, t);
3863 // For [foo, ..n] where n > 1, `foo` must have
3865 let lang_item = self.tcx.require_lang_item(lang_items::CopyTraitLangItem);
3866 self.require_type_meets(t, expr.span, traits::RepeatVec, lang_item);
3869 if element_ty.references_error() {
3872 tcx.mk_array(t, count)
3875 hir::ExprTup(ref elts) => {
3876 let flds = expected.only_has_type(self).and_then(|ty| {
3878 ty::TyTuple(ref flds, _) => Some(&flds[..]),
3883 let elt_ts_iter = elts.iter().enumerate().map(|(i, e)| {
3884 let t = match flds {
3885 Some(ref fs) if i < fs.len() => {
3887 self.check_expr_coercable_to_type(&e, ety);
3891 self.check_expr_with_expectation(&e, NoExpectation)
3896 let tuple = tcx.mk_tup(elt_ts_iter, false);
3897 if tuple.references_error() {
3900 self.require_type_is_sized(tuple, expr.span, traits::TupleInitializerSized);
3904 hir::ExprStruct(ref qpath, ref fields, ref base_expr) => {
3905 self.check_expr_struct(expr, expected, qpath, fields, base_expr)
3907 hir::ExprField(ref base, ref field) => {
3908 self.check_field(expr, lvalue_pref, &base, field)
3910 hir::ExprTupField(ref base, idx) => {
3911 self.check_tup_field(expr, lvalue_pref, &base, idx)
3913 hir::ExprIndex(ref base, ref idx) => {
3914 let base_t = self.check_expr_with_lvalue_pref(&base, lvalue_pref);
3915 let idx_t = self.check_expr(&idx);
3917 if base_t.references_error() {
3919 } else if idx_t.references_error() {
3922 let base_t = self.structurally_resolved_type(expr.span, base_t);
3923 match self.lookup_indexing(expr, base, base_t, idx_t, lvalue_pref) {
3924 Some((index_ty, element_ty)) => {
3925 self.demand_coerce(idx, idx_t, index_ty);
3929 let mut err = type_error_struct!(tcx.sess, expr.span, base_t, E0608,
3930 "cannot index into a value of type `{}`",
3932 // Try to give some advice about indexing tuples.
3933 if let ty::TyTuple(..) = base_t.sty {
3934 let mut needs_note = true;
3935 // If the index is an integer, we can show the actual
3936 // fixed expression:
3937 if let hir::ExprLit(ref lit) = idx.node {
3938 if let ast::LitKind::Int(i,
3939 ast::LitIntType::Unsuffixed) = lit.node {
3940 let snip = tcx.sess.codemap().span_to_snippet(base.span);
3941 if let Ok(snip) = snip {
3942 err.span_suggestion(expr.span,
3943 "to access tuple elements, use",
3944 format!("{}.{}", snip, i));
3950 err.help("to access tuple elements, use tuple indexing \
3951 syntax (e.g. `tuple.0`)");
3963 // Finish resolving a path in a struct expression or pattern `S::A { .. }` if necessary.
3964 // The newly resolved definition is written into `type_dependent_defs`.
3965 fn finish_resolving_struct_path(&self,
3968 node_id: ast::NodeId)
3972 hir::QPath::Resolved(ref maybe_qself, ref path) => {
3973 let opt_self_ty = maybe_qself.as_ref().map(|qself| self.to_ty(qself));
3974 let ty = AstConv::def_to_ty(self, opt_self_ty, path, true);
3977 hir::QPath::TypeRelative(ref qself, ref segment) => {
3978 let ty = self.to_ty(qself);
3980 let def = if let hir::TyPath(hir::QPath::Resolved(_, ref path)) = qself.node {
3985 let (ty, def) = AstConv::associated_path_def_to_ty(self, node_id, path_span,
3988 // Write back the new resolution.
3989 self.tables.borrow_mut().type_dependent_defs.insert(node_id, def);
3996 // Resolve associated value path into a base type and associated constant or method definition.
3997 // The newly resolved definition is written into `type_dependent_defs`.
3998 pub fn resolve_ty_and_def_ufcs<'b>(&self,
3999 qpath: &'b hir::QPath,
4000 node_id: ast::NodeId,
4002 -> (Def, Option<Ty<'tcx>>, &'b [hir::PathSegment])
4004 let (ty, item_segment) = match *qpath {
4005 hir::QPath::Resolved(ref opt_qself, ref path) => {
4007 opt_qself.as_ref().map(|qself| self.to_ty(qself)),
4008 &path.segments[..]);
4010 hir::QPath::TypeRelative(ref qself, ref segment) => {
4011 (self.to_ty(qself), segment)
4014 let item_name = item_segment.name;
4015 let def = match self.resolve_ufcs(span, item_name, ty, node_id) {
4018 let def = match error {
4019 method::MethodError::PrivateMatch(def) => def,
4022 if item_name != keywords::Invalid.name() {
4023 self.report_method_error(span, ty, item_name, None, error, None);
4029 // Write back the new resolution.
4030 self.tables.borrow_mut().type_dependent_defs.insert(node_id, def);
4031 (def, Some(ty), slice::ref_slice(&**item_segment))
4034 pub fn check_decl_initializer(&self,
4035 local: &'gcx hir::Local,
4036 init: &'gcx hir::Expr) -> Ty<'tcx>
4038 // FIXME(tschottdorf): contains_explicit_ref_binding() must be removed
4040 let ref_bindings = local.pat.contains_explicit_ref_binding();
4042 let local_ty = self.local_ty(init.span, local.id);
4043 if let Some(m) = ref_bindings {
4044 // Somewhat subtle: if we have a `ref` binding in the pattern,
4045 // we want to avoid introducing coercions for the RHS. This is
4046 // both because it helps preserve sanity and, in the case of
4047 // ref mut, for soundness (issue #23116). In particular, in
4048 // the latter case, we need to be clear that the type of the
4049 // referent for the reference that results is *equal to* the
4050 // type of the lvalue it is referencing, and not some
4051 // supertype thereof.
4052 let init_ty = self.check_expr_with_lvalue_pref(init, LvaluePreference::from_mutbl(m));
4053 self.demand_eqtype(init.span, init_ty, local_ty);
4056 self.check_expr_coercable_to_type(init, local_ty)
4060 pub fn check_decl_local(&self, local: &'gcx hir::Local) {
4061 let t = self.local_ty(local.span, local.id);
4062 self.write_ty(local.id, t);
4064 if let Some(ref init) = local.init {
4065 let init_ty = self.check_decl_initializer(local, &init);
4066 if init_ty.references_error() {
4067 self.write_ty(local.id, init_ty);
4071 self.check_pat(&local.pat, t);
4072 let pat_ty = self.node_ty(local.pat.id);
4073 if pat_ty.references_error() {
4074 self.write_ty(local.id, pat_ty);
4078 pub fn check_stmt(&self, stmt: &'gcx hir::Stmt) {
4079 // Don't do all the complex logic below for DeclItem.
4081 hir::StmtDecl(ref decl, _) => {
4083 hir::DeclLocal(_) => {}
4084 hir::DeclItem(_) => {
4089 hir::StmtExpr(..) | hir::StmtSemi(..) => {}
4092 self.warn_if_unreachable(stmt.node.id(), stmt.span, "statement");
4094 // Hide the outer diverging and has_errors flags.
4095 let old_diverges = self.diverges.get();
4096 let old_has_errors = self.has_errors.get();
4097 self.diverges.set(Diverges::Maybe);
4098 self.has_errors.set(false);
4101 hir::StmtDecl(ref decl, _) => {
4103 hir::DeclLocal(ref l) => {
4104 self.check_decl_local(&l);
4106 hir::DeclItem(_) => {/* ignore for now */}
4109 hir::StmtExpr(ref expr, _) => {
4110 // Check with expected type of ()
4111 self.check_expr_has_type_or_error(&expr, self.tcx.mk_nil());
4113 hir::StmtSemi(ref expr, _) => {
4114 self.check_expr(&expr);
4118 // Combine the diverging and has_error flags.
4119 self.diverges.set(self.diverges.get() | old_diverges);
4120 self.has_errors.set(self.has_errors.get() | old_has_errors);
4123 pub fn check_block_no_value(&self, blk: &'gcx hir::Block) {
4124 let unit = self.tcx.mk_nil();
4125 let ty = self.check_block_with_expected(blk, ExpectHasType(unit));
4127 // if the block produces a `!` value, that can always be
4128 // (effectively) coerced to unit.
4130 self.demand_suptype(blk.span, unit, ty);
4134 fn check_block_with_expected(&self,
4135 blk: &'gcx hir::Block,
4136 expected: Expectation<'tcx>) -> Ty<'tcx> {
4138 let mut fcx_ps = self.ps.borrow_mut();
4139 let unsafety_state = fcx_ps.recurse(blk);
4140 replace(&mut *fcx_ps, unsafety_state)
4143 // In some cases, blocks have just one exit, but other blocks
4144 // can be targeted by multiple breaks. This cannot happen in
4145 // normal Rust syntax today, but it can happen when we desugar
4146 // a `do catch { ... }` expression.
4150 // 'a: { if true { break 'a Err(()); } Ok(()) }
4152 // Here we would wind up with two coercions, one from
4153 // `Err(())` and the other from the tail expression
4154 // `Ok(())`. If the tail expression is omitted, that's a
4155 // "forced unit" -- unless the block diverges, in which
4156 // case we can ignore the tail expression (e.g., `'a: {
4157 // break 'a 22; }` would not force the type of the block
4159 let tail_expr = blk.expr.as_ref();
4160 let coerce_to_ty = expected.coercion_target_type(self, blk.span);
4161 let coerce = if blk.targeted_by_break {
4162 CoerceMany::new(coerce_to_ty)
4164 let tail_expr: &[P<hir::Expr>] = match tail_expr {
4165 Some(e) => ref_slice(e),
4168 CoerceMany::with_coercion_sites(coerce_to_ty, tail_expr)
4171 let ctxt = BreakableCtxt {
4172 coerce: Some(coerce),
4176 let (ctxt, ()) = self.with_breakable_ctxt(blk.id, ctxt, || {
4177 for s in &blk.stmts {
4181 // check the tail expression **without** holding the
4182 // `enclosing_breakables` lock below.
4183 let tail_expr_ty = tail_expr.map(|t| self.check_expr_with_expectation(t, expected));
4185 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4186 let mut ctxt = enclosing_breakables.find_breakable(blk.id);
4187 let mut coerce = ctxt.coerce.as_mut().unwrap();
4188 if let Some(tail_expr_ty) = tail_expr_ty {
4189 let tail_expr = tail_expr.unwrap();
4190 let cause = self.cause(tail_expr.span,
4191 ObligationCauseCode::BlockTailExpression(blk.id));
4196 self.diverges.get());
4198 // Subtle: if there is no explicit tail expression,
4199 // that is typically equivalent to a tail expression
4200 // of `()` -- except if the block diverges. In that
4201 // case, there is no value supplied from the tail
4202 // expression (assuming there are no other breaks,
4203 // this implies that the type of the block will be
4206 // #41425 -- label the implicit `()` as being the
4207 // "found type" here, rather than the "expected type".
4208 if !self.diverges.get().always() {
4209 coerce.coerce_forced_unit(self, &self.misc(blk.span), &mut |err| {
4210 if let Some(expected_ty) = expected.only_has_type(self) {
4211 self.consider_hint_about_removing_semicolon(blk,
4220 let mut ty = ctxt.coerce.unwrap().complete(self);
4222 if self.has_errors.get() || ty.references_error() {
4223 ty = self.tcx.types.err
4226 self.write_ty(blk.id, ty);
4228 *self.ps.borrow_mut() = prev;
4232 /// Given a `NodeId`, return the `FnDecl` of the method it is enclosed by and whether it is
4233 /// `fn main` if it is a method, `None` otherwise.
4234 pub fn get_fn_decl(&self, blk_id: ast::NodeId) -> Option<(hir::FnDecl, bool)> {
4235 // Get enclosing Fn, if it is a function or a trait method, unless there's a `loop` or
4236 // `while` before reaching it, as block tail returns are not available in them.
4237 if let Some(fn_id) = self.tcx.hir.get_return_block(blk_id) {
4238 let parent = self.tcx.hir.get(fn_id);
4240 if let Node::NodeItem(&hir::Item {
4241 name, node: hir::ItemFn(ref decl, ..), ..
4243 decl.clone().and_then(|decl| {
4244 // This is less than ideal, it will not present the return type span on any
4245 // method called `main`, regardless of whether it is actually the entry point.
4246 Some((decl, name == Symbol::intern("main")))
4248 } else if let Node::NodeTraitItem(&hir::TraitItem {
4249 node: hir::TraitItemKind::Method(hir::MethodSig {
4253 decl.clone().and_then(|decl| {
4264 /// On implicit return expressions with mismatched types, provide the following suggestions:
4266 /// - Point out the method's return type as the reason for the expected type
4267 /// - Possible missing semicolon
4268 /// - Possible missing return type if the return type is the default, and not `fn main()`
4269 pub fn suggest_mismatched_types_on_tail(&self,
4270 err: &mut DiagnosticBuilder<'tcx>,
4271 expression: &'gcx hir::Expr,
4275 blk_id: ast::NodeId) {
4276 self.suggest_missing_semicolon(err, expression, expected, cause_span);
4278 if let Some((fn_decl, is_main)) = self.get_fn_decl(blk_id) {
4279 // `fn main()` must return `()`, do not suggest changing return type
4281 self.suggest_missing_return_type(err, &fn_decl, found);
4286 /// A common error is to forget to add a semicolon at the end of a block:
4290 /// bar_that_returns_u32()
4294 /// This routine checks if the return expression in a block would make sense on its own as a
4295 /// statement and the return type has been left as defaultor has been specified as `()`. If so,
4296 /// it suggests adding a semicolon.
4297 fn suggest_missing_semicolon(&self,
4298 err: &mut DiagnosticBuilder<'tcx>,
4299 expression: &'gcx hir::Expr,
4302 if expected.is_nil() {
4303 // `BlockTailExpression` only relevant if the tail expr would be
4304 // useful on its own.
4305 match expression.node {
4307 hir::ExprMethodCall(..) |
4309 hir::ExprWhile(..) |
4311 hir::ExprMatch(..) |
4312 hir::ExprBlock(..) => {
4313 let sp = cause_span.next_point();
4314 err.span_suggestion(sp,
4315 "try adding a semicolon",
4324 /// A possible error is to forget to add a return type that is needed:
4328 /// bar_that_returns_u32()
4332 /// This routine checks if the return type is left as default, the method is not part of an
4333 /// `impl` block and that it isn't the `main` method. If so, it suggests setting the return
4335 fn suggest_missing_return_type(&self,
4336 err: &mut DiagnosticBuilder<'tcx>,
4337 fn_decl: &hir::FnDecl,
4340 // Only recommend changing the return type for methods that
4341 // haven't set a return type at all (and aren't `fn main()` or an impl).
4342 if let &hir::FnDecl {
4343 output: hir::FunctionRetTy::DefaultReturn(span), ..
4345 if ty.is_suggestable() {
4346 err.span_suggestion(span,
4347 "try adding a return type",
4348 format!("-> {} ", ty));
4350 err.span_label(span, "possibly return type missing here?");
4356 /// A common error is to add an extra semicolon:
4359 /// fn foo() -> usize {
4364 /// This routine checks if the final statement in a block is an
4365 /// expression with an explicit semicolon whose type is compatible
4366 /// with `expected_ty`. If so, it suggests removing the semicolon.
4367 fn consider_hint_about_removing_semicolon(&self,
4368 blk: &'gcx hir::Block,
4369 expected_ty: Ty<'tcx>,
4370 err: &mut DiagnosticBuilder) {
4371 // Be helpful when the user wrote `{... expr;}` and
4372 // taking the `;` off is enough to fix the error.
4373 let last_stmt = match blk.stmts.last() {
4377 let last_expr = match last_stmt.node {
4378 hir::StmtSemi(ref e, _) => e,
4381 let last_expr_ty = self.node_ty(last_expr.id);
4382 if self.can_sub(self.param_env, last_expr_ty, expected_ty).is_err() {
4385 let original_span = original_sp(last_stmt.span, blk.span);
4386 let span_semi = Span {
4387 lo: original_span.hi - BytePos(1),
4388 hi: original_span.hi,
4389 ctxt: original_span.ctxt,
4391 err.span_suggestion(span_semi, "consider removing this semicolon", "".to_string());
4394 // Instantiates the given path, which must refer to an item with the given
4395 // number of type parameters and type.
4396 pub fn instantiate_value_path(&self,
4397 segments: &[hir::PathSegment],
4398 opt_self_ty: Option<Ty<'tcx>>,
4401 node_id: ast::NodeId)
4403 debug!("instantiate_value_path(path={:?}, def={:?}, node_id={})",
4408 // We need to extract the type parameters supplied by the user in
4409 // the path `path`. Due to the current setup, this is a bit of a
4410 // tricky-process; the problem is that resolve only tells us the
4411 // end-point of the path resolution, and not the intermediate steps.
4412 // Luckily, we can (at least for now) deduce the intermediate steps
4413 // just from the end-point.
4415 // There are basically four cases to consider:
4417 // 1. Reference to a constructor of enum variant or struct:
4419 // struct Foo<T>(...)
4420 // enum E<T> { Foo(...) }
4422 // In these cases, the parameters are declared in the type
4425 // 2. Reference to a fn item or a free constant:
4429 // In this case, the path will again always have the form
4430 // `a::b::foo::<T>` where only the final segment should have
4431 // type parameters. However, in this case, those parameters are
4432 // declared on a value, and hence are in the `FnSpace`.
4434 // 3. Reference to a method or an associated constant:
4436 // impl<A> SomeStruct<A> {
4440 // Here we can have a path like
4441 // `a::b::SomeStruct::<A>::foo::<B>`, in which case parameters
4442 // may appear in two places. The penultimate segment,
4443 // `SomeStruct::<A>`, contains parameters in TypeSpace, and the
4444 // final segment, `foo::<B>` contains parameters in fn space.
4446 // 4. Reference to a local variable
4448 // Local variables can't have any type parameters.
4450 // The first step then is to categorize the segments appropriately.
4452 assert!(!segments.is_empty());
4454 let mut ufcs_associated = None;
4455 let mut type_segment = None;
4456 let mut fn_segment = None;
4458 // Case 1. Reference to a struct/variant constructor.
4459 Def::StructCtor(def_id, ..) |
4460 Def::VariantCtor(def_id, ..) => {
4461 // Everything but the final segment should have no
4462 // parameters at all.
4463 let mut generics = self.tcx.generics_of(def_id);
4464 if let Some(def_id) = generics.parent {
4465 // Variant and struct constructors use the
4466 // generics of their parent type definition.
4467 generics = self.tcx.generics_of(def_id);
4469 type_segment = Some((segments.last().unwrap(), generics));
4472 // Case 2. Reference to a top-level value.
4474 Def::Const(def_id) |
4475 Def::Static(def_id, _) => {
4476 fn_segment = Some((segments.last().unwrap(),
4477 self.tcx.generics_of(def_id)));
4480 // Case 3. Reference to a method or associated const.
4481 Def::Method(def_id) |
4482 Def::AssociatedConst(def_id) => {
4483 let container = self.tcx.associated_item(def_id).container;
4485 ty::TraitContainer(trait_did) => {
4486 callee::check_legal_trait_for_method_call(self.tcx, span, trait_did)
4488 ty::ImplContainer(_) => {}
4491 let generics = self.tcx.generics_of(def_id);
4492 if segments.len() >= 2 {
4493 let parent_generics = self.tcx.generics_of(generics.parent.unwrap());
4494 type_segment = Some((&segments[segments.len() - 2], parent_generics));
4496 // `<T>::assoc` will end up here, and so can `T::assoc`.
4497 let self_ty = opt_self_ty.expect("UFCS sugared assoc missing Self");
4498 ufcs_associated = Some((container, self_ty));
4500 fn_segment = Some((segments.last().unwrap(), generics));
4503 // Case 4. Local variable, no generics.
4504 Def::Local(..) | Def::Upvar(..) => {}
4506 _ => bug!("unexpected definition: {:?}", def),
4509 debug!("type_segment={:?} fn_segment={:?}", type_segment, fn_segment);
4511 // Now that we have categorized what space the parameters for each
4512 // segment belong to, let's sort out the parameters that the user
4513 // provided (if any) into their appropriate spaces. We'll also report
4514 // errors if type parameters are provided in an inappropriate place.
4515 let poly_segments = type_segment.is_some() as usize +
4516 fn_segment.is_some() as usize;
4517 AstConv::prohibit_type_params(self, &segments[..segments.len() - poly_segments]);
4520 Def::Local(def_id) | Def::Upvar(def_id, ..) => {
4521 let nid = self.tcx.hir.as_local_node_id(def_id).unwrap();
4522 let ty = self.local_ty(span, nid);
4523 let ty = self.normalize_associated_types_in(span, &ty);
4524 self.write_ty(node_id, ty);
4530 // Now we have to compare the types that the user *actually*
4531 // provided against the types that were *expected*. If the user
4532 // did not provide any types, then we want to substitute inference
4533 // variables. If the user provided some types, we may still need
4534 // to add defaults. If the user provided *too many* types, that's
4536 self.check_path_parameter_count(span, &mut type_segment, false);
4537 self.check_path_parameter_count(span, &mut fn_segment, false);
4539 let (fn_start, has_self) = match (type_segment, fn_segment) {
4540 (_, Some((_, generics))) => {
4541 (generics.parent_count(), generics.has_self)
4543 (Some((_, generics)), None) => {
4544 (generics.own_count(), generics.has_self)
4546 (None, None) => (0, false)
4548 let substs = Substs::for_item(self.tcx, def.def_id(), |def, _| {
4549 let mut i = def.index as usize;
4551 let segment = if i < fn_start {
4552 i -= has_self as usize;
4558 let lifetimes = match segment.map(|(s, _)| &s.parameters) {
4559 Some(&hir::AngleBracketedParameters(ref data)) => &data.lifetimes[..],
4560 Some(&hir::ParenthesizedParameters(_)) => bug!(),
4564 if let Some(lifetime) = lifetimes.get(i) {
4565 AstConv::ast_region_to_region(self, lifetime, Some(def))
4567 self.re_infer(span, Some(def)).unwrap()
4570 let mut i = def.index as usize;
4572 let segment = if i < fn_start {
4573 // Handle Self first, so we can adjust the index to match the AST.
4574 if has_self && i == 0 {
4575 return opt_self_ty.unwrap_or_else(|| {
4576 self.type_var_for_def(span, def, substs)
4579 i -= has_self as usize;
4585 let (types, infer_types) = match segment.map(|(s, _)| &s.parameters) {
4586 Some(&hir::AngleBracketedParameters(ref data)) => {
4587 (&data.types[..], data.infer_types)
4589 Some(&hir::ParenthesizedParameters(_)) => bug!(),
4590 None => (&[][..], true)
4593 // Skip over the lifetimes in the same segment.
4594 if let Some((_, generics)) = segment {
4595 i -= generics.regions.len();
4598 if let Some(ast_ty) = types.get(i) {
4599 // A provided type parameter.
4601 } else if !infer_types && def.has_default {
4602 // No type parameter provided, but a default exists.
4603 let default = self.tcx.type_of(def.def_id);
4606 default.subst_spanned(self.tcx, substs, Some(span))
4609 // No type parameters were provided, we can infer all.
4610 // This can also be reached in some error cases:
4611 // We prefer to use inference variables instead of
4612 // TyError to let type inference recover somewhat.
4613 self.type_var_for_def(span, def, substs)
4617 // The things we are substituting into the type should not contain
4618 // escaping late-bound regions, and nor should the base type scheme.
4619 let ty = self.tcx.type_of(def.def_id());
4620 assert!(!substs.has_escaping_regions());
4621 assert!(!ty.has_escaping_regions());
4623 // Add all the obligations that are required, substituting and
4624 // normalized appropriately.
4625 let bounds = self.instantiate_bounds(span, def.def_id(), &substs);
4626 self.add_obligations_for_parameters(
4627 traits::ObligationCause::new(span, self.body_id, traits::ItemObligation(def.def_id())),
4630 // Substitute the values for the type parameters into the type of
4631 // the referenced item.
4632 let ty_substituted = self.instantiate_type_scheme(span, &substs, &ty);
4634 if let Some((ty::ImplContainer(impl_def_id), self_ty)) = ufcs_associated {
4635 // In the case of `Foo<T>::method` and `<Foo<T>>::method`, if `method`
4636 // is inherent, there is no `Self` parameter, instead, the impl needs
4637 // type parameters, which we can infer by unifying the provided `Self`
4638 // with the substituted impl type.
4639 let ty = self.tcx.type_of(impl_def_id);
4641 let impl_ty = self.instantiate_type_scheme(span, &substs, &ty);
4642 match self.at(&self.misc(span), self.param_env).sup(impl_ty, self_ty) {
4643 Ok(ok) => self.register_infer_ok_obligations(ok),
4646 "instantiate_value_path: (UFCS) {:?} was a subtype of {:?} but now is not?",
4653 debug!("instantiate_value_path: type of {:?} is {:?}",
4656 self.write_substs(node_id, substs);
4660 /// Report errors if the provided parameters are too few or too many.
4661 fn check_path_parameter_count(&self,
4663 segment: &mut Option<(&hir::PathSegment, &ty::Generics)>,
4664 is_method_call: bool) {
4665 let (lifetimes, types, infer_types, bindings) = {
4666 match segment.map(|(s, _)| &s.parameters) {
4667 Some(&hir::AngleBracketedParameters(ref data)) => {
4668 (&data.lifetimes[..], &data.types[..], data.infer_types, &data.bindings[..])
4670 Some(&hir::ParenthesizedParameters(_)) => {
4671 AstConv::prohibit_parenthesized_params(self, &segment.as_ref().unwrap().0,
4673 (&[][..], &[][..], true, &[][..])
4675 None => (&[][..], &[][..], true, &[][..])
4678 let infer_lifetimes = lifetimes.len() == 0;
4680 let count_lifetime_params = |n| {
4681 format!("{} lifetime parameter{}", n, if n == 1 { "" } else { "s" })
4683 let count_type_params = |n| {
4684 format!("{} type parameter{}", n, if n == 1 { "" } else { "s" })
4687 // Check provided type parameters.
4688 let type_defs = segment.map_or(&[][..], |(_, generics)| {
4689 if generics.parent.is_none() {
4690 &generics.types[generics.has_self as usize..]
4695 let required_len = type_defs.iter().take_while(|d| !d.has_default).count();
4696 if types.len() > type_defs.len() {
4697 let span = types[type_defs.len()].span;
4698 let expected_text = count_type_params(type_defs.len());
4699 let actual_text = count_type_params(types.len());
4700 struct_span_err!(self.tcx.sess, span, E0087,
4701 "too many type parameters provided: \
4702 expected at most {}, found {}",
4703 expected_text, actual_text)
4704 .span_label(span, format!("expected {}", expected_text))
4707 // To prevent derived errors to accumulate due to extra
4708 // type parameters, we force instantiate_value_path to
4709 // use inference variables instead of the provided types.
4711 } else if types.len() < required_len && !infer_types {
4712 let expected_text = count_type_params(required_len);
4713 let actual_text = count_type_params(types.len());
4714 struct_span_err!(self.tcx.sess, span, E0089,
4715 "too few type parameters provided: \
4716 expected {}, found {}",
4717 expected_text, actual_text)
4718 .span_label(span, format!("expected {}", expected_text))
4722 if !bindings.is_empty() {
4723 span_err!(self.tcx.sess, bindings[0].span, E0182,
4724 "unexpected binding of associated item in expression path \
4725 (only allowed in type paths)");
4728 // Check provided lifetime parameters.
4729 let lifetime_defs = segment.map_or(&[][..], |(_, generics)| &generics.regions);
4730 let required_len = lifetime_defs.len();
4732 // Prohibit explicit lifetime arguments if late bound lifetime parameters are present.
4733 let has_late_bound_lifetime_defs =
4734 segment.map_or(None, |(_, generics)| generics.has_late_bound_regions);
4735 if let (Some(span_late), false) = (has_late_bound_lifetime_defs, lifetimes.is_empty()) {
4736 // Report this as a lint only if no error was reported previously.
4737 let primary_msg = "cannot specify lifetime arguments explicitly \
4738 if late bound lifetime parameters are present";
4739 let note_msg = "the late bound lifetime parameter is introduced here";
4740 if !is_method_call && (lifetimes.len() > lifetime_defs.len() ||
4741 lifetimes.len() < required_len && !infer_lifetimes) {
4742 let mut err = self.tcx.sess.struct_span_err(lifetimes[0].span, primary_msg);
4743 err.span_note(span_late, note_msg);
4747 let mut multispan = MultiSpan::from_span(lifetimes[0].span);
4748 multispan.push_span_label(span_late, note_msg.to_string());
4749 self.tcx.sess.add_lint(lint::builtin::LATE_BOUND_LIFETIME_ARGUMENTS,
4750 lifetimes[0].id, multispan, primary_msg.to_string());
4755 if lifetimes.len() > lifetime_defs.len() {
4756 let span = lifetimes[lifetime_defs.len()].span;
4757 let expected_text = count_lifetime_params(lifetime_defs.len());
4758 let actual_text = count_lifetime_params(lifetimes.len());
4759 struct_span_err!(self.tcx.sess, span, E0088,
4760 "too many lifetime parameters provided: \
4761 expected at most {}, found {}",
4762 expected_text, actual_text)
4763 .span_label(span, format!("expected {}", expected_text))
4765 } else if lifetimes.len() < required_len && !infer_lifetimes {
4766 let expected_text = count_lifetime_params(lifetime_defs.len());
4767 let actual_text = count_lifetime_params(lifetimes.len());
4768 struct_span_err!(self.tcx.sess, span, E0090,
4769 "too few lifetime parameters provided: \
4770 expected {}, found {}",
4771 expected_text, actual_text)
4772 .span_label(span, format!("expected {}", expected_text))
4777 fn structurally_resolve_type_or_else<F>(&self, sp: Span, ty: Ty<'tcx>, f: F)
4779 where F: Fn() -> Ty<'tcx>
4781 let mut ty = self.resolve_type_vars_with_obligations(ty);
4784 let alternative = f();
4787 if alternative.is_ty_var() || alternative.references_error() {
4788 if !self.is_tainted_by_errors() {
4789 type_error_struct!(self.tcx.sess, sp, ty, E0619,
4790 "the type of this value must be known in this context")
4793 self.demand_suptype(sp, self.tcx.types.err, ty);
4794 ty = self.tcx.types.err;
4796 self.demand_suptype(sp, alternative, ty);
4804 // Resolves `typ` by a single level if `typ` is a type variable. If no
4805 // resolution is possible, then an error is reported.
4806 pub fn structurally_resolved_type(&self, sp: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
4807 self.structurally_resolve_type_or_else(sp, ty, || {
4812 fn with_breakable_ctxt<F: FnOnce() -> R, R>(&self, id: ast::NodeId,
4813 ctxt: BreakableCtxt<'gcx, 'tcx>, f: F)
4814 -> (BreakableCtxt<'gcx, 'tcx>, R) {
4817 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4818 index = enclosing_breakables.stack.len();
4819 enclosing_breakables.by_id.insert(id, index);
4820 enclosing_breakables.stack.push(ctxt);
4824 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4825 debug_assert!(enclosing_breakables.stack.len() == index + 1);
4826 enclosing_breakables.by_id.remove(&id).expect("missing breakable context");
4827 enclosing_breakables.stack.pop().expect("missing breakable context")
4833 pub fn check_bounds_are_used<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
4834 generics: &hir::Generics,
4836 debug!("check_bounds_are_used(n_tps={}, ty={:?})",
4837 generics.ty_params.len(), ty);
4839 // make a vector of booleans initially false, set to true when used
4840 if generics.ty_params.is_empty() { return; }
4841 let mut tps_used = vec![false; generics.ty_params.len()];
4843 for leaf_ty in ty.walk() {
4844 if let ty::TyParam(ParamTy {idx, ..}) = leaf_ty.sty {
4845 debug!("Found use of ty param num {}", idx);
4846 tps_used[idx as usize - generics.lifetimes.len()] = true;
4850 for (&used, param) in tps_used.iter().zip(&generics.ty_params) {
4852 struct_span_err!(tcx.sess, param.span, E0091,
4853 "type parameter `{}` is unused",
4855 .span_label(param.span, "unused type parameter")