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;
149 mod generator_interior;
153 /// A wrapper for InferCtxt's `in_progress_tables` field.
154 #[derive(Copy, Clone)]
155 struct MaybeInProgressTables<'a, 'tcx: 'a> {
156 maybe_tables: Option<&'a RefCell<ty::TypeckTables<'tcx>>>,
159 impl<'a, 'tcx> MaybeInProgressTables<'a, 'tcx> {
160 fn borrow(self) -> Ref<'a, ty::TypeckTables<'tcx>> {
161 match self.maybe_tables {
162 Some(tables) => tables.borrow(),
164 bug!("MaybeInProgressTables: inh/fcx.tables.borrow() with no tables")
169 fn borrow_mut(self) -> RefMut<'a, ty::TypeckTables<'tcx>> {
170 match self.maybe_tables {
171 Some(tables) => tables.borrow_mut(),
173 bug!("MaybeInProgressTables: inh/fcx.tables.borrow_mut() with no tables")
180 /// closures defined within the function. For example:
183 /// bar(move|| { ... })
186 /// Here, the function `foo()` and the closure passed to
187 /// `bar()` will each have their own `FnCtxt`, but they will
188 /// share the inherited fields.
189 pub struct Inherited<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
190 infcx: InferCtxt<'a, 'gcx, 'tcx>,
192 tables: MaybeInProgressTables<'a, 'tcx>,
194 locals: RefCell<NodeMap<Ty<'tcx>>>,
196 fulfillment_cx: RefCell<traits::FulfillmentContext<'tcx>>,
198 // When we process a call like `c()` where `c` is a closure type,
199 // we may not have decided yet whether `c` is a `Fn`, `FnMut`, or
200 // `FnOnce` closure. In that case, we defer full resolution of the
201 // call until upvar inference can kick in and make the
202 // decision. We keep these deferred resolutions grouped by the
203 // def-id of the closure, so that once we decide, we can easily go
204 // back and process them.
205 deferred_call_resolutions: RefCell<DefIdMap<Vec<DeferredCallResolution<'gcx, 'tcx>>>>,
207 deferred_cast_checks: RefCell<Vec<cast::CastCheck<'tcx>>>,
209 deferred_generator_interiors: RefCell<Vec<(hir::BodyId, Ty<'tcx>)>>,
211 // Anonymized types found in explicit return types and their
212 // associated fresh inference variable. Writeback resolves these
213 // variables to get the concrete type, which can be used to
214 // deanonymize TyAnon, after typeck is done with all functions.
215 anon_types: RefCell<NodeMap<Ty<'tcx>>>,
217 /// Each type parameter has an implicit region bound that
218 /// indicates it must outlive at least the function body (the user
219 /// may specify stronger requirements). This field indicates the
220 /// region of the callee. If it is `None`, then the parameter
221 /// environment is for an item or something where the "callee" is
223 implicit_region_bound: Option<ty::Region<'tcx>>,
225 body_id: Option<hir::BodyId>,
228 impl<'a, 'gcx, 'tcx> Deref for Inherited<'a, 'gcx, 'tcx> {
229 type Target = InferCtxt<'a, 'gcx, 'tcx>;
230 fn deref(&self) -> &Self::Target {
235 /// When type-checking an expression, we propagate downward
236 /// whatever type hint we are able in the form of an `Expectation`.
237 #[derive(Copy, Clone, Debug)]
238 pub enum Expectation<'tcx> {
239 /// We know nothing about what type this expression should have.
242 /// This expression is an `if` condition, it must resolve to `bool`.
245 /// This expression should have the type given (or some subtype)
246 ExpectHasType(Ty<'tcx>),
248 /// This expression will be cast to the `Ty`
249 ExpectCastableToType(Ty<'tcx>),
251 /// This rvalue expression will be wrapped in `&` or `Box` and coerced
252 /// to `&Ty` or `Box<Ty>`, respectively. `Ty` is `[A]` or `Trait`.
253 ExpectRvalueLikeUnsized(Ty<'tcx>),
256 impl<'a, 'gcx, 'tcx> Expectation<'tcx> {
257 // Disregard "castable to" expectations because they
258 // can lead us astray. Consider for example `if cond
259 // {22} else {c} as u8` -- if we propagate the
260 // "castable to u8" constraint to 22, it will pick the
261 // type 22u8, which is overly constrained (c might not
262 // be a u8). In effect, the problem is that the
263 // "castable to" expectation is not the tightest thing
264 // we can say, so we want to drop it in this case.
265 // The tightest thing we can say is "must unify with
266 // else branch". Note that in the case of a "has type"
267 // constraint, this limitation does not hold.
269 // If the expected type is just a type variable, then don't use
270 // an expected type. Otherwise, we might write parts of the type
271 // when checking the 'then' block which are incompatible with the
273 fn adjust_for_branches(&self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) -> Expectation<'tcx> {
275 ExpectHasType(ety) => {
276 let ety = fcx.shallow_resolve(ety);
277 if !ety.is_ty_var() {
283 ExpectRvalueLikeUnsized(ety) => {
284 ExpectRvalueLikeUnsized(ety)
290 /// Provide an expectation for an rvalue expression given an *optional*
291 /// hint, which is not required for type safety (the resulting type might
292 /// be checked higher up, as is the case with `&expr` and `box expr`), but
293 /// is useful in determining the concrete type.
295 /// The primary use case is where the expected type is a fat pointer,
296 /// like `&[isize]`. For example, consider the following statement:
298 /// let x: &[isize] = &[1, 2, 3];
300 /// In this case, the expected type for the `&[1, 2, 3]` expression is
301 /// `&[isize]`. If however we were to say that `[1, 2, 3]` has the
302 /// expectation `ExpectHasType([isize])`, that would be too strong --
303 /// `[1, 2, 3]` does not have the type `[isize]` but rather `[isize; 3]`.
304 /// It is only the `&[1, 2, 3]` expression as a whole that can be coerced
305 /// to the type `&[isize]`. Therefore, we propagate this more limited hint,
306 /// which still is useful, because it informs integer literals and the like.
307 /// See the test case `test/run-pass/coerce-expect-unsized.rs` and #20169
308 /// for examples of where this comes up,.
309 fn rvalue_hint(fcx: &FnCtxt<'a, 'gcx, 'tcx>, ty: Ty<'tcx>) -> Expectation<'tcx> {
310 match fcx.tcx.struct_tail(ty).sty {
311 ty::TySlice(_) | ty::TyStr | ty::TyDynamic(..) => {
312 ExpectRvalueLikeUnsized(ty)
314 _ => ExpectHasType(ty)
318 // Resolves `expected` by a single level if it is a variable. If
319 // there is no expected type or resolution is not possible (e.g.,
320 // no constraints yet present), just returns `None`.
321 fn resolve(self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) -> Expectation<'tcx> {
323 NoExpectation => NoExpectation,
324 ExpectIfCondition => ExpectIfCondition,
325 ExpectCastableToType(t) => {
326 ExpectCastableToType(fcx.resolve_type_vars_if_possible(&t))
328 ExpectHasType(t) => {
329 ExpectHasType(fcx.resolve_type_vars_if_possible(&t))
331 ExpectRvalueLikeUnsized(t) => {
332 ExpectRvalueLikeUnsized(fcx.resolve_type_vars_if_possible(&t))
337 fn to_option(self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) -> Option<Ty<'tcx>> {
338 match self.resolve(fcx) {
339 NoExpectation => None,
340 ExpectIfCondition => Some(fcx.tcx.types.bool),
341 ExpectCastableToType(ty) |
343 ExpectRvalueLikeUnsized(ty) => Some(ty),
347 /// It sometimes happens that we want to turn an expectation into
348 /// a **hard constraint** (i.e., something that must be satisfied
349 /// for the program to type-check). `only_has_type` will return
350 /// such a constraint, if it exists.
351 fn only_has_type(self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) -> Option<Ty<'tcx>> {
352 match self.resolve(fcx) {
353 ExpectHasType(ty) => Some(ty),
354 ExpectIfCondition => Some(fcx.tcx.types.bool),
355 NoExpectation | ExpectCastableToType(_) | ExpectRvalueLikeUnsized(_) => None,
359 /// Like `only_has_type`, but instead of returning `None` if no
360 /// hard constraint exists, creates a fresh type variable.
361 fn coercion_target_type(self, fcx: &FnCtxt<'a, 'gcx, 'tcx>, span: Span) -> Ty<'tcx> {
362 self.only_has_type(fcx)
363 .unwrap_or_else(|| fcx.next_ty_var(TypeVariableOrigin::MiscVariable(span)))
367 #[derive(Copy, Clone)]
368 pub struct UnsafetyState {
369 pub def: ast::NodeId,
370 pub unsafety: hir::Unsafety,
371 pub unsafe_push_count: u32,
376 pub fn function(unsafety: hir::Unsafety, def: ast::NodeId) -> UnsafetyState {
377 UnsafetyState { def: def, unsafety: unsafety, unsafe_push_count: 0, from_fn: true }
380 pub fn recurse(&mut self, blk: &hir::Block) -> UnsafetyState {
381 match self.unsafety {
382 // If this unsafe, then if the outer function was already marked as
383 // unsafe we shouldn't attribute the unsafe'ness to the block. This
384 // way the block can be warned about instead of ignoring this
385 // extraneous block (functions are never warned about).
386 hir::Unsafety::Unsafe if self.from_fn => *self,
389 let (unsafety, def, count) = match blk.rules {
390 hir::PushUnsafeBlock(..) =>
391 (unsafety, blk.id, self.unsafe_push_count.checked_add(1).unwrap()),
392 hir::PopUnsafeBlock(..) =>
393 (unsafety, blk.id, self.unsafe_push_count.checked_sub(1).unwrap()),
394 hir::UnsafeBlock(..) =>
395 (hir::Unsafety::Unsafe, blk.id, self.unsafe_push_count),
397 (unsafety, self.def, self.unsafe_push_count),
401 unsafe_push_count: count,
408 #[derive(Debug, Copy, Clone)]
414 /// Tracks whether executing a node may exit normally (versus
415 /// return/break/panic, which "diverge", leaving dead code in their
416 /// wake). Tracked semi-automatically (through type variables marked
417 /// as diverging), with some manual adjustments for control-flow
418 /// primitives (approximating a CFG).
419 #[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
421 /// Potentially unknown, some cases converge,
422 /// others require a CFG to determine them.
425 /// Definitely known to diverge and therefore
426 /// not reach the next sibling or its parent.
429 /// Same as `Always` but with a reachability
430 /// warning already emitted
434 // Convenience impls for combinig `Diverges`.
436 impl ops::BitAnd for Diverges {
438 fn bitand(self, other: Self) -> Self {
439 cmp::min(self, other)
443 impl ops::BitOr for Diverges {
445 fn bitor(self, other: Self) -> Self {
446 cmp::max(self, other)
450 impl ops::BitAndAssign for Diverges {
451 fn bitand_assign(&mut self, other: Self) {
452 *self = *self & other;
456 impl ops::BitOrAssign for Diverges {
457 fn bitor_assign(&mut self, other: Self) {
458 *self = *self | other;
463 fn always(self) -> bool {
464 self >= Diverges::Always
468 pub struct BreakableCtxt<'gcx: 'tcx, 'tcx> {
471 // this is `null` for loops where break with a value is illegal,
472 // such as `while`, `for`, and `while let`
473 coerce: Option<DynamicCoerceMany<'gcx, 'tcx>>,
476 pub struct EnclosingBreakables<'gcx: 'tcx, 'tcx> {
477 stack: Vec<BreakableCtxt<'gcx, 'tcx>>,
478 by_id: NodeMap<usize>,
481 impl<'gcx, 'tcx> EnclosingBreakables<'gcx, 'tcx> {
482 fn find_breakable(&mut self, target_id: ast::NodeId) -> &mut BreakableCtxt<'gcx, 'tcx> {
483 let ix = *self.by_id.get(&target_id).unwrap_or_else(|| {
484 bug!("could not find enclosing breakable with id {}", target_id);
490 pub struct FnCtxt<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
491 body_id: ast::NodeId,
493 /// The parameter environment used for proving trait obligations
494 /// in this function. This can change when we descend into
495 /// closures (as they bring new things into scope), hence it is
496 /// not part of `Inherited` (as of the time of this writing,
497 /// closures do not yet change the environment, but they will
499 param_env: ty::ParamEnv<'tcx>,
501 // Number of errors that had been reported when we started
502 // checking this function. On exit, if we find that *more* errors
503 // have been reported, we will skip regionck and other work that
504 // expects the types within the function to be consistent.
505 err_count_on_creation: usize,
507 ret_coercion: Option<RefCell<DynamicCoerceMany<'gcx, 'tcx>>>,
509 yield_ty: Option<Ty<'tcx>>,
511 ps: RefCell<UnsafetyState>,
513 /// Whether the last checked node generates a divergence (e.g.,
514 /// `return` will set this to Always). In general, when entering
515 /// an expression or other node in the tree, the initial value
516 /// indicates whether prior parts of the containing expression may
517 /// have diverged. It is then typically set to `Maybe` (and the
518 /// old value remembered) for processing the subparts of the
519 /// current expression. As each subpart is processed, they may set
520 /// the flag to `Always` etc. Finally, at the end, we take the
521 /// result and "union" it with the original value, so that when we
522 /// return the flag indicates if any subpart of the the parent
523 /// expression (up to and including this part) has diverged. So,
524 /// if you read it after evaluating a subexpression `X`, the value
525 /// you get indicates whether any subexpression that was
526 /// evaluating up to and including `X` diverged.
528 /// We use this flag for two purposes:
530 /// - To warn about unreachable code: if, after processing a
531 /// sub-expression but before we have applied the effects of the
532 /// current node, we see that the flag is set to `Always`, we
533 /// can issue a warning. This corresponds to something like
534 /// `foo(return)`; we warn on the `foo()` expression. (We then
535 /// update the flag to `WarnedAlways` to suppress duplicate
536 /// reports.) Similarly, if we traverse to a fresh statement (or
537 /// tail expression) from a `Always` setting, we will issue a
538 /// warning. This corresponds to something like `{return;
539 /// foo();}` or `{return; 22}`, where we would warn on the
542 /// - To permit assignment into a local variable or other lvalue
543 /// (including the "return slot") of type `!`. This is allowed
544 /// if **either** the type of value being assigned is `!`, which
545 /// means the current code is dead, **or** the expression's
546 /// diverging flag is true, which means that a diverging value was
547 /// wrapped (e.g., `let x: ! = foo(return)`).
549 /// To repeat the last point: an expression represents dead-code
550 /// if, after checking it, **either** its type is `!` OR the
551 /// diverges flag is set to something other than `Maybe`.
552 diverges: Cell<Diverges>,
554 /// Whether any child nodes have any type errors.
555 has_errors: Cell<bool>,
557 enclosing_breakables: RefCell<EnclosingBreakables<'gcx, 'tcx>>,
559 inh: &'a Inherited<'a, 'gcx, 'tcx>,
562 impl<'a, 'gcx, 'tcx> Deref for FnCtxt<'a, 'gcx, 'tcx> {
563 type Target = Inherited<'a, 'gcx, 'tcx>;
564 fn deref(&self) -> &Self::Target {
569 /// Helper type of a temporary returned by Inherited::build(...).
570 /// Necessary because we can't write the following bound:
571 /// F: for<'b, 'tcx> where 'gcx: 'tcx FnOnce(Inherited<'b, 'gcx, 'tcx>).
572 pub struct InheritedBuilder<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
573 infcx: infer::InferCtxtBuilder<'a, 'gcx, 'tcx>,
577 impl<'a, 'gcx, 'tcx> Inherited<'a, 'gcx, 'tcx> {
578 pub fn build(tcx: TyCtxt<'a, 'gcx, 'gcx>, def_id: DefId)
579 -> InheritedBuilder<'a, 'gcx, 'tcx> {
580 let hir_id_root = if def_id.is_local() {
581 let node_id = tcx.hir.as_local_node_id(def_id).unwrap();
582 let hir_id = tcx.hir.definitions().node_to_hir_id(node_id);
583 DefId::local(hir_id.owner)
589 infcx: tcx.infer_ctxt().with_fresh_in_progress_tables(hir_id_root),
595 impl<'a, 'gcx, 'tcx> InheritedBuilder<'a, 'gcx, 'tcx> {
596 fn enter<F, R>(&'tcx mut self, f: F) -> R
597 where F: for<'b> FnOnce(Inherited<'b, 'gcx, 'tcx>) -> R
599 let def_id = self.def_id;
600 self.infcx.enter(|infcx| f(Inherited::new(infcx, def_id)))
604 impl<'a, 'gcx, 'tcx> Inherited<'a, 'gcx, 'tcx> {
605 fn new(infcx: InferCtxt<'a, 'gcx, 'tcx>, def_id: DefId) -> Self {
607 let item_id = tcx.hir.as_local_node_id(def_id);
608 let body_id = item_id.and_then(|id| tcx.hir.maybe_body_owned_by(id));
609 let implicit_region_bound = body_id.map(|body| {
610 tcx.mk_region(ty::ReScope(CodeExtent::CallSiteScope(body)))
614 tables: MaybeInProgressTables {
615 maybe_tables: infcx.in_progress_tables,
618 fulfillment_cx: RefCell::new(traits::FulfillmentContext::new()),
619 locals: RefCell::new(NodeMap()),
620 deferred_call_resolutions: RefCell::new(DefIdMap()),
621 deferred_cast_checks: RefCell::new(Vec::new()),
622 deferred_generator_interiors: RefCell::new(Vec::new()),
623 anon_types: RefCell::new(NodeMap()),
624 implicit_region_bound,
629 fn register_predicate(&self, obligation: traits::PredicateObligation<'tcx>) {
630 debug!("register_predicate({:?})", obligation);
631 if obligation.has_escaping_regions() {
632 span_bug!(obligation.cause.span, "escaping regions in predicate {:?}",
637 .register_predicate_obligation(self, obligation);
640 fn register_predicates<I>(&self, obligations: I)
641 where I: IntoIterator<Item = traits::PredicateObligation<'tcx>> {
642 for obligation in obligations {
643 self.register_predicate(obligation);
647 fn register_infer_ok_obligations<T>(&self, infer_ok: InferOk<'tcx, T>) -> T {
648 self.register_predicates(infer_ok.obligations);
652 fn normalize_associated_types_in<T>(&self,
654 body_id: ast::NodeId,
655 param_env: ty::ParamEnv<'tcx>,
657 where T : TypeFoldable<'tcx>
659 let ok = self.normalize_associated_types_in_as_infer_ok(span, body_id, param_env, value);
660 self.register_infer_ok_obligations(ok)
663 fn normalize_associated_types_in_as_infer_ok<T>(&self,
665 body_id: ast::NodeId,
666 param_env: ty::ParamEnv<'tcx>,
669 where T : TypeFoldable<'tcx>
671 debug!("normalize_associated_types_in(value={:?})", value);
672 let mut selcx = traits::SelectionContext::new(self);
673 let cause = ObligationCause::misc(span, body_id);
674 let traits::Normalized { value, obligations } =
675 traits::normalize(&mut selcx, param_env, cause, value);
676 debug!("normalize_associated_types_in: result={:?} predicates={:?}",
679 InferOk { value, obligations }
682 /// Replace any late-bound regions bound in `value` with
683 /// free variants attached to `all_outlive_scope`.
684 fn liberate_late_bound_regions<T>(&self,
685 all_outlive_scope: DefId,
686 value: &ty::Binder<T>)
688 where T: TypeFoldable<'tcx>
690 self.tcx.replace_late_bound_regions(value, |br| {
691 self.tcx.mk_region(ty::ReFree(ty::FreeRegion {
692 scope: all_outlive_scope,
699 struct CheckItemTypesVisitor<'a, 'tcx: 'a> { tcx: TyCtxt<'a, 'tcx, 'tcx> }
701 impl<'a, 'tcx> ItemLikeVisitor<'tcx> for CheckItemTypesVisitor<'a, 'tcx> {
702 fn visit_item(&mut self, i: &'tcx hir::Item) {
703 check_item_type(self.tcx, i);
705 fn visit_trait_item(&mut self, _: &'tcx hir::TraitItem) { }
706 fn visit_impl_item(&mut self, _: &'tcx hir::ImplItem) { }
709 pub fn check_wf_new<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Result<(), ErrorReported> {
710 tcx.sess.track_errors(|| {
711 let mut visit = wfcheck::CheckTypeWellFormedVisitor::new(tcx);
712 tcx.hir.krate().visit_all_item_likes(&mut visit.as_deep_visitor());
716 pub fn check_item_types<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Result<(), ErrorReported> {
717 tcx.sess.track_errors(|| {
718 tcx.hir.krate().visit_all_item_likes(&mut CheckItemTypesVisitor { tcx });
722 pub fn check_item_bodies<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Result<(), CompileIncomplete> {
723 tcx.typeck_item_bodies(LOCAL_CRATE)
726 fn typeck_item_bodies<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, crate_num: CrateNum)
727 -> Result<(), CompileIncomplete>
729 debug_assert!(crate_num == LOCAL_CRATE);
730 Ok(tcx.sess.track_errors(|| {
731 for body_owner_def_id in tcx.body_owners() {
732 tcx.typeck_tables_of(body_owner_def_id);
737 pub fn provide(providers: &mut Providers) {
738 *providers = Providers {
749 fn generator_sig<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
751 -> Option<ty::PolyGenSig<'tcx>> {
752 let node_id = tcx.hir.as_local_node_id(def_id).unwrap();
753 let hir_id = tcx.hir.node_to_hir_id(node_id);
754 tcx.typeck_tables_of(def_id).generator_sigs()[hir_id].map(|s| ty::Binder(s))
757 fn closure_kind<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
760 let node_id = tcx.hir.as_local_node_id(def_id).unwrap();
761 let hir_id = tcx.hir.node_to_hir_id(node_id);
762 tcx.typeck_tables_of(def_id).closure_kinds()[hir_id].0
765 fn adt_destructor<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
767 -> Option<ty::Destructor> {
768 tcx.calculate_dtor(def_id, &mut dropck::check_drop_impl)
771 /// If this def-id is a "primary tables entry", returns `Some((body_id, decl))`
772 /// with information about it's body-id and fn-decl (if any). Otherwise,
775 /// If this function returns "some", then `typeck_tables(def_id)` will
776 /// succeed; if it returns `None`, then `typeck_tables(def_id)` may or
777 /// may not succeed. In some cases where this function returns `None`
778 /// (notably closures), `typeck_tables(def_id)` would wind up
779 /// redirecting to the owning function.
780 fn primary_body_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
782 -> Option<(hir::BodyId, Option<&'tcx hir::FnDecl>)>
784 match tcx.hir.get(id) {
785 hir::map::NodeItem(item) => {
787 hir::ItemConst(_, body) |
788 hir::ItemStatic(_, _, body) =>
790 hir::ItemFn(ref decl, .., body) =>
791 Some((body, Some(decl))),
796 hir::map::NodeTraitItem(item) => {
798 hir::TraitItemKind::Const(_, Some(body)) =>
800 hir::TraitItemKind::Method(ref sig, hir::TraitMethod::Provided(body)) =>
801 Some((body, Some(&sig.decl))),
806 hir::map::NodeImplItem(item) => {
808 hir::ImplItemKind::Const(_, body) =>
810 hir::ImplItemKind::Method(ref sig, body) =>
811 Some((body, Some(&sig.decl))),
816 hir::map::NodeExpr(expr) => {
817 // FIXME(eddyb) Closures should have separate
818 // function definition IDs and expression IDs.
819 // Type-checking should not let closures get
820 // this far in a constant position.
821 // Assume that everything other than closures
822 // is a constant "initializer" expression.
824 hir::ExprClosure(..) =>
827 Some((hir::BodyId { node_id: expr.id }, None)),
834 fn has_typeck_tables<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
837 // Closures' tables come from their outermost function,
838 // as they are part of the same "inference environment".
839 let outer_def_id = tcx.closure_base_def_id(def_id);
840 if outer_def_id != def_id {
841 return tcx.has_typeck_tables(outer_def_id);
844 let id = tcx.hir.as_local_node_id(def_id).unwrap();
845 primary_body_of(tcx, id).is_some()
848 fn typeck_tables_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
850 -> &'tcx ty::TypeckTables<'tcx> {
851 // Closures' tables come from their outermost function,
852 // as they are part of the same "inference environment".
853 let outer_def_id = tcx.closure_base_def_id(def_id);
854 if outer_def_id != def_id {
855 return tcx.typeck_tables_of(outer_def_id);
858 let id = tcx.hir.as_local_node_id(def_id).unwrap();
859 let span = tcx.hir.span(id);
861 // Figure out what primary body this item has.
862 let (body_id, fn_decl) = primary_body_of(tcx, id).unwrap_or_else(|| {
863 span_bug!(span, "can't type-check body of {:?}", def_id);
865 let body = tcx.hir.body(body_id);
867 let tables = Inherited::build(tcx, def_id).enter(|inh| {
868 let param_env = tcx.param_env(def_id);
869 let fcx = if let Some(decl) = fn_decl {
870 let fn_sig = tcx.fn_sig(def_id);
872 check_abi(tcx, span, fn_sig.abi());
874 // Compute the fty from point of view of inside fn.
876 inh.liberate_late_bound_regions(def_id, &fn_sig);
878 inh.normalize_associated_types_in(body.value.span,
883 check_fn(&inh, param_env, fn_sig, decl, id, body, false).0
885 let fcx = FnCtxt::new(&inh, param_env, body.value.id);
886 let expected_type = tcx.type_of(def_id);
887 let expected_type = fcx.normalize_associated_types_in(body.value.span, &expected_type);
888 fcx.require_type_is_sized(expected_type, body.value.span, traits::ConstSized);
890 // Gather locals in statics (because of block expressions).
891 // This is technically unnecessary because locals in static items are forbidden,
892 // but prevents type checking from blowing up before const checking can properly
894 GatherLocalsVisitor { fcx: &fcx }.visit_body(body);
896 fcx.check_expr_coercable_to_type(&body.value, expected_type);
901 fcx.select_all_obligations_and_apply_defaults();
902 fcx.closure_analyze(body);
903 fcx.select_obligations_where_possible();
905 fcx.resolve_generator_interiors(def_id);
906 fcx.select_all_obligations_or_error();
908 if fn_decl.is_some() {
909 fcx.regionck_fn(id, body);
911 fcx.regionck_expr(body);
914 fcx.resolve_type_vars_in_body(body)
917 // Consistency check our TypeckTables instance can hold all ItemLocalIds
918 // it will need to hold.
919 assert_eq!(tables.local_id_root,
920 Some(DefId::local(tcx.hir.definitions().node_to_hir_id(id).owner)));
924 fn check_abi<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, span: Span, abi: Abi) {
925 if !tcx.sess.target.target.is_abi_supported(abi) {
926 struct_span_err!(tcx.sess, span, E0570,
927 "The ABI `{}` is not supported for the current target", abi).emit()
931 struct GatherLocalsVisitor<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
932 fcx: &'a FnCtxt<'a, 'gcx, 'tcx>
935 impl<'a, 'gcx, 'tcx> GatherLocalsVisitor<'a, 'gcx, 'tcx> {
936 fn assign(&mut self, span: Span, nid: ast::NodeId, ty_opt: Option<Ty<'tcx>>) -> Ty<'tcx> {
939 // infer the variable's type
940 let var_ty = self.fcx.next_ty_var(TypeVariableOrigin::TypeInference(span));
941 self.fcx.locals.borrow_mut().insert(nid, var_ty);
945 // take type that the user specified
946 self.fcx.locals.borrow_mut().insert(nid, typ);
953 impl<'a, 'gcx, 'tcx> Visitor<'gcx> for GatherLocalsVisitor<'a, 'gcx, 'tcx> {
954 fn nested_visit_map<'this>(&'this mut self) -> NestedVisitorMap<'this, 'gcx> {
955 NestedVisitorMap::None
958 // Add explicitly-declared locals.
959 fn visit_local(&mut self, local: &'gcx hir::Local) {
960 let o_ty = match local.ty {
961 Some(ref ty) => Some(self.fcx.to_ty(&ty)),
964 self.assign(local.span, local.id, o_ty);
965 debug!("Local variable {:?} is assigned type {}",
967 self.fcx.ty_to_string(
968 self.fcx.locals.borrow().get(&local.id).unwrap().clone()));
969 intravisit::walk_local(self, local);
972 // Add pattern bindings.
973 fn visit_pat(&mut self, p: &'gcx hir::Pat) {
974 if let PatKind::Binding(_, _, ref path1, _) = p.node {
975 let var_ty = self.assign(p.span, p.id, None);
977 self.fcx.require_type_is_sized(var_ty, p.span,
978 traits::VariableType(p.id));
980 debug!("Pattern binding {} is assigned to {} with type {:?}",
982 self.fcx.ty_to_string(
983 self.fcx.locals.borrow().get(&p.id).unwrap().clone()),
986 intravisit::walk_pat(self, p);
989 // Don't descend into the bodies of nested closures
990 fn visit_fn(&mut self, _: intravisit::FnKind<'gcx>, _: &'gcx hir::FnDecl,
991 _: hir::BodyId, _: Span, _: ast::NodeId) { }
994 /// Helper used for fns and closures. Does the grungy work of checking a function
995 /// body and returns the function context used for that purpose, since in the case of a fn item
996 /// there is still a bit more to do.
999 /// * inherited: other fields inherited from the enclosing fn (if any)
1000 fn check_fn<'a, 'gcx, 'tcx>(inherited: &'a Inherited<'a, 'gcx, 'tcx>,
1001 param_env: ty::ParamEnv<'tcx>,
1002 fn_sig: ty::FnSig<'tcx>,
1003 decl: &'gcx hir::FnDecl,
1005 body: &'gcx hir::Body,
1006 can_be_generator: bool)
1007 -> (FnCtxt<'a, 'gcx, 'tcx>, Option<ty::GeneratorInterior<'tcx>>)
1009 let mut fn_sig = fn_sig.clone();
1011 debug!("check_fn(sig={:?}, fn_id={}, param_env={:?})", fn_sig, fn_id, param_env);
1013 // Create the function context. This is either derived from scratch or,
1014 // in the case of function expressions, based on the outer context.
1015 let mut fcx = FnCtxt::new(inherited, param_env, body.value.id);
1016 *fcx.ps.borrow_mut() = UnsafetyState::function(fn_sig.unsafety, fn_id);
1018 let ret_ty = fn_sig.output();
1019 fcx.require_type_is_sized(ret_ty, decl.output.span(), traits::SizedReturnType);
1020 let ret_ty = fcx.instantiate_anon_types(&ret_ty);
1021 fcx.ret_coercion = Some(RefCell::new(CoerceMany::new(ret_ty)));
1022 fn_sig = fcx.tcx.mk_fn_sig(
1023 fn_sig.inputs().iter().cloned(),
1030 let span = body.value.span;
1032 if body.is_generator && can_be_generator {
1033 fcx.yield_ty = Some(fcx.next_ty_var(TypeVariableOrigin::TypeInference(span)));
1036 GatherLocalsVisitor { fcx: &fcx, }.visit_body(body);
1038 // Add formal parameters.
1039 for (arg_ty, arg) in fn_sig.inputs().iter().zip(&body.arguments) {
1040 // Check the pattern.
1041 fcx.check_pat_arg(&arg.pat, arg_ty, true);
1043 // Check that argument is Sized.
1044 // The check for a non-trivial pattern is a hack to avoid duplicate warnings
1045 // for simple cases like `fn foo(x: Trait)`,
1046 // where we would error once on the parameter as a whole, and once on the binding `x`.
1047 if arg.pat.simple_name().is_none() {
1048 fcx.require_type_is_sized(arg_ty, decl.output.span(), traits::MiscObligation);
1051 fcx.write_ty(arg.hir_id, arg_ty);
1054 let fn_hir_id = fcx.tcx.hir.node_to_hir_id(fn_id);
1055 let gen_ty = if can_be_generator && body.is_generator {
1056 let gen_sig = ty::GenSig {
1057 yield_ty: fcx.yield_ty.unwrap(),
1060 inherited.tables.borrow_mut().generator_sigs_mut().insert(fn_hir_id, Some(gen_sig));
1062 let witness = fcx.next_ty_var(TypeVariableOrigin::MiscVariable(span));
1063 fcx.deferred_generator_interiors.borrow_mut().push((body.id(), witness));
1064 let interior = ty::GeneratorInterior::new(witness);
1066 inherited.tables.borrow_mut().generator_interiors_mut().insert(fn_hir_id, interior);
1070 inherited.tables.borrow_mut().generator_sigs_mut().insert(fn_hir_id, None);
1073 inherited.tables.borrow_mut().liberated_fn_sigs_mut().insert(fn_hir_id, fn_sig);
1075 fcx.check_return_expr(&body.value);
1077 // Finalize the return check by taking the LUB of the return types
1078 // we saw and assigning it to the expected return type. This isn't
1079 // really expected to fail, since the coercions would have failed
1080 // earlier when trying to find a LUB.
1082 // However, the behavior around `!` is sort of complex. In the
1083 // event that the `actual_return_ty` comes back as `!`, that
1084 // indicates that the fn either does not return or "returns" only
1085 // values of type `!`. In this case, if there is an expected
1086 // return type that is *not* `!`, that should be ok. But if the
1087 // return type is being inferred, we want to "fallback" to `!`:
1089 // let x = move || panic!();
1091 // To allow for that, I am creating a type variable with diverging
1092 // fallback. This was deemed ever so slightly better than unifying
1093 // the return value with `!` because it allows for the caller to
1094 // make more assumptions about the return type (e.g., they could do
1096 // let y: Option<u32> = Some(x());
1098 // which would then cause this return type to become `u32`, not
1100 let coercion = fcx.ret_coercion.take().unwrap().into_inner();
1101 let mut actual_return_ty = coercion.complete(&fcx);
1102 if actual_return_ty.is_never() {
1103 actual_return_ty = fcx.next_diverging_ty_var(
1104 TypeVariableOrigin::DivergingFn(span));
1106 fcx.demand_suptype(span, ret_ty, actual_return_ty);
1111 fn check_struct<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1114 let def_id = tcx.hir.local_def_id(id);
1115 let def = tcx.adt_def(def_id);
1116 def.destructor(tcx); // force the destructor to be evaluated
1117 check_representable(tcx, span, def_id);
1119 if def.repr.simd() {
1120 check_simd(tcx, span, def_id);
1123 check_packed(tcx, span, def_id);
1126 fn check_union<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1129 let def_id = tcx.hir.local_def_id(id);
1130 let def = tcx.adt_def(def_id);
1131 def.destructor(tcx); // force the destructor to be evaluated
1132 check_representable(tcx, span, def_id);
1134 check_packed(tcx, span, def_id);
1137 pub fn check_item_type<'a,'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, it: &'tcx hir::Item) {
1138 debug!("check_item_type(it.id={}, it.name={})",
1140 tcx.item_path_str(tcx.hir.local_def_id(it.id)));
1141 let _indenter = indenter();
1143 // Consts can play a role in type-checking, so they are included here.
1144 hir::ItemStatic(..) |
1145 hir::ItemConst(..) => {
1146 tcx.typeck_tables_of(tcx.hir.local_def_id(it.id));
1148 hir::ItemEnum(ref enum_definition, _) => {
1151 &enum_definition.variants,
1154 hir::ItemFn(..) => {} // entirely within check_item_body
1155 hir::ItemImpl(.., ref impl_item_refs) => {
1156 debug!("ItemImpl {} with id {}", it.name, it.id);
1157 let impl_def_id = tcx.hir.local_def_id(it.id);
1158 if let Some(impl_trait_ref) = tcx.impl_trait_ref(impl_def_id) {
1159 check_impl_items_against_trait(tcx,
1164 let trait_def_id = impl_trait_ref.def_id;
1165 check_on_unimplemented(tcx, trait_def_id, it);
1168 hir::ItemTrait(..) => {
1169 let def_id = tcx.hir.local_def_id(it.id);
1170 check_on_unimplemented(tcx, def_id, it);
1172 hir::ItemStruct(..) => {
1173 check_struct(tcx, it.id, it.span);
1175 hir::ItemUnion(..) => {
1176 check_union(tcx, it.id, it.span);
1178 hir::ItemTy(_, ref generics) => {
1179 let def_id = tcx.hir.local_def_id(it.id);
1180 let pty_ty = tcx.type_of(def_id);
1181 check_bounds_are_used(tcx, generics, pty_ty);
1183 hir::ItemForeignMod(ref m) => {
1184 check_abi(tcx, it.span, m.abi);
1186 if m.abi == Abi::RustIntrinsic {
1187 for item in &m.items {
1188 intrinsic::check_intrinsic_type(tcx, item);
1190 } else if m.abi == Abi::PlatformIntrinsic {
1191 for item in &m.items {
1192 intrinsic::check_platform_intrinsic_type(tcx, item);
1195 for item in &m.items {
1196 let generics = tcx.generics_of(tcx.hir.local_def_id(item.id));
1197 if !generics.types.is_empty() {
1198 let mut err = struct_span_err!(tcx.sess, item.span, E0044,
1199 "foreign items may not have type parameters");
1200 span_help!(&mut err, item.span,
1201 "consider using specialization instead of \
1206 if let hir::ForeignItemFn(ref fn_decl, _, _) = item.node {
1207 require_c_abi_if_variadic(tcx, fn_decl, m.abi, item.span);
1212 _ => {/* nothing to do */ }
1216 fn check_on_unimplemented<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1219 let generics = tcx.generics_of(def_id);
1220 if let Some(ref attr) = item.attrs.iter().find(|a| {
1221 a.check_name("rustc_on_unimplemented")
1223 if let Some(istring) = attr.value_str() {
1224 let istring = istring.as_str();
1225 let name = tcx.item_name(def_id).as_str();
1226 let parser = Parser::new(&istring);
1227 let types = &generics.types;
1228 for token in parser {
1230 Piece::String(_) => (), // Normal string, no need to check it
1231 Piece::NextArgument(a) => match a.position {
1232 // `{Self}` is allowed
1233 Position::ArgumentNamed(s) if s == "Self" => (),
1234 // `{ThisTraitsName}` is allowed
1235 Position::ArgumentNamed(s) if s == name => (),
1236 // So is `{A}` if A is a type parameter
1237 Position::ArgumentNamed(s) => match types.iter().find(|t| {
1242 span_err!(tcx.sess, attr.span, E0230,
1243 "there is no type parameter \
1248 // `{:1}` and `{}` are not to be used
1249 Position::ArgumentIs(_) => {
1250 span_err!(tcx.sess, attr.span, E0231,
1251 "only named substitution \
1252 parameters are allowed");
1259 tcx.sess, attr.span, E0232,
1260 "this attribute must have a value")
1261 .span_label(attr.span, "attribute requires a value")
1262 .note(&format!("eg `#[rustc_on_unimplemented = \"foo\"]`"))
1268 fn report_forbidden_specialization<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1269 impl_item: &hir::ImplItem,
1272 let mut err = struct_span_err!(
1273 tcx.sess, impl_item.span, E0520,
1274 "`{}` specializes an item from a parent `impl`, but \
1275 that item is not marked `default`",
1277 err.span_label(impl_item.span, format!("cannot specialize default item `{}`",
1280 match tcx.span_of_impl(parent_impl) {
1282 err.span_label(span, "parent `impl` is here");
1283 err.note(&format!("to specialize, `{}` in the parent `impl` must be marked `default`",
1287 err.note(&format!("parent implementation is in crate `{}`", cname));
1294 fn check_specialization_validity<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1295 trait_def: &ty::TraitDef,
1297 impl_item: &hir::ImplItem)
1299 let ancestors = trait_def.ancestors(tcx, impl_id);
1301 let kind = match impl_item.node {
1302 hir::ImplItemKind::Const(..) => ty::AssociatedKind::Const,
1303 hir::ImplItemKind::Method(..) => ty::AssociatedKind::Method,
1304 hir::ImplItemKind::Type(_) => ty::AssociatedKind::Type
1306 let parent = ancestors.defs(tcx, impl_item.name, kind).skip(1).next()
1307 .map(|node_item| node_item.map(|parent| parent.defaultness));
1309 if let Some(parent) = parent {
1310 if tcx.impl_item_is_final(&parent) {
1311 report_forbidden_specialization(tcx, impl_item, parent.node.def_id());
1317 fn check_impl_items_against_trait<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1320 impl_trait_ref: ty::TraitRef<'tcx>,
1321 impl_item_refs: &[hir::ImplItemRef]) {
1322 // If the trait reference itself is erroneous (so the compilation is going
1323 // to fail), skip checking the items here -- the `impl_item` table in `tcx`
1324 // isn't populated for such impls.
1325 if impl_trait_ref.references_error() { return; }
1327 // Locate trait definition and items
1328 let trait_def = tcx.trait_def(impl_trait_ref.def_id);
1329 let mut overridden_associated_type = None;
1331 let impl_items = || impl_item_refs.iter().map(|iiref| tcx.hir.impl_item(iiref.id));
1333 // Check existing impl methods to see if they are both present in trait
1334 // and compatible with trait signature
1335 for impl_item in impl_items() {
1336 let ty_impl_item = tcx.associated_item(tcx.hir.local_def_id(impl_item.id));
1337 let ty_trait_item = tcx.associated_items(impl_trait_ref.def_id)
1338 .find(|ac| ac.name == ty_impl_item.name);
1340 // Check that impl definition matches trait definition
1341 if let Some(ty_trait_item) = ty_trait_item {
1342 match impl_item.node {
1343 hir::ImplItemKind::Const(..) => {
1344 // Find associated const definition.
1345 if ty_trait_item.kind == ty::AssociatedKind::Const {
1346 compare_const_impl(tcx,
1352 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0323,
1353 "item `{}` is an associated const, \
1354 which doesn't match its trait `{}`",
1357 err.span_label(impl_item.span, "does not match trait");
1358 // We can only get the spans from local trait definition
1359 // Same for E0324 and E0325
1360 if let Some(trait_span) = tcx.hir.span_if_local(ty_trait_item.def_id) {
1361 err.span_label(trait_span, "item in trait");
1366 hir::ImplItemKind::Method(..) => {
1367 let trait_span = tcx.hir.span_if_local(ty_trait_item.def_id);
1368 if ty_trait_item.kind == ty::AssociatedKind::Method {
1369 let err_count = tcx.sess.err_count();
1370 compare_impl_method(tcx,
1376 true); // start with old-broken-mode
1377 if err_count == tcx.sess.err_count() {
1378 // old broken mode did not report an error. Try with the new mode.
1379 compare_impl_method(tcx,
1385 false); // use the new mode
1388 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0324,
1389 "item `{}` is an associated method, \
1390 which doesn't match its trait `{}`",
1393 err.span_label(impl_item.span, "does not match trait");
1394 if let Some(trait_span) = tcx.hir.span_if_local(ty_trait_item.def_id) {
1395 err.span_label(trait_span, "item in trait");
1400 hir::ImplItemKind::Type(_) => {
1401 if ty_trait_item.kind == ty::AssociatedKind::Type {
1402 if ty_trait_item.defaultness.has_value() {
1403 overridden_associated_type = Some(impl_item);
1406 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0325,
1407 "item `{}` is an associated type, \
1408 which doesn't match its trait `{}`",
1411 err.span_label(impl_item.span, "does not match trait");
1412 if let Some(trait_span) = tcx.hir.span_if_local(ty_trait_item.def_id) {
1413 err.span_label(trait_span, "item in trait");
1421 check_specialization_validity(tcx, trait_def, impl_id, impl_item);
1424 // Check for missing items from trait
1425 let mut missing_items = Vec::new();
1426 let mut invalidated_items = Vec::new();
1427 let associated_type_overridden = overridden_associated_type.is_some();
1428 for trait_item in tcx.associated_items(impl_trait_ref.def_id) {
1429 let is_implemented = trait_def.ancestors(tcx, impl_id)
1430 .defs(tcx, trait_item.name, trait_item.kind)
1432 .map(|node_item| !node_item.node.is_from_trait())
1435 if !is_implemented {
1436 if !trait_item.defaultness.has_value() {
1437 missing_items.push(trait_item);
1438 } else if associated_type_overridden {
1439 invalidated_items.push(trait_item.name);
1444 if !missing_items.is_empty() {
1445 let mut err = struct_span_err!(tcx.sess, impl_span, E0046,
1446 "not all trait items implemented, missing: `{}`",
1447 missing_items.iter()
1448 .map(|trait_item| trait_item.name.to_string())
1449 .collect::<Vec<_>>().join("`, `"));
1450 err.span_label(impl_span, format!("missing `{}` in implementation",
1451 missing_items.iter()
1452 .map(|trait_item| trait_item.name.to_string())
1453 .collect::<Vec<_>>().join("`, `")));
1454 for trait_item in missing_items {
1455 if let Some(span) = tcx.hir.span_if_local(trait_item.def_id) {
1456 err.span_label(span, format!("`{}` from trait", trait_item.name));
1458 err.note_trait_signature(trait_item.name.to_string(),
1459 trait_item.signature(&tcx));
1465 if !invalidated_items.is_empty() {
1466 let invalidator = overridden_associated_type.unwrap();
1467 span_err!(tcx.sess, invalidator.span, E0399,
1468 "the following trait items need to be reimplemented \
1469 as `{}` was overridden: `{}`",
1471 invalidated_items.iter()
1472 .map(|name| name.to_string())
1473 .collect::<Vec<_>>().join("`, `"))
1477 /// Checks whether a type can be represented in memory. In particular, it
1478 /// identifies types that contain themselves without indirection through a
1479 /// pointer, which would mean their size is unbounded.
1480 fn check_representable<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1484 let rty = tcx.type_of(item_def_id);
1486 // Check that it is possible to represent this type. This call identifies
1487 // (1) types that contain themselves and (2) types that contain a different
1488 // recursive type. It is only necessary to throw an error on those that
1489 // contain themselves. For case 2, there must be an inner type that will be
1490 // caught by case 1.
1491 match rty.is_representable(tcx, sp) {
1492 Representability::SelfRecursive(spans) => {
1493 let mut err = tcx.recursive_type_with_infinite_size_error(item_def_id);
1495 err.span_label(span, "recursive without indirection");
1500 Representability::Representable | Representability::ContainsRecursive => (),
1505 pub fn check_simd<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, sp: Span, def_id: DefId) {
1506 let t = tcx.type_of(def_id);
1508 ty::TyAdt(def, substs) if def.is_struct() => {
1509 let fields = &def.struct_variant().fields;
1510 if fields.is_empty() {
1511 span_err!(tcx.sess, sp, E0075, "SIMD vector cannot be empty");
1514 let e = fields[0].ty(tcx, substs);
1515 if !fields.iter().all(|f| f.ty(tcx, substs) == e) {
1516 struct_span_err!(tcx.sess, sp, E0076, "SIMD vector should be homogeneous")
1517 .span_label(sp, "SIMD elements must have the same type")
1522 ty::TyParam(_) => { /* struct<T>(T, T, T, T) is ok */ }
1523 _ if e.is_machine() => { /* struct(u8, u8, u8, u8) is ok */ }
1525 span_err!(tcx.sess, sp, E0077,
1526 "SIMD vector element type should be machine type");
1535 fn check_packed<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, sp: Span, def_id: DefId) {
1536 if tcx.adt_def(def_id).repr.packed() {
1537 if tcx.adt_def(def_id).repr.align > 0 {
1538 struct_span_err!(tcx.sess, sp, E0587,
1539 "type has conflicting packed and align representation hints").emit();
1541 else if check_packed_inner(tcx, def_id, &mut Vec::new()) {
1542 struct_span_err!(tcx.sess, sp, E0588,
1543 "packed type cannot transitively contain a `[repr(align)]` type").emit();
1548 fn check_packed_inner<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1550 stack: &mut Vec<DefId>) -> bool {
1551 let t = tcx.type_of(def_id);
1552 if stack.contains(&def_id) {
1553 debug!("check_packed_inner: {:?} is recursive", t);
1557 ty::TyAdt(def, substs) if def.is_struct() || def.is_union() => {
1558 if tcx.adt_def(def.did).repr.align > 0 {
1561 // push struct def_id before checking fields
1563 for field in &def.struct_variant().fields {
1564 let f = field.ty(tcx, substs);
1566 ty::TyAdt(def, _) => {
1567 if check_packed_inner(tcx, def.did, stack) {
1574 // only need to pop if not early out
1582 #[allow(trivial_numeric_casts)]
1583 pub fn check_enum<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1585 vs: &'tcx [hir::Variant],
1587 let def_id = tcx.hir.local_def_id(id);
1588 let def = tcx.adt_def(def_id);
1589 def.destructor(tcx); // force the destructor to be evaluated
1591 if vs.is_empty() && tcx.has_attr(def_id, "repr") {
1593 tcx.sess, sp, E0084,
1594 "unsupported representation for zero-variant enum")
1595 .span_label(sp, "unsupported enum representation")
1599 let repr_type_ty = def.repr.discr_type().to_ty(tcx);
1600 if repr_type_ty == tcx.types.i128 || repr_type_ty == tcx.types.u128 {
1601 if !tcx.sess.features.borrow().i128_type {
1602 emit_feature_err(&tcx.sess.parse_sess,
1603 "i128_type", sp, GateIssue::Language, "128-bit type is unstable");
1608 if let Some(e) = v.node.disr_expr {
1609 tcx.typeck_tables_of(tcx.hir.local_def_id(e.node_id));
1613 let mut disr_vals: Vec<ConstInt> = Vec::new();
1614 for (discr, v) in def.discriminants(tcx).zip(vs) {
1615 // Check for duplicate discriminant values
1616 if let Some(i) = disr_vals.iter().position(|&x| x == discr) {
1617 let variant_i_node_id = tcx.hir.as_local_node_id(def.variants[i].did).unwrap();
1618 let variant_i = tcx.hir.expect_variant(variant_i_node_id);
1619 let i_span = match variant_i.node.disr_expr {
1620 Some(expr) => tcx.hir.span(expr.node_id),
1621 None => tcx.hir.span(variant_i_node_id)
1623 let span = match v.node.disr_expr {
1624 Some(expr) => tcx.hir.span(expr.node_id),
1627 struct_span_err!(tcx.sess, span, E0081,
1628 "discriminant value `{}` already exists", disr_vals[i])
1629 .span_label(i_span, format!("first use of `{}`", disr_vals[i]))
1630 .span_label(span , format!("enum already has `{}`", disr_vals[i]))
1633 disr_vals.push(discr);
1636 check_representable(tcx, sp, def_id);
1639 impl<'a, 'gcx, 'tcx> AstConv<'gcx, 'tcx> for FnCtxt<'a, 'gcx, 'tcx> {
1640 fn tcx<'b>(&'b self) -> TyCtxt<'b, 'gcx, 'tcx> { self.tcx }
1642 fn get_type_parameter_bounds(&self, _: Span, def_id: DefId)
1643 -> ty::GenericPredicates<'tcx>
1646 let node_id = tcx.hir.as_local_node_id(def_id).unwrap();
1647 let item_id = tcx.hir.ty_param_owner(node_id);
1648 let item_def_id = tcx.hir.local_def_id(item_id);
1649 let generics = tcx.generics_of(item_def_id);
1650 let index = generics.type_param_to_index[&def_id.index];
1651 ty::GenericPredicates {
1653 predicates: self.param_env.caller_bounds.iter().filter(|predicate| {
1655 ty::Predicate::Trait(ref data) => {
1656 data.0.self_ty().is_param(index)
1660 }).cloned().collect()
1664 fn re_infer(&self, span: Span, def: Option<&ty::RegionParameterDef>)
1665 -> Option<ty::Region<'tcx>> {
1667 Some(def) => infer::EarlyBoundRegion(span, def.name),
1668 None => infer::MiscVariable(span)
1670 Some(self.next_region_var(v))
1673 fn ty_infer(&self, span: Span) -> Ty<'tcx> {
1674 self.next_ty_var(TypeVariableOrigin::TypeInference(span))
1677 fn ty_infer_for_def(&self,
1678 ty_param_def: &ty::TypeParameterDef,
1679 substs: &[Kind<'tcx>],
1680 span: Span) -> Ty<'tcx> {
1681 self.type_var_for_def(span, ty_param_def, substs)
1684 fn projected_ty_from_poly_trait_ref(&self,
1687 poly_trait_ref: ty::PolyTraitRef<'tcx>)
1690 let (trait_ref, _) =
1691 self.replace_late_bound_regions_with_fresh_var(
1693 infer::LateBoundRegionConversionTime::AssocTypeProjection(item_def_id),
1696 self.tcx().mk_projection(item_def_id, trait_ref.substs)
1699 fn normalize_ty(&self, span: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
1700 if ty.has_escaping_regions() {
1701 ty // FIXME: normalization and escaping regions
1703 self.normalize_associated_types_in(span, &ty)
1707 fn set_tainted_by_errors(&self) {
1708 self.infcx.set_tainted_by_errors()
1712 /// Controls whether the arguments are tupled. This is used for the call
1715 /// Tupling means that all call-side arguments are packed into a tuple and
1716 /// passed as a single parameter. For example, if tupling is enabled, this
1719 /// fn f(x: (isize, isize))
1721 /// Can be called as:
1728 #[derive(Clone, Eq, PartialEq)]
1729 enum TupleArgumentsFlag {
1734 impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
1735 pub fn new(inh: &'a Inherited<'a, 'gcx, 'tcx>,
1736 param_env: ty::ParamEnv<'tcx>,
1737 body_id: ast::NodeId)
1738 -> FnCtxt<'a, 'gcx, 'tcx> {
1742 err_count_on_creation: inh.tcx.sess.err_count(),
1745 ps: RefCell::new(UnsafetyState::function(hir::Unsafety::Normal,
1746 ast::CRATE_NODE_ID)),
1747 diverges: Cell::new(Diverges::Maybe),
1748 has_errors: Cell::new(false),
1749 enclosing_breakables: RefCell::new(EnclosingBreakables {
1757 pub fn sess(&self) -> &Session {
1761 pub fn err_count_since_creation(&self) -> usize {
1762 self.tcx.sess.err_count() - self.err_count_on_creation
1765 /// Produce warning on the given node, if the current point in the
1766 /// function is unreachable, and there hasn't been another warning.
1767 fn warn_if_unreachable(&self, id: ast::NodeId, span: Span, kind: &str) {
1768 if self.diverges.get() == Diverges::Always {
1769 self.diverges.set(Diverges::WarnedAlways);
1771 debug!("warn_if_unreachable: id={:?} span={:?} kind={}", id, span, kind);
1773 self.tcx().lint_node(
1774 lint::builtin::UNREACHABLE_CODE,
1776 &format!("unreachable {}", kind));
1782 code: ObligationCauseCode<'tcx>)
1783 -> ObligationCause<'tcx> {
1784 ObligationCause::new(span, self.body_id, code)
1787 pub fn misc(&self, span: Span) -> ObligationCause<'tcx> {
1788 self.cause(span, ObligationCauseCode::MiscObligation)
1791 /// Resolves type variables in `ty` if possible. Unlike the infcx
1792 /// version (resolve_type_vars_if_possible), this version will
1793 /// also select obligations if it seems useful, in an effort
1794 /// to get more type information.
1795 fn resolve_type_vars_with_obligations(&self, mut ty: Ty<'tcx>) -> Ty<'tcx> {
1796 debug!("resolve_type_vars_with_obligations(ty={:?})", ty);
1798 // No TyInfer()? Nothing needs doing.
1799 if !ty.has_infer_types() {
1800 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
1804 // If `ty` is a type variable, see whether we already know what it is.
1805 ty = self.resolve_type_vars_if_possible(&ty);
1806 if !ty.has_infer_types() {
1807 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
1811 // If not, try resolving pending obligations as much as
1812 // possible. This can help substantially when there are
1813 // indirect dependencies that don't seem worth tracking
1815 self.select_obligations_where_possible();
1816 ty = self.resolve_type_vars_if_possible(&ty);
1818 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
1822 fn record_deferred_call_resolution(&self,
1823 closure_def_id: DefId,
1824 r: DeferredCallResolution<'gcx, 'tcx>) {
1825 let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
1826 deferred_call_resolutions.entry(closure_def_id).or_insert(vec![]).push(r);
1829 fn remove_deferred_call_resolutions(&self,
1830 closure_def_id: DefId)
1831 -> Vec<DeferredCallResolution<'gcx, 'tcx>>
1833 let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
1834 deferred_call_resolutions.remove(&closure_def_id).unwrap_or(vec![])
1837 pub fn tag(&self) -> String {
1838 let self_ptr: *const FnCtxt = self;
1839 format!("{:?}", self_ptr)
1842 pub fn local_ty(&self, span: Span, nid: ast::NodeId) -> Ty<'tcx> {
1843 match self.locals.borrow().get(&nid) {
1846 span_bug!(span, "no type for local variable {}",
1847 self.tcx.hir.node_to_string(nid));
1853 pub fn write_ty(&self, id: hir::HirId, ty: Ty<'tcx>) {
1854 debug!("write_ty({:?}, {:?}) in fcx {}",
1855 id, self.resolve_type_vars_if_possible(&ty), self.tag());
1856 self.tables.borrow_mut().node_types_mut().insert(id, ty);
1858 if ty.references_error() {
1859 self.has_errors.set(true);
1860 self.set_tainted_by_errors();
1864 // The NodeId and the ItemLocalId must identify the same item. We just pass
1865 // both of them for consistency checking.
1866 pub fn write_method_call(&self,
1868 method: MethodCallee<'tcx>) {
1871 .type_dependent_defs_mut()
1872 .insert(hir_id, Def::Method(method.def_id));
1873 self.write_substs(hir_id, method.substs);
1876 pub fn write_substs(&self, node_id: hir::HirId, substs: &'tcx Substs<'tcx>) {
1877 if !substs.is_noop() {
1878 debug!("write_substs({:?}, {:?}) in fcx {}",
1883 self.tables.borrow_mut().node_substs_mut().insert(node_id, substs);
1887 pub fn apply_adjustments(&self, expr: &hir::Expr, adj: Vec<Adjustment<'tcx>>) {
1888 debug!("apply_adjustments(expr={:?}, adj={:?})", expr, adj);
1894 match self.tables.borrow_mut().adjustments_mut().entry(expr.hir_id) {
1895 Entry::Vacant(entry) => { entry.insert(adj); },
1896 Entry::Occupied(mut entry) => {
1897 debug!(" - composing on top of {:?}", entry.get());
1898 match (&entry.get()[..], &adj[..]) {
1899 // Applying any adjustment on top of a NeverToAny
1900 // is a valid NeverToAny adjustment, because it can't
1902 (&[Adjustment { kind: Adjust::NeverToAny, .. }], _) => return,
1904 Adjustment { kind: Adjust::Deref(_), .. },
1905 Adjustment { kind: Adjust::Borrow(AutoBorrow::Ref(..)), .. },
1907 Adjustment { kind: Adjust::Deref(_), .. },
1908 .. // Any following adjustments are allowed.
1910 // A reborrow has no effect before a dereference.
1912 // FIXME: currently we never try to compose autoderefs
1913 // and ReifyFnPointer/UnsafeFnPointer, but we could.
1915 bug!("while adjusting {:?}, can't compose {:?} and {:?}",
1916 expr, entry.get(), adj)
1918 *entry.get_mut() = adj;
1923 /// Basically whenever we are converting from a type scheme into
1924 /// the fn body space, we always want to normalize associated
1925 /// types as well. This function combines the two.
1926 fn instantiate_type_scheme<T>(&self,
1928 substs: &Substs<'tcx>,
1931 where T : TypeFoldable<'tcx>
1933 let value = value.subst(self.tcx, substs);
1934 let result = self.normalize_associated_types_in(span, &value);
1935 debug!("instantiate_type_scheme(value={:?}, substs={:?}) = {:?}",
1942 /// As `instantiate_type_scheme`, but for the bounds found in a
1943 /// generic type scheme.
1944 fn instantiate_bounds(&self, span: Span, def_id: DefId, substs: &Substs<'tcx>)
1945 -> ty::InstantiatedPredicates<'tcx> {
1946 let bounds = self.tcx.predicates_of(def_id);
1947 let result = bounds.instantiate(self.tcx, substs);
1948 let result = self.normalize_associated_types_in(span, &result);
1949 debug!("instantiate_bounds(bounds={:?}, substs={:?}) = {:?}",
1956 /// Replace all anonymized types with fresh inference variables
1957 /// and record them for writeback.
1958 fn instantiate_anon_types<T: TypeFoldable<'tcx>>(&self, value: &T) -> T {
1959 value.fold_with(&mut BottomUpFolder { tcx: self.tcx, fldop: |ty| {
1960 if let ty::TyAnon(def_id, substs) = ty.sty {
1961 // Use the same type variable if the exact same TyAnon appears more
1962 // than once in the return type (e.g. if it's passed to a type alias).
1963 let id = self.tcx.hir.as_local_node_id(def_id).unwrap();
1964 if let Some(ty_var) = self.anon_types.borrow().get(&id) {
1967 let span = self.tcx.def_span(def_id);
1968 let ty_var = self.next_ty_var(TypeVariableOrigin::TypeInference(span));
1969 self.anon_types.borrow_mut().insert(id, ty_var);
1971 let predicates_of = self.tcx.predicates_of(def_id);
1972 let bounds = predicates_of.instantiate(self.tcx, substs);
1974 for predicate in bounds.predicates {
1975 // Change the predicate to refer to the type variable,
1976 // which will be the concrete type, instead of the TyAnon.
1977 // This also instantiates nested `impl Trait`.
1978 let predicate = self.instantiate_anon_types(&predicate);
1980 // Require that the predicate holds for the concrete type.
1981 let cause = traits::ObligationCause::new(span, self.body_id,
1982 traits::SizedReturnType);
1983 self.register_predicate(traits::Obligation::new(cause,
1995 fn normalize_associated_types_in<T>(&self, span: Span, value: &T) -> T
1996 where T : TypeFoldable<'tcx>
1998 self.inh.normalize_associated_types_in(span, self.body_id, self.param_env, value)
2001 fn normalize_associated_types_in_as_infer_ok<T>(&self, span: Span, value: &T)
2003 where T : TypeFoldable<'tcx>
2005 self.inh.normalize_associated_types_in_as_infer_ok(span,
2011 pub fn require_type_meets(&self,
2014 code: traits::ObligationCauseCode<'tcx>,
2017 self.register_bound(
2020 traits::ObligationCause::new(span, self.body_id, code));
2023 pub fn require_type_is_sized(&self,
2026 code: traits::ObligationCauseCode<'tcx>)
2028 let lang_item = self.tcx.require_lang_item(lang_items::SizedTraitLangItem);
2029 self.require_type_meets(ty, span, code, lang_item);
2032 pub fn register_bound(&self,
2035 cause: traits::ObligationCause<'tcx>)
2037 self.fulfillment_cx.borrow_mut()
2038 .register_bound(self, self.param_env, ty, def_id, cause);
2041 pub fn to_ty(&self, ast_t: &hir::Ty) -> Ty<'tcx> {
2042 let t = AstConv::ast_ty_to_ty(self, ast_t);
2043 self.register_wf_obligation(t, ast_t.span, traits::MiscObligation);
2047 pub fn node_ty(&self, id: hir::HirId) -> Ty<'tcx> {
2048 match self.tables.borrow().node_types().get(id) {
2050 None if self.err_count_since_creation() != 0 => self.tcx.types.err,
2052 let node_id = self.tcx.hir.definitions().find_node_for_hir_id(id);
2053 bug!("no type for node {}: {} in fcx {}",
2054 node_id, self.tcx.hir.node_to_string(node_id),
2060 /// Registers an obligation for checking later, during regionck, that the type `ty` must
2061 /// outlive the region `r`.
2062 pub fn register_wf_obligation(&self,
2065 code: traits::ObligationCauseCode<'tcx>)
2067 // WF obligations never themselves fail, so no real need to give a detailed cause:
2068 let cause = traits::ObligationCause::new(span, self.body_id, code);
2069 self.register_predicate(traits::Obligation::new(cause,
2071 ty::Predicate::WellFormed(ty)));
2074 /// Registers obligations that all types appearing in `substs` are well-formed.
2075 pub fn add_wf_bounds(&self, substs: &Substs<'tcx>, expr: &hir::Expr)
2077 for ty in substs.types() {
2078 self.register_wf_obligation(ty, expr.span, traits::MiscObligation);
2082 /// Given a fully substituted set of bounds (`generic_bounds`), and the values with which each
2083 /// type/region parameter was instantiated (`substs`), creates and registers suitable
2084 /// trait/region obligations.
2086 /// For example, if there is a function:
2089 /// fn foo<'a,T:'a>(...)
2092 /// and a reference:
2098 /// Then we will create a fresh region variable `'$0` and a fresh type variable `$1` for `'a`
2099 /// and `T`. This routine will add a region obligation `$1:'$0` and register it locally.
2100 pub fn add_obligations_for_parameters(&self,
2101 cause: traits::ObligationCause<'tcx>,
2102 predicates: &ty::InstantiatedPredicates<'tcx>)
2104 assert!(!predicates.has_escaping_regions());
2106 debug!("add_obligations_for_parameters(predicates={:?})",
2109 for obligation in traits::predicates_for_generics(cause, self.param_env, predicates) {
2110 self.register_predicate(obligation);
2114 // FIXME(arielb1): use this instead of field.ty everywhere
2115 // Only for fields! Returns <none> for methods>
2116 // Indifferent to privacy flags
2117 pub fn field_ty(&self,
2119 field: &'tcx ty::FieldDef,
2120 substs: &Substs<'tcx>)
2123 self.normalize_associated_types_in(span,
2124 &field.ty(self.tcx, substs))
2127 fn check_casts(&self) {
2128 let mut deferred_cast_checks = self.deferred_cast_checks.borrow_mut();
2129 for cast in deferred_cast_checks.drain(..) {
2134 fn resolve_generator_interiors(&self, def_id: DefId) {
2135 let mut deferred_generator_interiors = self.deferred_generator_interiors.borrow_mut();
2136 for (body_id, witness) in deferred_generator_interiors.drain(..) {
2137 generator_interior::resolve_interior(self, def_id, body_id, witness);
2141 /// Apply "fallbacks" to some types
2142 /// unconstrained types get replaced with ! or () (depending on whether
2143 /// feature(never_type) is enabled), unconstrained ints with i32, and
2144 /// unconstrained floats with f64.
2145 fn default_type_parameters(&self) {
2146 use rustc::ty::error::UnconstrainedNumeric::Neither;
2147 use rustc::ty::error::UnconstrainedNumeric::{UnconstrainedInt, UnconstrainedFloat};
2149 // Defaulting inference variables becomes very dubious if we have
2150 // encountered type-checking errors. Therefore, if we think we saw
2151 // some errors in this function, just resolve all uninstanted type
2152 // varibles to TyError.
2153 if self.is_tainted_by_errors() {
2154 for ty in &self.unsolved_variables() {
2155 if let ty::TyInfer(_) = self.shallow_resolve(ty).sty {
2156 debug!("default_type_parameters: defaulting `{:?}` to error", ty);
2157 self.demand_eqtype(syntax_pos::DUMMY_SP, *ty, self.tcx().types.err);
2163 for ty in &self.unsolved_variables() {
2164 let resolved = self.resolve_type_vars_if_possible(ty);
2165 if self.type_var_diverges(resolved) {
2166 debug!("default_type_parameters: defaulting `{:?}` to `!` because it diverges",
2168 self.demand_eqtype(syntax_pos::DUMMY_SP, *ty,
2169 self.tcx.mk_diverging_default());
2171 match self.type_is_unconstrained_numeric(resolved) {
2172 UnconstrainedInt => {
2173 debug!("default_type_parameters: defaulting `{:?}` to `i32`",
2175 self.demand_eqtype(syntax_pos::DUMMY_SP, *ty, self.tcx.types.i32)
2177 UnconstrainedFloat => {
2178 debug!("default_type_parameters: defaulting `{:?}` to `f32`",
2180 self.demand_eqtype(syntax_pos::DUMMY_SP, *ty, self.tcx.types.f64)
2188 // Implements type inference fallback algorithm
2189 fn select_all_obligations_and_apply_defaults(&self) {
2190 self.select_obligations_where_possible();
2191 self.default_type_parameters();
2192 self.select_obligations_where_possible();
2195 fn select_all_obligations_or_error(&self) {
2196 debug!("select_all_obligations_or_error");
2198 // upvar inference should have ensured that all deferred call
2199 // resolutions are handled by now.
2200 assert!(self.deferred_call_resolutions.borrow().is_empty());
2202 self.select_all_obligations_and_apply_defaults();
2204 let mut fulfillment_cx = self.fulfillment_cx.borrow_mut();
2206 match fulfillment_cx.select_all_or_error(self) {
2208 Err(errors) => { self.report_fulfillment_errors(&errors, self.inh.body_id); }
2212 /// Select as many obligations as we can at present.
2213 fn select_obligations_where_possible(&self) {
2214 match self.fulfillment_cx.borrow_mut().select_where_possible(self) {
2216 Err(errors) => { self.report_fulfillment_errors(&errors, self.inh.body_id); }
2220 /// For the overloaded lvalue expressions (`*x`, `x[3]`), the trait
2221 /// returns a type of `&T`, but the actual type we assign to the
2222 /// *expression* is `T`. So this function just peels off the return
2223 /// type by one layer to yield `T`.
2224 fn make_overloaded_lvalue_return_type(&self,
2225 method: MethodCallee<'tcx>)
2226 -> ty::TypeAndMut<'tcx>
2228 // extract method return type, which will be &T;
2229 let ret_ty = method.sig.output();
2231 // method returns &T, but the type as visible to user is T, so deref
2232 ret_ty.builtin_deref(true, NoPreference).unwrap()
2235 fn lookup_indexing(&self,
2237 base_expr: &'gcx hir::Expr,
2240 lvalue_pref: LvaluePreference)
2241 -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)>
2243 // FIXME(#18741) -- this is almost but not quite the same as the
2244 // autoderef that normal method probing does. They could likely be
2247 let mut autoderef = self.autoderef(base_expr.span, base_ty);
2248 let mut result = None;
2249 while result.is_none() && autoderef.next().is_some() {
2250 result = self.try_index_step(expr, base_expr, &autoderef, lvalue_pref, idx_ty);
2252 autoderef.finalize();
2256 /// To type-check `base_expr[index_expr]`, we progressively autoderef
2257 /// (and otherwise adjust) `base_expr`, looking for a type which either
2258 /// supports builtin indexing or overloaded indexing.
2259 /// This loop implements one step in that search; the autoderef loop
2260 /// is implemented by `lookup_indexing`.
2261 fn try_index_step(&self,
2263 base_expr: &hir::Expr,
2264 autoderef: &Autoderef<'a, 'gcx, 'tcx>,
2265 lvalue_pref: LvaluePreference,
2267 -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)>
2269 let adjusted_ty = autoderef.unambiguous_final_ty();
2270 debug!("try_index_step(expr={:?}, base_expr={:?}, adjusted_ty={:?}, \
2278 // First, try built-in indexing.
2279 match (adjusted_ty.builtin_index(), &index_ty.sty) {
2280 (Some(ty), &ty::TyUint(ast::UintTy::Us)) | (Some(ty), &ty::TyInfer(ty::IntVar(_))) => {
2281 debug!("try_index_step: success, using built-in indexing");
2282 let adjustments = autoderef.adjust_steps(lvalue_pref);
2283 self.apply_adjustments(base_expr, adjustments);
2284 return Some((self.tcx.types.usize, ty));
2289 for &unsize in &[false, true] {
2290 let mut self_ty = adjusted_ty;
2292 // We only unsize arrays here.
2293 if let ty::TyArray(element_ty, _) = adjusted_ty.sty {
2294 self_ty = self.tcx.mk_slice(element_ty);
2300 // If some lookup succeeds, write callee into table and extract index/element
2301 // type from the method signature.
2302 // If some lookup succeeded, install method in table
2303 let input_ty = self.next_ty_var(TypeVariableOrigin::AutoDeref(base_expr.span));
2304 let method = self.try_overloaded_lvalue_op(
2305 expr.span, self_ty, &[input_ty], lvalue_pref, LvalueOp::Index);
2307 let result = method.map(|ok| {
2308 debug!("try_index_step: success, using overloaded indexing");
2309 let method = self.register_infer_ok_obligations(ok);
2311 let mut adjustments = autoderef.adjust_steps(lvalue_pref);
2312 if let ty::TyRef(region, mt) = method.sig.inputs()[0].sty {
2313 adjustments.push(Adjustment {
2314 kind: Adjust::Borrow(AutoBorrow::Ref(region, mt.mutbl)),
2315 target: self.tcx.mk_ref(region, ty::TypeAndMut {
2322 adjustments.push(Adjustment {
2323 kind: Adjust::Unsize,
2324 target: method.sig.inputs()[0]
2327 self.apply_adjustments(base_expr, adjustments);
2329 self.write_method_call(expr.hir_id, method);
2330 (input_ty, self.make_overloaded_lvalue_return_type(method).ty)
2332 if result.is_some() {
2340 fn resolve_lvalue_op(&self, op: LvalueOp, is_mut: bool) -> (Option<DefId>, Symbol) {
2341 let (tr, name) = match (op, is_mut) {
2342 (LvalueOp::Deref, false) =>
2343 (self.tcx.lang_items.deref_trait(), "deref"),
2344 (LvalueOp::Deref, true) =>
2345 (self.tcx.lang_items.deref_mut_trait(), "deref_mut"),
2346 (LvalueOp::Index, false) =>
2347 (self.tcx.lang_items.index_trait(), "index"),
2348 (LvalueOp::Index, true) =>
2349 (self.tcx.lang_items.index_mut_trait(), "index_mut"),
2351 (tr, Symbol::intern(name))
2354 fn try_overloaded_lvalue_op(&self,
2357 arg_tys: &[Ty<'tcx>],
2358 lvalue_pref: LvaluePreference,
2360 -> Option<InferOk<'tcx, MethodCallee<'tcx>>>
2362 debug!("try_overloaded_lvalue_op({:?},{:?},{:?},{:?})",
2368 // Try Mut first, if preferred.
2369 let (mut_tr, mut_op) = self.resolve_lvalue_op(op, true);
2370 let method = match (lvalue_pref, mut_tr) {
2371 (PreferMutLvalue, Some(trait_did)) => {
2372 self.lookup_method_in_trait(span, mut_op, trait_did, base_ty, Some(arg_tys))
2377 // Otherwise, fall back to the immutable version.
2378 let (imm_tr, imm_op) = self.resolve_lvalue_op(op, false);
2379 let method = match (method, imm_tr) {
2380 (None, Some(trait_did)) => {
2381 self.lookup_method_in_trait(span, imm_op, trait_did, base_ty, Some(arg_tys))
2383 (method, _) => method,
2389 fn check_method_argument_types(&self,
2391 method: Result<MethodCallee<'tcx>, ()>,
2392 args_no_rcvr: &'gcx [hir::Expr],
2393 tuple_arguments: TupleArgumentsFlag,
2394 expected: Expectation<'tcx>)
2396 let has_error = match method {
2398 method.substs.references_error() || method.sig.references_error()
2403 let err_inputs = self.err_args(args_no_rcvr.len());
2405 let err_inputs = match tuple_arguments {
2406 DontTupleArguments => err_inputs,
2407 TupleArguments => vec![self.tcx.intern_tup(&err_inputs[..], false)],
2410 self.check_argument_types(sp, &err_inputs[..], &[], args_no_rcvr,
2411 false, tuple_arguments, None);
2412 return self.tcx.types.err;
2415 let method = method.unwrap();
2416 // HACK(eddyb) ignore self in the definition (see above).
2417 let expected_arg_tys = self.expected_inputs_for_expected_output(
2420 method.sig.output(),
2421 &method.sig.inputs()[1..]
2423 self.check_argument_types(sp, &method.sig.inputs()[1..], &expected_arg_tys[..],
2424 args_no_rcvr, method.sig.variadic, tuple_arguments,
2425 self.tcx.hir.span_if_local(method.def_id));
2429 /// Generic function that factors out common logic from function calls,
2430 /// method calls and overloaded operators.
2431 fn check_argument_types(&self,
2433 fn_inputs: &[Ty<'tcx>],
2434 expected_arg_tys: &[Ty<'tcx>],
2435 args: &'gcx [hir::Expr],
2437 tuple_arguments: TupleArgumentsFlag,
2438 def_span: Option<Span>) {
2441 // Grab the argument types, supplying fresh type variables
2442 // if the wrong number of arguments were supplied
2443 let supplied_arg_count = if tuple_arguments == DontTupleArguments {
2449 // All the input types from the fn signature must outlive the call
2450 // so as to validate implied bounds.
2451 for &fn_input_ty in fn_inputs {
2452 self.register_wf_obligation(fn_input_ty, sp, traits::MiscObligation);
2455 let mut expected_arg_tys = expected_arg_tys;
2456 let expected_arg_count = fn_inputs.len();
2458 let sp_args = if args.len() > 0 {
2459 let (first, args) = args.split_at(1);
2460 let mut sp_tmp = first[0].span;
2462 let sp_opt = self.sess().codemap().merge_spans(sp_tmp, arg.span);
2463 if ! sp_opt.is_some() {
2466 sp_tmp = sp_opt.unwrap();
2473 fn parameter_count_error<'tcx>(sess: &Session, sp: Span, expected_count: usize,
2474 arg_count: usize, error_code: &str, variadic: bool,
2475 def_span: Option<Span>, sugg_unit: bool) {
2476 let mut err = sess.struct_span_err_with_code(sp,
2477 &format!("this function takes {}{} parameter{} but {} parameter{} supplied",
2478 if variadic {"at least "} else {""},
2480 if expected_count == 1 {""} else {"s"},
2482 if arg_count == 1 {" was"} else {"s were"}),
2485 if let Some(def_s) = def_span {
2486 err.span_label(def_s, "defined here");
2489 let sugg_span = sp.end_point();
2490 // remove closing `)` from the span
2491 let sugg_span = sugg_span.with_hi(sugg_span.lo());
2492 err.span_suggestion(
2494 "expected the unit value `()`. You can create one with a pair of parenthesis",
2495 String::from("()"));
2497 err.span_label(sp, format!("expected {}{} parameter{}",
2498 if variadic {"at least "} else {""},
2500 if expected_count == 1 {""} else {"s"}));
2505 let formal_tys = if tuple_arguments == TupleArguments {
2506 let tuple_type = self.structurally_resolved_type(sp, fn_inputs[0]);
2507 match tuple_type.sty {
2508 ty::TyTuple(arg_types, _) if arg_types.len() != args.len() => {
2509 parameter_count_error(tcx.sess, sp_args, arg_types.len(), args.len(),
2510 "E0057", false, def_span, false);
2511 expected_arg_tys = &[];
2512 self.err_args(args.len())
2514 ty::TyTuple(arg_types, _) => {
2515 expected_arg_tys = match expected_arg_tys.get(0) {
2516 Some(&ty) => match ty.sty {
2517 ty::TyTuple(ref tys, _) => &tys,
2525 span_err!(tcx.sess, sp, E0059,
2526 "cannot use call notation; the first type parameter \
2527 for the function trait is neither a tuple nor unit");
2528 expected_arg_tys = &[];
2529 self.err_args(args.len())
2532 } else if expected_arg_count == supplied_arg_count {
2534 } else if variadic {
2535 if supplied_arg_count >= expected_arg_count {
2538 parameter_count_error(tcx.sess, sp_args, expected_arg_count,
2539 supplied_arg_count, "E0060", true, def_span, false);
2540 expected_arg_tys = &[];
2541 self.err_args(supplied_arg_count)
2544 // is the missing argument of type `()`?
2545 let sugg_unit = if expected_arg_tys.len() == 1 && supplied_arg_count == 0 {
2546 self.resolve_type_vars_if_possible(&expected_arg_tys[0]).is_nil()
2547 } else if fn_inputs.len() == 1 && supplied_arg_count == 0 {
2548 self.resolve_type_vars_if_possible(&fn_inputs[0]).is_nil()
2552 parameter_count_error(tcx.sess, sp_args, expected_arg_count,
2553 supplied_arg_count, "E0061", false, def_span, sugg_unit);
2554 expected_arg_tys = &[];
2555 self.err_args(supplied_arg_count)
2558 debug!("check_argument_types: formal_tys={:?}",
2559 formal_tys.iter().map(|t| self.ty_to_string(*t)).collect::<Vec<String>>());
2561 // Check the arguments.
2562 // We do this in a pretty awful way: first we typecheck any arguments
2563 // that are not closures, then we typecheck the closures. This is so
2564 // that we have more information about the types of arguments when we
2565 // typecheck the functions. This isn't really the right way to do this.
2566 for &check_closures in &[false, true] {
2567 debug!("check_closures={}", check_closures);
2569 // More awful hacks: before we check argument types, try to do
2570 // an "opportunistic" vtable resolution of any trait bounds on
2571 // the call. This helps coercions.
2573 self.select_obligations_where_possible();
2576 // For variadic functions, we don't have a declared type for all of
2577 // the arguments hence we only do our usual type checking with
2578 // the arguments who's types we do know.
2579 let t = if variadic {
2581 } else if tuple_arguments == TupleArguments {
2586 for (i, arg) in args.iter().take(t).enumerate() {
2587 // Warn only for the first loop (the "no closures" one).
2588 // Closure arguments themselves can't be diverging, but
2589 // a previous argument can, e.g. `foo(panic!(), || {})`.
2590 if !check_closures {
2591 self.warn_if_unreachable(arg.id, arg.span, "expression");
2594 let is_closure = match arg.node {
2595 hir::ExprClosure(..) => true,
2599 if is_closure != check_closures {
2603 debug!("checking the argument");
2604 let formal_ty = formal_tys[i];
2606 // The special-cased logic below has three functions:
2607 // 1. Provide as good of an expected type as possible.
2608 let expected = expected_arg_tys.get(i).map(|&ty| {
2609 Expectation::rvalue_hint(self, ty)
2612 let checked_ty = self.check_expr_with_expectation(
2614 expected.unwrap_or(ExpectHasType(formal_ty)));
2616 // 2. Coerce to the most detailed type that could be coerced
2617 // to, which is `expected_ty` if `rvalue_hint` returns an
2618 // `ExpectHasType(expected_ty)`, or the `formal_ty` otherwise.
2619 let coerce_ty = expected.and_then(|e| e.only_has_type(self));
2620 self.demand_coerce(&arg, checked_ty, coerce_ty.unwrap_or(formal_ty));
2622 // 3. Relate the expected type and the formal one,
2623 // if the expected type was used for the coercion.
2624 coerce_ty.map(|ty| self.demand_suptype(arg.span, formal_ty, ty));
2628 // We also need to make sure we at least write the ty of the other
2629 // arguments which we skipped above.
2631 fn variadic_error<'tcx>(s: &Session, span: Span, t: Ty<'tcx>, cast_ty: &str) {
2632 type_error_struct!(s, span, t, E0617,
2633 "can't pass `{}` to variadic function, cast to `{}`",
2637 for arg in args.iter().skip(expected_arg_count) {
2638 let arg_ty = self.check_expr(&arg);
2640 // There are a few types which get autopromoted when passed via varargs
2641 // in C but we just error out instead and require explicit casts.
2642 let arg_ty = self.structurally_resolved_type(arg.span, arg_ty);
2644 ty::TyFloat(ast::FloatTy::F32) => {
2645 variadic_error(tcx.sess, arg.span, arg_ty, "c_double");
2647 ty::TyInt(ast::IntTy::I8) | ty::TyInt(ast::IntTy::I16) | ty::TyBool => {
2648 variadic_error(tcx.sess, arg.span, arg_ty, "c_int");
2650 ty::TyUint(ast::UintTy::U8) | ty::TyUint(ast::UintTy::U16) => {
2651 variadic_error(tcx.sess, arg.span, arg_ty, "c_uint");
2653 ty::TyFnDef(..) => {
2654 let ptr_ty = self.tcx.mk_fn_ptr(arg_ty.fn_sig(self.tcx));
2655 let ptr_ty = self.resolve_type_vars_if_possible(&ptr_ty);
2656 variadic_error(tcx.sess, arg.span, arg_ty, &format!("{}", ptr_ty));
2664 fn err_args(&self, len: usize) -> Vec<Ty<'tcx>> {
2665 (0..len).map(|_| self.tcx.types.err).collect()
2668 // AST fragment checking
2671 expected: Expectation<'tcx>)
2677 ast::LitKind::Str(..) => tcx.mk_static_str(),
2678 ast::LitKind::ByteStr(ref v) => {
2679 tcx.mk_imm_ref(tcx.types.re_static,
2680 tcx.mk_array(tcx.types.u8, v.len()))
2682 ast::LitKind::Byte(_) => tcx.types.u8,
2683 ast::LitKind::Char(_) => tcx.types.char,
2684 ast::LitKind::Int(_, ast::LitIntType::Signed(t)) => tcx.mk_mach_int(t),
2685 ast::LitKind::Int(_, ast::LitIntType::Unsigned(t)) => tcx.mk_mach_uint(t),
2686 ast::LitKind::Int(_, ast::LitIntType::Unsuffixed) => {
2687 let opt_ty = expected.to_option(self).and_then(|ty| {
2689 ty::TyInt(_) | ty::TyUint(_) => Some(ty),
2690 ty::TyChar => Some(tcx.types.u8),
2691 ty::TyRawPtr(..) => Some(tcx.types.usize),
2692 ty::TyFnDef(..) | ty::TyFnPtr(_) => Some(tcx.types.usize),
2696 opt_ty.unwrap_or_else(
2697 || tcx.mk_int_var(self.next_int_var_id()))
2699 ast::LitKind::Float(_, t) => tcx.mk_mach_float(t),
2700 ast::LitKind::FloatUnsuffixed(_) => {
2701 let opt_ty = expected.to_option(self).and_then(|ty| {
2703 ty::TyFloat(_) => Some(ty),
2707 opt_ty.unwrap_or_else(
2708 || tcx.mk_float_var(self.next_float_var_id()))
2710 ast::LitKind::Bool(_) => tcx.types.bool
2714 fn check_expr_eq_type(&self,
2715 expr: &'gcx hir::Expr,
2716 expected: Ty<'tcx>) {
2717 let ty = self.check_expr_with_hint(expr, expected);
2718 self.demand_eqtype(expr.span, expected, ty);
2721 pub fn check_expr_has_type_or_error(&self,
2722 expr: &'gcx hir::Expr,
2723 expected: Ty<'tcx>) -> Ty<'tcx> {
2724 self.check_expr_meets_expectation_or_error(expr, ExpectHasType(expected))
2727 fn check_expr_meets_expectation_or_error(&self,
2728 expr: &'gcx hir::Expr,
2729 expected: Expectation<'tcx>) -> Ty<'tcx> {
2730 let expected_ty = expected.to_option(&self).unwrap_or(self.tcx.types.bool);
2731 let mut ty = self.check_expr_with_expectation(expr, expected);
2733 // While we don't allow *arbitrary* coercions here, we *do* allow
2734 // coercions from ! to `expected`.
2736 assert!(!self.tables.borrow().adjustments().contains_key(expr.hir_id),
2737 "expression with never type wound up being adjusted");
2738 let adj_ty = self.next_diverging_ty_var(
2739 TypeVariableOrigin::AdjustmentType(expr.span));
2740 self.apply_adjustments(expr, vec![Adjustment {
2741 kind: Adjust::NeverToAny,
2747 if let Some(mut err) = self.demand_suptype_diag(expr.span, expected_ty, ty) {
2748 // Add help to type error if this is an `if` condition with an assignment
2749 match (expected, &expr.node) {
2750 (ExpectIfCondition, &hir::ExprAssign(ref lhs, ref rhs)) => {
2751 let msg = "try comparing for equality";
2752 if let (Ok(left), Ok(right)) = (
2753 self.tcx.sess.codemap().span_to_snippet(lhs.span),
2754 self.tcx.sess.codemap().span_to_snippet(rhs.span))
2756 err.span_suggestion(expr.span, msg, format!("{} == {}", left, right));
2768 fn check_expr_coercable_to_type(&self,
2769 expr: &'gcx hir::Expr,
2770 expected: Ty<'tcx>) -> Ty<'tcx> {
2771 let ty = self.check_expr_with_hint(expr, expected);
2772 self.demand_coerce(expr, ty, expected);
2776 fn check_expr_with_hint(&self, expr: &'gcx hir::Expr,
2777 expected: Ty<'tcx>) -> Ty<'tcx> {
2778 self.check_expr_with_expectation(expr, ExpectHasType(expected))
2781 fn check_expr_with_expectation(&self,
2782 expr: &'gcx hir::Expr,
2783 expected: Expectation<'tcx>) -> Ty<'tcx> {
2784 self.check_expr_with_expectation_and_lvalue_pref(expr, expected, NoPreference)
2787 fn check_expr(&self, expr: &'gcx hir::Expr) -> Ty<'tcx> {
2788 self.check_expr_with_expectation(expr, NoExpectation)
2791 fn check_expr_with_lvalue_pref(&self, expr: &'gcx hir::Expr,
2792 lvalue_pref: LvaluePreference) -> Ty<'tcx> {
2793 self.check_expr_with_expectation_and_lvalue_pref(expr, NoExpectation, lvalue_pref)
2796 // determine the `self` type, using fresh variables for all variables
2797 // declared on the impl declaration e.g., `impl<A,B> for Vec<(A,B)>`
2798 // would return ($0, $1) where $0 and $1 are freshly instantiated type
2800 pub fn impl_self_ty(&self,
2801 span: Span, // (potential) receiver for this impl
2803 -> TypeAndSubsts<'tcx> {
2804 let ity = self.tcx.type_of(did);
2805 debug!("impl_self_ty: ity={:?}", ity);
2807 let substs = self.fresh_substs_for_item(span, did);
2808 let substd_ty = self.instantiate_type_scheme(span, &substs, &ity);
2810 TypeAndSubsts { substs: substs, ty: substd_ty }
2813 /// Unifies the output type with the expected type early, for more coercions
2814 /// and forward type information on the input expressions.
2815 fn expected_inputs_for_expected_output(&self,
2817 expected_ret: Expectation<'tcx>,
2818 formal_ret: Ty<'tcx>,
2819 formal_args: &[Ty<'tcx>])
2821 let expected_args = expected_ret.only_has_type(self).and_then(|ret_ty| {
2822 self.fudge_regions_if_ok(&RegionVariableOrigin::Coercion(call_span), || {
2823 // Attempt to apply a subtyping relationship between the formal
2824 // return type (likely containing type variables if the function
2825 // is polymorphic) and the expected return type.
2826 // No argument expectations are produced if unification fails.
2827 let origin = self.misc(call_span);
2828 let ures = self.at(&origin, self.param_env).sup(ret_ty, formal_ret);
2830 // FIXME(#15760) can't use try! here, FromError doesn't default
2831 // to identity so the resulting type is not constrained.
2834 // Process any obligations locally as much as
2835 // we can. We don't care if some things turn
2836 // out unconstrained or ambiguous, as we're
2837 // just trying to get hints here.
2838 let result = self.save_and_restore_in_snapshot_flag(|_| {
2839 let mut fulfill = FulfillmentContext::new();
2840 let ok = ok; // FIXME(#30046)
2841 for obligation in ok.obligations {
2842 fulfill.register_predicate_obligation(self, obligation);
2844 fulfill.select_where_possible(self)
2849 Err(_) => return Err(()),
2852 Err(_) => return Err(()),
2855 // Record all the argument types, with the substitutions
2856 // produced from the above subtyping unification.
2857 Ok(formal_args.iter().map(|ty| {
2858 self.resolve_type_vars_if_possible(ty)
2861 }).unwrap_or(vec![]);
2862 debug!("expected_inputs_for_expected_output(formal={:?} -> {:?}, expected={:?} -> {:?})",
2863 formal_args, formal_ret,
2864 expected_args, expected_ret);
2868 // Checks a method call.
2869 fn check_method_call(&self,
2870 expr: &'gcx hir::Expr,
2871 segment: &hir::PathSegment,
2873 args: &'gcx [hir::Expr],
2874 expected: Expectation<'tcx>,
2875 lvalue_pref: LvaluePreference) -> Ty<'tcx> {
2876 let rcvr = &args[0];
2877 let rcvr_t = self.check_expr_with_lvalue_pref(&rcvr, lvalue_pref);
2878 // no need to check for bot/err -- callee does that
2879 let rcvr_t = self.structurally_resolved_type(expr.span, rcvr_t);
2881 let method = match self.lookup_method(rcvr_t,
2887 self.write_method_call(expr.hir_id, method);
2891 if segment.name != keywords::Invalid.name() {
2892 self.report_method_error(span,
2903 // Call the generic checker.
2904 self.check_method_argument_types(span, method,
2910 fn check_return_expr(&self, return_expr: &'gcx hir::Expr) {
2914 .unwrap_or_else(|| span_bug!(return_expr.span,
2915 "check_return_expr called outside fn body"));
2917 let ret_ty = ret_coercion.borrow().expected_ty();
2918 let return_expr_ty = self.check_expr_with_hint(return_expr, ret_ty.clone());
2919 ret_coercion.borrow_mut()
2921 &self.cause(return_expr.span,
2922 ObligationCauseCode::ReturnType(return_expr.id)),
2925 self.diverges.get());
2929 // A generic function for checking the then and else in an if
2931 fn check_then_else(&self,
2932 cond_expr: &'gcx hir::Expr,
2933 then_expr: &'gcx hir::Expr,
2934 opt_else_expr: Option<&'gcx hir::Expr>,
2936 expected: Expectation<'tcx>) -> Ty<'tcx> {
2937 let cond_ty = self.check_expr_meets_expectation_or_error(cond_expr, ExpectIfCondition);
2938 let cond_diverges = self.diverges.get();
2939 self.diverges.set(Diverges::Maybe);
2941 let expected = expected.adjust_for_branches(self);
2942 let then_ty = self.check_expr_with_expectation(then_expr, expected);
2943 let then_diverges = self.diverges.get();
2944 self.diverges.set(Diverges::Maybe);
2946 // We've already taken the expected type's preferences
2947 // into account when typing the `then` branch. To figure
2948 // out the initial shot at a LUB, we thus only consider
2949 // `expected` if it represents a *hard* constraint
2950 // (`only_has_type`); otherwise, we just go with a
2951 // fresh type variable.
2952 let coerce_to_ty = expected.coercion_target_type(self, sp);
2953 let mut coerce: DynamicCoerceMany = CoerceMany::new(coerce_to_ty);
2955 let if_cause = self.cause(sp, ObligationCauseCode::IfExpression);
2956 coerce.coerce(self, &if_cause, then_expr, then_ty, then_diverges);
2958 if let Some(else_expr) = opt_else_expr {
2959 let else_ty = self.check_expr_with_expectation(else_expr, expected);
2960 let else_diverges = self.diverges.get();
2962 coerce.coerce(self, &if_cause, else_expr, else_ty, else_diverges);
2964 // We won't diverge unless both branches do (or the condition does).
2965 self.diverges.set(cond_diverges | then_diverges & else_diverges);
2967 let else_cause = self.cause(sp, ObligationCauseCode::IfExpressionWithNoElse);
2968 coerce.coerce_forced_unit(self, &else_cause, &mut |_| (), true);
2970 // If the condition is false we can't diverge.
2971 self.diverges.set(cond_diverges);
2974 let result_ty = coerce.complete(self);
2975 if cond_ty.references_error() {
2982 // Check field access expressions
2983 fn check_field(&self,
2984 expr: &'gcx hir::Expr,
2985 lvalue_pref: LvaluePreference,
2986 base: &'gcx hir::Expr,
2987 field: &Spanned<ast::Name>) -> Ty<'tcx> {
2988 let expr_t = self.check_expr_with_lvalue_pref(base, lvalue_pref);
2989 let expr_t = self.structurally_resolved_type(expr.span,
2991 let mut private_candidate = None;
2992 let mut autoderef = self.autoderef(expr.span, expr_t);
2993 while let Some((base_t, _)) = autoderef.next() {
2995 ty::TyAdt(base_def, substs) if !base_def.is_enum() => {
2996 debug!("struct named {:?}", base_t);
2997 let (ident, def_scope) =
2998 self.tcx.adjust(field.node, base_def.did, self.body_id);
2999 let fields = &base_def.struct_variant().fields;
3000 if let Some(field) = fields.iter().find(|f| f.name.to_ident() == ident) {
3001 let field_ty = self.field_ty(expr.span, field, substs);
3002 if field.vis.is_accessible_from(def_scope, self.tcx) {
3003 let adjustments = autoderef.adjust_steps(lvalue_pref);
3004 self.apply_adjustments(base, adjustments);
3005 autoderef.finalize();
3007 self.tcx.check_stability(field.did, expr.id, expr.span);
3011 private_candidate = Some((base_def.did, field_ty));
3017 autoderef.unambiguous_final_ty();
3019 if let Some((did, field_ty)) = private_candidate {
3020 let struct_path = self.tcx().item_path_str(did);
3021 let mut err = struct_span_err!(self.tcx().sess, expr.span, E0616,
3022 "field `{}` of struct `{}` is private",
3023 field.node, struct_path);
3024 // Also check if an accessible method exists, which is often what is meant.
3025 if self.method_exists(field.span, field.node, expr_t, expr.id, false) {
3026 err.note(&format!("a method `{}` also exists, perhaps you wish to call it",
3031 } else if field.node == keywords::Invalid.name() {
3032 self.tcx().types.err
3033 } else if self.method_exists(field.span, field.node, expr_t, expr.id, true) {
3034 type_error_struct!(self.tcx().sess, field.span, expr_t, E0615,
3035 "attempted to take value of method `{}` on type `{}`",
3037 .help("maybe a `()` to call it is missing?")
3039 self.tcx().types.err
3041 if !expr_t.is_primitive_ty() {
3042 let mut err = self.no_such_field_err(field.span, &field.node, expr_t);
3045 ty::TyAdt(def, _) if !def.is_enum() => {
3046 if let Some(suggested_field_name) =
3047 Self::suggest_field_name(def.struct_variant(), field, vec![]) {
3048 err.span_label(field.span,
3049 format!("did you mean `{}`?", suggested_field_name));
3051 err.span_label(field.span, "unknown field");
3052 let struct_variant_def = def.struct_variant();
3053 let field_names = self.available_field_names(struct_variant_def);
3054 if !field_names.is_empty() {
3055 err.note(&format!("available fields are: {}",
3056 self.name_series_display(field_names)));
3060 ty::TyRawPtr(..) => {
3061 err.note(&format!("`{0}` is a native pointer; perhaps you need to deref \
3063 self.tcx.hir.node_to_pretty_string(base.id),
3070 type_error_struct!(self.tcx().sess, field.span, expr_t, E0610,
3071 "`{}` is a primitive type and therefore doesn't have fields",
3074 self.tcx().types.err
3078 // Return an hint about the closest match in field names
3079 fn suggest_field_name(variant: &'tcx ty::VariantDef,
3080 field: &Spanned<ast::Name>,
3081 skip: Vec<InternedString>)
3083 let name = field.node.as_str();
3084 let names = variant.fields.iter().filter_map(|field| {
3085 // ignore already set fields and private fields from non-local crates
3086 if skip.iter().any(|x| *x == field.name.as_str()) ||
3087 (variant.did.krate != LOCAL_CRATE && field.vis != Visibility::Public) {
3094 find_best_match_for_name(names, &name, None)
3097 fn available_field_names(&self, variant: &'tcx ty::VariantDef) -> Vec<ast::Name> {
3098 let mut available = Vec::new();
3099 for field in variant.fields.iter() {
3100 let (_, def_scope) = self.tcx.adjust(field.name, variant.did, self.body_id);
3101 if field.vis.is_accessible_from(def_scope, self.tcx) {
3102 available.push(field.name);
3108 fn name_series_display(&self, names: Vec<ast::Name>) -> String {
3109 // dynamic limit, to never omit just one field
3110 let limit = if names.len() == 6 { 6 } else { 5 };
3111 let mut display = names.iter().take(limit)
3112 .map(|n| format!("`{}`", n)).collect::<Vec<_>>().join(", ");
3113 if names.len() > limit {
3114 display = format!("{} ... and {} others", display, names.len() - limit);
3119 // Check tuple index expressions
3120 fn check_tup_field(&self,
3121 expr: &'gcx hir::Expr,
3122 lvalue_pref: LvaluePreference,
3123 base: &'gcx hir::Expr,
3124 idx: codemap::Spanned<usize>) -> Ty<'tcx> {
3125 let expr_t = self.check_expr_with_lvalue_pref(base, lvalue_pref);
3126 let expr_t = self.structurally_resolved_type(expr.span,
3128 let mut private_candidate = None;
3129 let mut tuple_like = false;
3130 let mut autoderef = self.autoderef(expr.span, expr_t);
3131 while let Some((base_t, _)) = autoderef.next() {
3132 let field = match base_t.sty {
3133 ty::TyAdt(base_def, substs) if base_def.is_struct() => {
3134 tuple_like = base_def.struct_variant().ctor_kind == CtorKind::Fn;
3135 if !tuple_like { continue }
3137 debug!("tuple struct named {:?}", base_t);
3138 let ident = ast::Ident {
3139 name: Symbol::intern(&idx.node.to_string()),
3140 ctxt: idx.span.ctxt().modern(),
3142 let (ident, def_scope) =
3143 self.tcx.adjust_ident(ident, base_def.did, self.body_id);
3144 let fields = &base_def.struct_variant().fields;
3145 if let Some(field) = fields.iter().find(|f| f.name.to_ident() == ident) {
3146 let field_ty = self.field_ty(expr.span, field, substs);
3147 if field.vis.is_accessible_from(def_scope, self.tcx) {
3148 self.tcx.check_stability(field.did, expr.id, expr.span);
3151 private_candidate = Some((base_def.did, field_ty));
3158 ty::TyTuple(ref v, _) => {
3160 v.get(idx.node).cloned()
3165 if let Some(field_ty) = field {
3166 let adjustments = autoderef.adjust_steps(lvalue_pref);
3167 self.apply_adjustments(base, adjustments);
3168 autoderef.finalize();
3172 autoderef.unambiguous_final_ty();
3174 if let Some((did, field_ty)) = private_candidate {
3175 let struct_path = self.tcx().item_path_str(did);
3176 struct_span_err!(self.tcx().sess, expr.span, E0611,
3177 "field `{}` of tuple-struct `{}` is private",
3178 idx.node, struct_path).emit();
3183 type_error_struct!(self.tcx().sess, expr.span, expr_t, E0612,
3184 "attempted out-of-bounds tuple index `{}` on type `{}`",
3185 idx.node, expr_t).emit();
3187 self.no_such_field_err(expr.span, idx.node, expr_t).emit();
3190 self.tcx().types.err
3193 fn no_such_field_err<T: Display>(&self, span: Span, field: T, expr_t: &ty::TyS)
3194 -> DiagnosticBuilder {
3195 type_error_struct!(self.tcx().sess, span, expr_t, E0609,
3196 "no field `{}` on type `{}`",
3200 fn report_unknown_field(&self,
3202 variant: &'tcx ty::VariantDef,
3204 skip_fields: &[hir::Field],
3206 let mut err = self.type_error_struct_with_diag(
3208 |actual| match ty.sty {
3209 ty::TyAdt(adt, ..) if adt.is_enum() => {
3210 struct_span_err!(self.tcx.sess, field.name.span, E0559,
3211 "{} `{}::{}` has no field named `{}`",
3212 kind_name, actual, variant.name, field.name.node)
3215 struct_span_err!(self.tcx.sess, field.name.span, E0560,
3216 "{} `{}` has no field named `{}`",
3217 kind_name, actual, field.name.node)
3221 // prevent all specified fields from being suggested
3222 let skip_fields = skip_fields.iter().map(|ref x| x.name.node.as_str());
3223 if let Some(field_name) = Self::suggest_field_name(variant,
3225 skip_fields.collect()) {
3226 err.span_label(field.name.span,
3227 format!("field does not exist - did you mean `{}`?", field_name));
3230 ty::TyAdt(adt, ..) => {
3232 err.span_label(field.name.span,
3233 format!("`{}::{}` does not have this field",
3236 err.span_label(field.name.span,
3237 format!("`{}` does not have this field", ty));
3239 let available_field_names = self.available_field_names(variant);
3240 if !available_field_names.is_empty() {
3241 err.note(&format!("available fields are: {}",
3242 self.name_series_display(available_field_names)));
3245 _ => bug!("non-ADT passed to report_unknown_field")
3251 fn check_expr_struct_fields(&self,
3253 expected: Expectation<'tcx>,
3254 expr_id: ast::NodeId,
3256 variant: &'tcx ty::VariantDef,
3257 ast_fields: &'gcx [hir::Field],
3258 check_completeness: bool) {
3262 self.expected_inputs_for_expected_output(span, expected, adt_ty, &[adt_ty])
3263 .get(0).cloned().unwrap_or(adt_ty);
3264 // re-link the regions that EIfEO can erase.
3265 self.demand_eqtype(span, adt_ty_hint, adt_ty);
3267 let (substs, adt_kind, kind_name) = match &adt_ty.sty{
3268 &ty::TyAdt(adt, substs) => {
3269 (substs, adt.adt_kind(), adt.variant_descr())
3271 _ => span_bug!(span, "non-ADT passed to check_expr_struct_fields")
3274 let mut remaining_fields = FxHashMap();
3275 for field in &variant.fields {
3276 remaining_fields.insert(field.name.to_ident(), field);
3279 let mut seen_fields = FxHashMap();
3281 let mut error_happened = false;
3283 // Typecheck each field.
3284 for field in ast_fields {
3285 let ident = tcx.adjust(field.name.node, variant.did, self.body_id).0;
3286 let field_type = if let Some(v_field) = remaining_fields.remove(&ident) {
3287 seen_fields.insert(field.name.node, field.span);
3289 // we don't look at stability attributes on
3290 // struct-like enums (yet...), but it's definitely not
3291 // a bug to have construct one.
3292 if adt_kind != ty::AdtKind::Enum {
3293 tcx.check_stability(v_field.did, expr_id, field.span);
3296 self.field_ty(field.span, v_field, substs)
3298 error_happened = true;
3299 if let Some(_) = variant.find_field_named(field.name.node) {
3300 let mut err = struct_span_err!(self.tcx.sess,
3303 "field `{}` specified more than once",
3306 err.span_label(field.name.span, "used more than once");
3308 if let Some(prev_span) = seen_fields.get(&field.name.node) {
3309 err.span_label(*prev_span, format!("first use of `{}`", field.name.node));
3314 self.report_unknown_field(adt_ty, variant, field, ast_fields, kind_name);
3320 // Make sure to give a type to the field even if there's
3321 // an error, so we can continue typechecking
3322 self.check_expr_coercable_to_type(&field.expr, field_type);
3325 // Make sure the programmer specified correct number of fields.
3326 if kind_name == "union" {
3327 if ast_fields.len() != 1 {
3328 tcx.sess.span_err(span, "union expressions should have exactly one field");
3330 } else if check_completeness && !error_happened && !remaining_fields.is_empty() {
3331 let len = remaining_fields.len();
3333 let mut displayable_field_names = remaining_fields
3335 .map(|ident| ident.name.as_str())
3336 .collect::<Vec<_>>();
3338 displayable_field_names.sort();
3340 let truncated_fields_error = if len <= 3 {
3343 format!(" and {} other field{}", (len - 3), if len - 3 == 1 {""} else {"s"})
3346 let remaining_fields_names = displayable_field_names.iter().take(3)
3347 .map(|n| format!("`{}`", n))
3348 .collect::<Vec<_>>()
3351 struct_span_err!(tcx.sess, span, E0063,
3352 "missing field{} {}{} in initializer of `{}`",
3353 if remaining_fields.len() == 1 { "" } else { "s" },
3354 remaining_fields_names,
3355 truncated_fields_error,
3357 .span_label(span, format!("missing {}{}",
3358 remaining_fields_names,
3359 truncated_fields_error))
3364 fn check_struct_fields_on_error(&self,
3365 fields: &'gcx [hir::Field],
3366 base_expr: &'gcx Option<P<hir::Expr>>) {
3367 for field in fields {
3368 self.check_expr(&field.expr);
3372 self.check_expr(&base);
3378 pub fn check_struct_path(&self,
3380 node_id: ast::NodeId)
3381 -> Option<(&'tcx ty::VariantDef, Ty<'tcx>)> {
3382 let path_span = match *qpath {
3383 hir::QPath::Resolved(_, ref path) => path.span,
3384 hir::QPath::TypeRelative(ref qself, _) => qself.span
3386 let (def, ty) = self.finish_resolving_struct_path(qpath, path_span, node_id);
3387 let variant = match def {
3389 self.set_tainted_by_errors();
3392 Def::Variant(..) => {
3394 ty::TyAdt(adt, substs) => {
3395 Some((adt.variant_of_def(def), adt.did, substs))
3397 _ => bug!("unexpected type: {:?}", ty.sty)
3400 Def::Struct(..) | Def::Union(..) | Def::TyAlias(..) |
3401 Def::AssociatedTy(..) | Def::SelfTy(..) => {
3403 ty::TyAdt(adt, substs) if !adt.is_enum() => {
3404 Some((adt.struct_variant(), adt.did, substs))
3409 _ => bug!("unexpected definition: {:?}", def)
3412 if let Some((variant, did, substs)) = variant {
3413 // Check bounds on type arguments used in the path.
3414 let bounds = self.instantiate_bounds(path_span, did, substs);
3415 let cause = traits::ObligationCause::new(path_span, self.body_id,
3416 traits::ItemObligation(did));
3417 self.add_obligations_for_parameters(cause, &bounds);
3421 struct_span_err!(self.tcx.sess, path_span, E0071,
3422 "expected struct, variant or union type, found {}",
3423 ty.sort_string(self.tcx))
3424 .span_label(path_span, "not a struct")
3430 fn check_expr_struct(&self,
3432 expected: Expectation<'tcx>,
3434 fields: &'gcx [hir::Field],
3435 base_expr: &'gcx Option<P<hir::Expr>>) -> Ty<'tcx>
3437 // Find the relevant variant
3438 let (variant, struct_ty) =
3439 if let Some(variant_ty) = self.check_struct_path(qpath, expr.id) {
3442 self.check_struct_fields_on_error(fields, base_expr);
3443 return self.tcx.types.err;
3446 let path_span = match *qpath {
3447 hir::QPath::Resolved(_, ref path) => path.span,
3448 hir::QPath::TypeRelative(ref qself, _) => qself.span
3451 self.check_expr_struct_fields(struct_ty, expected, expr.id, path_span, variant, fields,
3452 base_expr.is_none());
3453 if let &Some(ref base_expr) = base_expr {
3454 self.check_expr_has_type_or_error(base_expr, struct_ty);
3455 match struct_ty.sty {
3456 ty::TyAdt(adt, substs) if adt.is_struct() => {
3457 let fru_field_types = adt.struct_variant().fields.iter().map(|f| {
3458 self.normalize_associated_types_in(expr.span, &f.ty(self.tcx, substs))
3463 .fru_field_types_mut()
3464 .insert(expr.hir_id, fru_field_types);
3467 span_err!(self.tcx.sess, base_expr.span, E0436,
3468 "functional record update syntax requires a struct");
3472 self.require_type_is_sized(struct_ty, expr.span, traits::StructInitializerSized);
3478 /// If an expression has any sub-expressions that result in a type error,
3479 /// inspecting that expression's type with `ty.references_error()` will return
3480 /// true. Likewise, if an expression is known to diverge, inspecting its
3481 /// type with `ty::type_is_bot` will return true (n.b.: since Rust is
3482 /// strict, _|_ can appear in the type of an expression that does not,
3483 /// itself, diverge: for example, fn() -> _|_.)
3484 /// Note that inspecting a type's structure *directly* may expose the fact
3485 /// that there are actually multiple representations for `TyError`, so avoid
3486 /// that when err needs to be handled differently.
3487 fn check_expr_with_expectation_and_lvalue_pref(&self,
3488 expr: &'gcx hir::Expr,
3489 expected: Expectation<'tcx>,
3490 lvalue_pref: LvaluePreference) -> Ty<'tcx> {
3491 debug!(">> typechecking: expr={:?} expected={:?}",
3494 // Warn for expressions after diverging siblings.
3495 self.warn_if_unreachable(expr.id, expr.span, "expression");
3497 // Hide the outer diverging and has_errors flags.
3498 let old_diverges = self.diverges.get();
3499 let old_has_errors = self.has_errors.get();
3500 self.diverges.set(Diverges::Maybe);
3501 self.has_errors.set(false);
3503 let ty = self.check_expr_kind(expr, expected, lvalue_pref);
3505 // Warn for non-block expressions with diverging children.
3508 hir::ExprLoop(..) | hir::ExprWhile(..) |
3509 hir::ExprIf(..) | hir::ExprMatch(..) => {}
3511 _ => self.warn_if_unreachable(expr.id, expr.span, "expression")
3514 // Any expression that produces a value of type `!` must have diverged
3516 self.diverges.set(self.diverges.get() | Diverges::Always);
3519 // Record the type, which applies it effects.
3520 // We need to do this after the warning above, so that
3521 // we don't warn for the diverging expression itself.
3522 self.write_ty(expr.hir_id, ty);
3524 // Combine the diverging and has_error flags.
3525 self.diverges.set(self.diverges.get() | old_diverges);
3526 self.has_errors.set(self.has_errors.get() | old_has_errors);
3528 debug!("type of {} is...", self.tcx.hir.node_to_string(expr.id));
3529 debug!("... {:?}, expected is {:?}", ty, expected);
3534 fn check_expr_kind(&self,
3535 expr: &'gcx hir::Expr,
3536 expected: Expectation<'tcx>,
3537 lvalue_pref: LvaluePreference) -> Ty<'tcx> {
3541 hir::ExprBox(ref subexpr) => {
3542 let expected_inner = expected.to_option(self).map_or(NoExpectation, |ty| {
3544 ty::TyAdt(def, _) if def.is_box()
3545 => Expectation::rvalue_hint(self, ty.boxed_ty()),
3549 let referent_ty = self.check_expr_with_expectation(subexpr, expected_inner);
3550 tcx.mk_box(referent_ty)
3553 hir::ExprLit(ref lit) => {
3554 self.check_lit(&lit, expected)
3556 hir::ExprBinary(op, ref lhs, ref rhs) => {
3557 self.check_binop(expr, op, lhs, rhs)
3559 hir::ExprAssignOp(op, ref lhs, ref rhs) => {
3560 self.check_binop_assign(expr, op, lhs, rhs)
3562 hir::ExprUnary(unop, ref oprnd) => {
3563 let expected_inner = match unop {
3564 hir::UnNot | hir::UnNeg => {
3571 let lvalue_pref = match unop {
3572 hir::UnDeref => lvalue_pref,
3575 let mut oprnd_t = self.check_expr_with_expectation_and_lvalue_pref(&oprnd,
3579 if !oprnd_t.references_error() {
3580 oprnd_t = self.structurally_resolved_type(expr.span, oprnd_t);
3583 if let Some(mt) = oprnd_t.builtin_deref(true, NoPreference) {
3585 } else if let Some(ok) = self.try_overloaded_deref(
3586 expr.span, oprnd_t, lvalue_pref) {
3587 let method = self.register_infer_ok_obligations(ok);
3588 if let ty::TyRef(region, mt) = method.sig.inputs()[0].sty {
3589 self.apply_adjustments(oprnd, vec![Adjustment {
3590 kind: Adjust::Borrow(AutoBorrow::Ref(region, mt.mutbl)),
3591 target: method.sig.inputs()[0]
3594 oprnd_t = self.make_overloaded_lvalue_return_type(method).ty;
3595 self.write_method_call(expr.hir_id, method);
3597 type_error_struct!(tcx.sess, expr.span, oprnd_t, E0614,
3598 "type `{}` cannot be dereferenced",
3600 oprnd_t = tcx.types.err;
3604 let result = self.check_user_unop(expr, oprnd_t, unop);
3605 // If it's builtin, we can reuse the type, this helps inference.
3606 if !(oprnd_t.is_integral() || oprnd_t.sty == ty::TyBool) {
3611 let result = self.check_user_unop(expr, oprnd_t, unop);
3612 // If it's builtin, we can reuse the type, this helps inference.
3613 if !(oprnd_t.is_integral() || oprnd_t.is_fp()) {
3621 hir::ExprAddrOf(mutbl, ref oprnd) => {
3622 let hint = expected.only_has_type(self).map_or(NoExpectation, |ty| {
3624 ty::TyRef(_, ref mt) | ty::TyRawPtr(ref mt) => {
3625 if self.tcx.expr_is_lval(&oprnd) {
3626 // Lvalues may legitimately have unsized types.
3627 // For example, dereferences of a fat pointer and
3628 // the last field of a struct can be unsized.
3629 ExpectHasType(mt.ty)
3631 Expectation::rvalue_hint(self, mt.ty)
3637 let lvalue_pref = LvaluePreference::from_mutbl(mutbl);
3638 let ty = self.check_expr_with_expectation_and_lvalue_pref(&oprnd, hint, lvalue_pref);
3640 let tm = ty::TypeAndMut { ty: ty, mutbl: mutbl };
3641 if tm.ty.references_error() {
3644 // Note: at this point, we cannot say what the best lifetime
3645 // is to use for resulting pointer. We want to use the
3646 // shortest lifetime possible so as to avoid spurious borrowck
3647 // errors. Moreover, the longest lifetime will depend on the
3648 // precise details of the value whose address is being taken
3649 // (and how long it is valid), which we don't know yet until type
3650 // inference is complete.
3652 // Therefore, here we simply generate a region variable. The
3653 // region inferencer will then select the ultimate value.
3654 // Finally, borrowck is charged with guaranteeing that the
3655 // value whose address was taken can actually be made to live
3656 // as long as it needs to live.
3657 let region = self.next_region_var(infer::AddrOfRegion(expr.span));
3658 tcx.mk_ref(region, tm)
3661 hir::ExprPath(ref qpath) => {
3662 let (def, opt_ty, segments) = self.resolve_ty_and_def_ufcs(qpath,
3663 expr.id, expr.span);
3664 let ty = if def != Def::Err {
3665 self.instantiate_value_path(segments, opt_ty, def, expr.span, id)
3667 self.set_tainted_by_errors();
3671 // We always require that the type provided as the value for
3672 // a type parameter outlives the moment of instantiation.
3673 let substs = self.tables.borrow().node_substs(expr.hir_id);
3674 self.add_wf_bounds(substs, expr);
3678 hir::ExprInlineAsm(_, ref outputs, ref inputs) => {
3679 for output in outputs {
3680 self.check_expr(output);
3682 for input in inputs {
3683 self.check_expr(input);
3687 hir::ExprBreak(destination, ref expr_opt) => {
3688 if let Some(target_id) = destination.target_id.opt_id() {
3689 let (e_ty, e_diverges, cause);
3690 if let Some(ref e) = *expr_opt {
3691 // If this is a break with a value, we need to type-check
3692 // the expression. Get an expected type from the loop context.
3693 let opt_coerce_to = {
3694 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
3695 enclosing_breakables.find_breakable(target_id)
3698 .map(|coerce| coerce.expected_ty())
3701 // If the loop context is not a `loop { }`, then break with
3702 // a value is illegal, and `opt_coerce_to` will be `None`.
3703 // Just set expectation to error in that case.
3704 let coerce_to = opt_coerce_to.unwrap_or(tcx.types.err);
3706 // Recurse without `enclosing_breakables` borrowed.
3707 e_ty = self.check_expr_with_hint(e, coerce_to);
3708 e_diverges = self.diverges.get();
3709 cause = self.misc(e.span);
3711 // Otherwise, this is a break *without* a value. That's
3712 // always legal, and is equivalent to `break ()`.
3713 e_ty = tcx.mk_nil();
3714 e_diverges = Diverges::Maybe;
3715 cause = self.misc(expr.span);
3718 // Now that we have type-checked `expr_opt`, borrow
3719 // the `enclosing_loops` field and let's coerce the
3720 // type of `expr_opt` into what is expected.
3721 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
3722 let ctxt = enclosing_breakables.find_breakable(target_id);
3723 if let Some(ref mut coerce) = ctxt.coerce {
3724 if let Some(ref e) = *expr_opt {
3725 coerce.coerce(self, &cause, e, e_ty, e_diverges);
3727 assert!(e_ty.is_nil());
3728 coerce.coerce_forced_unit(self, &cause, &mut |_| (), true);
3731 // If `ctxt.coerce` is `None`, we can just ignore
3732 // the type of the expresison. This is because
3733 // either this was a break *without* a value, in
3734 // which case it is always a legal type (`()`), or
3735 // else an error would have been flagged by the
3736 // `loops` pass for using break with an expression
3737 // where you are not supposed to.
3738 assert!(expr_opt.is_none() || self.tcx.sess.err_count() > 0);
3741 ctxt.may_break = true;
3743 // Otherwise, we failed to find the enclosing loop;
3744 // this can only happen if the `break` was not
3745 // inside a loop at all, which is caught by the
3746 // loop-checking pass.
3747 assert!(self.tcx.sess.err_count() > 0);
3749 // We still need to assign a type to the inner expression to
3750 // prevent the ICE in #43162.
3751 if let Some(ref e) = *expr_opt {
3752 self.check_expr_with_hint(e, tcx.types.err);
3754 // ... except when we try to 'break rust;'.
3755 // ICE this expression in particular (see #43162).
3756 if let hir::ExprPath(hir::QPath::Resolved(_, ref path)) = e.node {
3757 if path.segments.len() == 1 && path.segments[0].name == "rust" {
3758 fatally_break_rust(self.tcx.sess);
3764 // the type of a `break` is always `!`, since it diverges
3767 hir::ExprAgain(_) => { tcx.types.never }
3768 hir::ExprRet(ref expr_opt) => {
3769 if self.ret_coercion.is_none() {
3770 struct_span_err!(self.tcx.sess, expr.span, E0572,
3771 "return statement outside of function body").emit();
3772 } else if let Some(ref e) = *expr_opt {
3773 self.check_return_expr(e);
3775 let mut coercion = self.ret_coercion.as_ref().unwrap().borrow_mut();
3776 let cause = self.cause(expr.span, ObligationCauseCode::ReturnNoExpression);
3777 coercion.coerce_forced_unit(self, &cause, &mut |_| (), true);
3781 hir::ExprAssign(ref lhs, ref rhs) => {
3782 let lhs_ty = self.check_expr_with_lvalue_pref(&lhs, PreferMutLvalue);
3784 let rhs_ty = self.check_expr_coercable_to_type(&rhs, lhs_ty);
3787 ExpectIfCondition => {
3788 self.tcx.sess.delay_span_bug(lhs.span, "invalid lhs expression in if;\
3789 expected error elsehwere");
3792 // Only check this if not in an `if` condition, as the
3793 // mistyped comparison help is more appropriate.
3794 if !self.tcx.expr_is_lval(&lhs) {
3795 struct_span_err!(self.tcx.sess, expr.span, E0070,
3796 "invalid left-hand side expression")
3797 .span_label(expr.span, "left-hand of expression not valid")
3803 self.require_type_is_sized(lhs_ty, lhs.span, traits::AssignmentLhsSized);
3805 if lhs_ty.references_error() || rhs_ty.references_error() {
3811 hir::ExprIf(ref cond, ref then_expr, ref opt_else_expr) => {
3812 self.check_then_else(&cond, then_expr, opt_else_expr.as_ref().map(|e| &**e),
3813 expr.span, expected)
3815 hir::ExprWhile(ref cond, ref body, _) => {
3816 let ctxt = BreakableCtxt {
3817 // cannot use break with a value from a while loop
3822 self.with_breakable_ctxt(expr.id, ctxt, || {
3823 self.check_expr_has_type_or_error(&cond, tcx.types.bool);
3824 let cond_diverging = self.diverges.get();
3825 self.check_block_no_value(&body);
3827 // We may never reach the body so it diverging means nothing.
3828 self.diverges.set(cond_diverging);
3833 hir::ExprLoop(ref body, _, source) => {
3834 let coerce = match source {
3835 // you can only use break with a value from a normal `loop { }`
3836 hir::LoopSource::Loop => {
3837 let coerce_to = expected.coercion_target_type(self, body.span);
3838 Some(CoerceMany::new(coerce_to))
3841 hir::LoopSource::WhileLet |
3842 hir::LoopSource::ForLoop => {
3847 let ctxt = BreakableCtxt {
3849 may_break: false, // will get updated if/when we find a `break`
3852 let (ctxt, ()) = self.with_breakable_ctxt(expr.id, ctxt, || {
3853 self.check_block_no_value(&body);
3857 // No way to know whether it's diverging because
3858 // of a `break` or an outer `break` or `return.
3859 self.diverges.set(Diverges::Maybe);
3862 // If we permit break with a value, then result type is
3863 // the LUB of the breaks (possibly ! if none); else, it
3864 // is nil. This makes sense because infinite loops
3865 // (which would have type !) are only possible iff we
3866 // permit break with a value [1].
3867 assert!(ctxt.coerce.is_some() || ctxt.may_break); // [1]
3868 ctxt.coerce.map(|c| c.complete(self)).unwrap_or(self.tcx.mk_nil())
3870 hir::ExprMatch(ref discrim, ref arms, match_src) => {
3871 self.check_match(expr, &discrim, arms, expected, match_src)
3873 hir::ExprClosure(capture, ref decl, body_id, _, _) => {
3874 self.check_expr_closure(expr, capture, &decl, body_id, expected)
3876 hir::ExprBlock(ref body) => {
3877 self.check_block_with_expected(&body, expected)
3879 hir::ExprCall(ref callee, ref args) => {
3880 self.check_call(expr, &callee, args, expected)
3882 hir::ExprMethodCall(ref segment, span, ref args) => {
3883 self.check_method_call(expr, segment, span, args, expected, lvalue_pref)
3885 hir::ExprCast(ref e, ref t) => {
3886 // Find the type of `e`. Supply hints based on the type we are casting to,
3888 let t_cast = self.to_ty(t);
3889 let t_cast = self.resolve_type_vars_if_possible(&t_cast);
3890 let t_expr = self.check_expr_with_expectation(e, ExpectCastableToType(t_cast));
3891 let t_cast = self.resolve_type_vars_if_possible(&t_cast);
3892 let diverges = self.diverges.get();
3894 // Eagerly check for some obvious errors.
3895 if t_expr.references_error() || t_cast.references_error() {
3898 // Defer other checks until we're done type checking.
3899 let mut deferred_cast_checks = self.deferred_cast_checks.borrow_mut();
3900 match cast::CastCheck::new(self, e, t_expr, diverges, t_cast, t.span, expr.span) {
3902 deferred_cast_checks.push(cast_check);
3905 Err(ErrorReported) => {
3911 hir::ExprType(ref e, ref t) => {
3912 let typ = self.to_ty(&t);
3913 self.check_expr_eq_type(&e, typ);
3916 hir::ExprArray(ref args) => {
3917 let uty = expected.to_option(self).and_then(|uty| {
3919 ty::TyArray(ty, _) | ty::TySlice(ty) => Some(ty),
3924 let element_ty = if !args.is_empty() {
3925 let coerce_to = uty.unwrap_or_else(
3926 || self.next_ty_var(TypeVariableOrigin::TypeInference(expr.span)));
3927 let mut coerce = CoerceMany::with_coercion_sites(coerce_to, args);
3928 assert_eq!(self.diverges.get(), Diverges::Maybe);
3930 let e_ty = self.check_expr_with_hint(e, coerce_to);
3931 let cause = self.misc(e.span);
3932 coerce.coerce(self, &cause, e, e_ty, self.diverges.get());
3934 coerce.complete(self)
3936 self.next_ty_var(TypeVariableOrigin::TypeInference(expr.span))
3938 tcx.mk_array(element_ty, args.len())
3940 hir::ExprRepeat(ref element, count) => {
3941 let count = eval_length(self.tcx, count, "repeat count")
3944 let uty = match expected {
3945 ExpectHasType(uty) => {
3947 ty::TyArray(ty, _) | ty::TySlice(ty) => Some(ty),
3954 let (element_ty, t) = match uty {
3956 self.check_expr_coercable_to_type(&element, uty);
3960 let t: Ty = self.next_ty_var(TypeVariableOrigin::MiscVariable(element.span));
3961 let element_ty = self.check_expr_has_type_or_error(&element, t);
3967 // For [foo, ..n] where n > 1, `foo` must have
3969 let lang_item = self.tcx.require_lang_item(lang_items::CopyTraitLangItem);
3970 self.require_type_meets(t, expr.span, traits::RepeatVec, lang_item);
3973 if element_ty.references_error() {
3976 tcx.mk_array(t, count)
3979 hir::ExprTup(ref elts) => {
3980 let flds = expected.only_has_type(self).and_then(|ty| {
3982 ty::TyTuple(ref flds, _) => Some(&flds[..]),
3987 let elt_ts_iter = elts.iter().enumerate().map(|(i, e)| {
3988 let t = match flds {
3989 Some(ref fs) if i < fs.len() => {
3991 self.check_expr_coercable_to_type(&e, ety);
3995 self.check_expr_with_expectation(&e, NoExpectation)
4000 let tuple = tcx.mk_tup(elt_ts_iter, false);
4001 if tuple.references_error() {
4004 self.require_type_is_sized(tuple, expr.span, traits::TupleInitializerSized);
4008 hir::ExprStruct(ref qpath, ref fields, ref base_expr) => {
4009 self.check_expr_struct(expr, expected, qpath, fields, base_expr)
4011 hir::ExprField(ref base, ref field) => {
4012 self.check_field(expr, lvalue_pref, &base, field)
4014 hir::ExprTupField(ref base, idx) => {
4015 self.check_tup_field(expr, lvalue_pref, &base, idx)
4017 hir::ExprIndex(ref base, ref idx) => {
4018 let base_t = self.check_expr_with_lvalue_pref(&base, lvalue_pref);
4019 let idx_t = self.check_expr(&idx);
4021 if base_t.references_error() {
4023 } else if idx_t.references_error() {
4026 let base_t = self.structurally_resolved_type(expr.span, base_t);
4027 match self.lookup_indexing(expr, base, base_t, idx_t, lvalue_pref) {
4028 Some((index_ty, element_ty)) => {
4029 self.demand_coerce(idx, idx_t, index_ty);
4033 let mut err = type_error_struct!(tcx.sess, expr.span, base_t, E0608,
4034 "cannot index into a value of type `{}`",
4036 // Try to give some advice about indexing tuples.
4037 if let ty::TyTuple(..) = base_t.sty {
4038 let mut needs_note = true;
4039 // If the index is an integer, we can show the actual
4040 // fixed expression:
4041 if let hir::ExprLit(ref lit) = idx.node {
4042 if let ast::LitKind::Int(i,
4043 ast::LitIntType::Unsuffixed) = lit.node {
4044 let snip = tcx.sess.codemap().span_to_snippet(base.span);
4045 if let Ok(snip) = snip {
4046 err.span_suggestion(expr.span,
4047 "to access tuple elements, use",
4048 format!("{}.{}", snip, i));
4054 err.help("to access tuple elements, use tuple indexing \
4055 syntax (e.g. `tuple.0`)");
4064 hir::ExprYield(ref value) => {
4065 match self.yield_ty {
4067 self.check_expr_coercable_to_type(&value, ty);
4070 struct_span_err!(self.tcx.sess, expr.span, E0627,
4071 "yield statement outside of generator literal").emit();
4079 // Finish resolving a path in a struct expression or pattern `S::A { .. }` if necessary.
4080 // The newly resolved definition is written into `type_dependent_defs`.
4081 fn finish_resolving_struct_path(&self,
4084 node_id: ast::NodeId)
4088 hir::QPath::Resolved(ref maybe_qself, ref path) => {
4089 let opt_self_ty = maybe_qself.as_ref().map(|qself| self.to_ty(qself));
4090 let ty = AstConv::def_to_ty(self, opt_self_ty, path, true);
4093 hir::QPath::TypeRelative(ref qself, ref segment) => {
4094 let ty = self.to_ty(qself);
4096 let def = if let hir::TyPath(hir::QPath::Resolved(_, ref path)) = qself.node {
4101 let (ty, def) = AstConv::associated_path_def_to_ty(self, node_id, path_span,
4104 // Write back the new resolution.
4105 let hir_id = self.tcx.hir.node_to_hir_id(node_id);
4106 self.tables.borrow_mut().type_dependent_defs_mut().insert(hir_id, def);
4113 // Resolve associated value path into a base type and associated constant or method definition.
4114 // The newly resolved definition is written into `type_dependent_defs`.
4115 pub fn resolve_ty_and_def_ufcs<'b>(&self,
4116 qpath: &'b hir::QPath,
4117 node_id: ast::NodeId,
4119 -> (Def, Option<Ty<'tcx>>, &'b [hir::PathSegment])
4121 let (ty, item_segment) = match *qpath {
4122 hir::QPath::Resolved(ref opt_qself, ref path) => {
4124 opt_qself.as_ref().map(|qself| self.to_ty(qself)),
4125 &path.segments[..]);
4127 hir::QPath::TypeRelative(ref qself, ref segment) => {
4128 (self.to_ty(qself), segment)
4131 let item_name = item_segment.name;
4132 let def = match self.resolve_ufcs(span, item_name, ty, node_id) {
4135 let def = match error {
4136 method::MethodError::PrivateMatch(def, _) => def,
4139 if item_name != keywords::Invalid.name() {
4140 self.report_method_error(span, ty, item_name, None, error, None);
4146 // Write back the new resolution.
4147 let hir_id = self.tcx.hir.node_to_hir_id(node_id);
4148 self.tables.borrow_mut().type_dependent_defs_mut().insert(hir_id, def);
4149 (def, Some(ty), slice::ref_slice(&**item_segment))
4152 pub fn check_decl_initializer(&self,
4153 local: &'gcx hir::Local,
4154 init: &'gcx hir::Expr) -> Ty<'tcx>
4156 // FIXME(tschottdorf): contains_explicit_ref_binding() must be removed
4158 let ref_bindings = local.pat.contains_explicit_ref_binding();
4160 let local_ty = self.local_ty(init.span, local.id);
4161 if let Some(m) = ref_bindings {
4162 // Somewhat subtle: if we have a `ref` binding in the pattern,
4163 // we want to avoid introducing coercions for the RHS. This is
4164 // both because it helps preserve sanity and, in the case of
4165 // ref mut, for soundness (issue #23116). In particular, in
4166 // the latter case, we need to be clear that the type of the
4167 // referent for the reference that results is *equal to* the
4168 // type of the lvalue it is referencing, and not some
4169 // supertype thereof.
4170 let init_ty = self.check_expr_with_lvalue_pref(init, LvaluePreference::from_mutbl(m));
4171 self.demand_eqtype(init.span, init_ty, local_ty);
4174 self.check_expr_coercable_to_type(init, local_ty)
4178 pub fn check_decl_local(&self, local: &'gcx hir::Local) {
4179 let t = self.local_ty(local.span, local.id);
4180 self.write_ty(local.hir_id, t);
4182 if let Some(ref init) = local.init {
4183 let init_ty = self.check_decl_initializer(local, &init);
4184 if init_ty.references_error() {
4185 self.write_ty(local.hir_id, init_ty);
4189 self.check_pat(&local.pat, t);
4190 let pat_ty = self.node_ty(local.pat.hir_id);
4191 if pat_ty.references_error() {
4192 self.write_ty(local.hir_id, pat_ty);
4196 pub fn check_stmt(&self, stmt: &'gcx hir::Stmt) {
4197 // Don't do all the complex logic below for DeclItem.
4199 hir::StmtDecl(ref decl, _) => {
4201 hir::DeclLocal(_) => {}
4202 hir::DeclItem(_) => {
4207 hir::StmtExpr(..) | hir::StmtSemi(..) => {}
4210 self.warn_if_unreachable(stmt.node.id(), stmt.span, "statement");
4212 // Hide the outer diverging and has_errors flags.
4213 let old_diverges = self.diverges.get();
4214 let old_has_errors = self.has_errors.get();
4215 self.diverges.set(Diverges::Maybe);
4216 self.has_errors.set(false);
4219 hir::StmtDecl(ref decl, _) => {
4221 hir::DeclLocal(ref l) => {
4222 self.check_decl_local(&l);
4224 hir::DeclItem(_) => {/* ignore for now */}
4227 hir::StmtExpr(ref expr, _) => {
4228 // Check with expected type of ()
4229 self.check_expr_has_type_or_error(&expr, self.tcx.mk_nil());
4231 hir::StmtSemi(ref expr, _) => {
4232 self.check_expr(&expr);
4236 // Combine the diverging and has_error flags.
4237 self.diverges.set(self.diverges.get() | old_diverges);
4238 self.has_errors.set(self.has_errors.get() | old_has_errors);
4241 pub fn check_block_no_value(&self, blk: &'gcx hir::Block) {
4242 let unit = self.tcx.mk_nil();
4243 let ty = self.check_block_with_expected(blk, ExpectHasType(unit));
4245 // if the block produces a `!` value, that can always be
4246 // (effectively) coerced to unit.
4248 self.demand_suptype(blk.span, unit, ty);
4252 fn check_block_with_expected(&self,
4253 blk: &'gcx hir::Block,
4254 expected: Expectation<'tcx>) -> Ty<'tcx> {
4256 let mut fcx_ps = self.ps.borrow_mut();
4257 let unsafety_state = fcx_ps.recurse(blk);
4258 replace(&mut *fcx_ps, unsafety_state)
4261 // In some cases, blocks have just one exit, but other blocks
4262 // can be targeted by multiple breaks. This cannot happen in
4263 // normal Rust syntax today, but it can happen when we desugar
4264 // a `do catch { ... }` expression.
4268 // 'a: { if true { break 'a Err(()); } Ok(()) }
4270 // Here we would wind up with two coercions, one from
4271 // `Err(())` and the other from the tail expression
4272 // `Ok(())`. If the tail expression is omitted, that's a
4273 // "forced unit" -- unless the block diverges, in which
4274 // case we can ignore the tail expression (e.g., `'a: {
4275 // break 'a 22; }` would not force the type of the block
4277 let tail_expr = blk.expr.as_ref();
4278 let coerce_to_ty = expected.coercion_target_type(self, blk.span);
4279 let coerce = if blk.targeted_by_break {
4280 CoerceMany::new(coerce_to_ty)
4282 let tail_expr: &[P<hir::Expr>] = match tail_expr {
4283 Some(e) => ref_slice(e),
4286 CoerceMany::with_coercion_sites(coerce_to_ty, tail_expr)
4289 let ctxt = BreakableCtxt {
4290 coerce: Some(coerce),
4294 let (ctxt, ()) = self.with_breakable_ctxt(blk.id, ctxt, || {
4295 for s in &blk.stmts {
4299 // check the tail expression **without** holding the
4300 // `enclosing_breakables` lock below.
4301 let tail_expr_ty = tail_expr.map(|t| self.check_expr_with_expectation(t, expected));
4303 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4304 let ctxt = enclosing_breakables.find_breakable(blk.id);
4305 let coerce = ctxt.coerce.as_mut().unwrap();
4306 if let Some(tail_expr_ty) = tail_expr_ty {
4307 let tail_expr = tail_expr.unwrap();
4308 let cause = self.cause(tail_expr.span,
4309 ObligationCauseCode::BlockTailExpression(blk.id));
4314 self.diverges.get());
4316 // Subtle: if there is no explicit tail expression,
4317 // that is typically equivalent to a tail expression
4318 // of `()` -- except if the block diverges. In that
4319 // case, there is no value supplied from the tail
4320 // expression (assuming there are no other breaks,
4321 // this implies that the type of the block will be
4324 // #41425 -- label the implicit `()` as being the
4325 // "found type" here, rather than the "expected type".
4326 if !self.diverges.get().always() {
4327 coerce.coerce_forced_unit(self, &self.misc(blk.span), &mut |err| {
4328 if let Some(expected_ty) = expected.only_has_type(self) {
4329 self.consider_hint_about_removing_semicolon(blk,
4338 let mut ty = ctxt.coerce.unwrap().complete(self);
4340 if self.has_errors.get() || ty.references_error() {
4341 ty = self.tcx.types.err
4344 self.write_ty(blk.hir_id, ty);
4346 *self.ps.borrow_mut() = prev;
4350 /// Given a `NodeId`, return the `FnDecl` of the method it is enclosed by and whether a
4351 /// suggestion can be made, `None` otherwise.
4352 pub fn get_fn_decl(&self, blk_id: ast::NodeId) -> Option<(hir::FnDecl, bool)> {
4353 // Get enclosing Fn, if it is a function or a trait method, unless there's a `loop` or
4354 // `while` before reaching it, as block tail returns are not available in them.
4355 if let Some(fn_id) = self.tcx.hir.get_return_block(blk_id) {
4356 let parent = self.tcx.hir.get(fn_id);
4358 if let Node::NodeItem(&hir::Item {
4359 name, node: hir::ItemFn(ref decl, ..), ..
4361 decl.clone().and_then(|decl| {
4362 // This is less than ideal, it will not suggest a return type span on any
4363 // method called `main`, regardless of whether it is actually the entry point,
4364 // but it will still present it as the reason for the expected type.
4365 Some((decl, name != Symbol::intern("main")))
4367 } else if let Node::NodeTraitItem(&hir::TraitItem {
4368 node: hir::TraitItemKind::Method(hir::MethodSig {
4372 decl.clone().and_then(|decl| {
4375 } else if let Node::NodeImplItem(&hir::ImplItem {
4376 node: hir::ImplItemKind::Method(hir::MethodSig {
4380 decl.clone().and_then(|decl| {
4391 /// On implicit return expressions with mismatched types, provide the following suggestions:
4393 /// - Point out the method's return type as the reason for the expected type
4394 /// - Possible missing semicolon
4395 /// - Possible missing return type if the return type is the default, and not `fn main()`
4396 pub fn suggest_mismatched_types_on_tail(&self,
4397 err: &mut DiagnosticBuilder<'tcx>,
4398 expression: &'gcx hir::Expr,
4402 blk_id: ast::NodeId) {
4403 self.suggest_missing_semicolon(err, expression, expected, cause_span);
4405 if let Some((fn_decl, can_suggest)) = self.get_fn_decl(blk_id) {
4406 self.suggest_missing_return_type(err, &fn_decl, expected, found, can_suggest);
4410 /// A common error is to forget to add a semicolon at the end of a block:
4414 /// bar_that_returns_u32()
4418 /// This routine checks if the return expression in a block would make sense on its own as a
4419 /// statement and the return type has been left as default or has been specified as `()`. If so,
4420 /// it suggests adding a semicolon.
4421 fn suggest_missing_semicolon(&self,
4422 err: &mut DiagnosticBuilder<'tcx>,
4423 expression: &'gcx hir::Expr,
4426 if expected.is_nil() {
4427 // `BlockTailExpression` only relevant if the tail expr would be
4428 // useful on its own.
4429 match expression.node {
4431 hir::ExprMethodCall(..) |
4433 hir::ExprWhile(..) |
4435 hir::ExprMatch(..) |
4436 hir::ExprBlock(..) => {
4437 let sp = cause_span.next_point();
4438 err.span_suggestion(sp,
4439 "try adding a semicolon",
4448 /// A possible error is to forget to add a return type that is needed:
4452 /// bar_that_returns_u32()
4456 /// This routine checks if the return type is left as default, the method is not part of an
4457 /// `impl` block and that it isn't the `main` method. If so, it suggests setting the return
4459 fn suggest_missing_return_type(&self,
4460 err: &mut DiagnosticBuilder<'tcx>,
4461 fn_decl: &hir::FnDecl,
4464 can_suggest: bool) {
4465 // Only suggest changing the return type for methods that
4466 // haven't set a return type at all (and aren't `fn main()` or an impl).
4467 match (&fn_decl.output, found.is_suggestable(), can_suggest) {
4468 (&hir::FunctionRetTy::DefaultReturn(span), true, true) => {
4469 err.span_suggestion(span,
4470 "try adding a return type",
4471 format!("-> {} ", found));
4473 (&hir::FunctionRetTy::DefaultReturn(span), false, true) => {
4474 err.span_label(span, "possibly return type missing here?");
4476 (&hir::FunctionRetTy::DefaultReturn(span), _, _) => {
4477 // `fn main()` must return `()`, do not suggest changing return type
4478 err.span_label(span, "expected `()` because of default return type");
4480 (&hir::FunctionRetTy::Return(ref ty), _, _) => {
4481 // Only point to return type if the expected type is the return type, as if they
4482 // are not, the expectation must have been caused by something else.
4483 debug!("suggest_missing_return_type: return type {:?} node {:?}", ty, ty.node);
4485 let ty = AstConv::ast_ty_to_ty(self, ty);
4486 debug!("suggest_missing_return_type: return type sty {:?}", ty.sty);
4487 debug!("suggest_missing_return_type: expected type sty {:?}", ty.sty);
4488 if ty.sty == expected.sty {
4489 err.span_label(sp, format!("expected `{}` because of return type",
4497 /// A common error is to add an extra semicolon:
4500 /// fn foo() -> usize {
4505 /// This routine checks if the final statement in a block is an
4506 /// expression with an explicit semicolon whose type is compatible
4507 /// with `expected_ty`. If so, it suggests removing the semicolon.
4508 fn consider_hint_about_removing_semicolon(&self,
4509 blk: &'gcx hir::Block,
4510 expected_ty: Ty<'tcx>,
4511 err: &mut DiagnosticBuilder) {
4512 // Be helpful when the user wrote `{... expr;}` and
4513 // taking the `;` off is enough to fix the error.
4514 let last_stmt = match blk.stmts.last() {
4518 let last_expr = match last_stmt.node {
4519 hir::StmtSemi(ref e, _) => e,
4522 let last_expr_ty = self.node_ty(last_expr.hir_id);
4523 if self.can_sub(self.param_env, last_expr_ty, expected_ty).is_err() {
4526 let original_span = original_sp(last_stmt.span, blk.span);
4527 let span_semi = original_span.with_lo(original_span.hi() - BytePos(1));
4528 err.span_suggestion(span_semi, "consider removing this semicolon", "".to_string());
4531 // Instantiates the given path, which must refer to an item with the given
4532 // number of type parameters and type.
4533 pub fn instantiate_value_path(&self,
4534 segments: &[hir::PathSegment],
4535 opt_self_ty: Option<Ty<'tcx>>,
4538 node_id: ast::NodeId)
4540 debug!("instantiate_value_path(path={:?}, def={:?}, node_id={})",
4545 // We need to extract the type parameters supplied by the user in
4546 // the path `path`. Due to the current setup, this is a bit of a
4547 // tricky-process; the problem is that resolve only tells us the
4548 // end-point of the path resolution, and not the intermediate steps.
4549 // Luckily, we can (at least for now) deduce the intermediate steps
4550 // just from the end-point.
4552 // There are basically four cases to consider:
4554 // 1. Reference to a constructor of enum variant or struct:
4556 // struct Foo<T>(...)
4557 // enum E<T> { Foo(...) }
4559 // In these cases, the parameters are declared in the type
4562 // 2. Reference to a fn item or a free constant:
4566 // In this case, the path will again always have the form
4567 // `a::b::foo::<T>` where only the final segment should have
4568 // type parameters. However, in this case, those parameters are
4569 // declared on a value, and hence are in the `FnSpace`.
4571 // 3. Reference to a method or an associated constant:
4573 // impl<A> SomeStruct<A> {
4577 // Here we can have a path like
4578 // `a::b::SomeStruct::<A>::foo::<B>`, in which case parameters
4579 // may appear in two places. The penultimate segment,
4580 // `SomeStruct::<A>`, contains parameters in TypeSpace, and the
4581 // final segment, `foo::<B>` contains parameters in fn space.
4583 // 4. Reference to a local variable
4585 // Local variables can't have any type parameters.
4587 // The first step then is to categorize the segments appropriately.
4589 assert!(!segments.is_empty());
4591 let mut ufcs_associated = None;
4592 let mut type_segment = None;
4593 let mut fn_segment = None;
4595 // Case 1. Reference to a struct/variant constructor.
4596 Def::StructCtor(def_id, ..) |
4597 Def::VariantCtor(def_id, ..) => {
4598 // Everything but the final segment should have no
4599 // parameters at all.
4600 let mut generics = self.tcx.generics_of(def_id);
4601 if let Some(def_id) = generics.parent {
4602 // Variant and struct constructors use the
4603 // generics of their parent type definition.
4604 generics = self.tcx.generics_of(def_id);
4606 type_segment = Some((segments.last().unwrap(), generics));
4609 // Case 2. Reference to a top-level value.
4611 Def::Const(def_id) |
4612 Def::Static(def_id, _) => {
4613 fn_segment = Some((segments.last().unwrap(),
4614 self.tcx.generics_of(def_id)));
4617 // Case 3. Reference to a method or associated const.
4618 Def::Method(def_id) |
4619 Def::AssociatedConst(def_id) => {
4620 let container = self.tcx.associated_item(def_id).container;
4622 ty::TraitContainer(trait_did) => {
4623 callee::check_legal_trait_for_method_call(self.tcx, span, trait_did)
4625 ty::ImplContainer(_) => {}
4628 let generics = self.tcx.generics_of(def_id);
4629 if segments.len() >= 2 {
4630 let parent_generics = self.tcx.generics_of(generics.parent.unwrap());
4631 type_segment = Some((&segments[segments.len() - 2], parent_generics));
4633 // `<T>::assoc` will end up here, and so can `T::assoc`.
4634 let self_ty = opt_self_ty.expect("UFCS sugared assoc missing Self");
4635 ufcs_associated = Some((container, self_ty));
4637 fn_segment = Some((segments.last().unwrap(), generics));
4640 // Case 4. Local variable, no generics.
4641 Def::Local(..) | Def::Upvar(..) => {}
4643 _ => bug!("unexpected definition: {:?}", def),
4646 debug!("type_segment={:?} fn_segment={:?}", type_segment, fn_segment);
4648 // Now that we have categorized what space the parameters for each
4649 // segment belong to, let's sort out the parameters that the user
4650 // provided (if any) into their appropriate spaces. We'll also report
4651 // errors if type parameters are provided in an inappropriate place.
4652 let poly_segments = type_segment.is_some() as usize +
4653 fn_segment.is_some() as usize;
4654 AstConv::prohibit_type_params(self, &segments[..segments.len() - poly_segments]);
4657 Def::Local(def_id) | Def::Upvar(def_id, ..) => {
4658 let nid = self.tcx.hir.as_local_node_id(def_id).unwrap();
4659 let ty = self.local_ty(span, nid);
4660 let ty = self.normalize_associated_types_in(span, &ty);
4661 self.write_ty(self.tcx.hir.node_to_hir_id(node_id), ty);
4667 // Now we have to compare the types that the user *actually*
4668 // provided against the types that were *expected*. If the user
4669 // did not provide any types, then we want to substitute inference
4670 // variables. If the user provided some types, we may still need
4671 // to add defaults. If the user provided *too many* types, that's
4673 self.check_path_parameter_count(span, &mut type_segment, false);
4674 self.check_path_parameter_count(span, &mut fn_segment, false);
4676 let (fn_start, has_self) = match (type_segment, fn_segment) {
4677 (_, Some((_, generics))) => {
4678 (generics.parent_count(), generics.has_self)
4680 (Some((_, generics)), None) => {
4681 (generics.own_count(), generics.has_self)
4683 (None, None) => (0, false)
4685 let substs = Substs::for_item(self.tcx, def.def_id(), |def, _| {
4686 let mut i = def.index as usize;
4688 let segment = if i < fn_start {
4689 i -= has_self as usize;
4695 let lifetimes = segment.map_or(&[][..], |(s, _)| &s.parameters.lifetimes[..]);
4697 if let Some(lifetime) = lifetimes.get(i) {
4698 AstConv::ast_region_to_region(self, lifetime, Some(def))
4700 self.re_infer(span, Some(def)).unwrap()
4703 let mut i = def.index as usize;
4705 let segment = if i < fn_start {
4706 // Handle Self first, so we can adjust the index to match the AST.
4707 if has_self && i == 0 {
4708 return opt_self_ty.unwrap_or_else(|| {
4709 self.type_var_for_def(span, def, substs)
4712 i -= has_self as usize;
4718 let (types, infer_types) = segment.map_or((&[][..], true), |(s, _)| {
4719 (&s.parameters.types[..], s.parameters.infer_types)
4722 // Skip over the lifetimes in the same segment.
4723 if let Some((_, generics)) = segment {
4724 i -= generics.regions.len();
4727 if let Some(ast_ty) = types.get(i) {
4728 // A provided type parameter.
4730 } else if !infer_types && def.has_default {
4731 // No type parameter provided, but a default exists.
4732 let default = self.tcx.type_of(def.def_id);
4735 default.subst_spanned(self.tcx, substs, Some(span))
4738 // No type parameters were provided, we can infer all.
4739 // This can also be reached in some error cases:
4740 // We prefer to use inference variables instead of
4741 // TyError to let type inference recover somewhat.
4742 self.type_var_for_def(span, def, substs)
4746 // The things we are substituting into the type should not contain
4747 // escaping late-bound regions, and nor should the base type scheme.
4748 let ty = self.tcx.type_of(def.def_id());
4749 assert!(!substs.has_escaping_regions());
4750 assert!(!ty.has_escaping_regions());
4752 // Add all the obligations that are required, substituting and
4753 // normalized appropriately.
4754 let bounds = self.instantiate_bounds(span, def.def_id(), &substs);
4755 self.add_obligations_for_parameters(
4756 traits::ObligationCause::new(span, self.body_id, traits::ItemObligation(def.def_id())),
4759 // Substitute the values for the type parameters into the type of
4760 // the referenced item.
4761 let ty_substituted = self.instantiate_type_scheme(span, &substs, &ty);
4763 if let Some((ty::ImplContainer(impl_def_id), self_ty)) = ufcs_associated {
4764 // In the case of `Foo<T>::method` and `<Foo<T>>::method`, if `method`
4765 // is inherent, there is no `Self` parameter, instead, the impl needs
4766 // type parameters, which we can infer by unifying the provided `Self`
4767 // with the substituted impl type.
4768 let ty = self.tcx.type_of(impl_def_id);
4770 let impl_ty = self.instantiate_type_scheme(span, &substs, &ty);
4771 match self.at(&self.misc(span), self.param_env).sup(impl_ty, self_ty) {
4772 Ok(ok) => self.register_infer_ok_obligations(ok),
4775 "instantiate_value_path: (UFCS) {:?} was a subtype of {:?} but now is not?",
4782 debug!("instantiate_value_path: type of {:?} is {:?}",
4785 self.write_substs(self.tcx.hir.node_to_hir_id(node_id), substs);
4789 /// Report errors if the provided parameters are too few or too many.
4790 fn check_path_parameter_count(&self,
4792 segment: &mut Option<(&hir::PathSegment, &ty::Generics)>,
4793 is_method_call: bool) {
4794 let (lifetimes, types, infer_types, bindings) = segment.map_or(
4795 (&[][..], &[][..], true, &[][..]),
4796 |(s, _)| (&s.parameters.lifetimes[..], &s.parameters.types[..],
4797 s.parameters.infer_types, &s.parameters.bindings[..]));
4798 let infer_lifetimes = lifetimes.len() == 0;
4800 let count_lifetime_params = |n| {
4801 format!("{} lifetime parameter{}", n, if n == 1 { "" } else { "s" })
4803 let count_type_params = |n| {
4804 format!("{} type parameter{}", n, if n == 1 { "" } else { "s" })
4807 // Check provided type parameters.
4808 let type_defs = segment.map_or(&[][..], |(_, generics)| {
4809 if generics.parent.is_none() {
4810 &generics.types[generics.has_self as usize..]
4815 let required_len = type_defs.iter().take_while(|d| !d.has_default).count();
4816 if types.len() > type_defs.len() {
4817 let span = types[type_defs.len()].span;
4818 let expected_text = count_type_params(type_defs.len());
4819 let actual_text = count_type_params(types.len());
4820 struct_span_err!(self.tcx.sess, span, E0087,
4821 "too many type parameters provided: \
4822 expected at most {}, found {}",
4823 expected_text, actual_text)
4824 .span_label(span, format!("expected {}", expected_text))
4827 // To prevent derived errors to accumulate due to extra
4828 // type parameters, we force instantiate_value_path to
4829 // use inference variables instead of the provided types.
4831 } else if types.len() < required_len && !infer_types {
4832 let expected_text = count_type_params(required_len);
4833 let actual_text = count_type_params(types.len());
4834 struct_span_err!(self.tcx.sess, span, E0089,
4835 "too few type parameters provided: \
4836 expected {}, found {}",
4837 expected_text, actual_text)
4838 .span_label(span, format!("expected {}", expected_text))
4842 if !bindings.is_empty() {
4843 AstConv::prohibit_projection(self, bindings[0].span);
4846 // Check provided lifetime parameters.
4847 let lifetime_defs = segment.map_or(&[][..], |(_, generics)| &generics.regions);
4848 let required_len = lifetime_defs.len();
4850 // Prohibit explicit lifetime arguments if late bound lifetime parameters are present.
4851 let has_late_bound_lifetime_defs =
4852 segment.map_or(None, |(_, generics)| generics.has_late_bound_regions);
4853 if let (Some(span_late), false) = (has_late_bound_lifetime_defs, lifetimes.is_empty()) {
4854 // Report this as a lint only if no error was reported previously.
4855 let primary_msg = "cannot specify lifetime arguments explicitly \
4856 if late bound lifetime parameters are present";
4857 let note_msg = "the late bound lifetime parameter is introduced here";
4858 if !is_method_call && (lifetimes.len() > lifetime_defs.len() ||
4859 lifetimes.len() < required_len && !infer_lifetimes) {
4860 let mut err = self.tcx.sess.struct_span_err(lifetimes[0].span, primary_msg);
4861 err.span_note(span_late, note_msg);
4865 let mut multispan = MultiSpan::from_span(lifetimes[0].span);
4866 multispan.push_span_label(span_late, note_msg.to_string());
4867 self.tcx.lint_node(lint::builtin::LATE_BOUND_LIFETIME_ARGUMENTS,
4868 lifetimes[0].id, multispan, primary_msg);
4873 if lifetimes.len() > lifetime_defs.len() {
4874 let span = lifetimes[lifetime_defs.len()].span;
4875 let expected_text = count_lifetime_params(lifetime_defs.len());
4876 let actual_text = count_lifetime_params(lifetimes.len());
4877 struct_span_err!(self.tcx.sess, span, E0088,
4878 "too many lifetime parameters provided: \
4879 expected at most {}, found {}",
4880 expected_text, actual_text)
4881 .span_label(span, format!("expected {}", expected_text))
4883 } else if lifetimes.len() < required_len && !infer_lifetimes {
4884 let expected_text = count_lifetime_params(lifetime_defs.len());
4885 let actual_text = count_lifetime_params(lifetimes.len());
4886 struct_span_err!(self.tcx.sess, span, E0090,
4887 "too few lifetime parameters provided: \
4888 expected {}, found {}",
4889 expected_text, actual_text)
4890 .span_label(span, format!("expected {}", expected_text))
4895 fn structurally_resolve_type_or_else<F>(&self, sp: Span, ty: Ty<'tcx>, f: F)
4897 where F: Fn() -> Ty<'tcx>
4899 let mut ty = self.resolve_type_vars_with_obligations(ty);
4902 let alternative = f();
4905 if alternative.is_ty_var() || alternative.references_error() {
4906 if !self.is_tainted_by_errors() {
4907 type_error_struct!(self.tcx.sess, sp, ty, E0619,
4908 "the type of this value must be known in this context")
4911 self.demand_suptype(sp, self.tcx.types.err, ty);
4912 ty = self.tcx.types.err;
4914 self.demand_suptype(sp, alternative, ty);
4922 // Resolves `typ` by a single level if `typ` is a type variable. If no
4923 // resolution is possible, then an error is reported.
4924 pub fn structurally_resolved_type(&self, sp: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
4925 self.structurally_resolve_type_or_else(sp, ty, || {
4930 fn with_breakable_ctxt<F: FnOnce() -> R, R>(&self, id: ast::NodeId,
4931 ctxt: BreakableCtxt<'gcx, 'tcx>, f: F)
4932 -> (BreakableCtxt<'gcx, 'tcx>, R) {
4935 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4936 index = enclosing_breakables.stack.len();
4937 enclosing_breakables.by_id.insert(id, index);
4938 enclosing_breakables.stack.push(ctxt);
4942 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4943 debug_assert!(enclosing_breakables.stack.len() == index + 1);
4944 enclosing_breakables.by_id.remove(&id).expect("missing breakable context");
4945 enclosing_breakables.stack.pop().expect("missing breakable context")
4951 pub fn check_bounds_are_used<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
4952 generics: &hir::Generics,
4954 debug!("check_bounds_are_used(n_tps={}, ty={:?})",
4955 generics.ty_params.len(), ty);
4957 // make a vector of booleans initially false, set to true when used
4958 if generics.ty_params.is_empty() { return; }
4959 let mut tps_used = vec![false; generics.ty_params.len()];
4961 for leaf_ty in ty.walk() {
4962 if let ty::TyParam(ParamTy {idx, ..}) = leaf_ty.sty {
4963 debug!("Found use of ty param num {}", idx);
4964 tps_used[idx as usize - generics.lifetimes.len()] = true;
4968 for (&used, param) in tps_used.iter().zip(&generics.ty_params) {
4970 struct_span_err!(tcx.sess, param.span, E0091,
4971 "type parameter `{}` is unused",
4973 .span_label(param.span, "unused type parameter")
4979 fn fatally_break_rust(sess: &Session) {
4980 let handler = sess.diagnostic();
4981 handler.span_bug_no_panic(
4983 "It looks like you're trying to break rust; would you like some ICE?",
4985 handler.note_without_error("the compiler expectedly panicked. this is a feature.");
4986 handler.note_without_error(
4987 "we would appreciate a joke overview: \
4988 https://github.com/rust-lang/rust/issues/43162#issuecomment-320764675"
4990 handler.note_without_error(&format!("rustc {} running on {}",
4991 option_env!("CFG_VERSION").unwrap_or("unknown_version"),
4992 ::session::config::host_triple(),