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 hir::def::{Def, CtorKind};
89 use hir::def_id::{CrateNum, DefId, LOCAL_CRATE};
91 use namespace::Namespace;
92 use rustc::infer::{self, InferCtxt, InferOk, RegionVariableOrigin};
93 use rustc::infer::type_variable::{TypeVariableOrigin};
94 use rustc::middle::region;
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, DiagnosticId};
104 use require_c_abi_if_variadic;
105 use session::{CompileIncomplete, Session};
108 use util::common::{ErrorReported, indenter};
109 use util::nodemap::{DefIdMap, DefIdSet, FxHashMap, NodeMap};
111 use std::cell::{Cell, RefCell, Ref, RefMut};
113 use std::collections::hash_map::Entry;
115 use std::fmt::Display;
116 use std::mem::replace;
117 use std::ops::{self, Deref};
118 use syntax::abi::Abi;
121 use syntax::codemap::{self, original_sp, Spanned};
122 use syntax::feature_gate::{GateIssue, emit_feature_err};
124 use syntax::symbol::{Symbol, InternedString, keywords};
125 use syntax::util::lev_distance::find_best_match_for_name;
126 use syntax_pos::{self, BytePos, Span, MultiSpan};
128 use rustc::hir::intravisit::{self, Visitor, NestedVisitorMap};
129 use rustc::hir::itemlikevisit::ItemLikeVisitor;
130 use rustc::hir::map::Node;
131 use rustc::hir::{self, PatKind};
132 use rustc::middle::lang_items;
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<DefIdMap<AnonTypeDecl<'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 /// Information about the anonymous, abstract types whose values we
229 /// are inferring in this function (these are the `impl Trait` that
230 /// appear in the return type).
232 struct AnonTypeDecl<'tcx> {
233 /// The substitutions that we apply to the abstract that that this
234 /// `impl Trait` desugars to. e.g., if:
236 /// fn foo<'a, 'b, T>() -> impl Trait<'a>
238 /// winds up desugared to:
240 /// abstract type Foo<'x, T>: Trait<'x>
241 /// fn foo<'a, 'b, T>() -> Foo<'a, T>
243 /// then `substs` would be `['a, T]`.
244 substs: &'tcx Substs<'tcx>,
246 /// The type variable that represents the value of the abstract type
247 /// that we require. In other words, after we compile this function,
248 /// we will be created a constraint like:
252 /// where `?C` is the value of this type variable. =) It may
253 /// naturally refer to the type and lifetime parameters in scope
254 /// in this function, though ultimately it should only reference
255 /// those that are arguments to `Foo` in the constraint above. (In
256 /// other words, `?C` should not include `'b`, even though it's a
257 /// lifetime parameter on `foo`.)
258 concrete_ty: Ty<'tcx>,
260 /// A list of all required region bounds on the impl Trait type,
261 /// e.g. `'a` and `'b` in `fn foo<'a, 'b, 'c>() -> impl Trait<'c> + 'a + 'b`.
262 required_region_bounds: Vec<ty::Region<'tcx>>,
265 impl<'a, 'gcx, 'tcx> Deref for Inherited<'a, 'gcx, 'tcx> {
266 type Target = InferCtxt<'a, 'gcx, 'tcx>;
267 fn deref(&self) -> &Self::Target {
272 /// When type-checking an expression, we propagate downward
273 /// whatever type hint we are able in the form of an `Expectation`.
274 #[derive(Copy, Clone, Debug)]
275 pub enum Expectation<'tcx> {
276 /// We know nothing about what type this expression should have.
279 /// This expression is an `if` condition, it must resolve to `bool`.
282 /// This expression should have the type given (or some subtype)
283 ExpectHasType(Ty<'tcx>),
285 /// This expression will be cast to the `Ty`
286 ExpectCastableToType(Ty<'tcx>),
288 /// This rvalue expression will be wrapped in `&` or `Box` and coerced
289 /// to `&Ty` or `Box<Ty>`, respectively. `Ty` is `[A]` or `Trait`.
290 ExpectRvalueLikeUnsized(Ty<'tcx>),
293 impl<'a, 'gcx, 'tcx> Expectation<'tcx> {
294 // Disregard "castable to" expectations because they
295 // can lead us astray. Consider for example `if cond
296 // {22} else {c} as u8` -- if we propagate the
297 // "castable to u8" constraint to 22, it will pick the
298 // type 22u8, which is overly constrained (c might not
299 // be a u8). In effect, the problem is that the
300 // "castable to" expectation is not the tightest thing
301 // we can say, so we want to drop it in this case.
302 // The tightest thing we can say is "must unify with
303 // else branch". Note that in the case of a "has type"
304 // constraint, this limitation does not hold.
306 // If the expected type is just a type variable, then don't use
307 // an expected type. Otherwise, we might write parts of the type
308 // when checking the 'then' block which are incompatible with the
310 fn adjust_for_branches(&self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) -> Expectation<'tcx> {
312 ExpectHasType(ety) => {
313 let ety = fcx.shallow_resolve(ety);
314 if !ety.is_ty_var() {
320 ExpectRvalueLikeUnsized(ety) => {
321 ExpectRvalueLikeUnsized(ety)
327 /// Provide an expectation for an rvalue expression given an *optional*
328 /// hint, which is not required for type safety (the resulting type might
329 /// be checked higher up, as is the case with `&expr` and `box expr`), but
330 /// is useful in determining the concrete type.
332 /// The primary use case is where the expected type is a fat pointer,
333 /// like `&[isize]`. For example, consider the following statement:
335 /// let x: &[isize] = &[1, 2, 3];
337 /// In this case, the expected type for the `&[1, 2, 3]` expression is
338 /// `&[isize]`. If however we were to say that `[1, 2, 3]` has the
339 /// expectation `ExpectHasType([isize])`, that would be too strong --
340 /// `[1, 2, 3]` does not have the type `[isize]` but rather `[isize; 3]`.
341 /// It is only the `&[1, 2, 3]` expression as a whole that can be coerced
342 /// to the type `&[isize]`. Therefore, we propagate this more limited hint,
343 /// which still is useful, because it informs integer literals and the like.
344 /// See the test case `test/run-pass/coerce-expect-unsized.rs` and #20169
345 /// for examples of where this comes up,.
346 fn rvalue_hint(fcx: &FnCtxt<'a, 'gcx, 'tcx>, ty: Ty<'tcx>) -> Expectation<'tcx> {
347 match fcx.tcx.struct_tail(ty).sty {
348 ty::TySlice(_) | ty::TyStr | ty::TyDynamic(..) => {
349 ExpectRvalueLikeUnsized(ty)
351 _ => ExpectHasType(ty)
355 // Resolves `expected` by a single level if it is a variable. If
356 // there is no expected type or resolution is not possible (e.g.,
357 // no constraints yet present), just returns `None`.
358 fn resolve(self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) -> Expectation<'tcx> {
360 NoExpectation => NoExpectation,
361 ExpectIfCondition => ExpectIfCondition,
362 ExpectCastableToType(t) => {
363 ExpectCastableToType(fcx.resolve_type_vars_if_possible(&t))
365 ExpectHasType(t) => {
366 ExpectHasType(fcx.resolve_type_vars_if_possible(&t))
368 ExpectRvalueLikeUnsized(t) => {
369 ExpectRvalueLikeUnsized(fcx.resolve_type_vars_if_possible(&t))
374 fn to_option(self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) -> Option<Ty<'tcx>> {
375 match self.resolve(fcx) {
376 NoExpectation => None,
377 ExpectIfCondition => Some(fcx.tcx.types.bool),
378 ExpectCastableToType(ty) |
380 ExpectRvalueLikeUnsized(ty) => Some(ty),
384 /// It sometimes happens that we want to turn an expectation into
385 /// a **hard constraint** (i.e., something that must be satisfied
386 /// for the program to type-check). `only_has_type` will return
387 /// such a constraint, if it exists.
388 fn only_has_type(self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) -> Option<Ty<'tcx>> {
389 match self.resolve(fcx) {
390 ExpectHasType(ty) => Some(ty),
391 ExpectIfCondition => Some(fcx.tcx.types.bool),
392 NoExpectation | ExpectCastableToType(_) | ExpectRvalueLikeUnsized(_) => None,
396 /// Like `only_has_type`, but instead of returning `None` if no
397 /// hard constraint exists, creates a fresh type variable.
398 fn coercion_target_type(self, fcx: &FnCtxt<'a, 'gcx, 'tcx>, span: Span) -> Ty<'tcx> {
399 self.only_has_type(fcx)
400 .unwrap_or_else(|| fcx.next_ty_var(TypeVariableOrigin::MiscVariable(span)))
404 #[derive(Copy, Clone)]
405 pub struct UnsafetyState {
406 pub def: ast::NodeId,
407 pub unsafety: hir::Unsafety,
408 pub unsafe_push_count: u32,
413 pub fn function(unsafety: hir::Unsafety, def: ast::NodeId) -> UnsafetyState {
414 UnsafetyState { def: def, unsafety: unsafety, unsafe_push_count: 0, from_fn: true }
417 pub fn recurse(&mut self, blk: &hir::Block) -> UnsafetyState {
418 match self.unsafety {
419 // If this unsafe, then if the outer function was already marked as
420 // unsafe we shouldn't attribute the unsafe'ness to the block. This
421 // way the block can be warned about instead of ignoring this
422 // extraneous block (functions are never warned about).
423 hir::Unsafety::Unsafe if self.from_fn => *self,
426 let (unsafety, def, count) = match blk.rules {
427 hir::PushUnsafeBlock(..) =>
428 (unsafety, blk.id, self.unsafe_push_count.checked_add(1).unwrap()),
429 hir::PopUnsafeBlock(..) =>
430 (unsafety, blk.id, self.unsafe_push_count.checked_sub(1).unwrap()),
431 hir::UnsafeBlock(..) =>
432 (hir::Unsafety::Unsafe, blk.id, self.unsafe_push_count),
434 (unsafety, self.def, self.unsafe_push_count),
438 unsafe_push_count: count,
445 #[derive(Debug, Copy, Clone)]
451 /// Tracks whether executing a node may exit normally (versus
452 /// return/break/panic, which "diverge", leaving dead code in their
453 /// wake). Tracked semi-automatically (through type variables marked
454 /// as diverging), with some manual adjustments for control-flow
455 /// primitives (approximating a CFG).
456 #[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
458 /// Potentially unknown, some cases converge,
459 /// others require a CFG to determine them.
462 /// Definitely known to diverge and therefore
463 /// not reach the next sibling or its parent.
466 /// Same as `Always` but with a reachability
467 /// warning already emitted
471 // Convenience impls for combinig `Diverges`.
473 impl ops::BitAnd for Diverges {
475 fn bitand(self, other: Self) -> Self {
476 cmp::min(self, other)
480 impl ops::BitOr for Diverges {
482 fn bitor(self, other: Self) -> Self {
483 cmp::max(self, other)
487 impl ops::BitAndAssign for Diverges {
488 fn bitand_assign(&mut self, other: Self) {
489 *self = *self & other;
493 impl ops::BitOrAssign for Diverges {
494 fn bitor_assign(&mut self, other: Self) {
495 *self = *self | other;
500 fn always(self) -> bool {
501 self >= Diverges::Always
505 pub struct BreakableCtxt<'gcx: 'tcx, 'tcx> {
508 // this is `null` for loops where break with a value is illegal,
509 // such as `while`, `for`, and `while let`
510 coerce: Option<DynamicCoerceMany<'gcx, 'tcx>>,
513 pub struct EnclosingBreakables<'gcx: 'tcx, 'tcx> {
514 stack: Vec<BreakableCtxt<'gcx, 'tcx>>,
515 by_id: NodeMap<usize>,
518 impl<'gcx, 'tcx> EnclosingBreakables<'gcx, 'tcx> {
519 fn find_breakable(&mut self, target_id: ast::NodeId) -> &mut BreakableCtxt<'gcx, 'tcx> {
520 let ix = *self.by_id.get(&target_id).unwrap_or_else(|| {
521 bug!("could not find enclosing breakable with id {}", target_id);
527 pub struct FnCtxt<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
528 body_id: ast::NodeId,
530 /// The parameter environment used for proving trait obligations
531 /// in this function. This can change when we descend into
532 /// closures (as they bring new things into scope), hence it is
533 /// not part of `Inherited` (as of the time of this writing,
534 /// closures do not yet change the environment, but they will
536 param_env: ty::ParamEnv<'tcx>,
538 // Number of errors that had been reported when we started
539 // checking this function. On exit, if we find that *more* errors
540 // have been reported, we will skip regionck and other work that
541 // expects the types within the function to be consistent.
542 err_count_on_creation: usize,
544 ret_coercion: Option<RefCell<DynamicCoerceMany<'gcx, 'tcx>>>,
546 yield_ty: Option<Ty<'tcx>>,
548 ps: RefCell<UnsafetyState>,
550 /// Whether the last checked node generates a divergence (e.g.,
551 /// `return` will set this to Always). In general, when entering
552 /// an expression or other node in the tree, the initial value
553 /// indicates whether prior parts of the containing expression may
554 /// have diverged. It is then typically set to `Maybe` (and the
555 /// old value remembered) for processing the subparts of the
556 /// current expression. As each subpart is processed, they may set
557 /// the flag to `Always` etc. Finally, at the end, we take the
558 /// result and "union" it with the original value, so that when we
559 /// return the flag indicates if any subpart of the the parent
560 /// expression (up to and including this part) has diverged. So,
561 /// if you read it after evaluating a subexpression `X`, the value
562 /// you get indicates whether any subexpression that was
563 /// evaluating up to and including `X` diverged.
565 /// We use this flag for two purposes:
567 /// - To warn about unreachable code: if, after processing a
568 /// sub-expression but before we have applied the effects of the
569 /// current node, we see that the flag is set to `Always`, we
570 /// can issue a warning. This corresponds to something like
571 /// `foo(return)`; we warn on the `foo()` expression. (We then
572 /// update the flag to `WarnedAlways` to suppress duplicate
573 /// reports.) Similarly, if we traverse to a fresh statement (or
574 /// tail expression) from a `Always` setting, we will issue a
575 /// warning. This corresponds to something like `{return;
576 /// foo();}` or `{return; 22}`, where we would warn on the
579 /// - To permit assignment into a local variable or other lvalue
580 /// (including the "return slot") of type `!`. This is allowed
581 /// if **either** the type of value being assigned is `!`, which
582 /// means the current code is dead, **or** the expression's
583 /// diverging flag is true, which means that a diverging value was
584 /// wrapped (e.g., `let x: ! = foo(return)`).
586 /// To repeat the last point: an expression represents dead-code
587 /// if, after checking it, **either** its type is `!` OR the
588 /// diverges flag is set to something other than `Maybe`.
589 diverges: Cell<Diverges>,
591 /// Whether any child nodes have any type errors.
592 has_errors: Cell<bool>,
594 enclosing_breakables: RefCell<EnclosingBreakables<'gcx, 'tcx>>,
596 inh: &'a Inherited<'a, 'gcx, 'tcx>,
599 impl<'a, 'gcx, 'tcx> Deref for FnCtxt<'a, 'gcx, 'tcx> {
600 type Target = Inherited<'a, 'gcx, 'tcx>;
601 fn deref(&self) -> &Self::Target {
606 /// Helper type of a temporary returned by Inherited::build(...).
607 /// Necessary because we can't write the following bound:
608 /// F: for<'b, 'tcx> where 'gcx: 'tcx FnOnce(Inherited<'b, 'gcx, 'tcx>).
609 pub struct InheritedBuilder<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
610 infcx: infer::InferCtxtBuilder<'a, 'gcx, 'tcx>,
614 impl<'a, 'gcx, 'tcx> Inherited<'a, 'gcx, 'tcx> {
615 pub fn build(tcx: TyCtxt<'a, 'gcx, 'gcx>, def_id: DefId)
616 -> InheritedBuilder<'a, 'gcx, 'tcx> {
617 let hir_id_root = if def_id.is_local() {
618 let node_id = tcx.hir.as_local_node_id(def_id).unwrap();
619 let hir_id = tcx.hir.definitions().node_to_hir_id(node_id);
620 DefId::local(hir_id.owner)
626 infcx: tcx.infer_ctxt().with_fresh_in_progress_tables(hir_id_root),
632 impl<'a, 'gcx, 'tcx> InheritedBuilder<'a, 'gcx, 'tcx> {
633 fn enter<F, R>(&'tcx mut self, f: F) -> R
634 where F: for<'b> FnOnce(Inherited<'b, 'gcx, 'tcx>) -> R
636 let def_id = self.def_id;
637 self.infcx.enter(|infcx| f(Inherited::new(infcx, def_id)))
641 impl<'a, 'gcx, 'tcx> Inherited<'a, 'gcx, 'tcx> {
642 fn new(infcx: InferCtxt<'a, 'gcx, 'tcx>, def_id: DefId) -> Self {
644 let item_id = tcx.hir.as_local_node_id(def_id);
645 let body_id = item_id.and_then(|id| tcx.hir.maybe_body_owned_by(id));
646 let implicit_region_bound = body_id.map(|body_id| {
647 let body = tcx.hir.body(body_id);
648 tcx.mk_region(ty::ReScope(region::Scope::CallSite(body.value.hir_id.local_id)))
652 tables: MaybeInProgressTables {
653 maybe_tables: infcx.in_progress_tables,
656 fulfillment_cx: RefCell::new(traits::FulfillmentContext::new()),
657 locals: RefCell::new(NodeMap()),
658 deferred_call_resolutions: RefCell::new(DefIdMap()),
659 deferred_cast_checks: RefCell::new(Vec::new()),
660 deferred_generator_interiors: RefCell::new(Vec::new()),
661 anon_types: RefCell::new(DefIdMap()),
662 implicit_region_bound,
667 fn register_predicate(&self, obligation: traits::PredicateObligation<'tcx>) {
668 debug!("register_predicate({:?})", obligation);
669 if obligation.has_escaping_regions() {
670 span_bug!(obligation.cause.span, "escaping regions in predicate {:?}",
675 .register_predicate_obligation(self, obligation);
678 fn register_predicates<I>(&self, obligations: I)
679 where I: IntoIterator<Item = traits::PredicateObligation<'tcx>> {
680 for obligation in obligations {
681 self.register_predicate(obligation);
685 fn register_infer_ok_obligations<T>(&self, infer_ok: InferOk<'tcx, T>) -> T {
686 self.register_predicates(infer_ok.obligations);
690 fn normalize_associated_types_in<T>(&self,
692 body_id: ast::NodeId,
693 param_env: ty::ParamEnv<'tcx>,
695 where T : TypeFoldable<'tcx>
697 let ok = self.partially_normalize_associated_types_in(span, body_id, param_env, value);
698 self.register_infer_ok_obligations(ok)
702 struct CheckItemTypesVisitor<'a, 'tcx: 'a> { tcx: TyCtxt<'a, 'tcx, 'tcx> }
704 impl<'a, 'tcx> ItemLikeVisitor<'tcx> for CheckItemTypesVisitor<'a, 'tcx> {
705 fn visit_item(&mut self, i: &'tcx hir::Item) {
706 check_item_type(self.tcx, i);
708 fn visit_trait_item(&mut self, _: &'tcx hir::TraitItem) { }
709 fn visit_impl_item(&mut self, _: &'tcx hir::ImplItem) { }
712 pub fn check_wf_new<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Result<(), ErrorReported> {
713 tcx.sess.track_errors(|| {
714 let mut visit = wfcheck::CheckTypeWellFormedVisitor::new(tcx);
715 tcx.hir.krate().visit_all_item_likes(&mut visit.as_deep_visitor());
719 pub fn check_item_types<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Result<(), ErrorReported> {
720 tcx.sess.track_errors(|| {
721 tcx.hir.krate().visit_all_item_likes(&mut CheckItemTypesVisitor { tcx });
725 pub fn check_item_bodies<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Result<(), CompileIncomplete> {
726 tcx.typeck_item_bodies(LOCAL_CRATE)
729 fn typeck_item_bodies<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, crate_num: CrateNum)
730 -> Result<(), CompileIncomplete>
732 debug_assert!(crate_num == LOCAL_CRATE);
733 Ok(tcx.sess.track_errors(|| {
734 for body_owner_def_id in tcx.body_owners() {
735 ty::maps::queries::typeck_tables_of::ensure(tcx, body_owner_def_id);
740 pub fn provide(providers: &mut Providers) {
741 *providers = Providers {
751 fn adt_destructor<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
753 -> Option<ty::Destructor> {
754 tcx.calculate_dtor(def_id, &mut dropck::check_drop_impl)
757 /// If this def-id is a "primary tables entry", returns `Some((body_id, decl))`
758 /// with information about it's body-id and fn-decl (if any). Otherwise,
761 /// If this function returns "some", then `typeck_tables(def_id)` will
762 /// succeed; if it returns `None`, then `typeck_tables(def_id)` may or
763 /// may not succeed. In some cases where this function returns `None`
764 /// (notably closures), `typeck_tables(def_id)` would wind up
765 /// redirecting to the owning function.
766 fn primary_body_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
768 -> Option<(hir::BodyId, Option<&'tcx hir::FnDecl>)>
770 match tcx.hir.get(id) {
771 hir::map::NodeItem(item) => {
773 hir::ItemConst(_, body) |
774 hir::ItemStatic(_, _, body) =>
776 hir::ItemFn(ref decl, .., body) =>
777 Some((body, Some(decl))),
782 hir::map::NodeTraitItem(item) => {
784 hir::TraitItemKind::Const(_, Some(body)) =>
786 hir::TraitItemKind::Method(ref sig, hir::TraitMethod::Provided(body)) =>
787 Some((body, Some(&sig.decl))),
792 hir::map::NodeImplItem(item) => {
794 hir::ImplItemKind::Const(_, body) =>
796 hir::ImplItemKind::Method(ref sig, body) =>
797 Some((body, Some(&sig.decl))),
802 hir::map::NodeExpr(expr) => {
803 // FIXME(eddyb) Closures should have separate
804 // function definition IDs and expression IDs.
805 // Type-checking should not let closures get
806 // this far in a constant position.
807 // Assume that everything other than closures
808 // is a constant "initializer" expression.
810 hir::ExprClosure(..) =>
813 Some((hir::BodyId { node_id: expr.id }, None)),
820 fn has_typeck_tables<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
823 // Closures' tables come from their outermost function,
824 // as they are part of the same "inference environment".
825 let outer_def_id = tcx.closure_base_def_id(def_id);
826 if outer_def_id != def_id {
827 return tcx.has_typeck_tables(outer_def_id);
830 let id = tcx.hir.as_local_node_id(def_id).unwrap();
831 primary_body_of(tcx, id).is_some()
834 fn used_trait_imports<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
837 tcx.typeck_tables_of(def_id).used_trait_imports.clone()
840 fn typeck_tables_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
842 -> &'tcx ty::TypeckTables<'tcx> {
843 // Closures' tables come from their outermost function,
844 // as they are part of the same "inference environment".
845 let outer_def_id = tcx.closure_base_def_id(def_id);
846 if outer_def_id != def_id {
847 return tcx.typeck_tables_of(outer_def_id);
850 let id = tcx.hir.as_local_node_id(def_id).unwrap();
851 let span = tcx.hir.span(id);
853 // Figure out what primary body this item has.
854 let (body_id, fn_decl) = primary_body_of(tcx, id).unwrap_or_else(|| {
855 span_bug!(span, "can't type-check body of {:?}", def_id);
857 let body = tcx.hir.body(body_id);
859 let tables = Inherited::build(tcx, def_id).enter(|inh| {
860 let param_env = tcx.param_env(def_id);
861 let fcx = if let Some(decl) = fn_decl {
862 let fn_sig = tcx.fn_sig(def_id);
864 check_abi(tcx, span, fn_sig.abi());
866 // Compute the fty from point of view of inside fn.
868 tcx.liberate_late_bound_regions(def_id, &fn_sig);
870 inh.normalize_associated_types_in(body.value.span,
875 let fcx = check_fn(&inh, param_env, fn_sig, decl, id, body, false).0;
876 // Ensure anon_types have been instantiated prior to entering regionck
877 fcx.instantiate_anon_types(&fn_sig.output());
880 let fcx = FnCtxt::new(&inh, param_env, body.value.id);
881 let expected_type = tcx.type_of(def_id);
882 let expected_type = fcx.normalize_associated_types_in(body.value.span, &expected_type);
883 fcx.require_type_is_sized(expected_type, body.value.span, traits::ConstSized);
885 // Gather locals in statics (because of block expressions).
886 // This is technically unnecessary because locals in static items are forbidden,
887 // but prevents type checking from blowing up before const checking can properly
889 GatherLocalsVisitor { fcx: &fcx }.visit_body(body);
891 fcx.check_expr_coercable_to_type(&body.value, expected_type);
896 fcx.select_all_obligations_and_apply_defaults();
897 fcx.closure_analyze(body);
898 fcx.select_obligations_where_possible();
900 fcx.resolve_generator_interiors(def_id);
901 fcx.select_all_obligations_or_error();
903 if fn_decl.is_some() {
904 fcx.regionck_fn(id, body);
906 fcx.regionck_expr(body);
909 fcx.resolve_type_vars_in_body(body)
912 // Consistency check our TypeckTables instance can hold all ItemLocalIds
913 // it will need to hold.
914 assert_eq!(tables.local_id_root,
915 Some(DefId::local(tcx.hir.definitions().node_to_hir_id(id).owner)));
919 fn check_abi<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, span: Span, abi: Abi) {
920 if !tcx.sess.target.target.is_abi_supported(abi) {
921 struct_span_err!(tcx.sess, span, E0570,
922 "The ABI `{}` is not supported for the current target", abi).emit()
926 struct GatherLocalsVisitor<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
927 fcx: &'a FnCtxt<'a, 'gcx, 'tcx>
930 impl<'a, 'gcx, 'tcx> GatherLocalsVisitor<'a, 'gcx, 'tcx> {
931 fn assign(&mut self, span: Span, nid: ast::NodeId, ty_opt: Option<Ty<'tcx>>) -> Ty<'tcx> {
934 // infer the variable's type
935 let var_ty = self.fcx.next_ty_var(TypeVariableOrigin::TypeInference(span));
936 self.fcx.locals.borrow_mut().insert(nid, var_ty);
940 // take type that the user specified
941 self.fcx.locals.borrow_mut().insert(nid, typ);
948 impl<'a, 'gcx, 'tcx> Visitor<'gcx> for GatherLocalsVisitor<'a, 'gcx, 'tcx> {
949 fn nested_visit_map<'this>(&'this mut self) -> NestedVisitorMap<'this, 'gcx> {
950 NestedVisitorMap::None
953 // Add explicitly-declared locals.
954 fn visit_local(&mut self, local: &'gcx hir::Local) {
955 let o_ty = match local.ty {
956 Some(ref ty) => Some(self.fcx.to_ty(&ty)),
959 self.assign(local.span, local.id, o_ty);
960 debug!("Local variable {:?} is assigned type {}",
962 self.fcx.ty_to_string(
963 self.fcx.locals.borrow().get(&local.id).unwrap().clone()));
964 intravisit::walk_local(self, local);
967 // Add pattern bindings.
968 fn visit_pat(&mut self, p: &'gcx hir::Pat) {
969 if let PatKind::Binding(_, _, ref path1, _) = p.node {
970 let var_ty = self.assign(p.span, p.id, None);
972 self.fcx.require_type_is_sized(var_ty, p.span,
973 traits::VariableType(p.id));
975 debug!("Pattern binding {} is assigned to {} with type {:?}",
977 self.fcx.ty_to_string(
978 self.fcx.locals.borrow().get(&p.id).unwrap().clone()),
981 intravisit::walk_pat(self, p);
984 // Don't descend into the bodies of nested closures
985 fn visit_fn(&mut self, _: intravisit::FnKind<'gcx>, _: &'gcx hir::FnDecl,
986 _: hir::BodyId, _: Span, _: ast::NodeId) { }
989 /// When `check_fn` is invoked on a generator (i.e., a body that
990 /// includes yield), it returns back some information about the yield
992 struct GeneratorTypes<'tcx> {
993 /// Type of value that is yielded.
994 yield_ty: ty::Ty<'tcx>,
996 /// Types that are captured (see `GeneratorInterior` for more).
997 interior: ty::GeneratorInterior<'tcx>
1000 /// Helper used for fns and closures. Does the grungy work of checking a function
1001 /// body and returns the function context used for that purpose, since in the case of a fn item
1002 /// there is still a bit more to do.
1005 /// * inherited: other fields inherited from the enclosing fn (if any)
1006 fn check_fn<'a, 'gcx, 'tcx>(inherited: &'a Inherited<'a, 'gcx, 'tcx>,
1007 param_env: ty::ParamEnv<'tcx>,
1008 fn_sig: ty::FnSig<'tcx>,
1009 decl: &'gcx hir::FnDecl,
1011 body: &'gcx hir::Body,
1012 can_be_generator: bool)
1013 -> (FnCtxt<'a, 'gcx, 'tcx>, Option<GeneratorTypes<'tcx>>)
1015 let mut fn_sig = fn_sig.clone();
1017 debug!("check_fn(sig={:?}, fn_id={}, param_env={:?})", fn_sig, fn_id, param_env);
1019 // Create the function context. This is either derived from scratch or,
1020 // in the case of function expressions, based on the outer context.
1021 let mut fcx = FnCtxt::new(inherited, param_env, body.value.id);
1022 *fcx.ps.borrow_mut() = UnsafetyState::function(fn_sig.unsafety, fn_id);
1024 let ret_ty = fn_sig.output();
1025 fcx.require_type_is_sized(ret_ty, decl.output.span(), traits::SizedReturnType);
1026 let ret_ty = fcx.instantiate_anon_types(&ret_ty);
1027 fcx.ret_coercion = Some(RefCell::new(CoerceMany::new(ret_ty)));
1028 fn_sig = fcx.tcx.mk_fn_sig(
1029 fn_sig.inputs().iter().cloned(),
1036 let span = body.value.span;
1038 if body.is_generator && can_be_generator {
1039 fcx.yield_ty = Some(fcx.next_ty_var(TypeVariableOrigin::TypeInference(span)));
1042 GatherLocalsVisitor { fcx: &fcx, }.visit_body(body);
1044 // Add formal parameters.
1045 for (arg_ty, arg) in fn_sig.inputs().iter().zip(&body.arguments) {
1046 // Check the pattern.
1047 fcx.check_pat_walk(&arg.pat, arg_ty,
1048 ty::BindingMode::BindByValue(hir::Mutability::MutImmutable), true);
1050 // Check that argument is Sized.
1051 // The check for a non-trivial pattern is a hack to avoid duplicate warnings
1052 // for simple cases like `fn foo(x: Trait)`,
1053 // where we would error once on the parameter as a whole, and once on the binding `x`.
1054 if arg.pat.simple_name().is_none() {
1055 fcx.require_type_is_sized(arg_ty, decl.output.span(), traits::MiscObligation);
1058 fcx.write_ty(arg.hir_id, arg_ty);
1061 let fn_hir_id = fcx.tcx.hir.node_to_hir_id(fn_id);
1062 let gen_ty = if can_be_generator && body.is_generator {
1063 let witness = fcx.next_ty_var(TypeVariableOrigin::MiscVariable(span));
1064 fcx.deferred_generator_interiors.borrow_mut().push((body.id(), witness));
1065 let interior = ty::GeneratorInterior::new(witness);
1066 Some(GeneratorTypes { yield_ty: fcx.yield_ty.unwrap(), interior: interior })
1070 inherited.tables.borrow_mut().liberated_fn_sigs_mut().insert(fn_hir_id, fn_sig);
1072 fcx.check_return_expr(&body.value);
1074 // Finalize the return check by taking the LUB of the return types
1075 // we saw and assigning it to the expected return type. This isn't
1076 // really expected to fail, since the coercions would have failed
1077 // earlier when trying to find a LUB.
1079 // However, the behavior around `!` is sort of complex. In the
1080 // event that the `actual_return_ty` comes back as `!`, that
1081 // indicates that the fn either does not return or "returns" only
1082 // values of type `!`. In this case, if there is an expected
1083 // return type that is *not* `!`, that should be ok. But if the
1084 // return type is being inferred, we want to "fallback" to `!`:
1086 // let x = move || panic!();
1088 // To allow for that, I am creating a type variable with diverging
1089 // fallback. This was deemed ever so slightly better than unifying
1090 // the return value with `!` because it allows for the caller to
1091 // make more assumptions about the return type (e.g., they could do
1093 // let y: Option<u32> = Some(x());
1095 // which would then cause this return type to become `u32`, not
1097 let coercion = fcx.ret_coercion.take().unwrap().into_inner();
1098 let mut actual_return_ty = coercion.complete(&fcx);
1099 if actual_return_ty.is_never() {
1100 actual_return_ty = fcx.next_diverging_ty_var(
1101 TypeVariableOrigin::DivergingFn(span));
1103 fcx.demand_suptype(span, ret_ty, actual_return_ty);
1108 fn check_struct<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1111 let def_id = tcx.hir.local_def_id(id);
1112 let def = tcx.adt_def(def_id);
1113 def.destructor(tcx); // force the destructor to be evaluated
1114 check_representable(tcx, span, def_id);
1116 if def.repr.simd() {
1117 check_simd(tcx, span, def_id);
1120 check_packed(tcx, span, def_id);
1123 fn check_union<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1126 let def_id = tcx.hir.local_def_id(id);
1127 let def = tcx.adt_def(def_id);
1128 def.destructor(tcx); // force the destructor to be evaluated
1129 check_representable(tcx, span, def_id);
1131 check_packed(tcx, span, def_id);
1134 pub fn check_item_type<'a,'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, it: &'tcx hir::Item) {
1135 debug!("check_item_type(it.id={}, it.name={})",
1137 tcx.item_path_str(tcx.hir.local_def_id(it.id)));
1138 let _indenter = indenter();
1140 // Consts can play a role in type-checking, so they are included here.
1141 hir::ItemStatic(..) |
1142 hir::ItemConst(..) => {
1143 tcx.typeck_tables_of(tcx.hir.local_def_id(it.id));
1145 hir::ItemEnum(ref enum_definition, _) => {
1148 &enum_definition.variants,
1151 hir::ItemFn(..) => {} // entirely within check_item_body
1152 hir::ItemImpl(.., ref impl_item_refs) => {
1153 debug!("ItemImpl {} with id {}", it.name, it.id);
1154 let impl_def_id = tcx.hir.local_def_id(it.id);
1155 if let Some(impl_trait_ref) = tcx.impl_trait_ref(impl_def_id) {
1156 check_impl_items_against_trait(tcx,
1161 let trait_def_id = impl_trait_ref.def_id;
1162 check_on_unimplemented(tcx, trait_def_id, it);
1165 hir::ItemTrait(..) => {
1166 let def_id = tcx.hir.local_def_id(it.id);
1167 check_on_unimplemented(tcx, def_id, it);
1169 hir::ItemStruct(..) => {
1170 check_struct(tcx, it.id, it.span);
1172 hir::ItemUnion(..) => {
1173 check_union(tcx, it.id, it.span);
1175 hir::ItemTy(_, ref generics) => {
1176 let def_id = tcx.hir.local_def_id(it.id);
1177 let pty_ty = tcx.type_of(def_id);
1178 check_bounds_are_used(tcx, generics, pty_ty);
1180 hir::ItemForeignMod(ref m) => {
1181 check_abi(tcx, it.span, m.abi);
1183 if m.abi == Abi::RustIntrinsic {
1184 for item in &m.items {
1185 intrinsic::check_intrinsic_type(tcx, item);
1187 } else if m.abi == Abi::PlatformIntrinsic {
1188 for item in &m.items {
1189 intrinsic::check_platform_intrinsic_type(tcx, item);
1192 for item in &m.items {
1193 let generics = tcx.generics_of(tcx.hir.local_def_id(item.id));
1194 if !generics.types.is_empty() {
1195 let mut err = struct_span_err!(tcx.sess, item.span, E0044,
1196 "foreign items may not have type parameters");
1197 span_help!(&mut err, item.span,
1198 "consider using specialization instead of \
1203 if let hir::ForeignItemFn(ref fn_decl, _, _) = item.node {
1204 require_c_abi_if_variadic(tcx, fn_decl, m.abi, item.span);
1209 _ => {/* nothing to do */ }
1213 fn check_on_unimplemented<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1214 trait_def_id: DefId,
1216 let item_def_id = tcx.hir.local_def_id(item.id);
1217 // an error would be reported if this fails.
1218 let _ = traits::OnUnimplementedDirective::of_item(tcx, trait_def_id, item_def_id);
1221 fn report_forbidden_specialization<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1222 impl_item: &hir::ImplItem,
1225 let mut err = struct_span_err!(
1226 tcx.sess, impl_item.span, E0520,
1227 "`{}` specializes an item from a parent `impl`, but \
1228 that item is not marked `default`",
1230 err.span_label(impl_item.span, format!("cannot specialize default item `{}`",
1233 match tcx.span_of_impl(parent_impl) {
1235 err.span_label(span, "parent `impl` is here");
1236 err.note(&format!("to specialize, `{}` in the parent `impl` must be marked `default`",
1240 err.note(&format!("parent implementation is in crate `{}`", cname));
1247 fn check_specialization_validity<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1248 trait_def: &ty::TraitDef,
1249 trait_item: &ty::AssociatedItem,
1251 impl_item: &hir::ImplItem)
1253 let ancestors = trait_def.ancestors(tcx, impl_id);
1255 let kind = match impl_item.node {
1256 hir::ImplItemKind::Const(..) => ty::AssociatedKind::Const,
1257 hir::ImplItemKind::Method(..) => ty::AssociatedKind::Method,
1258 hir::ImplItemKind::Type(_) => ty::AssociatedKind::Type
1261 let parent = ancestors.defs(tcx, trait_item.name, kind, trait_def.def_id).skip(1).next()
1262 .map(|node_item| node_item.map(|parent| parent.defaultness));
1264 if let Some(parent) = parent {
1265 if tcx.impl_item_is_final(&parent) {
1266 report_forbidden_specialization(tcx, impl_item, parent.node.def_id());
1272 fn check_impl_items_against_trait<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1275 impl_trait_ref: ty::TraitRef<'tcx>,
1276 impl_item_refs: &[hir::ImplItemRef]) {
1277 // If the trait reference itself is erroneous (so the compilation is going
1278 // to fail), skip checking the items here -- the `impl_item` table in `tcx`
1279 // isn't populated for such impls.
1280 if impl_trait_ref.references_error() { return; }
1282 // Locate trait definition and items
1283 let trait_def = tcx.trait_def(impl_trait_ref.def_id);
1284 let mut overridden_associated_type = None;
1286 let impl_items = || impl_item_refs.iter().map(|iiref| tcx.hir.impl_item(iiref.id));
1288 // Check existing impl methods to see if they are both present in trait
1289 // and compatible with trait signature
1290 for impl_item in impl_items() {
1291 let ty_impl_item = tcx.associated_item(tcx.hir.local_def_id(impl_item.id));
1292 let ty_trait_item = tcx.associated_items(impl_trait_ref.def_id)
1293 .find(|ac| Namespace::from(&impl_item.node) == Namespace::from(ac.kind) &&
1294 tcx.hygienic_eq(ty_impl_item.name, ac.name, impl_trait_ref.def_id))
1296 // Not compatible, but needed for the error message
1297 tcx.associated_items(impl_trait_ref.def_id)
1298 .find(|ac| tcx.hygienic_eq(ty_impl_item.name, ac.name, impl_trait_ref.def_id))
1301 // Check that impl definition matches trait definition
1302 if let Some(ty_trait_item) = ty_trait_item {
1303 match impl_item.node {
1304 hir::ImplItemKind::Const(..) => {
1305 // Find associated const definition.
1306 if ty_trait_item.kind == ty::AssociatedKind::Const {
1307 compare_const_impl(tcx,
1313 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0323,
1314 "item `{}` is an associated const, \
1315 which doesn't match its trait `{}`",
1318 err.span_label(impl_item.span, "does not match trait");
1319 // We can only get the spans from local trait definition
1320 // Same for E0324 and E0325
1321 if let Some(trait_span) = tcx.hir.span_if_local(ty_trait_item.def_id) {
1322 err.span_label(trait_span, "item in trait");
1327 hir::ImplItemKind::Method(..) => {
1328 let trait_span = tcx.hir.span_if_local(ty_trait_item.def_id);
1329 if ty_trait_item.kind == ty::AssociatedKind::Method {
1330 compare_impl_method(tcx,
1337 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0324,
1338 "item `{}` is an associated method, \
1339 which doesn't match its trait `{}`",
1342 err.span_label(impl_item.span, "does not match trait");
1343 if let Some(trait_span) = tcx.hir.span_if_local(ty_trait_item.def_id) {
1344 err.span_label(trait_span, "item in trait");
1349 hir::ImplItemKind::Type(_) => {
1350 if ty_trait_item.kind == ty::AssociatedKind::Type {
1351 if ty_trait_item.defaultness.has_value() {
1352 overridden_associated_type = Some(impl_item);
1355 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0325,
1356 "item `{}` is an associated type, \
1357 which doesn't match its trait `{}`",
1360 err.span_label(impl_item.span, "does not match trait");
1361 if let Some(trait_span) = tcx.hir.span_if_local(ty_trait_item.def_id) {
1362 err.span_label(trait_span, "item in trait");
1369 check_specialization_validity(tcx, trait_def, &ty_trait_item, impl_id, impl_item);
1373 // Check for missing items from trait
1374 let mut missing_items = Vec::new();
1375 let mut invalidated_items = Vec::new();
1376 let associated_type_overridden = overridden_associated_type.is_some();
1377 for trait_item in tcx.associated_items(impl_trait_ref.def_id) {
1378 let is_implemented = trait_def.ancestors(tcx, impl_id)
1379 .defs(tcx, trait_item.name, trait_item.kind, impl_trait_ref.def_id)
1381 .map(|node_item| !node_item.node.is_from_trait())
1384 if !is_implemented {
1385 if !trait_item.defaultness.has_value() {
1386 missing_items.push(trait_item);
1387 } else if associated_type_overridden {
1388 invalidated_items.push(trait_item.name);
1393 if !missing_items.is_empty() {
1394 let mut err = struct_span_err!(tcx.sess, impl_span, E0046,
1395 "not all trait items implemented, missing: `{}`",
1396 missing_items.iter()
1397 .map(|trait_item| trait_item.name.to_string())
1398 .collect::<Vec<_>>().join("`, `"));
1399 err.span_label(impl_span, format!("missing `{}` in implementation",
1400 missing_items.iter()
1401 .map(|trait_item| trait_item.name.to_string())
1402 .collect::<Vec<_>>().join("`, `")));
1403 for trait_item in missing_items {
1404 if let Some(span) = tcx.hir.span_if_local(trait_item.def_id) {
1405 err.span_label(span, format!("`{}` from trait", trait_item.name));
1407 err.note_trait_signature(trait_item.name.to_string(),
1408 trait_item.signature(&tcx));
1414 if !invalidated_items.is_empty() {
1415 let invalidator = overridden_associated_type.unwrap();
1416 span_err!(tcx.sess, invalidator.span, E0399,
1417 "the following trait items need to be reimplemented \
1418 as `{}` was overridden: `{}`",
1420 invalidated_items.iter()
1421 .map(|name| name.to_string())
1422 .collect::<Vec<_>>().join("`, `"))
1426 /// Checks whether a type can be represented in memory. In particular, it
1427 /// identifies types that contain themselves without indirection through a
1428 /// pointer, which would mean their size is unbounded.
1429 fn check_representable<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1433 let rty = tcx.type_of(item_def_id);
1435 // Check that it is possible to represent this type. This call identifies
1436 // (1) types that contain themselves and (2) types that contain a different
1437 // recursive type. It is only necessary to throw an error on those that
1438 // contain themselves. For case 2, there must be an inner type that will be
1439 // caught by case 1.
1440 match rty.is_representable(tcx, sp) {
1441 Representability::SelfRecursive(spans) => {
1442 let mut err = tcx.recursive_type_with_infinite_size_error(item_def_id);
1444 err.span_label(span, "recursive without indirection");
1449 Representability::Representable | Representability::ContainsRecursive => (),
1454 pub fn check_simd<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, sp: Span, def_id: DefId) {
1455 let t = tcx.type_of(def_id);
1457 ty::TyAdt(def, substs) if def.is_struct() => {
1458 let fields = &def.struct_variant().fields;
1459 if fields.is_empty() {
1460 span_err!(tcx.sess, sp, E0075, "SIMD vector cannot be empty");
1463 let e = fields[0].ty(tcx, substs);
1464 if !fields.iter().all(|f| f.ty(tcx, substs) == e) {
1465 struct_span_err!(tcx.sess, sp, E0076, "SIMD vector should be homogeneous")
1466 .span_label(sp, "SIMD elements must have the same type")
1471 ty::TyParam(_) => { /* struct<T>(T, T, T, T) is ok */ }
1472 _ if e.is_machine() => { /* struct(u8, u8, u8, u8) is ok */ }
1474 span_err!(tcx.sess, sp, E0077,
1475 "SIMD vector element type should be machine type");
1484 fn check_packed<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, sp: Span, def_id: DefId) {
1485 if tcx.adt_def(def_id).repr.packed() {
1486 if tcx.adt_def(def_id).repr.align > 0 {
1487 struct_span_err!(tcx.sess, sp, E0587,
1488 "type has conflicting packed and align representation hints").emit();
1490 else if check_packed_inner(tcx, def_id, &mut Vec::new()) {
1491 struct_span_err!(tcx.sess, sp, E0588,
1492 "packed type cannot transitively contain a `[repr(align)]` type").emit();
1497 fn check_packed_inner<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1499 stack: &mut Vec<DefId>) -> bool {
1500 let t = tcx.type_of(def_id);
1501 if stack.contains(&def_id) {
1502 debug!("check_packed_inner: {:?} is recursive", t);
1506 ty::TyAdt(def, substs) if def.is_struct() || def.is_union() => {
1507 if tcx.adt_def(def.did).repr.align > 0 {
1510 // push struct def_id before checking fields
1512 for field in &def.struct_variant().fields {
1513 let f = field.ty(tcx, substs);
1515 ty::TyAdt(def, _) => {
1516 if check_packed_inner(tcx, def.did, stack) {
1523 // only need to pop if not early out
1531 #[allow(trivial_numeric_casts)]
1532 pub fn check_enum<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1534 vs: &'tcx [hir::Variant],
1536 let def_id = tcx.hir.local_def_id(id);
1537 let def = tcx.adt_def(def_id);
1538 def.destructor(tcx); // force the destructor to be evaluated
1541 let attributes = tcx.get_attrs(def_id);
1542 if let Some(attr) = attr::find_by_name(&attributes, "repr") {
1544 tcx.sess, attr.span, E0084,
1545 "unsupported representation for zero-variant enum")
1546 .span_label(sp, "zero-variant enum")
1551 let repr_type_ty = def.repr.discr_type().to_ty(tcx);
1552 if repr_type_ty == tcx.types.i128 || repr_type_ty == tcx.types.u128 {
1553 if !tcx.sess.features.borrow().repr128 {
1554 emit_feature_err(&tcx.sess.parse_sess,
1557 GateIssue::Language,
1558 "repr with 128-bit type is unstable");
1563 if let Some(e) = v.node.disr_expr {
1564 tcx.typeck_tables_of(tcx.hir.local_def_id(e.node_id));
1568 let mut disr_vals: Vec<ConstInt> = Vec::new();
1569 for (discr, v) in def.discriminants(tcx).zip(vs) {
1570 // Check for duplicate discriminant values
1571 if let Some(i) = disr_vals.iter().position(|&x| x == discr) {
1572 let variant_i_node_id = tcx.hir.as_local_node_id(def.variants[i].did).unwrap();
1573 let variant_i = tcx.hir.expect_variant(variant_i_node_id);
1574 let i_span = match variant_i.node.disr_expr {
1575 Some(expr) => tcx.hir.span(expr.node_id),
1576 None => tcx.hir.span(variant_i_node_id)
1578 let span = match v.node.disr_expr {
1579 Some(expr) => tcx.hir.span(expr.node_id),
1582 struct_span_err!(tcx.sess, span, E0081,
1583 "discriminant value `{}` already exists", disr_vals[i])
1584 .span_label(i_span, format!("first use of `{}`", disr_vals[i]))
1585 .span_label(span , format!("enum already has `{}`", disr_vals[i]))
1588 disr_vals.push(discr);
1591 check_representable(tcx, sp, def_id);
1594 impl<'a, 'gcx, 'tcx> AstConv<'gcx, 'tcx> for FnCtxt<'a, 'gcx, 'tcx> {
1595 fn tcx<'b>(&'b self) -> TyCtxt<'b, 'gcx, 'tcx> { self.tcx }
1597 fn get_type_parameter_bounds(&self, _: Span, def_id: DefId)
1598 -> ty::GenericPredicates<'tcx>
1601 let node_id = tcx.hir.as_local_node_id(def_id).unwrap();
1602 let item_id = tcx.hir.ty_param_owner(node_id);
1603 let item_def_id = tcx.hir.local_def_id(item_id);
1604 let generics = tcx.generics_of(item_def_id);
1605 let index = generics.type_param_to_index[&def_id.index];
1606 ty::GenericPredicates {
1608 predicates: self.param_env.caller_bounds.iter().filter(|predicate| {
1610 ty::Predicate::Trait(ref data) => {
1611 data.0.self_ty().is_param(index)
1615 }).cloned().collect()
1619 fn re_infer(&self, span: Span, def: Option<&ty::RegionParameterDef>)
1620 -> Option<ty::Region<'tcx>> {
1622 Some(def) => infer::EarlyBoundRegion(span, def.name),
1623 None => infer::MiscVariable(span)
1625 Some(self.next_region_var(v))
1628 fn ty_infer(&self, span: Span) -> Ty<'tcx> {
1629 self.next_ty_var(TypeVariableOrigin::TypeInference(span))
1632 fn ty_infer_for_def(&self,
1633 ty_param_def: &ty::TypeParameterDef,
1634 substs: &[Kind<'tcx>],
1635 span: Span) -> Ty<'tcx> {
1636 self.type_var_for_def(span, ty_param_def, substs)
1639 fn projected_ty_from_poly_trait_ref(&self,
1642 poly_trait_ref: ty::PolyTraitRef<'tcx>)
1645 let (trait_ref, _) =
1646 self.replace_late_bound_regions_with_fresh_var(
1648 infer::LateBoundRegionConversionTime::AssocTypeProjection(item_def_id),
1651 self.tcx().mk_projection(item_def_id, trait_ref.substs)
1654 fn normalize_ty(&self, span: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
1655 if ty.has_escaping_regions() {
1656 ty // FIXME: normalization and escaping regions
1658 self.normalize_associated_types_in(span, &ty)
1662 fn set_tainted_by_errors(&self) {
1663 self.infcx.set_tainted_by_errors()
1666 fn record_ty(&self, hir_id: hir::HirId, ty: Ty<'tcx>, _span: Span) {
1667 self.write_ty(hir_id, ty)
1671 /// Controls whether the arguments are tupled. This is used for the call
1674 /// Tupling means that all call-side arguments are packed into a tuple and
1675 /// passed as a single parameter. For example, if tupling is enabled, this
1678 /// fn f(x: (isize, isize))
1680 /// Can be called as:
1687 #[derive(Clone, Eq, PartialEq)]
1688 enum TupleArgumentsFlag {
1693 impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
1694 pub fn new(inh: &'a Inherited<'a, 'gcx, 'tcx>,
1695 param_env: ty::ParamEnv<'tcx>,
1696 body_id: ast::NodeId)
1697 -> FnCtxt<'a, 'gcx, 'tcx> {
1701 err_count_on_creation: inh.tcx.sess.err_count(),
1704 ps: RefCell::new(UnsafetyState::function(hir::Unsafety::Normal,
1705 ast::CRATE_NODE_ID)),
1706 diverges: Cell::new(Diverges::Maybe),
1707 has_errors: Cell::new(false),
1708 enclosing_breakables: RefCell::new(EnclosingBreakables {
1716 pub fn sess(&self) -> &Session {
1720 pub fn err_count_since_creation(&self) -> usize {
1721 self.tcx.sess.err_count() - self.err_count_on_creation
1724 /// Produce warning on the given node, if the current point in the
1725 /// function is unreachable, and there hasn't been another warning.
1726 fn warn_if_unreachable(&self, id: ast::NodeId, span: Span, kind: &str) {
1727 if self.diverges.get() == Diverges::Always {
1728 self.diverges.set(Diverges::WarnedAlways);
1730 debug!("warn_if_unreachable: id={:?} span={:?} kind={}", id, span, kind);
1732 self.tcx().lint_node(
1733 lint::builtin::UNREACHABLE_CODE,
1735 &format!("unreachable {}", kind));
1741 code: ObligationCauseCode<'tcx>)
1742 -> ObligationCause<'tcx> {
1743 ObligationCause::new(span, self.body_id, code)
1746 pub fn misc(&self, span: Span) -> ObligationCause<'tcx> {
1747 self.cause(span, ObligationCauseCode::MiscObligation)
1750 /// Resolves type variables in `ty` if possible. Unlike the infcx
1751 /// version (resolve_type_vars_if_possible), this version will
1752 /// also select obligations if it seems useful, in an effort
1753 /// to get more type information.
1754 fn resolve_type_vars_with_obligations(&self, mut ty: Ty<'tcx>) -> Ty<'tcx> {
1755 debug!("resolve_type_vars_with_obligations(ty={:?})", ty);
1757 // No TyInfer()? Nothing needs doing.
1758 if !ty.has_infer_types() {
1759 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
1763 // If `ty` is a type variable, see whether we already know what it is.
1764 ty = self.resolve_type_vars_if_possible(&ty);
1765 if !ty.has_infer_types() {
1766 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
1770 // If not, try resolving pending obligations as much as
1771 // possible. This can help substantially when there are
1772 // indirect dependencies that don't seem worth tracking
1774 self.select_obligations_where_possible();
1775 ty = self.resolve_type_vars_if_possible(&ty);
1777 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
1781 fn record_deferred_call_resolution(&self,
1782 closure_def_id: DefId,
1783 r: DeferredCallResolution<'gcx, 'tcx>) {
1784 let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
1785 deferred_call_resolutions.entry(closure_def_id).or_insert(vec![]).push(r);
1788 fn remove_deferred_call_resolutions(&self,
1789 closure_def_id: DefId)
1790 -> Vec<DeferredCallResolution<'gcx, 'tcx>>
1792 let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
1793 deferred_call_resolutions.remove(&closure_def_id).unwrap_or(vec![])
1796 pub fn tag(&self) -> String {
1797 let self_ptr: *const FnCtxt = self;
1798 format!("{:?}", self_ptr)
1801 pub fn local_ty(&self, span: Span, nid: ast::NodeId) -> Ty<'tcx> {
1802 match self.locals.borrow().get(&nid) {
1805 span_bug!(span, "no type for local variable {}",
1806 self.tcx.hir.node_to_string(nid));
1812 pub fn write_ty(&self, id: hir::HirId, ty: Ty<'tcx>) {
1813 debug!("write_ty({:?}, {:?}) in fcx {}",
1814 id, self.resolve_type_vars_if_possible(&ty), self.tag());
1815 self.tables.borrow_mut().node_types_mut().insert(id, ty);
1817 if ty.references_error() {
1818 self.has_errors.set(true);
1819 self.set_tainted_by_errors();
1823 // The NodeId and the ItemLocalId must identify the same item. We just pass
1824 // both of them for consistency checking.
1825 pub fn write_method_call(&self,
1827 method: MethodCallee<'tcx>) {
1830 .type_dependent_defs_mut()
1831 .insert(hir_id, Def::Method(method.def_id));
1832 self.write_substs(hir_id, method.substs);
1835 pub fn write_substs(&self, node_id: hir::HirId, substs: &'tcx Substs<'tcx>) {
1836 if !substs.is_noop() {
1837 debug!("write_substs({:?}, {:?}) in fcx {}",
1842 self.tables.borrow_mut().node_substs_mut().insert(node_id, substs);
1846 pub fn apply_adjustments(&self, expr: &hir::Expr, adj: Vec<Adjustment<'tcx>>) {
1847 debug!("apply_adjustments(expr={:?}, adj={:?})", expr, adj);
1853 match self.tables.borrow_mut().adjustments_mut().entry(expr.hir_id) {
1854 Entry::Vacant(entry) => { entry.insert(adj); },
1855 Entry::Occupied(mut entry) => {
1856 debug!(" - composing on top of {:?}", entry.get());
1857 match (&entry.get()[..], &adj[..]) {
1858 // Applying any adjustment on top of a NeverToAny
1859 // is a valid NeverToAny adjustment, because it can't
1861 (&[Adjustment { kind: Adjust::NeverToAny, .. }], _) => return,
1863 Adjustment { kind: Adjust::Deref(_), .. },
1864 Adjustment { kind: Adjust::Borrow(AutoBorrow::Ref(..)), .. },
1866 Adjustment { kind: Adjust::Deref(_), .. },
1867 .. // Any following adjustments are allowed.
1869 // A reborrow has no effect before a dereference.
1871 // FIXME: currently we never try to compose autoderefs
1872 // and ReifyFnPointer/UnsafeFnPointer, but we could.
1874 bug!("while adjusting {:?}, can't compose {:?} and {:?}",
1875 expr, entry.get(), adj)
1877 *entry.get_mut() = adj;
1882 /// Basically whenever we are converting from a type scheme into
1883 /// the fn body space, we always want to normalize associated
1884 /// types as well. This function combines the two.
1885 fn instantiate_type_scheme<T>(&self,
1887 substs: &Substs<'tcx>,
1890 where T : TypeFoldable<'tcx>
1892 let value = value.subst(self.tcx, substs);
1893 let result = self.normalize_associated_types_in(span, &value);
1894 debug!("instantiate_type_scheme(value={:?}, substs={:?}) = {:?}",
1901 /// As `instantiate_type_scheme`, but for the bounds found in a
1902 /// generic type scheme.
1903 fn instantiate_bounds(&self, span: Span, def_id: DefId, substs: &Substs<'tcx>)
1904 -> ty::InstantiatedPredicates<'tcx> {
1905 let bounds = self.tcx.predicates_of(def_id);
1906 let result = bounds.instantiate(self.tcx, substs);
1907 let result = self.normalize_associated_types_in(span, &result);
1908 debug!("instantiate_bounds(bounds={:?}, substs={:?}) = {:?}",
1915 /// Replace all anonymized types with fresh inference variables
1916 /// and record them for writeback.
1917 fn instantiate_anon_types<T: TypeFoldable<'tcx>>(&self, value: &T) -> T {
1918 debug!("instantiate_anon_types(value={:?})", value);
1919 value.fold_with(&mut BottomUpFolder { tcx: self.tcx, fldop: |ty| {
1920 if let ty::TyAnon(def_id, substs) = ty.sty {
1921 debug!("instantiate_anon_types: TyAnon(def_id={:?}, substs={:?})", def_id, substs);
1923 // Use the same type variable if the exact same TyAnon appears more
1924 // than once in the return type (e.g. if it's passed to a type alias).
1925 if let Some(anon_defn) = self.anon_types.borrow().get(&def_id) {
1926 return anon_defn.concrete_ty;
1928 let span = self.tcx.def_span(def_id);
1929 let ty_var = self.next_ty_var(TypeVariableOrigin::TypeInference(span));
1931 let predicates_of = self.tcx.predicates_of(def_id);
1932 let bounds = predicates_of.instantiate(self.tcx, substs);
1933 debug!("instantiate_anon_types: bounds={:?}", bounds);
1935 let required_region_bounds =
1936 self.tcx.required_region_bounds(ty, bounds.predicates.clone());
1937 debug!("instantiate_anon_types: required_region_bounds={:?}",
1938 required_region_bounds);
1940 self.anon_types.borrow_mut().insert(def_id, AnonTypeDecl {
1942 concrete_ty: ty_var,
1943 required_region_bounds,
1945 debug!("instantiate_anon_types: ty_var={:?}", ty_var);
1947 for predicate in bounds.predicates {
1948 // Change the predicate to refer to the type variable,
1949 // which will be the concrete type, instead of the TyAnon.
1950 // This also instantiates nested `impl Trait`.
1951 let predicate = self.instantiate_anon_types(&predicate);
1953 // Require that the predicate holds for the concrete type.
1954 let cause = traits::ObligationCause::new(span,
1956 traits::SizedReturnType);
1958 debug!("instantiate_anon_types: predicate={:?}", predicate);
1959 self.register_predicate(traits::Obligation::new(cause,
1971 fn normalize_associated_types_in<T>(&self, span: Span, value: &T) -> T
1972 where T : TypeFoldable<'tcx>
1974 self.inh.normalize_associated_types_in(span, self.body_id, self.param_env, value)
1977 fn normalize_associated_types_in_as_infer_ok<T>(&self, span: Span, value: &T)
1979 where T : TypeFoldable<'tcx>
1981 self.inh.partially_normalize_associated_types_in(span,
1987 pub fn require_type_meets(&self,
1990 code: traits::ObligationCauseCode<'tcx>,
1993 self.register_bound(
1996 traits::ObligationCause::new(span, self.body_id, code));
1999 pub fn require_type_is_sized(&self,
2002 code: traits::ObligationCauseCode<'tcx>)
2004 let lang_item = self.tcx.require_lang_item(lang_items::SizedTraitLangItem);
2005 self.require_type_meets(ty, span, code, lang_item);
2008 pub fn register_bound(&self,
2011 cause: traits::ObligationCause<'tcx>)
2013 self.fulfillment_cx.borrow_mut()
2014 .register_bound(self, self.param_env, ty, def_id, cause);
2017 pub fn to_ty(&self, ast_t: &hir::Ty) -> Ty<'tcx> {
2018 let t = AstConv::ast_ty_to_ty(self, ast_t);
2019 self.register_wf_obligation(t, ast_t.span, traits::MiscObligation);
2023 pub fn node_ty(&self, id: hir::HirId) -> Ty<'tcx> {
2024 match self.tables.borrow().node_types().get(id) {
2026 None if self.is_tainted_by_errors() => self.tcx.types.err,
2028 let node_id = self.tcx.hir.definitions().find_node_for_hir_id(id);
2029 bug!("no type for node {}: {} in fcx {}",
2030 node_id, self.tcx.hir.node_to_string(node_id),
2036 /// Registers an obligation for checking later, during regionck, that the type `ty` must
2037 /// outlive the region `r`.
2038 pub fn register_wf_obligation(&self,
2041 code: traits::ObligationCauseCode<'tcx>)
2043 // WF obligations never themselves fail, so no real need to give a detailed cause:
2044 let cause = traits::ObligationCause::new(span, self.body_id, code);
2045 self.register_predicate(traits::Obligation::new(cause,
2047 ty::Predicate::WellFormed(ty)));
2050 /// Registers obligations that all types appearing in `substs` are well-formed.
2051 pub fn add_wf_bounds(&self, substs: &Substs<'tcx>, expr: &hir::Expr)
2053 for ty in substs.types() {
2054 self.register_wf_obligation(ty, expr.span, traits::MiscObligation);
2058 /// Given a fully substituted set of bounds (`generic_bounds`), and the values with which each
2059 /// type/region parameter was instantiated (`substs`), creates and registers suitable
2060 /// trait/region obligations.
2062 /// For example, if there is a function:
2065 /// fn foo<'a,T:'a>(...)
2068 /// and a reference:
2074 /// Then we will create a fresh region variable `'$0` and a fresh type variable `$1` for `'a`
2075 /// and `T`. This routine will add a region obligation `$1:'$0` and register it locally.
2076 pub fn add_obligations_for_parameters(&self,
2077 cause: traits::ObligationCause<'tcx>,
2078 predicates: &ty::InstantiatedPredicates<'tcx>)
2080 assert!(!predicates.has_escaping_regions());
2082 debug!("add_obligations_for_parameters(predicates={:?})",
2085 for obligation in traits::predicates_for_generics(cause, self.param_env, predicates) {
2086 self.register_predicate(obligation);
2090 // FIXME(arielb1): use this instead of field.ty everywhere
2091 // Only for fields! Returns <none> for methods>
2092 // Indifferent to privacy flags
2093 pub fn field_ty(&self,
2095 field: &'tcx ty::FieldDef,
2096 substs: &Substs<'tcx>)
2099 self.normalize_associated_types_in(span,
2100 &field.ty(self.tcx, substs))
2103 fn check_casts(&self) {
2104 let mut deferred_cast_checks = self.deferred_cast_checks.borrow_mut();
2105 for cast in deferred_cast_checks.drain(..) {
2110 fn resolve_generator_interiors(&self, def_id: DefId) {
2111 let mut deferred_generator_interiors = self.deferred_generator_interiors.borrow_mut();
2112 for (body_id, witness) in deferred_generator_interiors.drain(..) {
2113 generator_interior::resolve_interior(self, def_id, body_id, witness);
2117 /// Apply "fallbacks" to some types
2118 /// unconstrained types get replaced with ! or () (depending on whether
2119 /// feature(never_type) is enabled), unconstrained ints with i32, and
2120 /// unconstrained floats with f64.
2121 fn default_type_parameters(&self) {
2122 use rustc::ty::error::UnconstrainedNumeric::Neither;
2123 use rustc::ty::error::UnconstrainedNumeric::{UnconstrainedInt, UnconstrainedFloat};
2125 // Defaulting inference variables becomes very dubious if we have
2126 // encountered type-checking errors. Therefore, if we think we saw
2127 // some errors in this function, just resolve all uninstanted type
2128 // varibles to TyError.
2129 if self.is_tainted_by_errors() {
2130 for ty in &self.unsolved_variables() {
2131 if let ty::TyInfer(_) = self.shallow_resolve(ty).sty {
2132 debug!("default_type_parameters: defaulting `{:?}` to error", ty);
2133 self.demand_eqtype(syntax_pos::DUMMY_SP, *ty, self.tcx().types.err);
2139 for ty in &self.unsolved_variables() {
2140 let resolved = self.resolve_type_vars_if_possible(ty);
2141 if self.type_var_diverges(resolved) {
2142 debug!("default_type_parameters: defaulting `{:?}` to `!` because it diverges",
2144 self.demand_eqtype(syntax_pos::DUMMY_SP, *ty,
2145 self.tcx.mk_diverging_default());
2147 match self.type_is_unconstrained_numeric(resolved) {
2148 UnconstrainedInt => {
2149 debug!("default_type_parameters: defaulting `{:?}` to `i32`",
2151 self.demand_eqtype(syntax_pos::DUMMY_SP, *ty, self.tcx.types.i32)
2153 UnconstrainedFloat => {
2154 debug!("default_type_parameters: defaulting `{:?}` to `f32`",
2156 self.demand_eqtype(syntax_pos::DUMMY_SP, *ty, self.tcx.types.f64)
2164 // Implements type inference fallback algorithm
2165 fn select_all_obligations_and_apply_defaults(&self) {
2166 self.select_obligations_where_possible();
2167 self.default_type_parameters();
2168 self.select_obligations_where_possible();
2171 fn select_all_obligations_or_error(&self) {
2172 debug!("select_all_obligations_or_error");
2174 // upvar inference should have ensured that all deferred call
2175 // resolutions are handled by now.
2176 assert!(self.deferred_call_resolutions.borrow().is_empty());
2178 self.select_all_obligations_and_apply_defaults();
2180 let mut fulfillment_cx = self.fulfillment_cx.borrow_mut();
2182 match fulfillment_cx.select_all_or_error(self) {
2184 Err(errors) => { self.report_fulfillment_errors(&errors, self.inh.body_id); }
2188 /// Select as many obligations as we can at present.
2189 fn select_obligations_where_possible(&self) {
2190 match self.fulfillment_cx.borrow_mut().select_where_possible(self) {
2192 Err(errors) => { self.report_fulfillment_errors(&errors, self.inh.body_id); }
2196 /// For the overloaded lvalue expressions (`*x`, `x[3]`), the trait
2197 /// returns a type of `&T`, but the actual type we assign to the
2198 /// *expression* is `T`. So this function just peels off the return
2199 /// type by one layer to yield `T`.
2200 fn make_overloaded_lvalue_return_type(&self,
2201 method: MethodCallee<'tcx>)
2202 -> ty::TypeAndMut<'tcx>
2204 // extract method return type, which will be &T;
2205 let ret_ty = method.sig.output();
2207 // method returns &T, but the type as visible to user is T, so deref
2208 ret_ty.builtin_deref(true, NoPreference).unwrap()
2211 fn lookup_indexing(&self,
2213 base_expr: &'gcx hir::Expr,
2216 lvalue_pref: LvaluePreference)
2217 -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)>
2219 // FIXME(#18741) -- this is almost but not quite the same as the
2220 // autoderef that normal method probing does. They could likely be
2223 let mut autoderef = self.autoderef(base_expr.span, base_ty);
2224 let mut result = None;
2225 while result.is_none() && autoderef.next().is_some() {
2226 result = self.try_index_step(expr, base_expr, &autoderef, lvalue_pref, idx_ty);
2228 autoderef.finalize();
2232 /// To type-check `base_expr[index_expr]`, we progressively autoderef
2233 /// (and otherwise adjust) `base_expr`, looking for a type which either
2234 /// supports builtin indexing or overloaded indexing.
2235 /// This loop implements one step in that search; the autoderef loop
2236 /// is implemented by `lookup_indexing`.
2237 fn try_index_step(&self,
2239 base_expr: &hir::Expr,
2240 autoderef: &Autoderef<'a, 'gcx, 'tcx>,
2241 lvalue_pref: LvaluePreference,
2243 -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)>
2245 let adjusted_ty = autoderef.unambiguous_final_ty();
2246 debug!("try_index_step(expr={:?}, base_expr={:?}, adjusted_ty={:?}, \
2253 // First, try built-in indexing.
2254 match (adjusted_ty.builtin_index(), &index_ty.sty) {
2255 (Some(ty), &ty::TyUint(ast::UintTy::Us)) | (Some(ty), &ty::TyInfer(ty::IntVar(_))) => {
2256 debug!("try_index_step: success, using built-in indexing");
2257 let adjustments = autoderef.adjust_steps(lvalue_pref);
2258 self.apply_adjustments(base_expr, adjustments);
2259 return Some((self.tcx.types.usize, ty));
2264 for &unsize in &[false, true] {
2265 let mut self_ty = adjusted_ty;
2267 // We only unsize arrays here.
2268 if let ty::TyArray(element_ty, _) = adjusted_ty.sty {
2269 self_ty = self.tcx.mk_slice(element_ty);
2275 // If some lookup succeeds, write callee into table and extract index/element
2276 // type from the method signature.
2277 // If some lookup succeeded, install method in table
2278 let input_ty = self.next_ty_var(TypeVariableOrigin::AutoDeref(base_expr.span));
2279 let method = self.try_overloaded_lvalue_op(
2280 expr.span, self_ty, &[input_ty], lvalue_pref, LvalueOp::Index);
2282 let result = method.map(|ok| {
2283 debug!("try_index_step: success, using overloaded indexing");
2284 let method = self.register_infer_ok_obligations(ok);
2286 let mut adjustments = autoderef.adjust_steps(lvalue_pref);
2287 if let ty::TyRef(region, mt) = method.sig.inputs()[0].sty {
2288 adjustments.push(Adjustment {
2289 kind: Adjust::Borrow(AutoBorrow::Ref(region, mt.mutbl)),
2290 target: self.tcx.mk_ref(region, ty::TypeAndMut {
2297 adjustments.push(Adjustment {
2298 kind: Adjust::Unsize,
2299 target: method.sig.inputs()[0]
2302 self.apply_adjustments(base_expr, adjustments);
2304 self.write_method_call(expr.hir_id, method);
2305 (input_ty, self.make_overloaded_lvalue_return_type(method).ty)
2307 if result.is_some() {
2315 fn resolve_lvalue_op(&self, op: LvalueOp, is_mut: bool) -> (Option<DefId>, Symbol) {
2316 let (tr, name) = match (op, is_mut) {
2317 (LvalueOp::Deref, false) =>
2318 (self.tcx.lang_items().deref_trait(), "deref"),
2319 (LvalueOp::Deref, true) =>
2320 (self.tcx.lang_items().deref_mut_trait(), "deref_mut"),
2321 (LvalueOp::Index, false) =>
2322 (self.tcx.lang_items().index_trait(), "index"),
2323 (LvalueOp::Index, true) =>
2324 (self.tcx.lang_items().index_mut_trait(), "index_mut"),
2326 (tr, Symbol::intern(name))
2329 fn try_overloaded_lvalue_op(&self,
2332 arg_tys: &[Ty<'tcx>],
2333 lvalue_pref: LvaluePreference,
2335 -> Option<InferOk<'tcx, MethodCallee<'tcx>>>
2337 debug!("try_overloaded_lvalue_op({:?},{:?},{:?},{:?})",
2343 // Try Mut first, if preferred.
2344 let (mut_tr, mut_op) = self.resolve_lvalue_op(op, true);
2345 let method = match (lvalue_pref, mut_tr) {
2346 (PreferMutLvalue, Some(trait_did)) => {
2347 self.lookup_method_in_trait(span, mut_op, trait_did, base_ty, Some(arg_tys))
2352 // Otherwise, fall back to the immutable version.
2353 let (imm_tr, imm_op) = self.resolve_lvalue_op(op, false);
2354 let method = match (method, imm_tr) {
2355 (None, Some(trait_did)) => {
2356 self.lookup_method_in_trait(span, imm_op, trait_did, base_ty, Some(arg_tys))
2358 (method, _) => method,
2364 fn check_method_argument_types(&self,
2367 method: Result<MethodCallee<'tcx>, ()>,
2368 args_no_rcvr: &'gcx [hir::Expr],
2369 tuple_arguments: TupleArgumentsFlag,
2370 expected: Expectation<'tcx>)
2372 let has_error = match method {
2374 method.substs.references_error() || method.sig.references_error()
2379 let err_inputs = self.err_args(args_no_rcvr.len());
2381 let err_inputs = match tuple_arguments {
2382 DontTupleArguments => err_inputs,
2383 TupleArguments => vec![self.tcx.intern_tup(&err_inputs[..], false)],
2386 self.check_argument_types(sp, expr_sp, &err_inputs[..], &[], args_no_rcvr,
2387 false, tuple_arguments, None);
2388 return self.tcx.types.err;
2391 let method = method.unwrap();
2392 // HACK(eddyb) ignore self in the definition (see above).
2393 let expected_arg_tys = self.expected_inputs_for_expected_output(
2396 method.sig.output(),
2397 &method.sig.inputs()[1..]
2399 self.check_argument_types(sp, expr_sp, &method.sig.inputs()[1..], &expected_arg_tys[..],
2400 args_no_rcvr, method.sig.variadic, tuple_arguments,
2401 self.tcx.hir.span_if_local(method.def_id));
2405 /// Generic function that factors out common logic from function calls,
2406 /// method calls and overloaded operators.
2407 fn check_argument_types(&self,
2410 fn_inputs: &[Ty<'tcx>],
2411 expected_arg_tys: &[Ty<'tcx>],
2412 args: &'gcx [hir::Expr],
2414 tuple_arguments: TupleArgumentsFlag,
2415 def_span: Option<Span>) {
2418 // Grab the argument types, supplying fresh type variables
2419 // if the wrong number of arguments were supplied
2420 let supplied_arg_count = if tuple_arguments == DontTupleArguments {
2426 // All the input types from the fn signature must outlive the call
2427 // so as to validate implied bounds.
2428 for &fn_input_ty in fn_inputs {
2429 self.register_wf_obligation(fn_input_ty, sp, traits::MiscObligation);
2432 let mut expected_arg_tys = expected_arg_tys;
2433 let expected_arg_count = fn_inputs.len();
2435 let sp_args = if args.len() > 0 {
2436 let (first, args) = args.split_at(1);
2437 let mut sp_tmp = first[0].span;
2439 let sp_opt = self.sess().codemap().merge_spans(sp_tmp, arg.span);
2440 if ! sp_opt.is_some() {
2443 sp_tmp = sp_opt.unwrap();
2450 fn parameter_count_error<'tcx>(sess: &Session,
2453 expected_count: usize,
2457 def_span: Option<Span>,
2459 let mut err = sess.struct_span_err_with_code(sp,
2460 &format!("this function takes {}{} parameter{} but {} parameter{} supplied",
2461 if variadic {"at least "} else {""},
2463 if expected_count == 1 {""} else {"s"},
2465 if arg_count == 1 {" was"} else {"s were"}),
2466 DiagnosticId::Error(error_code.to_owned()));
2468 if let Some(def_s) = def_span {
2469 err.span_label(def_s, "defined here");
2472 let sugg_span = expr_sp.end_point();
2473 // remove closing `)` from the span
2474 let sugg_span = sugg_span.with_hi(sugg_span.lo());
2475 err.span_suggestion(
2477 "expected the unit value `()`; create it with empty parentheses",
2478 String::from("()"));
2480 err.span_label(sp, format!("expected {}{} parameter{}",
2481 if variadic {"at least "} else {""},
2483 if expected_count == 1 {""} else {"s"}));
2488 let formal_tys = if tuple_arguments == TupleArguments {
2489 let tuple_type = self.structurally_resolved_type(sp, fn_inputs[0]);
2490 match tuple_type.sty {
2491 ty::TyTuple(arg_types, _) if arg_types.len() != args.len() => {
2492 parameter_count_error(tcx.sess, sp_args, expr_sp, arg_types.len(), args.len(),
2493 "E0057", false, def_span, false);
2494 expected_arg_tys = &[];
2495 self.err_args(args.len())
2497 ty::TyTuple(arg_types, _) => {
2498 expected_arg_tys = match expected_arg_tys.get(0) {
2499 Some(&ty) => match ty.sty {
2500 ty::TyTuple(ref tys, _) => &tys,
2508 span_err!(tcx.sess, sp, E0059,
2509 "cannot use call notation; the first type parameter \
2510 for the function trait is neither a tuple nor unit");
2511 expected_arg_tys = &[];
2512 self.err_args(args.len())
2515 } else if expected_arg_count == supplied_arg_count {
2517 } else if variadic {
2518 if supplied_arg_count >= expected_arg_count {
2521 parameter_count_error(tcx.sess, sp_args, expr_sp, expected_arg_count,
2522 supplied_arg_count, "E0060", true, def_span, false);
2523 expected_arg_tys = &[];
2524 self.err_args(supplied_arg_count)
2527 // is the missing argument of type `()`?
2528 let sugg_unit = if expected_arg_tys.len() == 1 && supplied_arg_count == 0 {
2529 self.resolve_type_vars_if_possible(&expected_arg_tys[0]).is_nil()
2530 } else if fn_inputs.len() == 1 && supplied_arg_count == 0 {
2531 self.resolve_type_vars_if_possible(&fn_inputs[0]).is_nil()
2535 parameter_count_error(tcx.sess, sp_args, expr_sp, expected_arg_count,
2536 supplied_arg_count, "E0061", false, def_span, sugg_unit);
2537 expected_arg_tys = &[];
2538 self.err_args(supplied_arg_count)
2541 debug!("check_argument_types: formal_tys={:?}",
2542 formal_tys.iter().map(|t| self.ty_to_string(*t)).collect::<Vec<String>>());
2544 // Check the arguments.
2545 // We do this in a pretty awful way: first we typecheck any arguments
2546 // that are not closures, then we typecheck the closures. This is so
2547 // that we have more information about the types of arguments when we
2548 // typecheck the functions. This isn't really the right way to do this.
2549 for &check_closures in &[false, true] {
2550 debug!("check_closures={}", check_closures);
2552 // More awful hacks: before we check argument types, try to do
2553 // an "opportunistic" vtable resolution of any trait bounds on
2554 // the call. This helps coercions.
2556 self.select_obligations_where_possible();
2559 // For variadic functions, we don't have a declared type for all of
2560 // the arguments hence we only do our usual type checking with
2561 // the arguments who's types we do know.
2562 let t = if variadic {
2564 } else if tuple_arguments == TupleArguments {
2569 for (i, arg) in args.iter().take(t).enumerate() {
2570 // Warn only for the first loop (the "no closures" one).
2571 // Closure arguments themselves can't be diverging, but
2572 // a previous argument can, e.g. `foo(panic!(), || {})`.
2573 if !check_closures {
2574 self.warn_if_unreachable(arg.id, arg.span, "expression");
2577 let is_closure = match arg.node {
2578 hir::ExprClosure(..) => true,
2582 if is_closure != check_closures {
2586 debug!("checking the argument");
2587 let formal_ty = formal_tys[i];
2589 // The special-cased logic below has three functions:
2590 // 1. Provide as good of an expected type as possible.
2591 let expected = expected_arg_tys.get(i).map(|&ty| {
2592 Expectation::rvalue_hint(self, ty)
2595 let checked_ty = self.check_expr_with_expectation(
2597 expected.unwrap_or(ExpectHasType(formal_ty)));
2599 // 2. Coerce to the most detailed type that could be coerced
2600 // to, which is `expected_ty` if `rvalue_hint` returns an
2601 // `ExpectHasType(expected_ty)`, or the `formal_ty` otherwise.
2602 let coerce_ty = expected.and_then(|e| e.only_has_type(self));
2603 self.demand_coerce(&arg, checked_ty, coerce_ty.unwrap_or(formal_ty));
2605 // 3. Relate the expected type and the formal one,
2606 // if the expected type was used for the coercion.
2607 coerce_ty.map(|ty| self.demand_suptype(arg.span, formal_ty, ty));
2611 // We also need to make sure we at least write the ty of the other
2612 // arguments which we skipped above.
2614 fn variadic_error<'tcx>(s: &Session, span: Span, t: Ty<'tcx>, cast_ty: &str) {
2615 type_error_struct!(s, span, t, E0617,
2616 "can't pass `{}` to variadic function, cast to `{}`",
2620 for arg in args.iter().skip(expected_arg_count) {
2621 let arg_ty = self.check_expr(&arg);
2623 // There are a few types which get autopromoted when passed via varargs
2624 // in C but we just error out instead and require explicit casts.
2625 let arg_ty = self.structurally_resolved_type(arg.span, arg_ty);
2627 ty::TyFloat(ast::FloatTy::F32) => {
2628 variadic_error(tcx.sess, arg.span, arg_ty, "c_double");
2630 ty::TyInt(ast::IntTy::I8) | ty::TyInt(ast::IntTy::I16) | ty::TyBool => {
2631 variadic_error(tcx.sess, arg.span, arg_ty, "c_int");
2633 ty::TyUint(ast::UintTy::U8) | ty::TyUint(ast::UintTy::U16) => {
2634 variadic_error(tcx.sess, arg.span, arg_ty, "c_uint");
2636 ty::TyFnDef(..) => {
2637 let ptr_ty = self.tcx.mk_fn_ptr(arg_ty.fn_sig(self.tcx));
2638 let ptr_ty = self.resolve_type_vars_if_possible(&ptr_ty);
2639 variadic_error(tcx.sess, arg.span, arg_ty, &format!("{}", ptr_ty));
2647 fn err_args(&self, len: usize) -> Vec<Ty<'tcx>> {
2648 (0..len).map(|_| self.tcx.types.err).collect()
2651 // AST fragment checking
2654 expected: Expectation<'tcx>)
2660 ast::LitKind::Str(..) => tcx.mk_static_str(),
2661 ast::LitKind::ByteStr(ref v) => {
2662 tcx.mk_imm_ref(tcx.types.re_static,
2663 tcx.mk_array(tcx.types.u8, v.len() as u64))
2665 ast::LitKind::Byte(_) => tcx.types.u8,
2666 ast::LitKind::Char(_) => tcx.types.char,
2667 ast::LitKind::Int(_, ast::LitIntType::Signed(t)) => tcx.mk_mach_int(t),
2668 ast::LitKind::Int(_, ast::LitIntType::Unsigned(t)) => tcx.mk_mach_uint(t),
2669 ast::LitKind::Int(_, ast::LitIntType::Unsuffixed) => {
2670 let opt_ty = expected.to_option(self).and_then(|ty| {
2672 ty::TyInt(_) | ty::TyUint(_) => Some(ty),
2673 ty::TyChar => Some(tcx.types.u8),
2674 ty::TyRawPtr(..) => Some(tcx.types.usize),
2675 ty::TyFnDef(..) | ty::TyFnPtr(_) => Some(tcx.types.usize),
2679 opt_ty.unwrap_or_else(
2680 || tcx.mk_int_var(self.next_int_var_id()))
2682 ast::LitKind::Float(_, t) => tcx.mk_mach_float(t),
2683 ast::LitKind::FloatUnsuffixed(_) => {
2684 let opt_ty = expected.to_option(self).and_then(|ty| {
2686 ty::TyFloat(_) => Some(ty),
2690 opt_ty.unwrap_or_else(
2691 || tcx.mk_float_var(self.next_float_var_id()))
2693 ast::LitKind::Bool(_) => tcx.types.bool
2697 fn check_expr_eq_type(&self,
2698 expr: &'gcx hir::Expr,
2699 expected: Ty<'tcx>) {
2700 let ty = self.check_expr_with_hint(expr, expected);
2701 self.demand_eqtype(expr.span, expected, ty);
2704 pub fn check_expr_has_type_or_error(&self,
2705 expr: &'gcx hir::Expr,
2706 expected: Ty<'tcx>) -> Ty<'tcx> {
2707 self.check_expr_meets_expectation_or_error(expr, ExpectHasType(expected))
2710 fn check_expr_meets_expectation_or_error(&self,
2711 expr: &'gcx hir::Expr,
2712 expected: Expectation<'tcx>) -> Ty<'tcx> {
2713 let expected_ty = expected.to_option(&self).unwrap_or(self.tcx.types.bool);
2714 let mut ty = self.check_expr_with_expectation(expr, expected);
2716 // While we don't allow *arbitrary* coercions here, we *do* allow
2717 // coercions from ! to `expected`.
2719 assert!(!self.tables.borrow().adjustments().contains_key(expr.hir_id),
2720 "expression with never type wound up being adjusted");
2721 let adj_ty = self.next_diverging_ty_var(
2722 TypeVariableOrigin::AdjustmentType(expr.span));
2723 self.apply_adjustments(expr, vec![Adjustment {
2724 kind: Adjust::NeverToAny,
2730 if let Some(mut err) = self.demand_suptype_diag(expr.span, expected_ty, ty) {
2731 // Add help to type error if this is an `if` condition with an assignment
2732 match (expected, &expr.node) {
2733 (ExpectIfCondition, &hir::ExprAssign(ref lhs, ref rhs)) => {
2734 let msg = "try comparing for equality";
2735 if let (Ok(left), Ok(right)) = (
2736 self.tcx.sess.codemap().span_to_snippet(lhs.span),
2737 self.tcx.sess.codemap().span_to_snippet(rhs.span))
2739 err.span_suggestion(expr.span, msg, format!("{} == {}", left, right));
2751 fn check_expr_coercable_to_type(&self,
2752 expr: &'gcx hir::Expr,
2753 expected: Ty<'tcx>) -> Ty<'tcx> {
2754 self.check_expr_coercable_to_type_with_lvalue_pref(expr, expected, NoPreference)
2757 fn check_expr_coercable_to_type_with_lvalue_pref(&self,
2758 expr: &'gcx hir::Expr,
2760 lvalue_pref: LvaluePreference)
2762 let ty = self.check_expr_with_expectation_and_lvalue_pref(
2764 ExpectHasType(expected),
2766 self.demand_coerce(expr, ty, expected)
2769 fn check_expr_with_hint(&self, expr: &'gcx hir::Expr,
2770 expected: Ty<'tcx>) -> Ty<'tcx> {
2771 self.check_expr_with_expectation(expr, ExpectHasType(expected))
2774 fn check_expr_with_expectation(&self,
2775 expr: &'gcx hir::Expr,
2776 expected: Expectation<'tcx>) -> Ty<'tcx> {
2777 self.check_expr_with_expectation_and_lvalue_pref(expr, expected, NoPreference)
2780 fn check_expr(&self, expr: &'gcx hir::Expr) -> Ty<'tcx> {
2781 self.check_expr_with_expectation(expr, NoExpectation)
2784 fn check_expr_with_lvalue_pref(&self, expr: &'gcx hir::Expr,
2785 lvalue_pref: LvaluePreference) -> Ty<'tcx> {
2786 self.check_expr_with_expectation_and_lvalue_pref(expr, NoExpectation, lvalue_pref)
2789 // determine the `self` type, using fresh variables for all variables
2790 // declared on the impl declaration e.g., `impl<A,B> for Vec<(A,B)>`
2791 // would return ($0, $1) where $0 and $1 are freshly instantiated type
2793 pub fn impl_self_ty(&self,
2794 span: Span, // (potential) receiver for this impl
2796 -> TypeAndSubsts<'tcx> {
2797 let ity = self.tcx.type_of(did);
2798 debug!("impl_self_ty: ity={:?}", ity);
2800 let substs = self.fresh_substs_for_item(span, did);
2801 let substd_ty = self.instantiate_type_scheme(span, &substs, &ity);
2803 TypeAndSubsts { substs: substs, ty: substd_ty }
2806 /// Unifies the output type with the expected type early, for more coercions
2807 /// and forward type information on the input expressions.
2808 fn expected_inputs_for_expected_output(&self,
2810 expected_ret: Expectation<'tcx>,
2811 formal_ret: Ty<'tcx>,
2812 formal_args: &[Ty<'tcx>])
2814 let formal_ret = self.resolve_type_vars_with_obligations(formal_ret);
2815 let expected_args = expected_ret.only_has_type(self).and_then(|ret_ty| {
2816 self.fudge_regions_if_ok(&RegionVariableOrigin::Coercion(call_span), || {
2817 // Attempt to apply a subtyping relationship between the formal
2818 // return type (likely containing type variables if the function
2819 // is polymorphic) and the expected return type.
2820 // No argument expectations are produced if unification fails.
2821 let origin = self.misc(call_span);
2822 let ures = self.at(&origin, self.param_env).sup(ret_ty, formal_ret);
2824 // FIXME(#15760) can't use try! here, FromError doesn't default
2825 // to identity so the resulting type is not constrained.
2828 // Process any obligations locally as much as
2829 // we can. We don't care if some things turn
2830 // out unconstrained or ambiguous, as we're
2831 // just trying to get hints here.
2832 let result = self.save_and_restore_in_snapshot_flag(|_| {
2833 let mut fulfill = FulfillmentContext::new();
2834 let ok = ok; // FIXME(#30046)
2835 for obligation in ok.obligations {
2836 fulfill.register_predicate_obligation(self, obligation);
2838 fulfill.select_where_possible(self)
2843 Err(_) => return Err(()),
2846 Err(_) => return Err(()),
2849 // Record all the argument types, with the substitutions
2850 // produced from the above subtyping unification.
2851 Ok(formal_args.iter().map(|ty| {
2852 self.resolve_type_vars_if_possible(ty)
2855 }).unwrap_or(vec![]);
2856 debug!("expected_inputs_for_expected_output(formal={:?} -> {:?}, expected={:?} -> {:?})",
2857 formal_args, formal_ret,
2858 expected_args, expected_ret);
2862 // Checks a method call.
2863 fn check_method_call(&self,
2864 expr: &'gcx hir::Expr,
2865 segment: &hir::PathSegment,
2867 args: &'gcx [hir::Expr],
2868 expected: Expectation<'tcx>,
2869 lvalue_pref: LvaluePreference) -> Ty<'tcx> {
2870 let rcvr = &args[0];
2871 let rcvr_t = self.check_expr_with_lvalue_pref(&rcvr, lvalue_pref);
2872 // no need to check for bot/err -- callee does that
2873 let rcvr_t = self.structurally_resolved_type(expr.span, rcvr_t);
2875 let method = match self.lookup_method(rcvr_t,
2881 self.write_method_call(expr.hir_id, method);
2885 if segment.name != keywords::Invalid.name() {
2886 self.report_method_error(span,
2897 // Call the generic checker.
2898 self.check_method_argument_types(span,
2906 fn check_return_expr(&self, return_expr: &'gcx hir::Expr) {
2910 .unwrap_or_else(|| span_bug!(return_expr.span,
2911 "check_return_expr called outside fn body"));
2913 let ret_ty = ret_coercion.borrow().expected_ty();
2914 let return_expr_ty = self.check_expr_with_hint(return_expr, ret_ty.clone());
2915 ret_coercion.borrow_mut()
2917 &self.cause(return_expr.span,
2918 ObligationCauseCode::ReturnType(return_expr.id)),
2921 self.diverges.get());
2925 // A generic function for checking the then and else in an if
2927 fn check_then_else(&self,
2928 cond_expr: &'gcx hir::Expr,
2929 then_expr: &'gcx hir::Expr,
2930 opt_else_expr: Option<&'gcx hir::Expr>,
2932 expected: Expectation<'tcx>) -> Ty<'tcx> {
2933 let cond_ty = self.check_expr_meets_expectation_or_error(cond_expr, ExpectIfCondition);
2934 let cond_diverges = self.diverges.get();
2935 self.diverges.set(Diverges::Maybe);
2937 let expected = expected.adjust_for_branches(self);
2938 let then_ty = self.check_expr_with_expectation(then_expr, expected);
2939 let then_diverges = self.diverges.get();
2940 self.diverges.set(Diverges::Maybe);
2942 // We've already taken the expected type's preferences
2943 // into account when typing the `then` branch. To figure
2944 // out the initial shot at a LUB, we thus only consider
2945 // `expected` if it represents a *hard* constraint
2946 // (`only_has_type`); otherwise, we just go with a
2947 // fresh type variable.
2948 let coerce_to_ty = expected.coercion_target_type(self, sp);
2949 let mut coerce: DynamicCoerceMany = CoerceMany::new(coerce_to_ty);
2951 let if_cause = self.cause(sp, ObligationCauseCode::IfExpression);
2952 coerce.coerce(self, &if_cause, then_expr, then_ty, then_diverges);
2954 if let Some(else_expr) = opt_else_expr {
2955 let else_ty = self.check_expr_with_expectation(else_expr, expected);
2956 let else_diverges = self.diverges.get();
2958 coerce.coerce(self, &if_cause, else_expr, else_ty, else_diverges);
2960 // We won't diverge unless both branches do (or the condition does).
2961 self.diverges.set(cond_diverges | then_diverges & else_diverges);
2963 let else_cause = self.cause(sp, ObligationCauseCode::IfExpressionWithNoElse);
2964 coerce.coerce_forced_unit(self, &else_cause, &mut |_| (), true);
2966 // If the condition is false we can't diverge.
2967 self.diverges.set(cond_diverges);
2970 let result_ty = coerce.complete(self);
2971 if cond_ty.references_error() {
2978 // Check field access expressions
2979 fn check_field(&self,
2980 expr: &'gcx hir::Expr,
2981 lvalue_pref: LvaluePreference,
2982 base: &'gcx hir::Expr,
2983 field: &Spanned<ast::Name>) -> Ty<'tcx> {
2984 let expr_t = self.check_expr_with_lvalue_pref(base, lvalue_pref);
2985 let expr_t = self.structurally_resolved_type(expr.span,
2987 let mut private_candidate = None;
2988 let mut autoderef = self.autoderef(expr.span, expr_t);
2989 while let Some((base_t, _)) = autoderef.next() {
2991 ty::TyAdt(base_def, substs) if !base_def.is_enum() => {
2992 debug!("struct named {:?}", base_t);
2993 let (ident, def_scope) =
2994 self.tcx.adjust(field.node, base_def.did, self.body_id);
2995 let fields = &base_def.struct_variant().fields;
2996 if let Some(field) = fields.iter().find(|f| f.name.to_ident() == ident) {
2997 let field_ty = self.field_ty(expr.span, field, substs);
2998 if field.vis.is_accessible_from(def_scope, self.tcx) {
2999 let adjustments = autoderef.adjust_steps(lvalue_pref);
3000 self.apply_adjustments(base, adjustments);
3001 autoderef.finalize();
3003 self.tcx.check_stability(field.did, expr.id, expr.span);
3007 private_candidate = Some((base_def.did, field_ty));
3013 autoderef.unambiguous_final_ty();
3015 if let Some((did, field_ty)) = private_candidate {
3016 let struct_path = self.tcx().item_path_str(did);
3017 let mut err = struct_span_err!(self.tcx().sess, expr.span, E0616,
3018 "field `{}` of struct `{}` is private",
3019 field.node, struct_path);
3020 // Also check if an accessible method exists, which is often what is meant.
3021 if self.method_exists(field.span, field.node, expr_t, expr.id, false) {
3022 err.note(&format!("a method `{}` also exists, perhaps you wish to call it",
3027 } else if field.node == keywords::Invalid.name() {
3028 self.tcx().types.err
3029 } else if self.method_exists(field.span, field.node, expr_t, expr.id, true) {
3030 type_error_struct!(self.tcx().sess, field.span, expr_t, E0615,
3031 "attempted to take value of method `{}` on type `{}`",
3033 .help("maybe a `()` to call it is missing?")
3035 self.tcx().types.err
3037 if !expr_t.is_primitive_ty() {
3038 let mut err = self.no_such_field_err(field.span, &field.node, expr_t);
3041 ty::TyAdt(def, _) if !def.is_enum() => {
3042 if let Some(suggested_field_name) =
3043 Self::suggest_field_name(def.struct_variant(), field, vec![]) {
3044 err.span_label(field.span,
3045 format!("did you mean `{}`?", suggested_field_name));
3047 err.span_label(field.span, "unknown field");
3048 let struct_variant_def = def.struct_variant();
3049 let field_names = self.available_field_names(struct_variant_def);
3050 if !field_names.is_empty() {
3051 err.note(&format!("available fields are: {}",
3052 self.name_series_display(field_names)));
3056 ty::TyRawPtr(..) => {
3057 err.note(&format!("`{0}` is a native pointer; perhaps you need to deref \
3059 self.tcx.hir.node_to_pretty_string(base.id),
3066 type_error_struct!(self.tcx().sess, field.span, expr_t, E0610,
3067 "`{}` is a primitive type and therefore doesn't have fields",
3070 self.tcx().types.err
3074 // Return an hint about the closest match in field names
3075 fn suggest_field_name(variant: &'tcx ty::VariantDef,
3076 field: &Spanned<ast::Name>,
3077 skip: Vec<InternedString>)
3079 let name = field.node.as_str();
3080 let names = variant.fields.iter().filter_map(|field| {
3081 // ignore already set fields and private fields from non-local crates
3082 if skip.iter().any(|x| *x == field.name.as_str()) ||
3083 (variant.did.krate != LOCAL_CRATE && field.vis != Visibility::Public) {
3090 find_best_match_for_name(names, &name, None)
3093 fn available_field_names(&self, variant: &'tcx ty::VariantDef) -> Vec<ast::Name> {
3094 let mut available = Vec::new();
3095 for field in variant.fields.iter() {
3096 let (_, def_scope) = self.tcx.adjust(field.name, variant.did, self.body_id);
3097 if field.vis.is_accessible_from(def_scope, self.tcx) {
3098 available.push(field.name);
3104 fn name_series_display(&self, names: Vec<ast::Name>) -> String {
3105 // dynamic limit, to never omit just one field
3106 let limit = if names.len() == 6 { 6 } else { 5 };
3107 let mut display = names.iter().take(limit)
3108 .map(|n| format!("`{}`", n)).collect::<Vec<_>>().join(", ");
3109 if names.len() > limit {
3110 display = format!("{} ... and {} others", display, names.len() - limit);
3115 // Check tuple index expressions
3116 fn check_tup_field(&self,
3117 expr: &'gcx hir::Expr,
3118 lvalue_pref: LvaluePreference,
3119 base: &'gcx hir::Expr,
3120 idx: codemap::Spanned<usize>) -> Ty<'tcx> {
3121 let expr_t = self.check_expr_with_lvalue_pref(base, lvalue_pref);
3122 let expr_t = self.structurally_resolved_type(expr.span,
3124 let mut private_candidate = None;
3125 let mut tuple_like = false;
3126 let mut autoderef = self.autoderef(expr.span, expr_t);
3127 while let Some((base_t, _)) = autoderef.next() {
3128 let field = match base_t.sty {
3129 ty::TyAdt(base_def, substs) if base_def.is_struct() => {
3130 tuple_like = base_def.struct_variant().ctor_kind == CtorKind::Fn;
3131 if !tuple_like { continue }
3133 debug!("tuple struct named {:?}", base_t);
3134 let ident = ast::Ident {
3135 name: Symbol::intern(&idx.node.to_string()),
3136 ctxt: idx.span.ctxt().modern(),
3138 let (ident, def_scope) =
3139 self.tcx.adjust_ident(ident, base_def.did, self.body_id);
3140 let fields = &base_def.struct_variant().fields;
3141 if let Some(field) = fields.iter().find(|f| f.name.to_ident() == ident) {
3142 let field_ty = self.field_ty(expr.span, field, substs);
3143 if field.vis.is_accessible_from(def_scope, self.tcx) {
3144 self.tcx.check_stability(field.did, expr.id, expr.span);
3147 private_candidate = Some((base_def.did, field_ty));
3154 ty::TyTuple(ref v, _) => {
3156 v.get(idx.node).cloned()
3161 if let Some(field_ty) = field {
3162 let adjustments = autoderef.adjust_steps(lvalue_pref);
3163 self.apply_adjustments(base, adjustments);
3164 autoderef.finalize();
3168 autoderef.unambiguous_final_ty();
3170 if let Some((did, field_ty)) = private_candidate {
3171 let struct_path = self.tcx().item_path_str(did);
3172 struct_span_err!(self.tcx().sess, expr.span, E0611,
3173 "field `{}` of tuple-struct `{}` is private",
3174 idx.node, struct_path).emit();
3179 type_error_struct!(self.tcx().sess, expr.span, expr_t, E0612,
3180 "attempted out-of-bounds tuple index `{}` on type `{}`",
3181 idx.node, expr_t).emit();
3183 self.no_such_field_err(expr.span, idx.node, expr_t).emit();
3186 self.tcx().types.err
3189 fn no_such_field_err<T: Display>(&self, span: Span, field: T, expr_t: &ty::TyS)
3190 -> DiagnosticBuilder {
3191 type_error_struct!(self.tcx().sess, span, expr_t, E0609,
3192 "no field `{}` on type `{}`",
3196 fn report_unknown_field(&self,
3198 variant: &'tcx ty::VariantDef,
3200 skip_fields: &[hir::Field],
3202 let mut err = self.type_error_struct_with_diag(
3204 |actual| match ty.sty {
3205 ty::TyAdt(adt, ..) if adt.is_enum() => {
3206 struct_span_err!(self.tcx.sess, field.name.span, E0559,
3207 "{} `{}::{}` has no field named `{}`",
3208 kind_name, actual, variant.name, field.name.node)
3211 struct_span_err!(self.tcx.sess, field.name.span, E0560,
3212 "{} `{}` has no field named `{}`",
3213 kind_name, actual, field.name.node)
3217 // prevent all specified fields from being suggested
3218 let skip_fields = skip_fields.iter().map(|ref x| x.name.node.as_str());
3219 if let Some(field_name) = Self::suggest_field_name(variant,
3221 skip_fields.collect()) {
3222 err.span_label(field.name.span,
3223 format!("field does not exist - did you mean `{}`?", field_name));
3226 ty::TyAdt(adt, ..) => {
3228 err.span_label(field.name.span,
3229 format!("`{}::{}` does not have this field",
3232 err.span_label(field.name.span,
3233 format!("`{}` does not have this field", ty));
3235 let available_field_names = self.available_field_names(variant);
3236 if !available_field_names.is_empty() {
3237 err.note(&format!("available fields are: {}",
3238 self.name_series_display(available_field_names)));
3241 _ => bug!("non-ADT passed to report_unknown_field")
3247 fn check_expr_struct_fields(&self,
3249 expected: Expectation<'tcx>,
3250 expr_id: ast::NodeId,
3252 variant: &'tcx ty::VariantDef,
3253 ast_fields: &'gcx [hir::Field],
3254 check_completeness: bool) {
3258 self.expected_inputs_for_expected_output(span, expected, adt_ty, &[adt_ty])
3259 .get(0).cloned().unwrap_or(adt_ty);
3260 // re-link the regions that EIfEO can erase.
3261 self.demand_eqtype(span, adt_ty_hint, adt_ty);
3263 let (substs, adt_kind, kind_name) = match &adt_ty.sty{
3264 &ty::TyAdt(adt, substs) => {
3265 (substs, adt.adt_kind(), adt.variant_descr())
3267 _ => span_bug!(span, "non-ADT passed to check_expr_struct_fields")
3270 let mut remaining_fields = FxHashMap();
3271 for field in &variant.fields {
3272 remaining_fields.insert(field.name.to_ident(), field);
3275 let mut seen_fields = FxHashMap();
3277 let mut error_happened = false;
3279 // Typecheck each field.
3280 for field in ast_fields {
3281 let ident = tcx.adjust(field.name.node, variant.did, self.body_id).0;
3282 let field_type = if let Some(v_field) = remaining_fields.remove(&ident) {
3283 seen_fields.insert(field.name.node, field.span);
3285 // we don't look at stability attributes on
3286 // struct-like enums (yet...), but it's definitely not
3287 // a bug to have construct one.
3288 if adt_kind != ty::AdtKind::Enum {
3289 tcx.check_stability(v_field.did, expr_id, field.span);
3292 self.field_ty(field.span, v_field, substs)
3294 error_happened = true;
3295 if let Some(_) = variant.find_field_named(field.name.node) {
3296 let mut err = struct_span_err!(self.tcx.sess,
3299 "field `{}` specified more than once",
3302 err.span_label(field.name.span, "used more than once");
3304 if let Some(prev_span) = seen_fields.get(&field.name.node) {
3305 err.span_label(*prev_span, format!("first use of `{}`", field.name.node));
3310 self.report_unknown_field(adt_ty, variant, field, ast_fields, kind_name);
3316 // Make sure to give a type to the field even if there's
3317 // an error, so we can continue typechecking
3318 self.check_expr_coercable_to_type(&field.expr, field_type);
3321 // Make sure the programmer specified correct number of fields.
3322 if kind_name == "union" {
3323 if ast_fields.len() != 1 {
3324 tcx.sess.span_err(span, "union expressions should have exactly one field");
3326 } else if check_completeness && !error_happened && !remaining_fields.is_empty() {
3327 let len = remaining_fields.len();
3329 let mut displayable_field_names = remaining_fields
3331 .map(|ident| ident.name.as_str())
3332 .collect::<Vec<_>>();
3334 displayable_field_names.sort();
3336 let truncated_fields_error = if len <= 3 {
3339 format!(" and {} other field{}", (len - 3), if len - 3 == 1 {""} else {"s"})
3342 let remaining_fields_names = displayable_field_names.iter().take(3)
3343 .map(|n| format!("`{}`", n))
3344 .collect::<Vec<_>>()
3347 struct_span_err!(tcx.sess, span, E0063,
3348 "missing field{} {}{} in initializer of `{}`",
3349 if remaining_fields.len() == 1 { "" } else { "s" },
3350 remaining_fields_names,
3351 truncated_fields_error,
3353 .span_label(span, format!("missing {}{}",
3354 remaining_fields_names,
3355 truncated_fields_error))
3360 fn check_struct_fields_on_error(&self,
3361 fields: &'gcx [hir::Field],
3362 base_expr: &'gcx Option<P<hir::Expr>>) {
3363 for field in fields {
3364 self.check_expr(&field.expr);
3368 self.check_expr(&base);
3374 pub fn check_struct_path(&self,
3376 node_id: ast::NodeId)
3377 -> Option<(&'tcx ty::VariantDef, Ty<'tcx>)> {
3378 let path_span = match *qpath {
3379 hir::QPath::Resolved(_, ref path) => path.span,
3380 hir::QPath::TypeRelative(ref qself, _) => qself.span
3382 let (def, ty) = self.finish_resolving_struct_path(qpath, path_span, node_id);
3383 let variant = match def {
3385 self.set_tainted_by_errors();
3388 Def::Variant(..) => {
3390 ty::TyAdt(adt, substs) => {
3391 Some((adt.variant_of_def(def), adt.did, substs))
3393 _ => bug!("unexpected type: {:?}", ty.sty)
3396 Def::Struct(..) | Def::Union(..) | Def::TyAlias(..) |
3397 Def::AssociatedTy(..) | Def::SelfTy(..) => {
3399 ty::TyAdt(adt, substs) if !adt.is_enum() => {
3400 Some((adt.struct_variant(), adt.did, substs))
3405 _ => bug!("unexpected definition: {:?}", def)
3408 if let Some((variant, did, substs)) = variant {
3409 // Check bounds on type arguments used in the path.
3410 let bounds = self.instantiate_bounds(path_span, did, substs);
3411 let cause = traits::ObligationCause::new(path_span, self.body_id,
3412 traits::ItemObligation(did));
3413 self.add_obligations_for_parameters(cause, &bounds);
3417 struct_span_err!(self.tcx.sess, path_span, E0071,
3418 "expected struct, variant or union type, found {}",
3419 ty.sort_string(self.tcx))
3420 .span_label(path_span, "not a struct")
3426 fn check_expr_struct(&self,
3428 expected: Expectation<'tcx>,
3430 fields: &'gcx [hir::Field],
3431 base_expr: &'gcx Option<P<hir::Expr>>) -> Ty<'tcx>
3433 // Find the relevant variant
3434 let (variant, struct_ty) =
3435 if let Some(variant_ty) = self.check_struct_path(qpath, expr.id) {
3438 self.check_struct_fields_on_error(fields, base_expr);
3439 return self.tcx.types.err;
3442 let path_span = match *qpath {
3443 hir::QPath::Resolved(_, ref path) => path.span,
3444 hir::QPath::TypeRelative(ref qself, _) => qself.span
3447 // Prohibit struct expressions when non exhaustive flag is set.
3448 if let ty::TyAdt(adt, _) = struct_ty.sty {
3449 if !adt.did.is_local() && adt.is_non_exhaustive() {
3450 span_err!(self.tcx.sess, expr.span, E0639,
3451 "cannot create non-exhaustive {} using struct expression",
3452 adt.variant_descr());
3456 self.check_expr_struct_fields(struct_ty, expected, expr.id, path_span, variant, fields,
3457 base_expr.is_none());
3458 if let &Some(ref base_expr) = base_expr {
3459 self.check_expr_has_type_or_error(base_expr, struct_ty);
3460 match struct_ty.sty {
3461 ty::TyAdt(adt, substs) if adt.is_struct() => {
3462 let fru_field_types = adt.struct_variant().fields.iter().map(|f| {
3463 self.normalize_associated_types_in(expr.span, &f.ty(self.tcx, substs))
3468 .fru_field_types_mut()
3469 .insert(expr.hir_id, fru_field_types);
3472 span_err!(self.tcx.sess, base_expr.span, E0436,
3473 "functional record update syntax requires a struct");
3477 self.require_type_is_sized(struct_ty, expr.span, traits::StructInitializerSized);
3483 /// If an expression has any sub-expressions that result in a type error,
3484 /// inspecting that expression's type with `ty.references_error()` will return
3485 /// true. Likewise, if an expression is known to diverge, inspecting its
3486 /// type with `ty::type_is_bot` will return true (n.b.: since Rust is
3487 /// strict, _|_ can appear in the type of an expression that does not,
3488 /// itself, diverge: for example, fn() -> _|_.)
3489 /// Note that inspecting a type's structure *directly* may expose the fact
3490 /// that there are actually multiple representations for `TyError`, so avoid
3491 /// that when err needs to be handled differently.
3492 fn check_expr_with_expectation_and_lvalue_pref(&self,
3493 expr: &'gcx hir::Expr,
3494 expected: Expectation<'tcx>,
3495 lvalue_pref: LvaluePreference) -> Ty<'tcx> {
3496 debug!(">> typechecking: expr={:?} expected={:?}",
3499 // Warn for expressions after diverging siblings.
3500 self.warn_if_unreachable(expr.id, expr.span, "expression");
3502 // Hide the outer diverging and has_errors flags.
3503 let old_diverges = self.diverges.get();
3504 let old_has_errors = self.has_errors.get();
3505 self.diverges.set(Diverges::Maybe);
3506 self.has_errors.set(false);
3508 let ty = self.check_expr_kind(expr, expected, lvalue_pref);
3510 // Warn for non-block expressions with diverging children.
3513 hir::ExprLoop(..) | hir::ExprWhile(..) |
3514 hir::ExprIf(..) | hir::ExprMatch(..) => {}
3516 _ => self.warn_if_unreachable(expr.id, expr.span, "expression")
3519 // Any expression that produces a value of type `!` must have diverged
3521 self.diverges.set(self.diverges.get() | Diverges::Always);
3524 // Record the type, which applies it effects.
3525 // We need to do this after the warning above, so that
3526 // we don't warn for the diverging expression itself.
3527 self.write_ty(expr.hir_id, ty);
3529 // Combine the diverging and has_error flags.
3530 self.diverges.set(self.diverges.get() | old_diverges);
3531 self.has_errors.set(self.has_errors.get() | old_has_errors);
3533 debug!("type of {} is...", self.tcx.hir.node_to_string(expr.id));
3534 debug!("... {:?}, expected is {:?}", ty, expected);
3539 fn check_expr_kind(&self,
3540 expr: &'gcx hir::Expr,
3541 expected: Expectation<'tcx>,
3542 lvalue_pref: LvaluePreference) -> Ty<'tcx> {
3546 hir::ExprBox(ref subexpr) => {
3547 let expected_inner = expected.to_option(self).map_or(NoExpectation, |ty| {
3549 ty::TyAdt(def, _) if def.is_box()
3550 => Expectation::rvalue_hint(self, ty.boxed_ty()),
3554 let referent_ty = self.check_expr_with_expectation(subexpr, expected_inner);
3555 tcx.mk_box(referent_ty)
3558 hir::ExprLit(ref lit) => {
3559 self.check_lit(&lit, expected)
3561 hir::ExprBinary(op, ref lhs, ref rhs) => {
3562 self.check_binop(expr, op, lhs, rhs)
3564 hir::ExprAssignOp(op, ref lhs, ref rhs) => {
3565 self.check_binop_assign(expr, op, lhs, rhs)
3567 hir::ExprUnary(unop, ref oprnd) => {
3568 let expected_inner = match unop {
3569 hir::UnNot | hir::UnNeg => {
3576 let lvalue_pref = match unop {
3577 hir::UnDeref => lvalue_pref,
3580 let mut oprnd_t = self.check_expr_with_expectation_and_lvalue_pref(&oprnd,
3584 if !oprnd_t.references_error() {
3585 oprnd_t = self.structurally_resolved_type(expr.span, oprnd_t);
3588 if let Some(mt) = oprnd_t.builtin_deref(true, NoPreference) {
3590 } else if let Some(ok) = self.try_overloaded_deref(
3591 expr.span, oprnd_t, lvalue_pref) {
3592 let method = self.register_infer_ok_obligations(ok);
3593 if let ty::TyRef(region, mt) = method.sig.inputs()[0].sty {
3594 self.apply_adjustments(oprnd, vec![Adjustment {
3595 kind: Adjust::Borrow(AutoBorrow::Ref(region, mt.mutbl)),
3596 target: method.sig.inputs()[0]
3599 oprnd_t = self.make_overloaded_lvalue_return_type(method).ty;
3600 self.write_method_call(expr.hir_id, method);
3602 type_error_struct!(tcx.sess, expr.span, oprnd_t, E0614,
3603 "type `{}` cannot be dereferenced",
3605 oprnd_t = tcx.types.err;
3609 let result = self.check_user_unop(expr, oprnd_t, unop);
3610 // If it's builtin, we can reuse the type, this helps inference.
3611 if !(oprnd_t.is_integral() || oprnd_t.sty == ty::TyBool) {
3616 let result = self.check_user_unop(expr, oprnd_t, unop);
3617 // If it's builtin, we can reuse the type, this helps inference.
3618 if !(oprnd_t.is_integral() || oprnd_t.is_fp()) {
3626 hir::ExprAddrOf(mutbl, ref oprnd) => {
3627 let hint = expected.only_has_type(self).map_or(NoExpectation, |ty| {
3629 ty::TyRef(_, ref mt) | ty::TyRawPtr(ref mt) => {
3630 if self.tcx.expr_is_lval(&oprnd) {
3631 // Lvalues may legitimately have unsized types.
3632 // For example, dereferences of a fat pointer and
3633 // the last field of a struct can be unsized.
3634 ExpectHasType(mt.ty)
3636 Expectation::rvalue_hint(self, mt.ty)
3642 let lvalue_pref = LvaluePreference::from_mutbl(mutbl);
3643 let ty = self.check_expr_with_expectation_and_lvalue_pref(&oprnd, hint, lvalue_pref);
3645 let tm = ty::TypeAndMut { ty: ty, mutbl: mutbl };
3646 if tm.ty.references_error() {
3649 // Note: at this point, we cannot say what the best lifetime
3650 // is to use for resulting pointer. We want to use the
3651 // shortest lifetime possible so as to avoid spurious borrowck
3652 // errors. Moreover, the longest lifetime will depend on the
3653 // precise details of the value whose address is being taken
3654 // (and how long it is valid), which we don't know yet until type
3655 // inference is complete.
3657 // Therefore, here we simply generate a region variable. The
3658 // region inferencer will then select the ultimate value.
3659 // Finally, borrowck is charged with guaranteeing that the
3660 // value whose address was taken can actually be made to live
3661 // as long as it needs to live.
3662 let region = self.next_region_var(infer::AddrOfRegion(expr.span));
3663 tcx.mk_ref(region, tm)
3666 hir::ExprPath(ref qpath) => {
3667 let (def, opt_ty, segments) = self.resolve_ty_and_def_ufcs(qpath,
3668 expr.id, expr.span);
3669 let ty = if def != Def::Err {
3670 self.instantiate_value_path(segments, opt_ty, def, expr.span, id)
3672 self.set_tainted_by_errors();
3676 // We always require that the type provided as the value for
3677 // a type parameter outlives the moment of instantiation.
3678 let substs = self.tables.borrow().node_substs(expr.hir_id);
3679 self.add_wf_bounds(substs, expr);
3683 hir::ExprInlineAsm(_, ref outputs, ref inputs) => {
3684 for output in outputs {
3685 self.check_expr(output);
3687 for input in inputs {
3688 self.check_expr(input);
3692 hir::ExprBreak(destination, ref expr_opt) => {
3693 if let Some(target_id) = destination.target_id.opt_id() {
3694 let (e_ty, e_diverges, cause);
3695 if let Some(ref e) = *expr_opt {
3696 // If this is a break with a value, we need to type-check
3697 // the expression. Get an expected type from the loop context.
3698 let opt_coerce_to = {
3699 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
3700 enclosing_breakables.find_breakable(target_id)
3703 .map(|coerce| coerce.expected_ty())
3706 // If the loop context is not a `loop { }`, then break with
3707 // a value is illegal, and `opt_coerce_to` will be `None`.
3708 // Just set expectation to error in that case.
3709 let coerce_to = opt_coerce_to.unwrap_or(tcx.types.err);
3711 // Recurse without `enclosing_breakables` borrowed.
3712 e_ty = self.check_expr_with_hint(e, coerce_to);
3713 e_diverges = self.diverges.get();
3714 cause = self.misc(e.span);
3716 // Otherwise, this is a break *without* a value. That's
3717 // always legal, and is equivalent to `break ()`.
3718 e_ty = tcx.mk_nil();
3719 e_diverges = Diverges::Maybe;
3720 cause = self.misc(expr.span);
3723 // Now that we have type-checked `expr_opt`, borrow
3724 // the `enclosing_loops` field and let's coerce the
3725 // type of `expr_opt` into what is expected.
3726 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
3727 let ctxt = enclosing_breakables.find_breakable(target_id);
3728 if let Some(ref mut coerce) = ctxt.coerce {
3729 if let Some(ref e) = *expr_opt {
3730 coerce.coerce(self, &cause, e, e_ty, e_diverges);
3732 assert!(e_ty.is_nil());
3733 coerce.coerce_forced_unit(self, &cause, &mut |_| (), true);
3736 // If `ctxt.coerce` is `None`, we can just ignore
3737 // the type of the expresison. This is because
3738 // either this was a break *without* a value, in
3739 // which case it is always a legal type (`()`), or
3740 // else an error would have been flagged by the
3741 // `loops` pass for using break with an expression
3742 // where you are not supposed to.
3743 assert!(expr_opt.is_none() || self.tcx.sess.err_count() > 0);
3746 ctxt.may_break = true;
3748 // Otherwise, we failed to find the enclosing loop;
3749 // this can only happen if the `break` was not
3750 // inside a loop at all, which is caught by the
3751 // loop-checking pass.
3752 assert!(self.tcx.sess.err_count() > 0);
3754 // We still need to assign a type to the inner expression to
3755 // prevent the ICE in #43162.
3756 if let Some(ref e) = *expr_opt {
3757 self.check_expr_with_hint(e, tcx.types.err);
3759 // ... except when we try to 'break rust;'.
3760 // ICE this expression in particular (see #43162).
3761 if let hir::ExprPath(hir::QPath::Resolved(_, ref path)) = e.node {
3762 if path.segments.len() == 1 && path.segments[0].name == "rust" {
3763 fatally_break_rust(self.tcx.sess);
3769 // the type of a `break` is always `!`, since it diverges
3772 hir::ExprAgain(_) => { tcx.types.never }
3773 hir::ExprRet(ref expr_opt) => {
3774 if self.ret_coercion.is_none() {
3775 struct_span_err!(self.tcx.sess, expr.span, E0572,
3776 "return statement outside of function body").emit();
3777 } else if let Some(ref e) = *expr_opt {
3778 self.check_return_expr(e);
3780 let mut coercion = self.ret_coercion.as_ref().unwrap().borrow_mut();
3781 let cause = self.cause(expr.span, ObligationCauseCode::ReturnNoExpression);
3782 coercion.coerce_forced_unit(self, &cause, &mut |_| (), true);
3786 hir::ExprAssign(ref lhs, ref rhs) => {
3787 let lhs_ty = self.check_expr_with_lvalue_pref(&lhs, PreferMutLvalue);
3789 let rhs_ty = self.check_expr_coercable_to_type(&rhs, lhs_ty);
3792 ExpectIfCondition => {
3793 self.tcx.sess.delay_span_bug(lhs.span, "invalid lhs expression in if;\
3794 expected error elsehwere");
3797 // Only check this if not in an `if` condition, as the
3798 // mistyped comparison help is more appropriate.
3799 if !self.tcx.expr_is_lval(&lhs) {
3800 struct_span_err!(self.tcx.sess, expr.span, E0070,
3801 "invalid left-hand side expression")
3802 .span_label(expr.span, "left-hand of expression not valid")
3808 self.require_type_is_sized(lhs_ty, lhs.span, traits::AssignmentLhsSized);
3810 if lhs_ty.references_error() || rhs_ty.references_error() {
3816 hir::ExprIf(ref cond, ref then_expr, ref opt_else_expr) => {
3817 self.check_then_else(&cond, then_expr, opt_else_expr.as_ref().map(|e| &**e),
3818 expr.span, expected)
3820 hir::ExprWhile(ref cond, ref body, _) => {
3821 let ctxt = BreakableCtxt {
3822 // cannot use break with a value from a while loop
3827 self.with_breakable_ctxt(expr.id, ctxt, || {
3828 self.check_expr_has_type_or_error(&cond, tcx.types.bool);
3829 let cond_diverging = self.diverges.get();
3830 self.check_block_no_value(&body);
3832 // We may never reach the body so it diverging means nothing.
3833 self.diverges.set(cond_diverging);
3838 hir::ExprLoop(ref body, _, source) => {
3839 let coerce = match source {
3840 // you can only use break with a value from a normal `loop { }`
3841 hir::LoopSource::Loop => {
3842 let coerce_to = expected.coercion_target_type(self, body.span);
3843 Some(CoerceMany::new(coerce_to))
3846 hir::LoopSource::WhileLet |
3847 hir::LoopSource::ForLoop => {
3852 let ctxt = BreakableCtxt {
3854 may_break: false, // will get updated if/when we find a `break`
3857 let (ctxt, ()) = self.with_breakable_ctxt(expr.id, ctxt, || {
3858 self.check_block_no_value(&body);
3862 // No way to know whether it's diverging because
3863 // of a `break` or an outer `break` or `return.
3864 self.diverges.set(Diverges::Maybe);
3867 // If we permit break with a value, then result type is
3868 // the LUB of the breaks (possibly ! if none); else, it
3869 // is nil. This makes sense because infinite loops
3870 // (which would have type !) are only possible iff we
3871 // permit break with a value [1].
3872 assert!(ctxt.coerce.is_some() || ctxt.may_break); // [1]
3873 ctxt.coerce.map(|c| c.complete(self)).unwrap_or(self.tcx.mk_nil())
3875 hir::ExprMatch(ref discrim, ref arms, match_src) => {
3876 self.check_match(expr, &discrim, arms, expected, match_src)
3878 hir::ExprClosure(capture, ref decl, body_id, _, _) => {
3879 self.check_expr_closure(expr, capture, &decl, body_id, expected)
3881 hir::ExprBlock(ref body) => {
3882 self.check_block_with_expected(&body, expected)
3884 hir::ExprCall(ref callee, ref args) => {
3885 self.check_call(expr, &callee, args, expected)
3887 hir::ExprMethodCall(ref segment, span, ref args) => {
3888 self.check_method_call(expr, segment, span, args, expected, lvalue_pref)
3890 hir::ExprCast(ref e, ref t) => {
3891 // Find the type of `e`. Supply hints based on the type we are casting to,
3893 let t_cast = self.to_ty(t);
3894 let t_cast = self.resolve_type_vars_if_possible(&t_cast);
3895 let t_expr = self.check_expr_with_expectation(e, ExpectCastableToType(t_cast));
3896 let t_cast = self.resolve_type_vars_if_possible(&t_cast);
3897 let diverges = self.diverges.get();
3899 // Eagerly check for some obvious errors.
3900 if t_expr.references_error() || t_cast.references_error() {
3903 // Defer other checks until we're done type checking.
3904 let mut deferred_cast_checks = self.deferred_cast_checks.borrow_mut();
3905 match cast::CastCheck::new(self, e, t_expr, diverges, t_cast, t.span, expr.span) {
3907 deferred_cast_checks.push(cast_check);
3910 Err(ErrorReported) => {
3916 hir::ExprType(ref e, ref t) => {
3917 let typ = self.to_ty(&t);
3918 self.check_expr_eq_type(&e, typ);
3921 hir::ExprArray(ref args) => {
3922 let uty = expected.to_option(self).and_then(|uty| {
3924 ty::TyArray(ty, _) | ty::TySlice(ty) => Some(ty),
3929 let element_ty = if !args.is_empty() {
3930 let coerce_to = uty.unwrap_or_else(
3931 || self.next_ty_var(TypeVariableOrigin::TypeInference(expr.span)));
3932 let mut coerce = CoerceMany::with_coercion_sites(coerce_to, args);
3933 assert_eq!(self.diverges.get(), Diverges::Maybe);
3935 let e_ty = self.check_expr_with_hint(e, coerce_to);
3936 let cause = self.misc(e.span);
3937 coerce.coerce(self, &cause, e, e_ty, self.diverges.get());
3939 coerce.complete(self)
3941 self.next_ty_var(TypeVariableOrigin::TypeInference(expr.span))
3943 tcx.mk_array(element_ty, args.len() as u64)
3945 hir::ExprRepeat(ref element, count) => {
3946 let count_def_id = tcx.hir.body_owner_def_id(count);
3947 let param_env = ty::ParamEnv::empty(traits::Reveal::UserFacing);
3948 let substs = Substs::identity_for_item(tcx.global_tcx(), count_def_id);
3949 let count = tcx.const_eval(param_env.and((count_def_id, substs)));
3951 if let Err(ref err) = count {
3952 err.report(tcx, tcx.def_span(count_def_id), "constant expression");
3955 let uty = match expected {
3956 ExpectHasType(uty) => {
3958 ty::TyArray(ty, _) | ty::TySlice(ty) => Some(ty),
3965 let (element_ty, t) = match uty {
3967 self.check_expr_coercable_to_type(&element, uty);
3971 let t: Ty = self.next_ty_var(TypeVariableOrigin::MiscVariable(element.span));
3972 let element_ty = self.check_expr_has_type_or_error(&element, t);
3977 if let Ok(count) = count {
3978 let zero_or_one = count.val.to_const_int().and_then(|count| {
3979 count.to_u64().map(|count| count <= 1)
3980 }).unwrap_or(false);
3982 // For [foo, ..n] where n > 1, `foo` must have
3984 let lang_item = self.tcx.require_lang_item(lang_items::CopyTraitLangItem);
3985 self.require_type_meets(t, expr.span, traits::RepeatVec, lang_item);
3989 if element_ty.references_error() {
3991 } else if let Ok(count) = count {
3992 tcx.mk_ty(ty::TyArray(t, count))
3997 hir::ExprTup(ref elts) => {
3998 let flds = expected.only_has_type(self).and_then(|ty| {
3999 let ty = self.resolve_type_vars_with_obligations(ty);
4001 ty::TyTuple(ref flds, _) => Some(&flds[..]),
4006 let elt_ts_iter = elts.iter().enumerate().map(|(i, e)| {
4007 let t = match flds {
4008 Some(ref fs) if i < fs.len() => {
4010 self.check_expr_coercable_to_type(&e, ety);
4014 self.check_expr_with_expectation(&e, NoExpectation)
4019 let tuple = tcx.mk_tup(elt_ts_iter, false);
4020 if tuple.references_error() {
4023 self.require_type_is_sized(tuple, expr.span, traits::TupleInitializerSized);
4027 hir::ExprStruct(ref qpath, ref fields, ref base_expr) => {
4028 self.check_expr_struct(expr, expected, qpath, fields, base_expr)
4030 hir::ExprField(ref base, ref field) => {
4031 self.check_field(expr, lvalue_pref, &base, field)
4033 hir::ExprTupField(ref base, idx) => {
4034 self.check_tup_field(expr, lvalue_pref, &base, idx)
4036 hir::ExprIndex(ref base, ref idx) => {
4037 let base_t = self.check_expr_with_lvalue_pref(&base, lvalue_pref);
4038 let idx_t = self.check_expr(&idx);
4040 if base_t.references_error() {
4042 } else if idx_t.references_error() {
4045 let base_t = self.structurally_resolved_type(expr.span, base_t);
4046 match self.lookup_indexing(expr, base, base_t, idx_t, lvalue_pref) {
4047 Some((index_ty, element_ty)) => {
4048 self.demand_coerce(idx, idx_t, index_ty);
4052 let mut err = type_error_struct!(tcx.sess, expr.span, base_t, E0608,
4053 "cannot index into a value of type `{}`",
4055 // Try to give some advice about indexing tuples.
4056 if let ty::TyTuple(..) = base_t.sty {
4057 let mut needs_note = true;
4058 // If the index is an integer, we can show the actual
4059 // fixed expression:
4060 if let hir::ExprLit(ref lit) = idx.node {
4061 if let ast::LitKind::Int(i,
4062 ast::LitIntType::Unsuffixed) = lit.node {
4063 let snip = tcx.sess.codemap().span_to_snippet(base.span);
4064 if let Ok(snip) = snip {
4065 err.span_suggestion(expr.span,
4066 "to access tuple elements, use",
4067 format!("{}.{}", snip, i));
4073 err.help("to access tuple elements, use tuple indexing \
4074 syntax (e.g. `tuple.0`)");
4083 hir::ExprYield(ref value) => {
4084 match self.yield_ty {
4086 self.check_expr_coercable_to_type(&value, ty);
4089 struct_span_err!(self.tcx.sess, expr.span, E0627,
4090 "yield statement outside of generator literal").emit();
4098 // Finish resolving a path in a struct expression or pattern `S::A { .. }` if necessary.
4099 // The newly resolved definition is written into `type_dependent_defs`.
4100 fn finish_resolving_struct_path(&self,
4103 node_id: ast::NodeId)
4107 hir::QPath::Resolved(ref maybe_qself, ref path) => {
4108 let opt_self_ty = maybe_qself.as_ref().map(|qself| self.to_ty(qself));
4109 let ty = AstConv::def_to_ty(self, opt_self_ty, path, true);
4112 hir::QPath::TypeRelative(ref qself, ref segment) => {
4113 let ty = self.to_ty(qself);
4115 let def = if let hir::TyPath(hir::QPath::Resolved(_, ref path)) = qself.node {
4120 let (ty, def) = AstConv::associated_path_def_to_ty(self, node_id, path_span,
4123 // Write back the new resolution.
4124 let hir_id = self.tcx.hir.node_to_hir_id(node_id);
4125 self.tables.borrow_mut().type_dependent_defs_mut().insert(hir_id, def);
4132 // Resolve associated value path into a base type and associated constant or method definition.
4133 // The newly resolved definition is written into `type_dependent_defs`.
4134 pub fn resolve_ty_and_def_ufcs<'b>(&self,
4135 qpath: &'b hir::QPath,
4136 node_id: ast::NodeId,
4138 -> (Def, Option<Ty<'tcx>>, &'b [hir::PathSegment])
4140 let (ty, item_segment) = match *qpath {
4141 hir::QPath::Resolved(ref opt_qself, ref path) => {
4143 opt_qself.as_ref().map(|qself| self.to_ty(qself)),
4144 &path.segments[..]);
4146 hir::QPath::TypeRelative(ref qself, ref segment) => {
4147 (self.to_ty(qself), segment)
4150 let hir_id = self.tcx.hir.node_to_hir_id(node_id);
4151 if let Some(cached_def) = self.tables.borrow().type_dependent_defs().get(hir_id) {
4152 // Return directly on cache hit. This is useful to avoid doubly reporting
4153 // errors with default match binding modes. See #44614.
4154 return (*cached_def, Some(ty), slice::from_ref(&**item_segment))
4156 let item_name = item_segment.name;
4157 let def = match self.resolve_ufcs(span, item_name, ty, node_id) {
4160 let def = match error {
4161 method::MethodError::PrivateMatch(def, _) => def,
4164 if item_name != keywords::Invalid.name() {
4165 self.report_method_error(span, ty, item_name, None, error, None);
4171 // Write back the new resolution.
4172 self.tables.borrow_mut().type_dependent_defs_mut().insert(hir_id, def);
4173 (def, Some(ty), slice::from_ref(&**item_segment))
4176 pub fn check_decl_initializer(&self,
4177 local: &'gcx hir::Local,
4178 init: &'gcx hir::Expr) -> Ty<'tcx>
4180 // FIXME(tschottdorf): contains_explicit_ref_binding() must be removed
4181 // for #42640 (default match binding modes).
4184 let ref_bindings = local.pat.contains_explicit_ref_binding();
4186 let local_ty = self.local_ty(init.span, local.id);
4187 if let Some(m) = ref_bindings {
4188 // Somewhat subtle: if we have a `ref` binding in the pattern,
4189 // we want to avoid introducing coercions for the RHS. This is
4190 // both because it helps preserve sanity and, in the case of
4191 // ref mut, for soundness (issue #23116). In particular, in
4192 // the latter case, we need to be clear that the type of the
4193 // referent for the reference that results is *equal to* the
4194 // type of the lvalue it is referencing, and not some
4195 // supertype thereof.
4196 let init_ty = self.check_expr_with_lvalue_pref(init, LvaluePreference::from_mutbl(m));
4197 self.demand_eqtype(init.span, init_ty, local_ty);
4200 self.check_expr_coercable_to_type(init, local_ty)
4204 pub fn check_decl_local(&self, local: &'gcx hir::Local) {
4205 let t = self.local_ty(local.span, local.id);
4206 self.write_ty(local.hir_id, t);
4208 if let Some(ref init) = local.init {
4209 let init_ty = self.check_decl_initializer(local, &init);
4210 if init_ty.references_error() {
4211 self.write_ty(local.hir_id, init_ty);
4215 self.check_pat_walk(&local.pat, t,
4216 ty::BindingMode::BindByValue(hir::Mutability::MutImmutable),
4218 let pat_ty = self.node_ty(local.pat.hir_id);
4219 if pat_ty.references_error() {
4220 self.write_ty(local.hir_id, pat_ty);
4224 pub fn check_stmt(&self, stmt: &'gcx hir::Stmt) {
4225 // Don't do all the complex logic below for DeclItem.
4227 hir::StmtDecl(ref decl, _) => {
4229 hir::DeclLocal(_) => {}
4230 hir::DeclItem(_) => {
4235 hir::StmtExpr(..) | hir::StmtSemi(..) => {}
4238 self.warn_if_unreachable(stmt.node.id(), stmt.span, "statement");
4240 // Hide the outer diverging and has_errors flags.
4241 let old_diverges = self.diverges.get();
4242 let old_has_errors = self.has_errors.get();
4243 self.diverges.set(Diverges::Maybe);
4244 self.has_errors.set(false);
4247 hir::StmtDecl(ref decl, _) => {
4249 hir::DeclLocal(ref l) => {
4250 self.check_decl_local(&l);
4252 hir::DeclItem(_) => {/* ignore for now */}
4255 hir::StmtExpr(ref expr, _) => {
4256 // Check with expected type of ()
4257 self.check_expr_has_type_or_error(&expr, self.tcx.mk_nil());
4259 hir::StmtSemi(ref expr, _) => {
4260 self.check_expr(&expr);
4264 // Combine the diverging and has_error flags.
4265 self.diverges.set(self.diverges.get() | old_diverges);
4266 self.has_errors.set(self.has_errors.get() | old_has_errors);
4269 pub fn check_block_no_value(&self, blk: &'gcx hir::Block) {
4270 let unit = self.tcx.mk_nil();
4271 let ty = self.check_block_with_expected(blk, ExpectHasType(unit));
4273 // if the block produces a `!` value, that can always be
4274 // (effectively) coerced to unit.
4276 self.demand_suptype(blk.span, unit, ty);
4280 fn check_block_with_expected(&self,
4281 blk: &'gcx hir::Block,
4282 expected: Expectation<'tcx>) -> Ty<'tcx> {
4284 let mut fcx_ps = self.ps.borrow_mut();
4285 let unsafety_state = fcx_ps.recurse(blk);
4286 replace(&mut *fcx_ps, unsafety_state)
4289 // In some cases, blocks have just one exit, but other blocks
4290 // can be targeted by multiple breaks. This cannot happen in
4291 // normal Rust syntax today, but it can happen when we desugar
4292 // a `do catch { ... }` expression.
4296 // 'a: { if true { break 'a Err(()); } Ok(()) }
4298 // Here we would wind up with two coercions, one from
4299 // `Err(())` and the other from the tail expression
4300 // `Ok(())`. If the tail expression is omitted, that's a
4301 // "forced unit" -- unless the block diverges, in which
4302 // case we can ignore the tail expression (e.g., `'a: {
4303 // break 'a 22; }` would not force the type of the block
4305 let tail_expr = blk.expr.as_ref();
4306 let coerce_to_ty = expected.coercion_target_type(self, blk.span);
4307 let coerce = if blk.targeted_by_break {
4308 CoerceMany::new(coerce_to_ty)
4310 let tail_expr: &[P<hir::Expr>] = match tail_expr {
4311 Some(e) => slice::from_ref(e),
4314 CoerceMany::with_coercion_sites(coerce_to_ty, tail_expr)
4317 let prev_diverges = self.diverges.get();
4318 let ctxt = BreakableCtxt {
4319 coerce: Some(coerce),
4323 let (ctxt, ()) = self.with_breakable_ctxt(blk.id, ctxt, || {
4324 for s in &blk.stmts {
4328 // check the tail expression **without** holding the
4329 // `enclosing_breakables` lock below.
4330 let tail_expr_ty = tail_expr.map(|t| self.check_expr_with_expectation(t, expected));
4332 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4333 let ctxt = enclosing_breakables.find_breakable(blk.id);
4334 let coerce = ctxt.coerce.as_mut().unwrap();
4335 if let Some(tail_expr_ty) = tail_expr_ty {
4336 let tail_expr = tail_expr.unwrap();
4337 let cause = self.cause(tail_expr.span,
4338 ObligationCauseCode::BlockTailExpression(blk.id));
4343 self.diverges.get());
4345 // Subtle: if there is no explicit tail expression,
4346 // that is typically equivalent to a tail expression
4347 // of `()` -- except if the block diverges. In that
4348 // case, there is no value supplied from the tail
4349 // expression (assuming there are no other breaks,
4350 // this implies that the type of the block will be
4353 // #41425 -- label the implicit `()` as being the
4354 // "found type" here, rather than the "expected type".
4355 if !self.diverges.get().always() {
4356 coerce.coerce_forced_unit(self, &self.misc(blk.span), &mut |err| {
4357 if let Some(expected_ty) = expected.only_has_type(self) {
4358 self.consider_hint_about_removing_semicolon(blk,
4368 // If we can break from the block, then the block's exit is always reachable
4369 // (... as long as the entry is reachable) - regardless of the tail of the block.
4370 self.diverges.set(prev_diverges);
4373 let mut ty = ctxt.coerce.unwrap().complete(self);
4375 if self.has_errors.get() || ty.references_error() {
4376 ty = self.tcx.types.err
4379 self.write_ty(blk.hir_id, ty);
4381 *self.ps.borrow_mut() = prev;
4385 /// Given a `NodeId`, return the `FnDecl` of the method it is enclosed by and whether a
4386 /// suggestion can be made, `None` otherwise.
4387 pub fn get_fn_decl(&self, blk_id: ast::NodeId) -> Option<(hir::FnDecl, bool)> {
4388 // Get enclosing Fn, if it is a function or a trait method, unless there's a `loop` or
4389 // `while` before reaching it, as block tail returns are not available in them.
4390 if let Some(fn_id) = self.tcx.hir.get_return_block(blk_id) {
4391 let parent = self.tcx.hir.get(fn_id);
4393 if let Node::NodeItem(&hir::Item {
4394 name, node: hir::ItemFn(ref decl, ..), ..
4396 decl.clone().and_then(|decl| {
4397 // This is less than ideal, it will not suggest a return type span on any
4398 // method called `main`, regardless of whether it is actually the entry point,
4399 // but it will still present it as the reason for the expected type.
4400 Some((decl, name != Symbol::intern("main")))
4402 } else if let Node::NodeTraitItem(&hir::TraitItem {
4403 node: hir::TraitItemKind::Method(hir::MethodSig {
4407 decl.clone().and_then(|decl| {
4410 } else if let Node::NodeImplItem(&hir::ImplItem {
4411 node: hir::ImplItemKind::Method(hir::MethodSig {
4415 decl.clone().and_then(|decl| {
4426 /// On implicit return expressions with mismatched types, provide the following suggestions:
4428 /// - Point out the method's return type as the reason for the expected type
4429 /// - Possible missing semicolon
4430 /// - Possible missing return type if the return type is the default, and not `fn main()`
4431 pub fn suggest_mismatched_types_on_tail(&self,
4432 err: &mut DiagnosticBuilder<'tcx>,
4433 expression: &'gcx hir::Expr,
4437 blk_id: ast::NodeId) {
4438 self.suggest_missing_semicolon(err, expression, expected, cause_span);
4440 if let Some((fn_decl, can_suggest)) = self.get_fn_decl(blk_id) {
4441 self.suggest_missing_return_type(err, &fn_decl, expected, found, can_suggest);
4445 /// A common error is to forget to add a semicolon at the end of a block:
4449 /// bar_that_returns_u32()
4453 /// This routine checks if the return expression in a block would make sense on its own as a
4454 /// statement and the return type has been left as default or has been specified as `()`. If so,
4455 /// it suggests adding a semicolon.
4456 fn suggest_missing_semicolon(&self,
4457 err: &mut DiagnosticBuilder<'tcx>,
4458 expression: &'gcx hir::Expr,
4461 if expected.is_nil() {
4462 // `BlockTailExpression` only relevant if the tail expr would be
4463 // useful on its own.
4464 match expression.node {
4466 hir::ExprMethodCall(..) |
4468 hir::ExprWhile(..) |
4470 hir::ExprMatch(..) |
4471 hir::ExprBlock(..) => {
4472 let sp = cause_span.next_point();
4473 err.span_suggestion(sp,
4474 "try adding a semicolon",
4483 /// A possible error is to forget to add a return type that is needed:
4487 /// bar_that_returns_u32()
4491 /// This routine checks if the return type is left as default, the method is not part of an
4492 /// `impl` block and that it isn't the `main` method. If so, it suggests setting the return
4494 fn suggest_missing_return_type(&self,
4495 err: &mut DiagnosticBuilder<'tcx>,
4496 fn_decl: &hir::FnDecl,
4499 can_suggest: bool) {
4500 // Only suggest changing the return type for methods that
4501 // haven't set a return type at all (and aren't `fn main()` or an impl).
4502 match (&fn_decl.output, found.is_suggestable(), can_suggest) {
4503 (&hir::FunctionRetTy::DefaultReturn(span), true, true) => {
4504 err.span_suggestion(span,
4505 "try adding a return type",
4506 format!("-> {} ", found));
4508 (&hir::FunctionRetTy::DefaultReturn(span), false, true) => {
4509 err.span_label(span, "possibly return type missing here?");
4511 (&hir::FunctionRetTy::DefaultReturn(span), _, _) => {
4512 // `fn main()` must return `()`, do not suggest changing return type
4513 err.span_label(span, "expected `()` because of default return type");
4515 (&hir::FunctionRetTy::Return(ref ty), _, _) => {
4516 // Only point to return type if the expected type is the return type, as if they
4517 // are not, the expectation must have been caused by something else.
4518 debug!("suggest_missing_return_type: return type {:?} node {:?}", ty, ty.node);
4520 let ty = AstConv::ast_ty_to_ty(self, ty);
4521 debug!("suggest_missing_return_type: return type sty {:?}", ty.sty);
4522 debug!("suggest_missing_return_type: expected type sty {:?}", ty.sty);
4523 if ty.sty == expected.sty {
4524 err.span_label(sp, format!("expected `{}` because of return type",
4532 /// A common error is to add an extra semicolon:
4535 /// fn foo() -> usize {
4540 /// This routine checks if the final statement in a block is an
4541 /// expression with an explicit semicolon whose type is compatible
4542 /// with `expected_ty`. If so, it suggests removing the semicolon.
4543 fn consider_hint_about_removing_semicolon(&self,
4544 blk: &'gcx hir::Block,
4545 expected_ty: Ty<'tcx>,
4546 err: &mut DiagnosticBuilder) {
4547 // Be helpful when the user wrote `{... expr;}` and
4548 // taking the `;` off is enough to fix the error.
4549 let last_stmt = match blk.stmts.last() {
4553 let last_expr = match last_stmt.node {
4554 hir::StmtSemi(ref e, _) => e,
4557 let last_expr_ty = self.node_ty(last_expr.hir_id);
4558 if self.can_sub(self.param_env, last_expr_ty, expected_ty).is_err() {
4561 let original_span = original_sp(last_stmt.span, blk.span);
4562 let span_semi = original_span.with_lo(original_span.hi() - BytePos(1));
4563 err.span_suggestion(span_semi, "consider removing this semicolon", "".to_string());
4566 // Instantiates the given path, which must refer to an item with the given
4567 // number of type parameters and type.
4568 pub fn instantiate_value_path(&self,
4569 segments: &[hir::PathSegment],
4570 opt_self_ty: Option<Ty<'tcx>>,
4573 node_id: ast::NodeId)
4575 debug!("instantiate_value_path(path={:?}, def={:?}, node_id={})",
4580 // We need to extract the type parameters supplied by the user in
4581 // the path `path`. Due to the current setup, this is a bit of a
4582 // tricky-process; the problem is that resolve only tells us the
4583 // end-point of the path resolution, and not the intermediate steps.
4584 // Luckily, we can (at least for now) deduce the intermediate steps
4585 // just from the end-point.
4587 // There are basically four cases to consider:
4589 // 1. Reference to a constructor of enum variant or struct:
4591 // struct Foo<T>(...)
4592 // enum E<T> { Foo(...) }
4594 // In these cases, the parameters are declared in the type
4597 // 2. Reference to a fn item or a free constant:
4601 // In this case, the path will again always have the form
4602 // `a::b::foo::<T>` where only the final segment should have
4603 // type parameters. However, in this case, those parameters are
4604 // declared on a value, and hence are in the `FnSpace`.
4606 // 3. Reference to a method or an associated constant:
4608 // impl<A> SomeStruct<A> {
4612 // Here we can have a path like
4613 // `a::b::SomeStruct::<A>::foo::<B>`, in which case parameters
4614 // may appear in two places. The penultimate segment,
4615 // `SomeStruct::<A>`, contains parameters in TypeSpace, and the
4616 // final segment, `foo::<B>` contains parameters in fn space.
4618 // 4. Reference to a local variable
4620 // Local variables can't have any type parameters.
4622 // The first step then is to categorize the segments appropriately.
4624 assert!(!segments.is_empty());
4626 let mut ufcs_associated = None;
4627 let mut type_segment = None;
4628 let mut fn_segment = None;
4630 // Case 1. Reference to a struct/variant constructor.
4631 Def::StructCtor(def_id, ..) |
4632 Def::VariantCtor(def_id, ..) => {
4633 // Everything but the final segment should have no
4634 // parameters at all.
4635 let mut generics = self.tcx.generics_of(def_id);
4636 if let Some(def_id) = generics.parent {
4637 // Variant and struct constructors use the
4638 // generics of their parent type definition.
4639 generics = self.tcx.generics_of(def_id);
4641 type_segment = Some((segments.last().unwrap(), generics));
4644 // Case 2. Reference to a top-level value.
4646 Def::Const(def_id) |
4647 Def::Static(def_id, _) => {
4648 fn_segment = Some((segments.last().unwrap(),
4649 self.tcx.generics_of(def_id)));
4652 // Case 3. Reference to a method or associated const.
4653 Def::Method(def_id) |
4654 Def::AssociatedConst(def_id) => {
4655 let container = self.tcx.associated_item(def_id).container;
4657 ty::TraitContainer(trait_did) => {
4658 callee::check_legal_trait_for_method_call(self.tcx, span, trait_did)
4660 ty::ImplContainer(_) => {}
4663 let generics = self.tcx.generics_of(def_id);
4664 if segments.len() >= 2 {
4665 let parent_generics = self.tcx.generics_of(generics.parent.unwrap());
4666 type_segment = Some((&segments[segments.len() - 2], parent_generics));
4668 // `<T>::assoc` will end up here, and so can `T::assoc`.
4669 let self_ty = opt_self_ty.expect("UFCS sugared assoc missing Self");
4670 ufcs_associated = Some((container, self_ty));
4672 fn_segment = Some((segments.last().unwrap(), generics));
4675 // Case 4. Local variable, no generics.
4676 Def::Local(..) | Def::Upvar(..) => {}
4678 _ => bug!("unexpected definition: {:?}", def),
4681 debug!("type_segment={:?} fn_segment={:?}", type_segment, fn_segment);
4683 // Now that we have categorized what space the parameters for each
4684 // segment belong to, let's sort out the parameters that the user
4685 // provided (if any) into their appropriate spaces. We'll also report
4686 // errors if type parameters are provided in an inappropriate place.
4687 let poly_segments = type_segment.is_some() as usize +
4688 fn_segment.is_some() as usize;
4689 AstConv::prohibit_type_params(self, &segments[..segments.len() - poly_segments]);
4692 Def::Local(nid) | Def::Upvar(nid, ..) => {
4693 let ty = self.local_ty(span, nid);
4694 let ty = self.normalize_associated_types_in(span, &ty);
4695 self.write_ty(self.tcx.hir.node_to_hir_id(node_id), ty);
4701 // Now we have to compare the types that the user *actually*
4702 // provided against the types that were *expected*. If the user
4703 // did not provide any types, then we want to substitute inference
4704 // variables. If the user provided some types, we may still need
4705 // to add defaults. If the user provided *too many* types, that's
4707 self.check_path_parameter_count(span, &mut type_segment, false);
4708 self.check_path_parameter_count(span, &mut fn_segment, false);
4709 self.check_impl_trait(span, &mut fn_segment);
4711 let (fn_start, has_self) = match (type_segment, fn_segment) {
4712 (_, Some((_, generics))) => {
4713 (generics.parent_count(), generics.has_self)
4715 (Some((_, generics)), None) => {
4716 (generics.own_count(), generics.has_self)
4718 (None, None) => (0, false)
4720 let substs = Substs::for_item(self.tcx, def.def_id(), |def, _| {
4721 let mut i = def.index as usize;
4723 let segment = if i < fn_start {
4724 i -= has_self as usize;
4730 let lifetimes = segment.map_or(&[][..], |(s, _)| {
4731 s.parameters.as_ref().map_or(&[][..], |p| &p.lifetimes[..])
4734 if let Some(lifetime) = lifetimes.get(i) {
4735 AstConv::ast_region_to_region(self, lifetime, Some(def))
4737 self.re_infer(span, Some(def)).unwrap()
4740 let mut i = def.index as usize;
4742 let segment = if i < fn_start {
4743 // Handle Self first, so we can adjust the index to match the AST.
4744 if has_self && i == 0 {
4745 return opt_self_ty.unwrap_or_else(|| {
4746 self.type_var_for_def(span, def, substs)
4749 i -= has_self as usize;
4755 let (types, infer_types) = segment.map_or((&[][..], true), |(s, _)| {
4756 (s.parameters.as_ref().map_or(&[][..], |p| &p.types[..]), s.infer_types)
4759 // Skip over the lifetimes in the same segment.
4760 if let Some((_, generics)) = segment {
4761 i -= generics.regions.len();
4764 if let Some(ast_ty) = types.get(i) {
4765 // A provided type parameter.
4767 } else if !infer_types && def.has_default {
4768 // No type parameter provided, but a default exists.
4769 let default = self.tcx.type_of(def.def_id);
4772 default.subst_spanned(self.tcx, substs, Some(span))
4775 // No type parameters were provided, we can infer all.
4776 // This can also be reached in some error cases:
4777 // We prefer to use inference variables instead of
4778 // TyError to let type inference recover somewhat.
4779 self.type_var_for_def(span, def, substs)
4783 // The things we are substituting into the type should not contain
4784 // escaping late-bound regions, and nor should the base type scheme.
4785 let ty = self.tcx.type_of(def.def_id());
4786 assert!(!substs.has_escaping_regions());
4787 assert!(!ty.has_escaping_regions());
4789 // Add all the obligations that are required, substituting and
4790 // normalized appropriately.
4791 let bounds = self.instantiate_bounds(span, def.def_id(), &substs);
4792 self.add_obligations_for_parameters(
4793 traits::ObligationCause::new(span, self.body_id, traits::ItemObligation(def.def_id())),
4796 // Substitute the values for the type parameters into the type of
4797 // the referenced item.
4798 let ty_substituted = self.instantiate_type_scheme(span, &substs, &ty);
4800 if let Some((ty::ImplContainer(impl_def_id), self_ty)) = ufcs_associated {
4801 // In the case of `Foo<T>::method` and `<Foo<T>>::method`, if `method`
4802 // is inherent, there is no `Self` parameter, instead, the impl needs
4803 // type parameters, which we can infer by unifying the provided `Self`
4804 // with the substituted impl type.
4805 let ty = self.tcx.type_of(impl_def_id);
4807 let impl_ty = self.instantiate_type_scheme(span, &substs, &ty);
4808 match self.at(&self.misc(span), self.param_env).sup(impl_ty, self_ty) {
4809 Ok(ok) => self.register_infer_ok_obligations(ok),
4812 "instantiate_value_path: (UFCS) {:?} was a subtype of {:?} but now is not?",
4819 debug!("instantiate_value_path: type of {:?} is {:?}",
4822 self.write_substs(self.tcx.hir.node_to_hir_id(node_id), substs);
4826 /// Report errors if the provided parameters are too few or too many.
4827 fn check_path_parameter_count(&self,
4829 segment: &mut Option<(&hir::PathSegment, &ty::Generics)>,
4830 is_method_call: bool) {
4831 let (lifetimes, types, infer_types, bindings) = segment.map_or(
4832 (&[][..], &[][..], true, &[][..]),
4833 |(s, _)| s.parameters.as_ref().map_or(
4834 (&[][..], &[][..], s.infer_types, &[][..]),
4835 |p| (&p.lifetimes[..], &p.types[..],
4836 s.infer_types, &p.bindings[..])));
4837 let infer_lifetimes = lifetimes.len() == 0;
4839 let count_lifetime_params = |n| {
4840 format!("{} lifetime parameter{}", n, if n == 1 { "" } else { "s" })
4842 let count_type_params = |n| {
4843 format!("{} type parameter{}", n, if n == 1 { "" } else { "s" })
4846 // Check provided type parameters.
4847 let type_defs = segment.map_or(&[][..], |(_, generics)| {
4848 if generics.parent.is_none() {
4849 &generics.types[generics.has_self as usize..]
4854 let required_len = type_defs.iter().take_while(|d| !d.has_default).count();
4855 if types.len() > type_defs.len() {
4856 let span = types[type_defs.len()].span;
4857 let expected_text = count_type_params(type_defs.len());
4858 let actual_text = count_type_params(types.len());
4859 struct_span_err!(self.tcx.sess, span, E0087,
4860 "too many type parameters provided: \
4861 expected at most {}, found {}",
4862 expected_text, actual_text)
4863 .span_label(span, format!("expected {}", expected_text))
4866 // To prevent derived errors to accumulate due to extra
4867 // type parameters, we force instantiate_value_path to
4868 // use inference variables instead of the provided types.
4870 } else if types.len() < required_len && !infer_types {
4871 let expected_text = count_type_params(required_len);
4872 let actual_text = count_type_params(types.len());
4873 struct_span_err!(self.tcx.sess, span, E0089,
4874 "too few type parameters provided: \
4875 expected {}, found {}",
4876 expected_text, actual_text)
4877 .span_label(span, format!("expected {}", expected_text))
4881 if !bindings.is_empty() {
4882 AstConv::prohibit_projection(self, bindings[0].span);
4885 // Check provided lifetime parameters.
4886 let lifetime_defs = segment.map_or(&[][..], |(_, generics)| &generics.regions);
4887 let required_len = lifetime_defs.len();
4889 // Prohibit explicit lifetime arguments if late bound lifetime parameters are present.
4890 let has_late_bound_lifetime_defs =
4891 segment.map_or(None, |(_, generics)| generics.has_late_bound_regions);
4892 if let (Some(span_late), false) = (has_late_bound_lifetime_defs, lifetimes.is_empty()) {
4893 // Report this as a lint only if no error was reported previously.
4894 let primary_msg = "cannot specify lifetime arguments explicitly \
4895 if late bound lifetime parameters are present";
4896 let note_msg = "the late bound lifetime parameter is introduced here";
4897 if !is_method_call && (lifetimes.len() > lifetime_defs.len() ||
4898 lifetimes.len() < required_len && !infer_lifetimes) {
4899 let mut err = self.tcx.sess.struct_span_err(lifetimes[0].span, primary_msg);
4900 err.span_note(span_late, note_msg);
4904 let mut multispan = MultiSpan::from_span(lifetimes[0].span);
4905 multispan.push_span_label(span_late, note_msg.to_string());
4906 self.tcx.lint_node(lint::builtin::LATE_BOUND_LIFETIME_ARGUMENTS,
4907 lifetimes[0].id, multispan, primary_msg);
4912 if lifetimes.len() > lifetime_defs.len() {
4913 let span = lifetimes[lifetime_defs.len()].span;
4914 let expected_text = count_lifetime_params(lifetime_defs.len());
4915 let actual_text = count_lifetime_params(lifetimes.len());
4916 struct_span_err!(self.tcx.sess, span, E0088,
4917 "too many lifetime parameters provided: \
4918 expected at most {}, found {}",
4919 expected_text, actual_text)
4920 .span_label(span, format!("expected {}", expected_text))
4922 } else if lifetimes.len() < required_len && !infer_lifetimes {
4923 let expected_text = count_lifetime_params(lifetime_defs.len());
4924 let actual_text = count_lifetime_params(lifetimes.len());
4925 struct_span_err!(self.tcx.sess, span, E0090,
4926 "too few lifetime parameters provided: \
4927 expected {}, found {}",
4928 expected_text, actual_text)
4929 .span_label(span, format!("expected {}", expected_text))
4934 /// Report error if there is an explicit type parameter when using `impl Trait`.
4935 fn check_impl_trait(&self,
4937 segment: &mut Option<(&hir::PathSegment, &ty::Generics)>) {
4938 use hir::SyntheticTyParamKind::*;
4940 segment.map(|(path_segment, generics)| {
4941 let explicit = !path_segment.infer_types;
4942 let impl_trait = generics.types.iter()
4944 match ty_param.synthetic {
4945 Some(ImplTrait) => true,
4950 if explicit && impl_trait {
4951 let mut err = struct_span_err! {
4955 "cannot provide explicit type parameters when `impl Trait` is \
4956 used in argument position."
4964 fn structurally_resolve_type_or_else<F>(&self, sp: Span, ty: Ty<'tcx>, f: F)
4966 where F: Fn() -> Ty<'tcx>
4968 let mut ty = self.resolve_type_vars_with_obligations(ty);
4971 let alternative = f();
4974 if alternative.is_ty_var() || alternative.references_error() {
4975 if !self.is_tainted_by_errors() {
4976 type_error_struct!(self.tcx.sess, sp, ty, E0619,
4977 "the type of this value must be known in this context")
4980 self.demand_suptype(sp, self.tcx.types.err, ty);
4981 ty = self.tcx.types.err;
4983 self.demand_suptype(sp, alternative, ty);
4991 // Resolves `typ` by a single level if `typ` is a type variable. If no
4992 // resolution is possible, then an error is reported.
4993 pub fn structurally_resolved_type(&self, sp: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
4994 self.structurally_resolve_type_or_else(sp, ty, || {
4999 fn with_breakable_ctxt<F: FnOnce() -> R, R>(&self, id: ast::NodeId,
5000 ctxt: BreakableCtxt<'gcx, 'tcx>, f: F)
5001 -> (BreakableCtxt<'gcx, 'tcx>, R) {
5004 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
5005 index = enclosing_breakables.stack.len();
5006 enclosing_breakables.by_id.insert(id, index);
5007 enclosing_breakables.stack.push(ctxt);
5011 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
5012 debug_assert!(enclosing_breakables.stack.len() == index + 1);
5013 enclosing_breakables.by_id.remove(&id).expect("missing breakable context");
5014 enclosing_breakables.stack.pop().expect("missing breakable context")
5020 pub fn check_bounds_are_used<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
5021 generics: &hir::Generics,
5023 debug!("check_bounds_are_used(n_tps={}, ty={:?})",
5024 generics.ty_params.len(), ty);
5026 // make a vector of booleans initially false, set to true when used
5027 if generics.ty_params.is_empty() { return; }
5028 let mut tps_used = vec![false; generics.ty_params.len()];
5030 for leaf_ty in ty.walk() {
5031 if let ty::TyParam(ParamTy {idx, ..}) = leaf_ty.sty {
5032 debug!("Found use of ty param num {}", idx);
5033 tps_used[idx as usize - generics.lifetimes.len()] = true;
5034 } else if let ty::TyError = leaf_ty.sty {
5035 // If there already another error, do not emit an error for not using a type Parameter
5036 assert!(tcx.sess.err_count() > 0);
5041 for (&used, param) in tps_used.iter().zip(&generics.ty_params) {
5043 struct_span_err!(tcx.sess, param.span, E0091,
5044 "type parameter `{}` is unused",
5046 .span_label(param.span, "unused type parameter")
5052 fn fatally_break_rust(sess: &Session) {
5053 let handler = sess.diagnostic();
5054 handler.span_bug_no_panic(
5056 "It looks like you're trying to break rust; would you like some ICE?",
5058 handler.note_without_error("the compiler expectedly panicked. this is a feature.");
5059 handler.note_without_error(
5060 "we would appreciate a joke overview: \
5061 https://github.com/rust-lang/rust/issues/43162#issuecomment-320764675"
5063 handler.note_without_error(&format!("rustc {} running on {}",
5064 option_env!("CFG_VERSION").unwrap_or("unknown_version"),
5065 ::session::config::host_triple(),