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::anon_types::AnonTypeDecl;
94 use rustc::infer::type_variable::{TypeVariableOrigin};
95 use rustc::middle::region;
96 use rustc::ty::subst::{Kind, Subst, Substs};
97 use rustc::traits::{self, FulfillmentContext, ObligationCause, ObligationCauseCode};
98 use rustc::ty::{ParamTy, LvaluePreference, NoPreference, PreferMutLvalue};
99 use rustc::ty::{self, Ty, TyCtxt, Visibility, ToPredicate};
100 use rustc::ty::adjustment::{Adjust, Adjustment, AutoBorrow};
101 use rustc::ty::fold::TypeFoldable;
102 use rustc::ty::maps::Providers;
103 use rustc::ty::util::{Representability, IntTypeExt};
104 use rustc::ty::layout::LayoutOf;
105 use errors::{DiagnosticBuilder, DiagnosticId};
107 use require_c_abi_if_variadic;
108 use session::{CompileIncomplete, config, Session};
111 use util::common::{ErrorReported, indenter};
112 use util::nodemap::{DefIdMap, DefIdSet, FxHashMap, NodeMap};
114 use std::cell::{Cell, RefCell, Ref, RefMut};
116 use std::collections::hash_map::Entry;
118 use std::fmt::Display;
119 use std::mem::replace;
121 use std::ops::{self, Deref};
122 use syntax::abi::Abi;
125 use syntax::codemap::{self, original_sp, Spanned};
126 use syntax::feature_gate::{GateIssue, emit_feature_err};
128 use syntax::symbol::{Symbol, InternedString, keywords};
129 use syntax::util::lev_distance::find_best_match_for_name;
130 use syntax_pos::{self, BytePos, Span, MultiSpan};
132 use rustc::hir::intravisit::{self, Visitor, NestedVisitorMap};
133 use rustc::hir::itemlikevisit::ItemLikeVisitor;
134 use rustc::hir::map::Node;
135 use rustc::hir::{self, PatKind};
136 use rustc::middle::lang_items;
137 use rustc_const_math::ConstInt;
153 mod generator_interior;
157 /// A wrapper for InferCtxt's `in_progress_tables` field.
158 #[derive(Copy, Clone)]
159 struct MaybeInProgressTables<'a, 'tcx: 'a> {
160 maybe_tables: Option<&'a RefCell<ty::TypeckTables<'tcx>>>,
163 impl<'a, 'tcx> MaybeInProgressTables<'a, 'tcx> {
164 fn borrow(self) -> Ref<'a, ty::TypeckTables<'tcx>> {
165 match self.maybe_tables {
166 Some(tables) => tables.borrow(),
168 bug!("MaybeInProgressTables: inh/fcx.tables.borrow() with no tables")
173 fn borrow_mut(self) -> RefMut<'a, ty::TypeckTables<'tcx>> {
174 match self.maybe_tables {
175 Some(tables) => tables.borrow_mut(),
177 bug!("MaybeInProgressTables: inh/fcx.tables.borrow_mut() with no tables")
184 /// closures defined within the function. For example:
187 /// bar(move|| { ... })
190 /// Here, the function `foo()` and the closure passed to
191 /// `bar()` will each have their own `FnCtxt`, but they will
192 /// share the inherited fields.
193 pub struct Inherited<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
194 infcx: InferCtxt<'a, 'gcx, 'tcx>,
196 tables: MaybeInProgressTables<'a, 'tcx>,
198 locals: RefCell<NodeMap<Ty<'tcx>>>,
200 fulfillment_cx: RefCell<traits::FulfillmentContext<'tcx>>,
202 // When we process a call like `c()` where `c` is a closure type,
203 // we may not have decided yet whether `c` is a `Fn`, `FnMut`, or
204 // `FnOnce` closure. In that case, we defer full resolution of the
205 // call until upvar inference can kick in and make the
206 // decision. We keep these deferred resolutions grouped by the
207 // def-id of the closure, so that once we decide, we can easily go
208 // back and process them.
209 deferred_call_resolutions: RefCell<DefIdMap<Vec<DeferredCallResolution<'gcx, 'tcx>>>>,
211 deferred_cast_checks: RefCell<Vec<cast::CastCheck<'tcx>>>,
213 deferred_generator_interiors: RefCell<Vec<(hir::BodyId, ty::GeneratorInterior<'tcx>)>>,
215 // Anonymized types found in explicit return types and their
216 // associated fresh inference variable. Writeback resolves these
217 // variables to get the concrete type, which can be used to
218 // deanonymize TyAnon, after typeck is done with all functions.
219 anon_types: RefCell<DefIdMap<AnonTypeDecl<'tcx>>>,
221 /// Each type parameter has an implicit region bound that
222 /// indicates it must outlive at least the function body (the user
223 /// may specify stronger requirements). This field indicates the
224 /// region of the callee. If it is `None`, then the parameter
225 /// environment is for an item or something where the "callee" is
227 implicit_region_bound: Option<ty::Region<'tcx>>,
229 body_id: Option<hir::BodyId>,
232 impl<'a, 'gcx, 'tcx> Deref for Inherited<'a, 'gcx, 'tcx> {
233 type Target = InferCtxt<'a, 'gcx, 'tcx>;
234 fn deref(&self) -> &Self::Target {
239 /// When type-checking an expression, we propagate downward
240 /// whatever type hint we are able in the form of an `Expectation`.
241 #[derive(Copy, Clone, Debug)]
242 pub enum Expectation<'tcx> {
243 /// We know nothing about what type this expression should have.
246 /// This expression is an `if` condition, it must resolve to `bool`.
249 /// This expression should have the type given (or some subtype)
250 ExpectHasType(Ty<'tcx>),
252 /// This expression will be cast to the `Ty`
253 ExpectCastableToType(Ty<'tcx>),
255 /// This rvalue expression will be wrapped in `&` or `Box` and coerced
256 /// to `&Ty` or `Box<Ty>`, respectively. `Ty` is `[A]` or `Trait`.
257 ExpectRvalueLikeUnsized(Ty<'tcx>),
260 impl<'a, 'gcx, 'tcx> Expectation<'tcx> {
261 // Disregard "castable to" expectations because they
262 // can lead us astray. Consider for example `if cond
263 // {22} else {c} as u8` -- if we propagate the
264 // "castable to u8" constraint to 22, it will pick the
265 // type 22u8, which is overly constrained (c might not
266 // be a u8). In effect, the problem is that the
267 // "castable to" expectation is not the tightest thing
268 // we can say, so we want to drop it in this case.
269 // The tightest thing we can say is "must unify with
270 // else branch". Note that in the case of a "has type"
271 // constraint, this limitation does not hold.
273 // If the expected type is just a type variable, then don't use
274 // an expected type. Otherwise, we might write parts of the type
275 // when checking the 'then' block which are incompatible with the
277 fn adjust_for_branches(&self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) -> Expectation<'tcx> {
279 ExpectHasType(ety) => {
280 let ety = fcx.shallow_resolve(ety);
281 if !ety.is_ty_var() {
287 ExpectRvalueLikeUnsized(ety) => {
288 ExpectRvalueLikeUnsized(ety)
294 /// Provide an expectation for an rvalue expression given an *optional*
295 /// hint, which is not required for type safety (the resulting type might
296 /// be checked higher up, as is the case with `&expr` and `box expr`), but
297 /// is useful in determining the concrete type.
299 /// The primary use case is where the expected type is a fat pointer,
300 /// like `&[isize]`. For example, consider the following statement:
302 /// let x: &[isize] = &[1, 2, 3];
304 /// In this case, the expected type for the `&[1, 2, 3]` expression is
305 /// `&[isize]`. If however we were to say that `[1, 2, 3]` has the
306 /// expectation `ExpectHasType([isize])`, that would be too strong --
307 /// `[1, 2, 3]` does not have the type `[isize]` but rather `[isize; 3]`.
308 /// It is only the `&[1, 2, 3]` expression as a whole that can be coerced
309 /// to the type `&[isize]`. Therefore, we propagate this more limited hint,
310 /// which still is useful, because it informs integer literals and the like.
311 /// See the test case `test/run-pass/coerce-expect-unsized.rs` and #20169
312 /// for examples of where this comes up,.
313 fn rvalue_hint(fcx: &FnCtxt<'a, 'gcx, 'tcx>, ty: Ty<'tcx>) -> Expectation<'tcx> {
314 match fcx.tcx.struct_tail(ty).sty {
315 ty::TySlice(_) | ty::TyStr | ty::TyDynamic(..) => {
316 ExpectRvalueLikeUnsized(ty)
318 _ => ExpectHasType(ty)
322 // Resolves `expected` by a single level if it is a variable. If
323 // there is no expected type or resolution is not possible (e.g.,
324 // no constraints yet present), just returns `None`.
325 fn resolve(self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) -> Expectation<'tcx> {
327 NoExpectation => NoExpectation,
328 ExpectIfCondition => ExpectIfCondition,
329 ExpectCastableToType(t) => {
330 ExpectCastableToType(fcx.resolve_type_vars_if_possible(&t))
332 ExpectHasType(t) => {
333 ExpectHasType(fcx.resolve_type_vars_if_possible(&t))
335 ExpectRvalueLikeUnsized(t) => {
336 ExpectRvalueLikeUnsized(fcx.resolve_type_vars_if_possible(&t))
341 fn to_option(self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) -> Option<Ty<'tcx>> {
342 match self.resolve(fcx) {
343 NoExpectation => None,
344 ExpectIfCondition => Some(fcx.tcx.types.bool),
345 ExpectCastableToType(ty) |
347 ExpectRvalueLikeUnsized(ty) => Some(ty),
351 /// It sometimes happens that we want to turn an expectation into
352 /// a **hard constraint** (i.e., something that must be satisfied
353 /// for the program to type-check). `only_has_type` will return
354 /// such a constraint, if it exists.
355 fn only_has_type(self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) -> Option<Ty<'tcx>> {
356 match self.resolve(fcx) {
357 ExpectHasType(ty) => Some(ty),
358 ExpectIfCondition => Some(fcx.tcx.types.bool),
359 NoExpectation | ExpectCastableToType(_) | ExpectRvalueLikeUnsized(_) => None,
363 /// Like `only_has_type`, but instead of returning `None` if no
364 /// hard constraint exists, creates a fresh type variable.
365 fn coercion_target_type(self, fcx: &FnCtxt<'a, 'gcx, 'tcx>, span: Span) -> Ty<'tcx> {
366 self.only_has_type(fcx)
367 .unwrap_or_else(|| fcx.next_ty_var(TypeVariableOrigin::MiscVariable(span)))
371 #[derive(Copy, Clone)]
372 pub struct UnsafetyState {
373 pub def: ast::NodeId,
374 pub unsafety: hir::Unsafety,
375 pub unsafe_push_count: u32,
380 pub fn function(unsafety: hir::Unsafety, def: ast::NodeId) -> UnsafetyState {
381 UnsafetyState { def: def, unsafety: unsafety, unsafe_push_count: 0, from_fn: true }
384 pub fn recurse(&mut self, blk: &hir::Block) -> UnsafetyState {
385 match self.unsafety {
386 // If this unsafe, then if the outer function was already marked as
387 // unsafe we shouldn't attribute the unsafe'ness to the block. This
388 // way the block can be warned about instead of ignoring this
389 // extraneous block (functions are never warned about).
390 hir::Unsafety::Unsafe if self.from_fn => *self,
393 let (unsafety, def, count) = match blk.rules {
394 hir::PushUnsafeBlock(..) =>
395 (unsafety, blk.id, self.unsafe_push_count.checked_add(1).unwrap()),
396 hir::PopUnsafeBlock(..) =>
397 (unsafety, blk.id, self.unsafe_push_count.checked_sub(1).unwrap()),
398 hir::UnsafeBlock(..) =>
399 (hir::Unsafety::Unsafe, blk.id, self.unsafe_push_count),
401 (unsafety, self.def, self.unsafe_push_count),
405 unsafe_push_count: count,
412 #[derive(Debug, Copy, Clone)]
418 /// Tracks whether executing a node may exit normally (versus
419 /// return/break/panic, which "diverge", leaving dead code in their
420 /// wake). Tracked semi-automatically (through type variables marked
421 /// as diverging), with some manual adjustments for control-flow
422 /// primitives (approximating a CFG).
423 #[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
425 /// Potentially unknown, some cases converge,
426 /// others require a CFG to determine them.
429 /// Definitely known to diverge and therefore
430 /// not reach the next sibling or its parent.
433 /// Same as `Always` but with a reachability
434 /// warning already emitted
438 // Convenience impls for combinig `Diverges`.
440 impl ops::BitAnd for Diverges {
442 fn bitand(self, other: Self) -> Self {
443 cmp::min(self, other)
447 impl ops::BitOr for Diverges {
449 fn bitor(self, other: Self) -> Self {
450 cmp::max(self, other)
454 impl ops::BitAndAssign for Diverges {
455 fn bitand_assign(&mut self, other: Self) {
456 *self = *self & other;
460 impl ops::BitOrAssign for Diverges {
461 fn bitor_assign(&mut self, other: Self) {
462 *self = *self | other;
467 fn always(self) -> bool {
468 self >= Diverges::Always
472 pub struct BreakableCtxt<'gcx: 'tcx, 'tcx> {
475 // this is `null` for loops where break with a value is illegal,
476 // such as `while`, `for`, and `while let`
477 coerce: Option<DynamicCoerceMany<'gcx, 'tcx>>,
480 pub struct EnclosingBreakables<'gcx: 'tcx, 'tcx> {
481 stack: Vec<BreakableCtxt<'gcx, 'tcx>>,
482 by_id: NodeMap<usize>,
485 impl<'gcx, 'tcx> EnclosingBreakables<'gcx, 'tcx> {
486 fn find_breakable(&mut self, target_id: ast::NodeId) -> &mut BreakableCtxt<'gcx, 'tcx> {
487 let ix = *self.by_id.get(&target_id).unwrap_or_else(|| {
488 bug!("could not find enclosing breakable with id {}", target_id);
494 pub struct FnCtxt<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
495 body_id: ast::NodeId,
497 /// The parameter environment used for proving trait obligations
498 /// in this function. This can change when we descend into
499 /// closures (as they bring new things into scope), hence it is
500 /// not part of `Inherited` (as of the time of this writing,
501 /// closures do not yet change the environment, but they will
503 param_env: ty::ParamEnv<'tcx>,
505 // Number of errors that had been reported when we started
506 // checking this function. On exit, if we find that *more* errors
507 // have been reported, we will skip regionck and other work that
508 // expects the types within the function to be consistent.
509 err_count_on_creation: usize,
511 ret_coercion: Option<RefCell<DynamicCoerceMany<'gcx, 'tcx>>>,
513 yield_ty: Option<Ty<'tcx>>,
515 ps: RefCell<UnsafetyState>,
517 /// Whether the last checked node generates a divergence (e.g.,
518 /// `return` will set this to Always). In general, when entering
519 /// an expression or other node in the tree, the initial value
520 /// indicates whether prior parts of the containing expression may
521 /// have diverged. It is then typically set to `Maybe` (and the
522 /// old value remembered) for processing the subparts of the
523 /// current expression. As each subpart is processed, they may set
524 /// the flag to `Always` etc. Finally, at the end, we take the
525 /// result and "union" it with the original value, so that when we
526 /// return the flag indicates if any subpart of the the parent
527 /// expression (up to and including this part) has diverged. So,
528 /// if you read it after evaluating a subexpression `X`, the value
529 /// you get indicates whether any subexpression that was
530 /// evaluating up to and including `X` diverged.
532 /// We use this flag for two purposes:
534 /// - To warn about unreachable code: if, after processing a
535 /// sub-expression but before we have applied the effects of the
536 /// current node, we see that the flag is set to `Always`, we
537 /// can issue a warning. This corresponds to something like
538 /// `foo(return)`; we warn on the `foo()` expression. (We then
539 /// update the flag to `WarnedAlways` to suppress duplicate
540 /// reports.) Similarly, if we traverse to a fresh statement (or
541 /// tail expression) from a `Always` setting, we will issue a
542 /// warning. This corresponds to something like `{return;
543 /// foo();}` or `{return; 22}`, where we would warn on the
546 /// - To permit assignment into a local variable or other lvalue
547 /// (including the "return slot") of type `!`. This is allowed
548 /// if **either** the type of value being assigned is `!`, which
549 /// means the current code is dead, **or** the expression's
550 /// diverging flag is true, which means that a diverging value was
551 /// wrapped (e.g., `let x: ! = foo(return)`).
553 /// To repeat the last point: an expression represents dead-code
554 /// if, after checking it, **either** its type is `!` OR the
555 /// diverges flag is set to something other than `Maybe`.
556 diverges: Cell<Diverges>,
558 /// Whether any child nodes have any type errors.
559 has_errors: Cell<bool>,
561 enclosing_breakables: RefCell<EnclosingBreakables<'gcx, 'tcx>>,
563 inh: &'a Inherited<'a, 'gcx, 'tcx>,
566 impl<'a, 'gcx, 'tcx> Deref for FnCtxt<'a, 'gcx, 'tcx> {
567 type Target = Inherited<'a, 'gcx, 'tcx>;
568 fn deref(&self) -> &Self::Target {
573 /// Helper type of a temporary returned by Inherited::build(...).
574 /// Necessary because we can't write the following bound:
575 /// F: for<'b, 'tcx> where 'gcx: 'tcx FnOnce(Inherited<'b, 'gcx, 'tcx>).
576 pub struct InheritedBuilder<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
577 infcx: infer::InferCtxtBuilder<'a, 'gcx, 'tcx>,
581 impl<'a, 'gcx, 'tcx> Inherited<'a, 'gcx, 'tcx> {
582 pub fn build(tcx: TyCtxt<'a, 'gcx, 'gcx>, def_id: DefId)
583 -> InheritedBuilder<'a, 'gcx, 'tcx> {
584 let hir_id_root = if def_id.is_local() {
585 let node_id = tcx.hir.as_local_node_id(def_id).unwrap();
586 let hir_id = tcx.hir.definitions().node_to_hir_id(node_id);
587 DefId::local(hir_id.owner)
593 infcx: tcx.infer_ctxt().with_fresh_in_progress_tables(hir_id_root),
599 impl<'a, 'gcx, 'tcx> InheritedBuilder<'a, 'gcx, 'tcx> {
600 fn enter<F, R>(&'tcx mut self, f: F) -> R
601 where F: for<'b> FnOnce(Inherited<'b, 'gcx, 'tcx>) -> R
603 let def_id = self.def_id;
604 self.infcx.enter(|infcx| f(Inherited::new(infcx, def_id)))
608 impl<'a, 'gcx, 'tcx> Inherited<'a, 'gcx, 'tcx> {
609 fn new(infcx: InferCtxt<'a, 'gcx, 'tcx>, def_id: DefId) -> Self {
611 let item_id = tcx.hir.as_local_node_id(def_id);
612 let body_id = item_id.and_then(|id| tcx.hir.maybe_body_owned_by(id));
613 let implicit_region_bound = body_id.map(|body_id| {
614 let body = tcx.hir.body(body_id);
615 tcx.mk_region(ty::ReScope(region::Scope::CallSite(body.value.hir_id.local_id)))
619 tables: MaybeInProgressTables {
620 maybe_tables: infcx.in_progress_tables,
623 fulfillment_cx: RefCell::new(traits::FulfillmentContext::new()),
624 locals: RefCell::new(NodeMap()),
625 deferred_call_resolutions: RefCell::new(DefIdMap()),
626 deferred_cast_checks: RefCell::new(Vec::new()),
627 deferred_generator_interiors: RefCell::new(Vec::new()),
628 anon_types: RefCell::new(DefIdMap()),
629 implicit_region_bound,
634 fn register_predicate(&self, obligation: traits::PredicateObligation<'tcx>) {
635 debug!("register_predicate({:?})", obligation);
636 if obligation.has_escaping_regions() {
637 span_bug!(obligation.cause.span, "escaping regions in predicate {:?}",
642 .register_predicate_obligation(self, obligation);
645 fn register_predicates<I>(&self, obligations: I)
646 where I: IntoIterator<Item = traits::PredicateObligation<'tcx>> {
647 for obligation in obligations {
648 self.register_predicate(obligation);
652 fn register_infer_ok_obligations<T>(&self, infer_ok: InferOk<'tcx, T>) -> T {
653 self.register_predicates(infer_ok.obligations);
657 fn normalize_associated_types_in<T>(&self,
659 body_id: ast::NodeId,
660 param_env: ty::ParamEnv<'tcx>,
662 where T : TypeFoldable<'tcx>
664 let ok = self.partially_normalize_associated_types_in(span, body_id, param_env, value);
665 self.register_infer_ok_obligations(ok)
669 struct CheckItemTypesVisitor<'a, 'tcx: 'a> { tcx: TyCtxt<'a, 'tcx, 'tcx> }
671 impl<'a, 'tcx> ItemLikeVisitor<'tcx> for CheckItemTypesVisitor<'a, 'tcx> {
672 fn visit_item(&mut self, i: &'tcx hir::Item) {
673 check_item_type(self.tcx, i);
675 fn visit_trait_item(&mut self, _: &'tcx hir::TraitItem) { }
676 fn visit_impl_item(&mut self, _: &'tcx hir::ImplItem) { }
679 pub fn check_wf_new<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Result<(), ErrorReported> {
680 tcx.sess.track_errors(|| {
681 let mut visit = wfcheck::CheckTypeWellFormedVisitor::new(tcx);
682 tcx.hir.krate().visit_all_item_likes(&mut visit.as_deep_visitor());
686 pub fn check_item_types<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Result<(), ErrorReported> {
687 tcx.sess.track_errors(|| {
688 tcx.hir.krate().visit_all_item_likes(&mut CheckItemTypesVisitor { tcx });
692 pub fn check_item_bodies<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Result<(), CompileIncomplete> {
693 tcx.typeck_item_bodies(LOCAL_CRATE)
696 fn typeck_item_bodies<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, crate_num: CrateNum)
697 -> Result<(), CompileIncomplete>
699 debug_assert!(crate_num == LOCAL_CRATE);
700 Ok(tcx.sess.track_errors(|| {
701 for body_owner_def_id in tcx.body_owners() {
702 ty::maps::queries::typeck_tables_of::ensure(tcx, body_owner_def_id);
707 pub fn provide(providers: &mut Providers) {
708 *providers = Providers {
718 fn adt_destructor<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
720 -> Option<ty::Destructor> {
721 tcx.calculate_dtor(def_id, &mut dropck::check_drop_impl)
724 /// If this def-id is a "primary tables entry", returns `Some((body_id, decl))`
725 /// with information about it's body-id and fn-decl (if any). Otherwise,
728 /// If this function returns "some", then `typeck_tables(def_id)` will
729 /// succeed; if it returns `None`, then `typeck_tables(def_id)` may or
730 /// may not succeed. In some cases where this function returns `None`
731 /// (notably closures), `typeck_tables(def_id)` would wind up
732 /// redirecting to the owning function.
733 fn primary_body_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
735 -> Option<(hir::BodyId, Option<&'tcx hir::FnDecl>)>
737 match tcx.hir.get(id) {
738 hir::map::NodeItem(item) => {
740 hir::ItemConst(_, body) |
741 hir::ItemStatic(_, _, body) =>
743 hir::ItemFn(ref decl, .., body) =>
744 Some((body, Some(decl))),
749 hir::map::NodeTraitItem(item) => {
751 hir::TraitItemKind::Const(_, Some(body)) =>
753 hir::TraitItemKind::Method(ref sig, hir::TraitMethod::Provided(body)) =>
754 Some((body, Some(&sig.decl))),
759 hir::map::NodeImplItem(item) => {
761 hir::ImplItemKind::Const(_, body) =>
763 hir::ImplItemKind::Method(ref sig, body) =>
764 Some((body, Some(&sig.decl))),
769 hir::map::NodeExpr(expr) => {
770 // FIXME(eddyb) Closures should have separate
771 // function definition IDs and expression IDs.
772 // Type-checking should not let closures get
773 // this far in a constant position.
774 // Assume that everything other than closures
775 // is a constant "initializer" expression.
777 hir::ExprClosure(..) =>
780 Some((hir::BodyId { node_id: expr.id }, None)),
787 fn has_typeck_tables<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
790 // Closures' tables come from their outermost function,
791 // as they are part of the same "inference environment".
792 let outer_def_id = tcx.closure_base_def_id(def_id);
793 if outer_def_id != def_id {
794 return tcx.has_typeck_tables(outer_def_id);
797 let id = tcx.hir.as_local_node_id(def_id).unwrap();
798 primary_body_of(tcx, id).is_some()
801 fn used_trait_imports<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
804 tcx.typeck_tables_of(def_id).used_trait_imports.clone()
807 fn typeck_tables_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
809 -> &'tcx ty::TypeckTables<'tcx> {
810 // Closures' tables come from their outermost function,
811 // as they are part of the same "inference environment".
812 let outer_def_id = tcx.closure_base_def_id(def_id);
813 if outer_def_id != def_id {
814 return tcx.typeck_tables_of(outer_def_id);
817 let id = tcx.hir.as_local_node_id(def_id).unwrap();
818 let span = tcx.hir.span(id);
820 // Figure out what primary body this item has.
821 let (body_id, fn_decl) = primary_body_of(tcx, id).unwrap_or_else(|| {
822 span_bug!(span, "can't type-check body of {:?}", def_id);
824 let body = tcx.hir.body(body_id);
826 let tables = Inherited::build(tcx, def_id).enter(|inh| {
827 let param_env = tcx.param_env(def_id);
828 let fcx = if let Some(decl) = fn_decl {
829 let fn_sig = tcx.fn_sig(def_id);
831 check_abi(tcx, span, fn_sig.abi());
833 // Compute the fty from point of view of inside fn.
835 tcx.liberate_late_bound_regions(def_id, &fn_sig);
837 inh.normalize_associated_types_in(body.value.span,
842 let fcx = check_fn(&inh, param_env, fn_sig, decl, id, body, None).0;
845 let fcx = FnCtxt::new(&inh, param_env, body.value.id);
846 let expected_type = tcx.type_of(def_id);
847 let expected_type = fcx.normalize_associated_types_in(body.value.span, &expected_type);
848 fcx.require_type_is_sized(expected_type, body.value.span, traits::ConstSized);
850 // Gather locals in statics (because of block expressions).
851 // This is technically unnecessary because locals in static items are forbidden,
852 // but prevents type checking from blowing up before const checking can properly
854 GatherLocalsVisitor { fcx: &fcx }.visit_body(body);
856 fcx.check_expr_coercable_to_type(&body.value, expected_type);
861 fcx.select_all_obligations_and_apply_defaults();
862 fcx.closure_analyze(body);
863 fcx.select_obligations_where_possible();
865 fcx.resolve_generator_interiors(def_id);
866 fcx.select_all_obligations_or_error();
868 if fn_decl.is_some() {
869 fcx.regionck_fn(id, body);
871 fcx.regionck_expr(body);
874 fcx.resolve_type_vars_in_body(body)
877 // Consistency check our TypeckTables instance can hold all ItemLocalIds
878 // it will need to hold.
879 assert_eq!(tables.local_id_root,
880 Some(DefId::local(tcx.hir.definitions().node_to_hir_id(id).owner)));
884 fn check_abi<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, span: Span, abi: Abi) {
885 if !tcx.sess.target.target.is_abi_supported(abi) {
886 struct_span_err!(tcx.sess, span, E0570,
887 "The ABI `{}` is not supported for the current target", abi).emit()
891 struct GatherLocalsVisitor<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
892 fcx: &'a FnCtxt<'a, 'gcx, 'tcx>
895 impl<'a, 'gcx, 'tcx> GatherLocalsVisitor<'a, 'gcx, 'tcx> {
896 fn assign(&mut self, span: Span, nid: ast::NodeId, ty_opt: Option<Ty<'tcx>>) -> Ty<'tcx> {
899 // infer the variable's type
900 let var_ty = self.fcx.next_ty_var(TypeVariableOrigin::TypeInference(span));
901 self.fcx.locals.borrow_mut().insert(nid, var_ty);
905 // take type that the user specified
906 self.fcx.locals.borrow_mut().insert(nid, typ);
913 impl<'a, 'gcx, 'tcx> Visitor<'gcx> for GatherLocalsVisitor<'a, 'gcx, 'tcx> {
914 fn nested_visit_map<'this>(&'this mut self) -> NestedVisitorMap<'this, 'gcx> {
915 NestedVisitorMap::None
918 // Add explicitly-declared locals.
919 fn visit_local(&mut self, local: &'gcx hir::Local) {
920 let o_ty = match local.ty {
921 Some(ref ty) => Some(self.fcx.to_ty(&ty)),
924 self.assign(local.span, local.id, o_ty);
925 debug!("Local variable {:?} is assigned type {}",
927 self.fcx.ty_to_string(
928 self.fcx.locals.borrow().get(&local.id).unwrap().clone()));
929 intravisit::walk_local(self, local);
932 // Add pattern bindings.
933 fn visit_pat(&mut self, p: &'gcx hir::Pat) {
934 if let PatKind::Binding(_, _, ref path1, _) = p.node {
935 let var_ty = self.assign(p.span, p.id, None);
937 self.fcx.require_type_is_sized(var_ty, p.span,
938 traits::VariableType(p.id));
940 debug!("Pattern binding {} is assigned to {} with type {:?}",
942 self.fcx.ty_to_string(
943 self.fcx.locals.borrow().get(&p.id).unwrap().clone()),
946 intravisit::walk_pat(self, p);
949 // Don't descend into the bodies of nested closures
950 fn visit_fn(&mut self, _: intravisit::FnKind<'gcx>, _: &'gcx hir::FnDecl,
951 _: hir::BodyId, _: Span, _: ast::NodeId) { }
954 /// When `check_fn` is invoked on a generator (i.e., a body that
955 /// includes yield), it returns back some information about the yield
957 struct GeneratorTypes<'tcx> {
958 /// Type of value that is yielded.
959 yield_ty: ty::Ty<'tcx>,
961 /// Types that are captured (see `GeneratorInterior` for more).
962 interior: ty::GeneratorInterior<'tcx>
965 /// Helper used for fns and closures. Does the grungy work of checking a function
966 /// body and returns the function context used for that purpose, since in the case of a fn item
967 /// there is still a bit more to do.
970 /// * inherited: other fields inherited from the enclosing fn (if any)
971 fn check_fn<'a, 'gcx, 'tcx>(inherited: &'a Inherited<'a, 'gcx, 'tcx>,
972 param_env: ty::ParamEnv<'tcx>,
973 fn_sig: ty::FnSig<'tcx>,
974 decl: &'gcx hir::FnDecl,
976 body: &'gcx hir::Body,
977 can_be_generator: Option<hir::GeneratorMovability>)
978 -> (FnCtxt<'a, 'gcx, 'tcx>, Option<GeneratorTypes<'tcx>>)
980 let mut fn_sig = fn_sig.clone();
982 debug!("check_fn(sig={:?}, fn_id={}, param_env={:?})", fn_sig, fn_id, param_env);
984 // Create the function context. This is either derived from scratch or,
985 // in the case of function expressions, based on the outer context.
986 let mut fcx = FnCtxt::new(inherited, param_env, body.value.id);
987 *fcx.ps.borrow_mut() = UnsafetyState::function(fn_sig.unsafety, fn_id);
989 let ret_ty = fn_sig.output();
990 fcx.require_type_is_sized(ret_ty, decl.output.span(), traits::SizedReturnType);
991 let ret_ty = fcx.instantiate_anon_types_from_return_value(fn_id, &ret_ty);
992 fcx.ret_coercion = Some(RefCell::new(CoerceMany::new(ret_ty)));
993 fn_sig = fcx.tcx.mk_fn_sig(
994 fn_sig.inputs().iter().cloned(),
1001 let span = body.value.span;
1003 if body.is_generator && can_be_generator.is_some() {
1004 fcx.yield_ty = Some(fcx.next_ty_var(TypeVariableOrigin::TypeInference(span)));
1007 GatherLocalsVisitor { fcx: &fcx, }.visit_body(body);
1009 // Add formal parameters.
1010 for (arg_ty, arg) in fn_sig.inputs().iter().zip(&body.arguments) {
1011 // Check the pattern.
1012 fcx.check_pat_walk(&arg.pat, arg_ty,
1013 ty::BindingMode::BindByValue(hir::Mutability::MutImmutable), true);
1015 // Check that argument is Sized.
1016 // The check for a non-trivial pattern is a hack to avoid duplicate warnings
1017 // for simple cases like `fn foo(x: Trait)`,
1018 // where we would error once on the parameter as a whole, and once on the binding `x`.
1019 if arg.pat.simple_name().is_none() {
1020 fcx.require_type_is_sized(arg_ty, decl.output.span(), traits::MiscObligation);
1023 fcx.write_ty(arg.hir_id, arg_ty);
1026 let fn_hir_id = fcx.tcx.hir.node_to_hir_id(fn_id);
1027 inherited.tables.borrow_mut().liberated_fn_sigs_mut().insert(fn_hir_id, fn_sig);
1029 fcx.check_return_expr(&body.value);
1031 // We insert the deferred_generator_interiors entry after visiting the body.
1032 // This ensures that all nested generators appear before the entry of this generator.
1033 // resolve_generator_interiors relies on this property.
1034 let gen_ty = if can_be_generator.is_some() && body.is_generator {
1035 let witness = fcx.next_ty_var(TypeVariableOrigin::MiscVariable(span));
1036 let interior = ty::GeneratorInterior {
1038 movable: can_be_generator.unwrap() == hir::GeneratorMovability::Movable,
1040 fcx.deferred_generator_interiors.borrow_mut().push((body.id(), interior));
1041 Some(GeneratorTypes { yield_ty: fcx.yield_ty.unwrap(), interior: interior })
1046 // Finalize the return check by taking the LUB of the return types
1047 // we saw and assigning it to the expected return type. This isn't
1048 // really expected to fail, since the coercions would have failed
1049 // earlier when trying to find a LUB.
1051 // However, the behavior around `!` is sort of complex. In the
1052 // event that the `actual_return_ty` comes back as `!`, that
1053 // indicates that the fn either does not return or "returns" only
1054 // values of type `!`. In this case, if there is an expected
1055 // return type that is *not* `!`, that should be ok. But if the
1056 // return type is being inferred, we want to "fallback" to `!`:
1058 // let x = move || panic!();
1060 // To allow for that, I am creating a type variable with diverging
1061 // fallback. This was deemed ever so slightly better than unifying
1062 // the return value with `!` because it allows for the caller to
1063 // make more assumptions about the return type (e.g., they could do
1065 // let y: Option<u32> = Some(x());
1067 // which would then cause this return type to become `u32`, not
1069 let coercion = fcx.ret_coercion.take().unwrap().into_inner();
1070 let mut actual_return_ty = coercion.complete(&fcx);
1071 if actual_return_ty.is_never() {
1072 actual_return_ty = fcx.next_diverging_ty_var(
1073 TypeVariableOrigin::DivergingFn(span));
1075 fcx.demand_suptype(span, ret_ty, actual_return_ty);
1077 if fcx.tcx.sess.features.borrow().termination_trait {
1078 // If the termination trait language item is activated, check that the main return type
1079 // implements the termination trait.
1080 if let Some(term_id) = fcx.tcx.lang_items().termination() {
1081 if let Some((id, _)) = *fcx.tcx.sess.entry_fn.borrow() {
1083 match fcx.sess().entry_type.get() {
1084 Some(config::EntryMain) => {
1085 let substs = fcx.tcx.mk_substs(iter::once(Kind::from(ret_ty)));
1086 let trait_ref = ty::TraitRef::new(term_id, substs);
1087 let cause = traits::ObligationCause::new(
1088 span, fn_id, ObligationCauseCode::MainFunctionType);
1090 inherited.register_predicate(
1091 traits::Obligation::new(
1092 cause, param_env, trait_ref.to_predicate()));
1104 fn check_struct<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1107 let def_id = tcx.hir.local_def_id(id);
1108 let def = tcx.adt_def(def_id);
1109 def.destructor(tcx); // force the destructor to be evaluated
1110 check_representable(tcx, span, def_id);
1112 if def.repr.simd() {
1113 check_simd(tcx, span, def_id);
1116 check_transparent(tcx, span, def_id);
1117 check_packed(tcx, span, def_id);
1120 fn check_union<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1123 let def_id = tcx.hir.local_def_id(id);
1124 let def = tcx.adt_def(def_id);
1125 def.destructor(tcx); // force the destructor to be evaluated
1126 check_representable(tcx, span, def_id);
1128 check_packed(tcx, span, def_id);
1131 pub fn check_item_type<'a,'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, it: &'tcx hir::Item) {
1132 debug!("check_item_type(it.id={}, it.name={})",
1134 tcx.item_path_str(tcx.hir.local_def_id(it.id)));
1135 let _indenter = indenter();
1137 // Consts can play a role in type-checking, so they are included here.
1138 hir::ItemStatic(..) |
1139 hir::ItemConst(..) => {
1140 tcx.typeck_tables_of(tcx.hir.local_def_id(it.id));
1142 hir::ItemEnum(ref enum_definition, _) => {
1145 &enum_definition.variants,
1148 hir::ItemFn(..) => {} // entirely within check_item_body
1149 hir::ItemImpl(.., ref impl_item_refs) => {
1150 debug!("ItemImpl {} with id {}", it.name, it.id);
1151 let impl_def_id = tcx.hir.local_def_id(it.id);
1152 if let Some(impl_trait_ref) = tcx.impl_trait_ref(impl_def_id) {
1153 check_impl_items_against_trait(tcx,
1158 let trait_def_id = impl_trait_ref.def_id;
1159 check_on_unimplemented(tcx, trait_def_id, it);
1162 hir::ItemTrait(..) => {
1163 let def_id = tcx.hir.local_def_id(it.id);
1164 check_on_unimplemented(tcx, def_id, it);
1166 hir::ItemStruct(..) => {
1167 check_struct(tcx, it.id, it.span);
1169 hir::ItemUnion(..) => {
1170 check_union(tcx, it.id, it.span);
1172 hir::ItemTy(_, ref generics) => {
1173 let def_id = tcx.hir.local_def_id(it.id);
1174 let pty_ty = tcx.type_of(def_id);
1175 check_bounds_are_used(tcx, generics, pty_ty);
1177 hir::ItemForeignMod(ref m) => {
1178 check_abi(tcx, it.span, m.abi);
1180 if m.abi == Abi::RustIntrinsic {
1181 for item in &m.items {
1182 intrinsic::check_intrinsic_type(tcx, item);
1184 } else if m.abi == Abi::PlatformIntrinsic {
1185 for item in &m.items {
1186 intrinsic::check_platform_intrinsic_type(tcx, item);
1189 for item in &m.items {
1190 let generics = tcx.generics_of(tcx.hir.local_def_id(item.id));
1191 if !generics.types.is_empty() {
1192 let mut err = struct_span_err!(tcx.sess, item.span, E0044,
1193 "foreign items may not have type parameters");
1194 span_help!(&mut err, item.span,
1195 "consider using specialization instead of \
1200 if let hir::ForeignItemFn(ref fn_decl, _, _) = item.node {
1201 require_c_abi_if_variadic(tcx, fn_decl, m.abi, item.span);
1206 _ => {/* nothing to do */ }
1210 fn check_on_unimplemented<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1211 trait_def_id: DefId,
1213 let item_def_id = tcx.hir.local_def_id(item.id);
1214 // an error would be reported if this fails.
1215 let _ = traits::OnUnimplementedDirective::of_item(tcx, trait_def_id, item_def_id);
1218 fn report_forbidden_specialization<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1219 impl_item: &hir::ImplItem,
1222 let mut err = struct_span_err!(
1223 tcx.sess, impl_item.span, E0520,
1224 "`{}` specializes an item from a parent `impl`, but \
1225 that item is not marked `default`",
1227 err.span_label(impl_item.span, format!("cannot specialize default item `{}`",
1230 match tcx.span_of_impl(parent_impl) {
1232 err.span_label(span, "parent `impl` is here");
1233 err.note(&format!("to specialize, `{}` in the parent `impl` must be marked `default`",
1237 err.note(&format!("parent implementation is in crate `{}`", cname));
1244 fn check_specialization_validity<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1245 trait_def: &ty::TraitDef,
1246 trait_item: &ty::AssociatedItem,
1248 impl_item: &hir::ImplItem)
1250 let ancestors = trait_def.ancestors(tcx, impl_id);
1252 let kind = match impl_item.node {
1253 hir::ImplItemKind::Const(..) => ty::AssociatedKind::Const,
1254 hir::ImplItemKind::Method(..) => ty::AssociatedKind::Method,
1255 hir::ImplItemKind::Type(_) => ty::AssociatedKind::Type
1258 let parent = ancestors.defs(tcx, trait_item.name, kind, trait_def.def_id).skip(1).next()
1259 .map(|node_item| node_item.map(|parent| parent.defaultness));
1261 if let Some(parent) = parent {
1262 if tcx.impl_item_is_final(&parent) {
1263 report_forbidden_specialization(tcx, impl_item, parent.node.def_id());
1269 fn check_impl_items_against_trait<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1272 impl_trait_ref: ty::TraitRef<'tcx>,
1273 impl_item_refs: &[hir::ImplItemRef]) {
1274 let impl_span = tcx.sess.codemap().def_span(impl_span);
1276 // If the trait reference itself is erroneous (so the compilation is going
1277 // to fail), skip checking the items here -- the `impl_item` table in `tcx`
1278 // isn't populated for such impls.
1279 if impl_trait_ref.references_error() { return; }
1281 // Locate trait definition and items
1282 let trait_def = tcx.trait_def(impl_trait_ref.def_id);
1283 let mut overridden_associated_type = None;
1285 let impl_items = || impl_item_refs.iter().map(|iiref| tcx.hir.impl_item(iiref.id));
1287 // Check existing impl methods to see if they are both present in trait
1288 // and compatible with trait signature
1289 for impl_item in impl_items() {
1290 let ty_impl_item = tcx.associated_item(tcx.hir.local_def_id(impl_item.id));
1291 let ty_trait_item = tcx.associated_items(impl_trait_ref.def_id)
1292 .find(|ac| Namespace::from(&impl_item.node) == Namespace::from(ac.kind) &&
1293 tcx.hygienic_eq(ty_impl_item.name, ac.name, impl_trait_ref.def_id))
1295 // Not compatible, but needed for the error message
1296 tcx.associated_items(impl_trait_ref.def_id)
1297 .find(|ac| tcx.hygienic_eq(ty_impl_item.name, ac.name, impl_trait_ref.def_id))
1300 // Check that impl definition matches trait definition
1301 if let Some(ty_trait_item) = ty_trait_item {
1302 match impl_item.node {
1303 hir::ImplItemKind::Const(..) => {
1304 // Find associated const definition.
1305 if ty_trait_item.kind == ty::AssociatedKind::Const {
1306 compare_const_impl(tcx,
1312 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0323,
1313 "item `{}` is an associated const, \
1314 which doesn't match its trait `{}`",
1317 err.span_label(impl_item.span, "does not match trait");
1318 // We can only get the spans from local trait definition
1319 // Same for E0324 and E0325
1320 if let Some(trait_span) = tcx.hir.span_if_local(ty_trait_item.def_id) {
1321 err.span_label(trait_span, "item in trait");
1326 hir::ImplItemKind::Method(..) => {
1327 let trait_span = tcx.hir.span_if_local(ty_trait_item.def_id);
1328 if ty_trait_item.kind == ty::AssociatedKind::Method {
1329 compare_impl_method(tcx,
1336 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0324,
1337 "item `{}` is an associated method, \
1338 which doesn't match its trait `{}`",
1341 err.span_label(impl_item.span, "does not match trait");
1342 if let Some(trait_span) = tcx.hir.span_if_local(ty_trait_item.def_id) {
1343 err.span_label(trait_span, "item in trait");
1348 hir::ImplItemKind::Type(_) => {
1349 if ty_trait_item.kind == ty::AssociatedKind::Type {
1350 if ty_trait_item.defaultness.has_value() {
1351 overridden_associated_type = Some(impl_item);
1354 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0325,
1355 "item `{}` is an associated type, \
1356 which doesn't match its trait `{}`",
1359 err.span_label(impl_item.span, "does not match trait");
1360 if let Some(trait_span) = tcx.hir.span_if_local(ty_trait_item.def_id) {
1361 err.span_label(trait_span, "item in trait");
1368 check_specialization_validity(tcx, trait_def, &ty_trait_item, impl_id, impl_item);
1372 // Check for missing items from trait
1373 let mut missing_items = Vec::new();
1374 let mut invalidated_items = Vec::new();
1375 let associated_type_overridden = overridden_associated_type.is_some();
1376 for trait_item in tcx.associated_items(impl_trait_ref.def_id) {
1377 let is_implemented = trait_def.ancestors(tcx, impl_id)
1378 .defs(tcx, trait_item.name, trait_item.kind, impl_trait_ref.def_id)
1380 .map(|node_item| !node_item.node.is_from_trait())
1383 if !is_implemented {
1384 if !trait_item.defaultness.has_value() {
1385 missing_items.push(trait_item);
1386 } else if associated_type_overridden {
1387 invalidated_items.push(trait_item.name);
1392 if !missing_items.is_empty() {
1393 let mut err = struct_span_err!(tcx.sess, impl_span, E0046,
1394 "not all trait items implemented, missing: `{}`",
1395 missing_items.iter()
1396 .map(|trait_item| trait_item.name.to_string())
1397 .collect::<Vec<_>>().join("`, `"));
1398 err.span_label(impl_span, format!("missing `{}` in implementation",
1399 missing_items.iter()
1400 .map(|trait_item| trait_item.name.to_string())
1401 .collect::<Vec<_>>().join("`, `")));
1402 for trait_item in missing_items {
1403 if let Some(span) = tcx.hir.span_if_local(trait_item.def_id) {
1404 err.span_label(span, format!("`{}` from trait", trait_item.name));
1406 err.note_trait_signature(trait_item.name.to_string(),
1407 trait_item.signature(&tcx));
1413 if !invalidated_items.is_empty() {
1414 let invalidator = overridden_associated_type.unwrap();
1415 span_err!(tcx.sess, invalidator.span, E0399,
1416 "the following trait items need to be reimplemented \
1417 as `{}` was overridden: `{}`",
1419 invalidated_items.iter()
1420 .map(|name| name.to_string())
1421 .collect::<Vec<_>>().join("`, `"))
1425 /// Checks whether a type can be represented in memory. In particular, it
1426 /// identifies types that contain themselves without indirection through a
1427 /// pointer, which would mean their size is unbounded.
1428 fn check_representable<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1432 let rty = tcx.type_of(item_def_id);
1434 // Check that it is possible to represent this type. This call identifies
1435 // (1) types that contain themselves and (2) types that contain a different
1436 // recursive type. It is only necessary to throw an error on those that
1437 // contain themselves. For case 2, there must be an inner type that will be
1438 // caught by case 1.
1439 match rty.is_representable(tcx, sp) {
1440 Representability::SelfRecursive(spans) => {
1441 let mut err = tcx.recursive_type_with_infinite_size_error(item_def_id);
1443 err.span_label(span, "recursive without indirection");
1448 Representability::Representable | Representability::ContainsRecursive => (),
1453 pub fn check_simd<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, sp: Span, def_id: DefId) {
1454 let t = tcx.type_of(def_id);
1456 ty::TyAdt(def, substs) if def.is_struct() => {
1457 let fields = &def.non_enum_variant().fields;
1458 if fields.is_empty() {
1459 span_err!(tcx.sess, sp, E0075, "SIMD vector cannot be empty");
1462 let e = fields[0].ty(tcx, substs);
1463 if !fields.iter().all(|f| f.ty(tcx, substs) == e) {
1464 struct_span_err!(tcx.sess, sp, E0076, "SIMD vector should be homogeneous")
1465 .span_label(sp, "SIMD elements must have the same type")
1470 ty::TyParam(_) => { /* struct<T>(T, T, T, T) is ok */ }
1471 _ if e.is_machine() => { /* struct(u8, u8, u8, u8) is ok */ }
1473 span_err!(tcx.sess, sp, E0077,
1474 "SIMD vector element type should be machine type");
1483 fn check_packed<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, sp: Span, def_id: DefId) {
1484 if tcx.adt_def(def_id).repr.packed() {
1485 if tcx.adt_def(def_id).repr.align > 0 {
1486 struct_span_err!(tcx.sess, sp, E0587,
1487 "type has conflicting packed and align representation hints").emit();
1489 else if check_packed_inner(tcx, def_id, &mut Vec::new()) {
1490 struct_span_err!(tcx.sess, sp, E0588,
1491 "packed type cannot transitively contain a `[repr(align)]` type").emit();
1496 fn check_packed_inner<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1498 stack: &mut Vec<DefId>) -> bool {
1499 let t = tcx.type_of(def_id);
1500 if stack.contains(&def_id) {
1501 debug!("check_packed_inner: {:?} is recursive", t);
1505 ty::TyAdt(def, substs) if def.is_struct() || def.is_union() => {
1506 if tcx.adt_def(def.did).repr.align > 0 {
1509 // push struct def_id before checking fields
1511 for field in &def.non_enum_variant().fields {
1512 let f = field.ty(tcx, substs);
1514 ty::TyAdt(def, _) => {
1515 if check_packed_inner(tcx, def.did, stack) {
1522 // only need to pop if not early out
1530 fn check_transparent<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, sp: Span, def_id: DefId) {
1531 let adt = tcx.adt_def(def_id);
1532 if !adt.repr.transparent() {
1536 // For each field, figure out if it's known to be a ZST and align(1)
1537 let field_infos: Vec<_> = adt.non_enum_variant().fields.iter().map(|field| {
1538 let ty = field.ty(tcx, Substs::identity_for_item(tcx, field.did));
1539 let param_env = tcx.param_env(field.did);
1540 let layout = (tcx, param_env).layout_of(ty);
1541 // We are currently checking the type this field came from, so it must be local
1542 let span = tcx.hir.span_if_local(field.did).unwrap();
1543 let zst = layout.map(|layout| layout.is_zst()).unwrap_or(false);
1544 let align1 = layout.map(|layout| layout.align.abi() == 1).unwrap_or(false);
1548 let non_zst_fields = field_infos.iter().filter(|(_span, zst, _align1)| !*zst);
1549 let non_zst_count = non_zst_fields.clone().count();
1550 if non_zst_count != 1 {
1551 let field_spans: Vec<_> = non_zst_fields.map(|(span, _zst, _align1)| *span).collect();
1552 struct_span_err!(tcx.sess, sp, E0690,
1553 "transparent struct needs exactly one non-zero-sized field, but has {}",
1555 .span_note(field_spans, "non-zero-sized field")
1558 for &(span, zst, align1) in &field_infos {
1560 span_err!(tcx.sess, span, E0691,
1561 "zero-sized field in transparent struct has alignment larger than 1");
1566 #[allow(trivial_numeric_casts)]
1567 pub fn check_enum<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1569 vs: &'tcx [hir::Variant],
1571 let def_id = tcx.hir.local_def_id(id);
1572 let def = tcx.adt_def(def_id);
1573 def.destructor(tcx); // force the destructor to be evaluated
1576 let attributes = tcx.get_attrs(def_id);
1577 if let Some(attr) = attr::find_by_name(&attributes, "repr") {
1579 tcx.sess, attr.span, E0084,
1580 "unsupported representation for zero-variant enum")
1581 .span_label(sp, "zero-variant enum")
1586 let repr_type_ty = def.repr.discr_type().to_ty(tcx);
1587 if repr_type_ty == tcx.types.i128 || repr_type_ty == tcx.types.u128 {
1588 if !tcx.sess.features.borrow().repr128 {
1589 emit_feature_err(&tcx.sess.parse_sess,
1592 GateIssue::Language,
1593 "repr with 128-bit type is unstable");
1598 if let Some(e) = v.node.disr_expr {
1599 tcx.typeck_tables_of(tcx.hir.local_def_id(e.node_id));
1603 let mut disr_vals: Vec<ConstInt> = Vec::new();
1604 for (discr, v) in def.discriminants(tcx).zip(vs) {
1605 // Check for duplicate discriminant values
1606 if let Some(i) = disr_vals.iter().position(|&x| x == discr) {
1607 let variant_i_node_id = tcx.hir.as_local_node_id(def.variants[i].did).unwrap();
1608 let variant_i = tcx.hir.expect_variant(variant_i_node_id);
1609 let i_span = match variant_i.node.disr_expr {
1610 Some(expr) => tcx.hir.span(expr.node_id),
1611 None => tcx.hir.span(variant_i_node_id)
1613 let span = match v.node.disr_expr {
1614 Some(expr) => tcx.hir.span(expr.node_id),
1617 struct_span_err!(tcx.sess, span, E0081,
1618 "discriminant value `{}` already exists", disr_vals[i])
1619 .span_label(i_span, format!("first use of `{}`", disr_vals[i]))
1620 .span_label(span , format!("enum already has `{}`", disr_vals[i]))
1623 disr_vals.push(discr);
1626 check_representable(tcx, sp, def_id);
1629 impl<'a, 'gcx, 'tcx> AstConv<'gcx, 'tcx> for FnCtxt<'a, 'gcx, 'tcx> {
1630 fn tcx<'b>(&'b self) -> TyCtxt<'b, 'gcx, 'tcx> { self.tcx }
1632 fn get_type_parameter_bounds(&self, _: Span, def_id: DefId)
1633 -> ty::GenericPredicates<'tcx>
1636 let node_id = tcx.hir.as_local_node_id(def_id).unwrap();
1637 let item_id = tcx.hir.ty_param_owner(node_id);
1638 let item_def_id = tcx.hir.local_def_id(item_id);
1639 let generics = tcx.generics_of(item_def_id);
1640 let index = generics.type_param_to_index[&def_id];
1641 ty::GenericPredicates {
1643 predicates: self.param_env.caller_bounds.iter().filter(|predicate| {
1645 ty::Predicate::Trait(ref data) => {
1646 data.0.self_ty().is_param(index)
1650 }).cloned().collect()
1654 fn re_infer(&self, span: Span, def: Option<&ty::RegionParameterDef>)
1655 -> Option<ty::Region<'tcx>> {
1657 Some(def) => infer::EarlyBoundRegion(span, def.name),
1658 None => infer::MiscVariable(span)
1660 Some(self.next_region_var(v))
1663 fn ty_infer(&self, span: Span) -> Ty<'tcx> {
1664 self.next_ty_var(TypeVariableOrigin::TypeInference(span))
1667 fn ty_infer_for_def(&self,
1668 ty_param_def: &ty::TypeParameterDef,
1669 substs: &[Kind<'tcx>],
1670 span: Span) -> Ty<'tcx> {
1671 self.type_var_for_def(span, ty_param_def, substs)
1674 fn projected_ty_from_poly_trait_ref(&self,
1677 poly_trait_ref: ty::PolyTraitRef<'tcx>)
1680 let (trait_ref, _) =
1681 self.replace_late_bound_regions_with_fresh_var(
1683 infer::LateBoundRegionConversionTime::AssocTypeProjection(item_def_id),
1686 self.tcx().mk_projection(item_def_id, trait_ref.substs)
1689 fn normalize_ty(&self, span: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
1690 if ty.has_escaping_regions() {
1691 ty // FIXME: normalization and escaping regions
1693 self.normalize_associated_types_in(span, &ty)
1697 fn set_tainted_by_errors(&self) {
1698 self.infcx.set_tainted_by_errors()
1701 fn record_ty(&self, hir_id: hir::HirId, ty: Ty<'tcx>, _span: Span) {
1702 self.write_ty(hir_id, ty)
1706 /// Controls whether the arguments are tupled. This is used for the call
1709 /// Tupling means that all call-side arguments are packed into a tuple and
1710 /// passed as a single parameter. For example, if tupling is enabled, this
1713 /// fn f(x: (isize, isize))
1715 /// Can be called as:
1722 #[derive(Clone, Eq, PartialEq)]
1723 enum TupleArgumentsFlag {
1728 impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
1729 pub fn new(inh: &'a Inherited<'a, 'gcx, 'tcx>,
1730 param_env: ty::ParamEnv<'tcx>,
1731 body_id: ast::NodeId)
1732 -> FnCtxt<'a, 'gcx, 'tcx> {
1736 err_count_on_creation: inh.tcx.sess.err_count(),
1739 ps: RefCell::new(UnsafetyState::function(hir::Unsafety::Normal,
1740 ast::CRATE_NODE_ID)),
1741 diverges: Cell::new(Diverges::Maybe),
1742 has_errors: Cell::new(false),
1743 enclosing_breakables: RefCell::new(EnclosingBreakables {
1751 pub fn sess(&self) -> &Session {
1755 pub fn err_count_since_creation(&self) -> usize {
1756 self.tcx.sess.err_count() - self.err_count_on_creation
1759 /// Produce warning on the given node, if the current point in the
1760 /// function is unreachable, and there hasn't been another warning.
1761 fn warn_if_unreachable(&self, id: ast::NodeId, span: Span, kind: &str) {
1762 if self.diverges.get() == Diverges::Always {
1763 self.diverges.set(Diverges::WarnedAlways);
1765 debug!("warn_if_unreachable: id={:?} span={:?} kind={}", id, span, kind);
1767 self.tcx().lint_node(
1768 lint::builtin::UNREACHABLE_CODE,
1770 &format!("unreachable {}", kind));
1776 code: ObligationCauseCode<'tcx>)
1777 -> ObligationCause<'tcx> {
1778 ObligationCause::new(span, self.body_id, code)
1781 pub fn misc(&self, span: Span) -> ObligationCause<'tcx> {
1782 self.cause(span, ObligationCauseCode::MiscObligation)
1785 /// Resolves type variables in `ty` if possible. Unlike the infcx
1786 /// version (resolve_type_vars_if_possible), this version will
1787 /// also select obligations if it seems useful, in an effort
1788 /// to get more type information.
1789 fn resolve_type_vars_with_obligations(&self, mut ty: Ty<'tcx>) -> Ty<'tcx> {
1790 debug!("resolve_type_vars_with_obligations(ty={:?})", ty);
1792 // No TyInfer()? Nothing needs doing.
1793 if !ty.has_infer_types() {
1794 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
1798 // If `ty` is a type variable, see whether we already know what it is.
1799 ty = self.resolve_type_vars_if_possible(&ty);
1800 if !ty.has_infer_types() {
1801 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
1805 // If not, try resolving pending obligations as much as
1806 // possible. This can help substantially when there are
1807 // indirect dependencies that don't seem worth tracking
1809 self.select_obligations_where_possible();
1810 ty = self.resolve_type_vars_if_possible(&ty);
1812 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
1816 fn record_deferred_call_resolution(&self,
1817 closure_def_id: DefId,
1818 r: DeferredCallResolution<'gcx, 'tcx>) {
1819 let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
1820 deferred_call_resolutions.entry(closure_def_id).or_insert(vec![]).push(r);
1823 fn remove_deferred_call_resolutions(&self,
1824 closure_def_id: DefId)
1825 -> Vec<DeferredCallResolution<'gcx, 'tcx>>
1827 let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
1828 deferred_call_resolutions.remove(&closure_def_id).unwrap_or(vec![])
1831 pub fn tag(&self) -> String {
1832 let self_ptr: *const FnCtxt = self;
1833 format!("{:?}", self_ptr)
1836 pub fn local_ty(&self, span: Span, nid: ast::NodeId) -> Ty<'tcx> {
1837 match self.locals.borrow().get(&nid) {
1840 span_bug!(span, "no type for local variable {}",
1841 self.tcx.hir.node_to_string(nid));
1847 pub fn write_ty(&self, id: hir::HirId, ty: Ty<'tcx>) {
1848 debug!("write_ty({:?}, {:?}) in fcx {}",
1849 id, self.resolve_type_vars_if_possible(&ty), self.tag());
1850 self.tables.borrow_mut().node_types_mut().insert(id, ty);
1852 if ty.references_error() {
1853 self.has_errors.set(true);
1854 self.set_tainted_by_errors();
1858 // The NodeId and the ItemLocalId must identify the same item. We just pass
1859 // both of them for consistency checking.
1860 pub fn write_method_call(&self,
1862 method: MethodCallee<'tcx>) {
1865 .type_dependent_defs_mut()
1866 .insert(hir_id, Def::Method(method.def_id));
1867 self.write_substs(hir_id, method.substs);
1870 pub fn write_substs(&self, node_id: hir::HirId, substs: &'tcx Substs<'tcx>) {
1871 if !substs.is_noop() {
1872 debug!("write_substs({:?}, {:?}) in fcx {}",
1877 self.tables.borrow_mut().node_substs_mut().insert(node_id, substs);
1881 pub fn apply_adjustments(&self, expr: &hir::Expr, adj: Vec<Adjustment<'tcx>>) {
1882 debug!("apply_adjustments(expr={:?}, adj={:?})", expr, adj);
1888 match self.tables.borrow_mut().adjustments_mut().entry(expr.hir_id) {
1889 Entry::Vacant(entry) => { entry.insert(adj); },
1890 Entry::Occupied(mut entry) => {
1891 debug!(" - composing on top of {:?}", entry.get());
1892 match (&entry.get()[..], &adj[..]) {
1893 // Applying any adjustment on top of a NeverToAny
1894 // is a valid NeverToAny adjustment, because it can't
1896 (&[Adjustment { kind: Adjust::NeverToAny, .. }], _) => return,
1898 Adjustment { kind: Adjust::Deref(_), .. },
1899 Adjustment { kind: Adjust::Borrow(AutoBorrow::Ref(..)), .. },
1901 Adjustment { kind: Adjust::Deref(_), .. },
1902 .. // Any following adjustments are allowed.
1904 // A reborrow has no effect before a dereference.
1906 // FIXME: currently we never try to compose autoderefs
1907 // and ReifyFnPointer/UnsafeFnPointer, but we could.
1909 bug!("while adjusting {:?}, can't compose {:?} and {:?}",
1910 expr, entry.get(), adj)
1912 *entry.get_mut() = adj;
1917 /// Basically whenever we are converting from a type scheme into
1918 /// the fn body space, we always want to normalize associated
1919 /// types as well. This function combines the two.
1920 fn instantiate_type_scheme<T>(&self,
1922 substs: &Substs<'tcx>,
1925 where T : TypeFoldable<'tcx>
1927 let value = value.subst(self.tcx, substs);
1928 let result = self.normalize_associated_types_in(span, &value);
1929 debug!("instantiate_type_scheme(value={:?}, substs={:?}) = {:?}",
1936 /// As `instantiate_type_scheme`, but for the bounds found in a
1937 /// generic type scheme.
1938 fn instantiate_bounds(&self, span: Span, def_id: DefId, substs: &Substs<'tcx>)
1939 -> ty::InstantiatedPredicates<'tcx> {
1940 let bounds = self.tcx.predicates_of(def_id);
1941 let result = bounds.instantiate(self.tcx, substs);
1942 let result = self.normalize_associated_types_in(span, &result);
1943 debug!("instantiate_bounds(bounds={:?}, substs={:?}) = {:?}",
1950 /// Replace the anonymized types from the return value of the
1951 /// function with type variables and records the `AnonTypeMap` for
1952 /// later use during writeback. See
1953 /// `InferCtxt::instantiate_anon_types` for more details.
1954 fn instantiate_anon_types_from_return_value<T: TypeFoldable<'tcx>>(
1959 let fn_def_id = self.tcx.hir.local_def_id(fn_id);
1961 "instantiate_anon_types_from_return_value(fn_def_id={:?}, value={:?})",
1966 let (value, anon_type_map) = self.register_infer_ok_obligations(
1967 self.instantiate_anon_types(
1975 let mut anon_types = self.anon_types.borrow_mut();
1976 for (ty, decl) in anon_type_map {
1977 let old_value = anon_types.insert(ty, decl);
1978 assert!(old_value.is_none(), "instantiated twice: {:?}/{:?}", ty, decl);
1984 fn normalize_associated_types_in<T>(&self, span: Span, value: &T) -> T
1985 where T : TypeFoldable<'tcx>
1987 self.inh.normalize_associated_types_in(span, self.body_id, self.param_env, value)
1990 fn normalize_associated_types_in_as_infer_ok<T>(&self, span: Span, value: &T)
1992 where T : TypeFoldable<'tcx>
1994 self.inh.partially_normalize_associated_types_in(span,
2000 pub fn require_type_meets(&self,
2003 code: traits::ObligationCauseCode<'tcx>,
2006 self.register_bound(
2009 traits::ObligationCause::new(span, self.body_id, code));
2012 pub fn require_type_is_sized(&self,
2015 code: traits::ObligationCauseCode<'tcx>)
2017 let lang_item = self.tcx.require_lang_item(lang_items::SizedTraitLangItem);
2018 self.require_type_meets(ty, span, code, lang_item);
2021 pub fn register_bound(&self,
2024 cause: traits::ObligationCause<'tcx>)
2026 self.fulfillment_cx.borrow_mut()
2027 .register_bound(self, self.param_env, ty, def_id, cause);
2030 pub fn to_ty(&self, ast_t: &hir::Ty) -> Ty<'tcx> {
2031 let t = AstConv::ast_ty_to_ty(self, ast_t);
2032 self.register_wf_obligation(t, ast_t.span, traits::MiscObligation);
2036 pub fn node_ty(&self, id: hir::HirId) -> Ty<'tcx> {
2037 match self.tables.borrow().node_types().get(id) {
2039 None if self.is_tainted_by_errors() => self.tcx.types.err,
2041 let node_id = self.tcx.hir.definitions().find_node_for_hir_id(id);
2042 bug!("no type for node {}: {} in fcx {}",
2043 node_id, self.tcx.hir.node_to_string(node_id),
2049 /// Registers an obligation for checking later, during regionck, that the type `ty` must
2050 /// outlive the region `r`.
2051 pub fn register_wf_obligation(&self,
2054 code: traits::ObligationCauseCode<'tcx>)
2056 // WF obligations never themselves fail, so no real need to give a detailed cause:
2057 let cause = traits::ObligationCause::new(span, self.body_id, code);
2058 self.register_predicate(traits::Obligation::new(cause,
2060 ty::Predicate::WellFormed(ty)));
2063 /// Registers obligations that all types appearing in `substs` are well-formed.
2064 pub fn add_wf_bounds(&self, substs: &Substs<'tcx>, expr: &hir::Expr)
2066 for ty in substs.types() {
2067 self.register_wf_obligation(ty, expr.span, traits::MiscObligation);
2071 /// Given a fully substituted set of bounds (`generic_bounds`), and the values with which each
2072 /// type/region parameter was instantiated (`substs`), creates and registers suitable
2073 /// trait/region obligations.
2075 /// For example, if there is a function:
2078 /// fn foo<'a,T:'a>(...)
2081 /// and a reference:
2087 /// Then we will create a fresh region variable `'$0` and a fresh type variable `$1` for `'a`
2088 /// and `T`. This routine will add a region obligation `$1:'$0` and register it locally.
2089 pub fn add_obligations_for_parameters(&self,
2090 cause: traits::ObligationCause<'tcx>,
2091 predicates: &ty::InstantiatedPredicates<'tcx>)
2093 assert!(!predicates.has_escaping_regions());
2095 debug!("add_obligations_for_parameters(predicates={:?})",
2098 for obligation in traits::predicates_for_generics(cause, self.param_env, predicates) {
2099 self.register_predicate(obligation);
2103 // FIXME(arielb1): use this instead of field.ty everywhere
2104 // Only for fields! Returns <none> for methods>
2105 // Indifferent to privacy flags
2106 pub fn field_ty(&self,
2108 field: &'tcx ty::FieldDef,
2109 substs: &Substs<'tcx>)
2112 self.normalize_associated_types_in(span,
2113 &field.ty(self.tcx, substs))
2116 fn check_casts(&self) {
2117 let mut deferred_cast_checks = self.deferred_cast_checks.borrow_mut();
2118 for cast in deferred_cast_checks.drain(..) {
2123 fn resolve_generator_interiors(&self, def_id: DefId) {
2124 let mut generators = self.deferred_generator_interiors.borrow_mut();
2125 for (body_id, interior) in generators.drain(..) {
2126 self.select_obligations_where_possible();
2127 generator_interior::resolve_interior(self, def_id, body_id, interior);
2131 /// Apply "fallbacks" to some types
2132 /// unconstrained types get replaced with ! or () (depending on whether
2133 /// feature(never_type) is enabled), unconstrained ints with i32, and
2134 /// unconstrained floats with f64.
2135 fn default_type_parameters(&self) {
2136 use rustc::ty::error::UnconstrainedNumeric::Neither;
2137 use rustc::ty::error::UnconstrainedNumeric::{UnconstrainedInt, UnconstrainedFloat};
2139 // Defaulting inference variables becomes very dubious if we have
2140 // encountered type-checking errors. Therefore, if we think we saw
2141 // some errors in this function, just resolve all uninstanted type
2142 // varibles to TyError.
2143 if self.is_tainted_by_errors() {
2144 for ty in &self.unsolved_variables() {
2145 if let ty::TyInfer(_) = self.shallow_resolve(ty).sty {
2146 debug!("default_type_parameters: defaulting `{:?}` to error", ty);
2147 self.demand_eqtype(syntax_pos::DUMMY_SP, *ty, self.tcx().types.err);
2153 for ty in &self.unsolved_variables() {
2154 let resolved = self.resolve_type_vars_if_possible(ty);
2155 if self.type_var_diverges(resolved) {
2156 debug!("default_type_parameters: defaulting `{:?}` to `!` because it diverges",
2158 self.demand_eqtype(syntax_pos::DUMMY_SP, *ty,
2159 self.tcx.mk_diverging_default());
2161 match self.type_is_unconstrained_numeric(resolved) {
2162 UnconstrainedInt => {
2163 debug!("default_type_parameters: defaulting `{:?}` to `i32`",
2165 self.demand_eqtype(syntax_pos::DUMMY_SP, *ty, self.tcx.types.i32)
2167 UnconstrainedFloat => {
2168 debug!("default_type_parameters: defaulting `{:?}` to `f32`",
2170 self.demand_eqtype(syntax_pos::DUMMY_SP, *ty, self.tcx.types.f64)
2178 // Implements type inference fallback algorithm
2179 fn select_all_obligations_and_apply_defaults(&self) {
2180 self.select_obligations_where_possible();
2181 self.default_type_parameters();
2182 self.select_obligations_where_possible();
2185 fn select_all_obligations_or_error(&self) {
2186 debug!("select_all_obligations_or_error");
2188 // upvar inference should have ensured that all deferred call
2189 // resolutions are handled by now.
2190 assert!(self.deferred_call_resolutions.borrow().is_empty());
2192 self.select_all_obligations_and_apply_defaults();
2194 let mut fulfillment_cx = self.fulfillment_cx.borrow_mut();
2196 match fulfillment_cx.select_all_or_error(self) {
2198 Err(errors) => { self.report_fulfillment_errors(&errors, self.inh.body_id); }
2202 /// Select as many obligations as we can at present.
2203 fn select_obligations_where_possible(&self) {
2204 match self.fulfillment_cx.borrow_mut().select_where_possible(self) {
2206 Err(errors) => { self.report_fulfillment_errors(&errors, self.inh.body_id); }
2210 /// For the overloaded lvalue expressions (`*x`, `x[3]`), the trait
2211 /// returns a type of `&T`, but the actual type we assign to the
2212 /// *expression* is `T`. So this function just peels off the return
2213 /// type by one layer to yield `T`.
2214 fn make_overloaded_lvalue_return_type(&self,
2215 method: MethodCallee<'tcx>)
2216 -> ty::TypeAndMut<'tcx>
2218 // extract method return type, which will be &T;
2219 let ret_ty = method.sig.output();
2221 // method returns &T, but the type as visible to user is T, so deref
2222 ret_ty.builtin_deref(true, NoPreference).unwrap()
2225 fn lookup_indexing(&self,
2227 base_expr: &'gcx hir::Expr,
2230 lvalue_pref: LvaluePreference)
2231 -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)>
2233 // FIXME(#18741) -- this is almost but not quite the same as the
2234 // autoderef that normal method probing does. They could likely be
2237 let mut autoderef = self.autoderef(base_expr.span, base_ty);
2238 let mut result = None;
2239 while result.is_none() && autoderef.next().is_some() {
2240 result = self.try_index_step(expr, base_expr, &autoderef, lvalue_pref, idx_ty);
2242 autoderef.finalize();
2246 /// To type-check `base_expr[index_expr]`, we progressively autoderef
2247 /// (and otherwise adjust) `base_expr`, looking for a type which either
2248 /// supports builtin indexing or overloaded indexing.
2249 /// This loop implements one step in that search; the autoderef loop
2250 /// is implemented by `lookup_indexing`.
2251 fn try_index_step(&self,
2253 base_expr: &hir::Expr,
2254 autoderef: &Autoderef<'a, 'gcx, 'tcx>,
2255 lvalue_pref: LvaluePreference,
2257 -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)>
2259 let adjusted_ty = autoderef.unambiguous_final_ty();
2260 debug!("try_index_step(expr={:?}, base_expr={:?}, adjusted_ty={:?}, \
2267 for &unsize in &[false, true] {
2268 let mut self_ty = adjusted_ty;
2270 // We only unsize arrays here.
2271 if let ty::TyArray(element_ty, _) = adjusted_ty.sty {
2272 self_ty = self.tcx.mk_slice(element_ty);
2278 // If some lookup succeeds, write callee into table and extract index/element
2279 // type from the method signature.
2280 // If some lookup succeeded, install method in table
2281 let input_ty = self.next_ty_var(TypeVariableOrigin::AutoDeref(base_expr.span));
2282 let method = self.try_overloaded_lvalue_op(
2283 expr.span, self_ty, &[input_ty], lvalue_pref, LvalueOp::Index);
2285 let result = method.map(|ok| {
2286 debug!("try_index_step: success, using overloaded indexing");
2287 let method = self.register_infer_ok_obligations(ok);
2289 let mut adjustments = autoderef.adjust_steps(lvalue_pref);
2290 if let ty::TyRef(region, mt) = method.sig.inputs()[0].sty {
2291 adjustments.push(Adjustment {
2292 kind: Adjust::Borrow(AutoBorrow::Ref(region, mt.mutbl)),
2293 target: self.tcx.mk_ref(region, ty::TypeAndMut {
2300 adjustments.push(Adjustment {
2301 kind: Adjust::Unsize,
2302 target: method.sig.inputs()[0]
2305 self.apply_adjustments(base_expr, adjustments);
2307 self.write_method_call(expr.hir_id, method);
2308 (input_ty, self.make_overloaded_lvalue_return_type(method).ty)
2310 if result.is_some() {
2318 fn resolve_lvalue_op(&self, op: LvalueOp, is_mut: bool) -> (Option<DefId>, Symbol) {
2319 let (tr, name) = match (op, is_mut) {
2320 (LvalueOp::Deref, false) =>
2321 (self.tcx.lang_items().deref_trait(), "deref"),
2322 (LvalueOp::Deref, true) =>
2323 (self.tcx.lang_items().deref_mut_trait(), "deref_mut"),
2324 (LvalueOp::Index, false) =>
2325 (self.tcx.lang_items().index_trait(), "index"),
2326 (LvalueOp::Index, true) =>
2327 (self.tcx.lang_items().index_mut_trait(), "index_mut"),
2329 (tr, Symbol::intern(name))
2332 fn try_overloaded_lvalue_op(&self,
2335 arg_tys: &[Ty<'tcx>],
2336 lvalue_pref: LvaluePreference,
2338 -> Option<InferOk<'tcx, MethodCallee<'tcx>>>
2340 debug!("try_overloaded_lvalue_op({:?},{:?},{:?},{:?})",
2346 // Try Mut first, if preferred.
2347 let (mut_tr, mut_op) = self.resolve_lvalue_op(op, true);
2348 let method = match (lvalue_pref, mut_tr) {
2349 (PreferMutLvalue, Some(trait_did)) => {
2350 self.lookup_method_in_trait(span, mut_op, trait_did, base_ty, Some(arg_tys))
2355 // Otherwise, fall back to the immutable version.
2356 let (imm_tr, imm_op) = self.resolve_lvalue_op(op, false);
2357 let method = match (method, imm_tr) {
2358 (None, Some(trait_did)) => {
2359 self.lookup_method_in_trait(span, imm_op, trait_did, base_ty, Some(arg_tys))
2361 (method, _) => method,
2367 fn check_method_argument_types(&self,
2370 method: Result<MethodCallee<'tcx>, ()>,
2371 args_no_rcvr: &'gcx [hir::Expr],
2372 tuple_arguments: TupleArgumentsFlag,
2373 expected: Expectation<'tcx>)
2375 let has_error = match method {
2377 method.substs.references_error() || method.sig.references_error()
2382 let err_inputs = self.err_args(args_no_rcvr.len());
2384 let err_inputs = match tuple_arguments {
2385 DontTupleArguments => err_inputs,
2386 TupleArguments => vec![self.tcx.intern_tup(&err_inputs[..], false)],
2389 self.check_argument_types(sp, expr_sp, &err_inputs[..], &[], args_no_rcvr,
2390 false, tuple_arguments, None);
2391 return self.tcx.types.err;
2394 let method = method.unwrap();
2395 // HACK(eddyb) ignore self in the definition (see above).
2396 let expected_arg_tys = self.expected_inputs_for_expected_output(
2399 method.sig.output(),
2400 &method.sig.inputs()[1..]
2402 self.check_argument_types(sp, expr_sp, &method.sig.inputs()[1..], &expected_arg_tys[..],
2403 args_no_rcvr, method.sig.variadic, tuple_arguments,
2404 self.tcx.hir.span_if_local(method.def_id));
2408 /// Generic function that factors out common logic from function calls,
2409 /// method calls and overloaded operators.
2410 fn check_argument_types(&self,
2413 fn_inputs: &[Ty<'tcx>],
2414 expected_arg_tys: &[Ty<'tcx>],
2415 args: &'gcx [hir::Expr],
2417 tuple_arguments: TupleArgumentsFlag,
2418 def_span: Option<Span>) {
2421 // Grab the argument types, supplying fresh type variables
2422 // if the wrong number of arguments were supplied
2423 let supplied_arg_count = if tuple_arguments == DontTupleArguments {
2429 // All the input types from the fn signature must outlive the call
2430 // so as to validate implied bounds.
2431 for &fn_input_ty in fn_inputs {
2432 self.register_wf_obligation(fn_input_ty, sp, traits::MiscObligation);
2435 let mut expected_arg_tys = expected_arg_tys;
2436 let expected_arg_count = fn_inputs.len();
2438 fn parameter_count_error<'tcx>(sess: &Session,
2441 expected_count: usize,
2445 def_span: Option<Span>,
2447 let mut err = sess.struct_span_err_with_code(sp,
2448 &format!("this function takes {}{} parameter{} but {} parameter{} supplied",
2449 if variadic {"at least "} else {""},
2451 if expected_count == 1 {""} else {"s"},
2453 if arg_count == 1 {" was"} else {"s were"}),
2454 DiagnosticId::Error(error_code.to_owned()));
2456 if let Some(def_s) = def_span.map(|sp| sess.codemap().def_span(sp)) {
2457 err.span_label(def_s, "defined here");
2460 let sugg_span = expr_sp.end_point();
2461 // remove closing `)` from the span
2462 let sugg_span = sugg_span.with_hi(sugg_span.lo());
2463 err.span_suggestion(
2465 "expected the unit value `()`; create it with empty parentheses",
2466 String::from("()"));
2468 err.span_label(sp, format!("expected {}{} parameter{}",
2469 if variadic {"at least "} else {""},
2471 if expected_count == 1 {""} else {"s"}));
2476 let formal_tys = if tuple_arguments == TupleArguments {
2477 let tuple_type = self.structurally_resolved_type(sp, fn_inputs[0]);
2478 match tuple_type.sty {
2479 ty::TyTuple(arg_types, _) if arg_types.len() != args.len() => {
2480 parameter_count_error(tcx.sess, sp, expr_sp, arg_types.len(), args.len(),
2481 "E0057", false, def_span, false);
2482 expected_arg_tys = &[];
2483 self.err_args(args.len())
2485 ty::TyTuple(arg_types, _) => {
2486 expected_arg_tys = match expected_arg_tys.get(0) {
2487 Some(&ty) => match ty.sty {
2488 ty::TyTuple(ref tys, _) => &tys,
2496 span_err!(tcx.sess, sp, E0059,
2497 "cannot use call notation; the first type parameter \
2498 for the function trait is neither a tuple nor unit");
2499 expected_arg_tys = &[];
2500 self.err_args(args.len())
2503 } else if expected_arg_count == supplied_arg_count {
2505 } else if variadic {
2506 if supplied_arg_count >= expected_arg_count {
2509 parameter_count_error(tcx.sess, sp, expr_sp, expected_arg_count,
2510 supplied_arg_count, "E0060", true, def_span, false);
2511 expected_arg_tys = &[];
2512 self.err_args(supplied_arg_count)
2515 // is the missing argument of type `()`?
2516 let sugg_unit = if expected_arg_tys.len() == 1 && supplied_arg_count == 0 {
2517 self.resolve_type_vars_if_possible(&expected_arg_tys[0]).is_nil()
2518 } else if fn_inputs.len() == 1 && supplied_arg_count == 0 {
2519 self.resolve_type_vars_if_possible(&fn_inputs[0]).is_nil()
2523 parameter_count_error(tcx.sess, sp, expr_sp, expected_arg_count,
2524 supplied_arg_count, "E0061", false, def_span, sugg_unit);
2525 expected_arg_tys = &[];
2526 self.err_args(supplied_arg_count)
2529 debug!("check_argument_types: formal_tys={:?}",
2530 formal_tys.iter().map(|t| self.ty_to_string(*t)).collect::<Vec<String>>());
2532 // Check the arguments.
2533 // We do this in a pretty awful way: first we typecheck any arguments
2534 // that are not closures, then we typecheck the closures. This is so
2535 // that we have more information about the types of arguments when we
2536 // typecheck the functions. This isn't really the right way to do this.
2537 for &check_closures in &[false, true] {
2538 debug!("check_closures={}", check_closures);
2540 // More awful hacks: before we check argument types, try to do
2541 // an "opportunistic" vtable resolution of any trait bounds on
2542 // the call. This helps coercions.
2544 self.select_obligations_where_possible();
2547 // For variadic functions, we don't have a declared type for all of
2548 // the arguments hence we only do our usual type checking with
2549 // the arguments who's types we do know.
2550 let t = if variadic {
2552 } else if tuple_arguments == TupleArguments {
2557 for (i, arg) in args.iter().take(t).enumerate() {
2558 // Warn only for the first loop (the "no closures" one).
2559 // Closure arguments themselves can't be diverging, but
2560 // a previous argument can, e.g. `foo(panic!(), || {})`.
2561 if !check_closures {
2562 self.warn_if_unreachable(arg.id, arg.span, "expression");
2565 let is_closure = match arg.node {
2566 hir::ExprClosure(..) => true,
2570 if is_closure != check_closures {
2574 debug!("checking the argument");
2575 let formal_ty = formal_tys[i];
2577 // The special-cased logic below has three functions:
2578 // 1. Provide as good of an expected type as possible.
2579 let expected = expected_arg_tys.get(i).map(|&ty| {
2580 Expectation::rvalue_hint(self, ty)
2583 let checked_ty = self.check_expr_with_expectation(
2585 expected.unwrap_or(ExpectHasType(formal_ty)));
2587 // 2. Coerce to the most detailed type that could be coerced
2588 // to, which is `expected_ty` if `rvalue_hint` returns an
2589 // `ExpectHasType(expected_ty)`, or the `formal_ty` otherwise.
2590 let coerce_ty = expected.and_then(|e| e.only_has_type(self));
2591 self.demand_coerce(&arg, checked_ty, coerce_ty.unwrap_or(formal_ty));
2593 // 3. Relate the expected type and the formal one,
2594 // if the expected type was used for the coercion.
2595 coerce_ty.map(|ty| self.demand_suptype(arg.span, formal_ty, ty));
2599 // We also need to make sure we at least write the ty of the other
2600 // arguments which we skipped above.
2602 fn variadic_error<'tcx>(s: &Session, span: Span, t: Ty<'tcx>, cast_ty: &str) {
2603 use structured_errors::{VariadicError, StructuredDiagnostic};
2604 VariadicError::new(s, span, t, cast_ty).diagnostic().emit();
2607 for arg in args.iter().skip(expected_arg_count) {
2608 let arg_ty = self.check_expr(&arg);
2610 // There are a few types which get autopromoted when passed via varargs
2611 // in C but we just error out instead and require explicit casts.
2612 let arg_ty = self.structurally_resolved_type(arg.span, arg_ty);
2614 ty::TyFloat(ast::FloatTy::F32) => {
2615 variadic_error(tcx.sess, arg.span, arg_ty, "c_double");
2617 ty::TyInt(ast::IntTy::I8) | ty::TyInt(ast::IntTy::I16) | ty::TyBool => {
2618 variadic_error(tcx.sess, arg.span, arg_ty, "c_int");
2620 ty::TyUint(ast::UintTy::U8) | ty::TyUint(ast::UintTy::U16) => {
2621 variadic_error(tcx.sess, arg.span, arg_ty, "c_uint");
2623 ty::TyFnDef(..) => {
2624 let ptr_ty = self.tcx.mk_fn_ptr(arg_ty.fn_sig(self.tcx));
2625 let ptr_ty = self.resolve_type_vars_if_possible(&ptr_ty);
2626 variadic_error(tcx.sess, arg.span, arg_ty, &format!("{}", ptr_ty));
2634 fn err_args(&self, len: usize) -> Vec<Ty<'tcx>> {
2635 (0..len).map(|_| self.tcx.types.err).collect()
2638 // AST fragment checking
2641 expected: Expectation<'tcx>)
2647 ast::LitKind::Str(..) => tcx.mk_static_str(),
2648 ast::LitKind::ByteStr(ref v) => {
2649 tcx.mk_imm_ref(tcx.types.re_static,
2650 tcx.mk_array(tcx.types.u8, v.len() as u64))
2652 ast::LitKind::Byte(_) => tcx.types.u8,
2653 ast::LitKind::Char(_) => tcx.types.char,
2654 ast::LitKind::Int(_, ast::LitIntType::Signed(t)) => tcx.mk_mach_int(t),
2655 ast::LitKind::Int(_, ast::LitIntType::Unsigned(t)) => tcx.mk_mach_uint(t),
2656 ast::LitKind::Int(_, ast::LitIntType::Unsuffixed) => {
2657 let opt_ty = expected.to_option(self).and_then(|ty| {
2659 ty::TyInt(_) | ty::TyUint(_) => Some(ty),
2660 ty::TyChar => Some(tcx.types.u8),
2661 ty::TyRawPtr(..) => Some(tcx.types.usize),
2662 ty::TyFnDef(..) | ty::TyFnPtr(_) => Some(tcx.types.usize),
2666 opt_ty.unwrap_or_else(
2667 || tcx.mk_int_var(self.next_int_var_id()))
2669 ast::LitKind::Float(_, t) => tcx.mk_mach_float(t),
2670 ast::LitKind::FloatUnsuffixed(_) => {
2671 let opt_ty = expected.to_option(self).and_then(|ty| {
2673 ty::TyFloat(_) => Some(ty),
2677 opt_ty.unwrap_or_else(
2678 || tcx.mk_float_var(self.next_float_var_id()))
2680 ast::LitKind::Bool(_) => tcx.types.bool
2684 fn check_expr_eq_type(&self,
2685 expr: &'gcx hir::Expr,
2686 expected: Ty<'tcx>) {
2687 let ty = self.check_expr_with_hint(expr, expected);
2688 self.demand_eqtype(expr.span, expected, ty);
2691 pub fn check_expr_has_type_or_error(&self,
2692 expr: &'gcx hir::Expr,
2693 expected: Ty<'tcx>) -> Ty<'tcx> {
2694 self.check_expr_meets_expectation_or_error(expr, ExpectHasType(expected))
2697 fn check_expr_meets_expectation_or_error(&self,
2698 expr: &'gcx hir::Expr,
2699 expected: Expectation<'tcx>) -> Ty<'tcx> {
2700 let expected_ty = expected.to_option(&self).unwrap_or(self.tcx.types.bool);
2701 let mut ty = self.check_expr_with_expectation(expr, expected);
2703 // While we don't allow *arbitrary* coercions here, we *do* allow
2704 // coercions from ! to `expected`.
2706 assert!(!self.tables.borrow().adjustments().contains_key(expr.hir_id),
2707 "expression with never type wound up being adjusted");
2708 let adj_ty = self.next_diverging_ty_var(
2709 TypeVariableOrigin::AdjustmentType(expr.span));
2710 self.apply_adjustments(expr, vec![Adjustment {
2711 kind: Adjust::NeverToAny,
2717 if let Some(mut err) = self.demand_suptype_diag(expr.span, expected_ty, ty) {
2718 // Add help to type error if this is an `if` condition with an assignment
2719 match (expected, &expr.node) {
2720 (ExpectIfCondition, &hir::ExprAssign(ref lhs, ref rhs)) => {
2721 let msg = "try comparing for equality";
2722 if let (Ok(left), Ok(right)) = (
2723 self.tcx.sess.codemap().span_to_snippet(lhs.span),
2724 self.tcx.sess.codemap().span_to_snippet(rhs.span))
2726 err.span_suggestion(expr.span, msg, format!("{} == {}", left, right));
2738 fn check_expr_coercable_to_type(&self,
2739 expr: &'gcx hir::Expr,
2740 expected: Ty<'tcx>) -> Ty<'tcx> {
2741 self.check_expr_coercable_to_type_with_lvalue_pref(expr, expected, NoPreference)
2744 fn check_expr_coercable_to_type_with_lvalue_pref(&self,
2745 expr: &'gcx hir::Expr,
2747 lvalue_pref: LvaluePreference)
2749 let ty = self.check_expr_with_expectation_and_lvalue_pref(
2751 ExpectHasType(expected),
2753 self.demand_coerce(expr, ty, expected)
2756 fn check_expr_with_hint(&self, expr: &'gcx hir::Expr,
2757 expected: Ty<'tcx>) -> Ty<'tcx> {
2758 self.check_expr_with_expectation(expr, ExpectHasType(expected))
2761 fn check_expr_with_expectation(&self,
2762 expr: &'gcx hir::Expr,
2763 expected: Expectation<'tcx>) -> Ty<'tcx> {
2764 self.check_expr_with_expectation_and_lvalue_pref(expr, expected, NoPreference)
2767 fn check_expr(&self, expr: &'gcx hir::Expr) -> Ty<'tcx> {
2768 self.check_expr_with_expectation(expr, NoExpectation)
2771 fn check_expr_with_lvalue_pref(&self, expr: &'gcx hir::Expr,
2772 lvalue_pref: LvaluePreference) -> Ty<'tcx> {
2773 self.check_expr_with_expectation_and_lvalue_pref(expr, NoExpectation, lvalue_pref)
2776 // determine the `self` type, using fresh variables for all variables
2777 // declared on the impl declaration e.g., `impl<A,B> for Vec<(A,B)>`
2778 // would return ($0, $1) where $0 and $1 are freshly instantiated type
2780 pub fn impl_self_ty(&self,
2781 span: Span, // (potential) receiver for this impl
2783 -> TypeAndSubsts<'tcx> {
2784 let ity = self.tcx.type_of(did);
2785 debug!("impl_self_ty: ity={:?}", ity);
2787 let substs = self.fresh_substs_for_item(span, did);
2788 let substd_ty = self.instantiate_type_scheme(span, &substs, &ity);
2790 TypeAndSubsts { substs: substs, ty: substd_ty }
2793 /// Unifies the output type with the expected type early, for more coercions
2794 /// and forward type information on the input expressions.
2795 fn expected_inputs_for_expected_output(&self,
2797 expected_ret: Expectation<'tcx>,
2798 formal_ret: Ty<'tcx>,
2799 formal_args: &[Ty<'tcx>])
2801 let formal_ret = self.resolve_type_vars_with_obligations(formal_ret);
2802 let expected_args = expected_ret.only_has_type(self).and_then(|ret_ty| {
2803 self.fudge_regions_if_ok(&RegionVariableOrigin::Coercion(call_span), || {
2804 // Attempt to apply a subtyping relationship between the formal
2805 // return type (likely containing type variables if the function
2806 // is polymorphic) and the expected return type.
2807 // No argument expectations are produced if unification fails.
2808 let origin = self.misc(call_span);
2809 let ures = self.at(&origin, self.param_env).sup(ret_ty, formal_ret);
2811 // FIXME(#15760) can't use try! here, FromError doesn't default
2812 // to identity so the resulting type is not constrained.
2815 // Process any obligations locally as much as
2816 // we can. We don't care if some things turn
2817 // out unconstrained or ambiguous, as we're
2818 // just trying to get hints here.
2819 let result = self.save_and_restore_in_snapshot_flag(|_| {
2820 let mut fulfill = FulfillmentContext::new();
2821 let ok = ok; // FIXME(#30046)
2822 for obligation in ok.obligations {
2823 fulfill.register_predicate_obligation(self, obligation);
2825 fulfill.select_where_possible(self)
2830 Err(_) => return Err(()),
2833 Err(_) => return Err(()),
2836 // Record all the argument types, with the substitutions
2837 // produced from the above subtyping unification.
2838 Ok(formal_args.iter().map(|ty| {
2839 self.resolve_type_vars_if_possible(ty)
2842 }).unwrap_or(vec![]);
2843 debug!("expected_inputs_for_expected_output(formal={:?} -> {:?}, expected={:?} -> {:?})",
2844 formal_args, formal_ret,
2845 expected_args, expected_ret);
2849 // Checks a method call.
2850 fn check_method_call(&self,
2851 expr: &'gcx hir::Expr,
2852 segment: &hir::PathSegment,
2854 args: &'gcx [hir::Expr],
2855 expected: Expectation<'tcx>,
2856 lvalue_pref: LvaluePreference) -> Ty<'tcx> {
2857 let rcvr = &args[0];
2858 let rcvr_t = self.check_expr_with_lvalue_pref(&rcvr, lvalue_pref);
2859 // no need to check for bot/err -- callee does that
2860 let rcvr_t = self.structurally_resolved_type(expr.span, rcvr_t);
2862 let method = match self.lookup_method(rcvr_t,
2868 self.write_method_call(expr.hir_id, method);
2872 if segment.name != keywords::Invalid.name() {
2873 self.report_method_error(span,
2884 // Call the generic checker.
2885 self.check_method_argument_types(span,
2893 fn check_return_expr(&self, return_expr: &'gcx hir::Expr) {
2897 .unwrap_or_else(|| span_bug!(return_expr.span,
2898 "check_return_expr called outside fn body"));
2900 let ret_ty = ret_coercion.borrow().expected_ty();
2901 let return_expr_ty = self.check_expr_with_hint(return_expr, ret_ty.clone());
2902 ret_coercion.borrow_mut()
2904 &self.cause(return_expr.span,
2905 ObligationCauseCode::ReturnType(return_expr.id)),
2908 self.diverges.get());
2912 // A generic function for checking the then and else in an if
2914 fn check_then_else(&self,
2915 cond_expr: &'gcx hir::Expr,
2916 then_expr: &'gcx hir::Expr,
2917 opt_else_expr: Option<&'gcx hir::Expr>,
2919 expected: Expectation<'tcx>) -> Ty<'tcx> {
2920 let cond_ty = self.check_expr_meets_expectation_or_error(cond_expr, ExpectIfCondition);
2921 let cond_diverges = self.diverges.get();
2922 self.diverges.set(Diverges::Maybe);
2924 let expected = expected.adjust_for_branches(self);
2925 let then_ty = self.check_expr_with_expectation(then_expr, expected);
2926 let then_diverges = self.diverges.get();
2927 self.diverges.set(Diverges::Maybe);
2929 // We've already taken the expected type's preferences
2930 // into account when typing the `then` branch. To figure
2931 // out the initial shot at a LUB, we thus only consider
2932 // `expected` if it represents a *hard* constraint
2933 // (`only_has_type`); otherwise, we just go with a
2934 // fresh type variable.
2935 let coerce_to_ty = expected.coercion_target_type(self, sp);
2936 let mut coerce: DynamicCoerceMany = CoerceMany::new(coerce_to_ty);
2938 let if_cause = self.cause(sp, ObligationCauseCode::IfExpression);
2939 coerce.coerce(self, &if_cause, then_expr, then_ty, then_diverges);
2941 if let Some(else_expr) = opt_else_expr {
2942 let else_ty = self.check_expr_with_expectation(else_expr, expected);
2943 let else_diverges = self.diverges.get();
2945 coerce.coerce(self, &if_cause, else_expr, else_ty, else_diverges);
2947 // We won't diverge unless both branches do (or the condition does).
2948 self.diverges.set(cond_diverges | then_diverges & else_diverges);
2950 let else_cause = self.cause(sp, ObligationCauseCode::IfExpressionWithNoElse);
2951 coerce.coerce_forced_unit(self, &else_cause, &mut |_| (), true);
2953 // If the condition is false we can't diverge.
2954 self.diverges.set(cond_diverges);
2957 let result_ty = coerce.complete(self);
2958 if cond_ty.references_error() {
2965 // Check field access expressions
2966 fn check_field(&self,
2967 expr: &'gcx hir::Expr,
2968 lvalue_pref: LvaluePreference,
2969 base: &'gcx hir::Expr,
2970 field: &Spanned<ast::Name>) -> Ty<'tcx> {
2971 let expr_t = self.check_expr_with_lvalue_pref(base, lvalue_pref);
2972 let expr_t = self.structurally_resolved_type(expr.span,
2974 let mut private_candidate = None;
2975 let mut autoderef = self.autoderef(expr.span, expr_t);
2976 while let Some((base_t, _)) = autoderef.next() {
2978 ty::TyAdt(base_def, substs) if !base_def.is_enum() => {
2979 debug!("struct named {:?}", base_t);
2980 let (ident, def_scope) =
2981 self.tcx.adjust(field.node, base_def.did, self.body_id);
2982 let fields = &base_def.non_enum_variant().fields;
2983 if let Some(field) = fields.iter().find(|f| f.name.to_ident() == ident) {
2984 let field_ty = self.field_ty(expr.span, field, substs);
2985 if field.vis.is_accessible_from(def_scope, self.tcx) {
2986 let adjustments = autoderef.adjust_steps(lvalue_pref);
2987 self.apply_adjustments(base, adjustments);
2988 autoderef.finalize();
2990 self.tcx.check_stability(field.did, expr.id, expr.span);
2994 private_candidate = Some((base_def.did, field_ty));
3000 autoderef.unambiguous_final_ty();
3002 if let Some((did, field_ty)) = private_candidate {
3003 let struct_path = self.tcx().item_path_str(did);
3004 let mut err = struct_span_err!(self.tcx().sess, expr.span, E0616,
3005 "field `{}` of struct `{}` is private",
3006 field.node, struct_path);
3007 // Also check if an accessible method exists, which is often what is meant.
3008 if self.method_exists(field.span, field.node, expr_t, expr.id, false) {
3009 err.note(&format!("a method `{}` also exists, perhaps you wish to call it",
3014 } else if field.node == keywords::Invalid.name() {
3015 self.tcx().types.err
3016 } else if self.method_exists(field.span, field.node, expr_t, expr.id, true) {
3017 type_error_struct!(self.tcx().sess, field.span, expr_t, E0615,
3018 "attempted to take value of method `{}` on type `{}`",
3020 .help("maybe a `()` to call it is missing?")
3022 self.tcx().types.err
3024 if !expr_t.is_primitive_ty() {
3025 let mut err = self.no_such_field_err(field.span, &field.node, expr_t);
3028 ty::TyAdt(def, _) if !def.is_enum() => {
3029 if let Some(suggested_field_name) =
3030 Self::suggest_field_name(def.non_enum_variant(), field, vec![]) {
3031 err.span_label(field.span,
3032 format!("did you mean `{}`?", suggested_field_name));
3034 err.span_label(field.span, "unknown field");
3035 let struct_variant_def = def.non_enum_variant();
3036 let field_names = self.available_field_names(struct_variant_def);
3037 if !field_names.is_empty() {
3038 err.note(&format!("available fields are: {}",
3039 self.name_series_display(field_names)));
3043 ty::TyRawPtr(..) => {
3044 err.note(&format!("`{0}` is a native pointer; perhaps you need to deref \
3046 self.tcx.hir.node_to_pretty_string(base.id),
3053 type_error_struct!(self.tcx().sess, field.span, expr_t, E0610,
3054 "`{}` is a primitive type and therefore doesn't have fields",
3057 self.tcx().types.err
3061 // Return an hint about the closest match in field names
3062 fn suggest_field_name(variant: &'tcx ty::VariantDef,
3063 field: &Spanned<ast::Name>,
3064 skip: Vec<InternedString>)
3066 let name = field.node.as_str();
3067 let names = variant.fields.iter().filter_map(|field| {
3068 // ignore already set fields and private fields from non-local crates
3069 if skip.iter().any(|x| *x == field.name.as_str()) ||
3070 (variant.did.krate != LOCAL_CRATE && field.vis != Visibility::Public) {
3077 find_best_match_for_name(names, &name, None)
3080 fn available_field_names(&self, variant: &'tcx ty::VariantDef) -> Vec<ast::Name> {
3081 let mut available = Vec::new();
3082 for field in variant.fields.iter() {
3083 let (_, def_scope) = self.tcx.adjust(field.name, variant.did, self.body_id);
3084 if field.vis.is_accessible_from(def_scope, self.tcx) {
3085 available.push(field.name);
3091 fn name_series_display(&self, names: Vec<ast::Name>) -> String {
3092 // dynamic limit, to never omit just one field
3093 let limit = if names.len() == 6 { 6 } else { 5 };
3094 let mut display = names.iter().take(limit)
3095 .map(|n| format!("`{}`", n)).collect::<Vec<_>>().join(", ");
3096 if names.len() > limit {
3097 display = format!("{} ... and {} others", display, names.len() - limit);
3102 // Check tuple index expressions
3103 fn check_tup_field(&self,
3104 expr: &'gcx hir::Expr,
3105 lvalue_pref: LvaluePreference,
3106 base: &'gcx hir::Expr,
3107 idx: codemap::Spanned<usize>) -> Ty<'tcx> {
3108 let expr_t = self.check_expr_with_lvalue_pref(base, lvalue_pref);
3109 let expr_t = self.structurally_resolved_type(expr.span,
3111 let mut private_candidate = None;
3112 let mut tuple_like = false;
3113 let mut autoderef = self.autoderef(expr.span, expr_t);
3114 while let Some((base_t, _)) = autoderef.next() {
3115 let field = match base_t.sty {
3116 ty::TyAdt(base_def, substs) if base_def.is_struct() => {
3117 tuple_like = base_def.non_enum_variant().ctor_kind == CtorKind::Fn;
3118 if !tuple_like { continue }
3120 debug!("tuple struct named {:?}", base_t);
3121 let ident = ast::Ident {
3122 name: Symbol::intern(&idx.node.to_string()),
3123 ctxt: idx.span.ctxt().modern(),
3125 let (ident, def_scope) =
3126 self.tcx.adjust_ident(ident, base_def.did, self.body_id);
3127 let fields = &base_def.non_enum_variant().fields;
3128 if let Some(field) = fields.iter().find(|f| f.name.to_ident() == ident) {
3129 let field_ty = self.field_ty(expr.span, field, substs);
3130 if field.vis.is_accessible_from(def_scope, self.tcx) {
3131 self.tcx.check_stability(field.did, expr.id, expr.span);
3134 private_candidate = Some((base_def.did, field_ty));
3141 ty::TyTuple(ref v, _) => {
3143 v.get(idx.node).cloned()
3148 if let Some(field_ty) = field {
3149 let adjustments = autoderef.adjust_steps(lvalue_pref);
3150 self.apply_adjustments(base, adjustments);
3151 autoderef.finalize();
3155 autoderef.unambiguous_final_ty();
3157 if let Some((did, field_ty)) = private_candidate {
3158 let struct_path = self.tcx().item_path_str(did);
3159 struct_span_err!(self.tcx().sess, expr.span, E0611,
3160 "field `{}` of tuple-struct `{}` is private",
3161 idx.node, struct_path).emit();
3166 type_error_struct!(self.tcx().sess, expr.span, expr_t, E0612,
3167 "attempted out-of-bounds tuple index `{}` on type `{}`",
3168 idx.node, expr_t).emit();
3170 self.no_such_field_err(expr.span, idx.node, expr_t).emit();
3173 self.tcx().types.err
3176 fn no_such_field_err<T: Display>(&self, span: Span, field: T, expr_t: &ty::TyS)
3177 -> DiagnosticBuilder {
3178 type_error_struct!(self.tcx().sess, span, expr_t, E0609,
3179 "no field `{}` on type `{}`",
3183 fn report_unknown_field(&self,
3185 variant: &'tcx ty::VariantDef,
3187 skip_fields: &[hir::Field],
3189 let mut err = self.type_error_struct_with_diag(
3191 |actual| match ty.sty {
3192 ty::TyAdt(adt, ..) if adt.is_enum() => {
3193 struct_span_err!(self.tcx.sess, field.name.span, E0559,
3194 "{} `{}::{}` has no field named `{}`",
3195 kind_name, actual, variant.name, field.name.node)
3198 struct_span_err!(self.tcx.sess, field.name.span, E0560,
3199 "{} `{}` has no field named `{}`",
3200 kind_name, actual, field.name.node)
3204 // prevent all specified fields from being suggested
3205 let skip_fields = skip_fields.iter().map(|ref x| x.name.node.as_str());
3206 if let Some(field_name) = Self::suggest_field_name(variant,
3208 skip_fields.collect()) {
3209 err.span_label(field.name.span,
3210 format!("field does not exist - did you mean `{}`?", field_name));
3213 ty::TyAdt(adt, ..) => {
3215 err.span_label(field.name.span,
3216 format!("`{}::{}` does not have this field",
3219 err.span_label(field.name.span,
3220 format!("`{}` does not have this field", ty));
3222 let available_field_names = self.available_field_names(variant);
3223 if !available_field_names.is_empty() {
3224 err.note(&format!("available fields are: {}",
3225 self.name_series_display(available_field_names)));
3228 _ => bug!("non-ADT passed to report_unknown_field")
3234 fn check_expr_struct_fields(&self,
3236 expected: Expectation<'tcx>,
3237 expr_id: ast::NodeId,
3239 variant: &'tcx ty::VariantDef,
3240 ast_fields: &'gcx [hir::Field],
3241 check_completeness: bool) {
3245 self.expected_inputs_for_expected_output(span, expected, adt_ty, &[adt_ty])
3246 .get(0).cloned().unwrap_or(adt_ty);
3247 // re-link the regions that EIfEO can erase.
3248 self.demand_eqtype(span, adt_ty_hint, adt_ty);
3250 let (substs, adt_kind, kind_name) = match &adt_ty.sty{
3251 &ty::TyAdt(adt, substs) => {
3252 (substs, adt.adt_kind(), adt.variant_descr())
3254 _ => span_bug!(span, "non-ADT passed to check_expr_struct_fields")
3257 let mut remaining_fields = FxHashMap();
3258 for field in &variant.fields {
3259 remaining_fields.insert(field.name.to_ident(), field);
3262 let mut seen_fields = FxHashMap();
3264 let mut error_happened = false;
3266 // Typecheck each field.
3267 for field in ast_fields {
3268 let ident = tcx.adjust(field.name.node, variant.did, self.body_id).0;
3269 let field_type = if let Some(v_field) = remaining_fields.remove(&ident) {
3270 seen_fields.insert(field.name.node, field.span);
3272 // we don't look at stability attributes on
3273 // struct-like enums (yet...), but it's definitely not
3274 // a bug to have construct one.
3275 if adt_kind != ty::AdtKind::Enum {
3276 tcx.check_stability(v_field.did, expr_id, field.span);
3279 self.field_ty(field.span, v_field, substs)
3281 error_happened = true;
3282 if let Some(_) = variant.find_field_named(field.name.node) {
3283 let mut err = struct_span_err!(self.tcx.sess,
3286 "field `{}` specified more than once",
3289 err.span_label(field.name.span, "used more than once");
3291 if let Some(prev_span) = seen_fields.get(&field.name.node) {
3292 err.span_label(*prev_span, format!("first use of `{}`", field.name.node));
3297 self.report_unknown_field(adt_ty, variant, field, ast_fields, kind_name);
3303 // Make sure to give a type to the field even if there's
3304 // an error, so we can continue typechecking
3305 self.check_expr_coercable_to_type(&field.expr, field_type);
3308 // Make sure the programmer specified correct number of fields.
3309 if kind_name == "union" {
3310 if ast_fields.len() != 1 {
3311 tcx.sess.span_err(span, "union expressions should have exactly one field");
3313 } else if check_completeness && !error_happened && !remaining_fields.is_empty() {
3314 let len = remaining_fields.len();
3316 let mut displayable_field_names = remaining_fields
3318 .map(|ident| ident.name.as_str())
3319 .collect::<Vec<_>>();
3321 displayable_field_names.sort();
3323 let truncated_fields_error = if len <= 3 {
3326 format!(" and {} other field{}", (len - 3), if len - 3 == 1 {""} else {"s"})
3329 let remaining_fields_names = displayable_field_names.iter().take(3)
3330 .map(|n| format!("`{}`", n))
3331 .collect::<Vec<_>>()
3334 struct_span_err!(tcx.sess, span, E0063,
3335 "missing field{} {}{} in initializer of `{}`",
3336 if remaining_fields.len() == 1 { "" } else { "s" },
3337 remaining_fields_names,
3338 truncated_fields_error,
3340 .span_label(span, format!("missing {}{}",
3341 remaining_fields_names,
3342 truncated_fields_error))
3347 fn check_struct_fields_on_error(&self,
3348 fields: &'gcx [hir::Field],
3349 base_expr: &'gcx Option<P<hir::Expr>>) {
3350 for field in fields {
3351 self.check_expr(&field.expr);
3355 self.check_expr(&base);
3361 pub fn check_struct_path(&self,
3363 node_id: ast::NodeId)
3364 -> Option<(&'tcx ty::VariantDef, Ty<'tcx>)> {
3365 let path_span = match *qpath {
3366 hir::QPath::Resolved(_, ref path) => path.span,
3367 hir::QPath::TypeRelative(ref qself, _) => qself.span
3369 let (def, ty) = self.finish_resolving_struct_path(qpath, path_span, node_id);
3370 let variant = match def {
3372 self.set_tainted_by_errors();
3375 Def::Variant(..) => {
3377 ty::TyAdt(adt, substs) => {
3378 Some((adt.variant_of_def(def), adt.did, substs))
3380 _ => bug!("unexpected type: {:?}", ty.sty)
3383 Def::Struct(..) | Def::Union(..) | Def::TyAlias(..) |
3384 Def::AssociatedTy(..) | Def::SelfTy(..) => {
3386 ty::TyAdt(adt, substs) if !adt.is_enum() => {
3387 Some((adt.non_enum_variant(), adt.did, substs))
3392 _ => bug!("unexpected definition: {:?}", def)
3395 if let Some((variant, did, substs)) = variant {
3396 // Check bounds on type arguments used in the path.
3397 let bounds = self.instantiate_bounds(path_span, did, substs);
3398 let cause = traits::ObligationCause::new(path_span, self.body_id,
3399 traits::ItemObligation(did));
3400 self.add_obligations_for_parameters(cause, &bounds);
3404 struct_span_err!(self.tcx.sess, path_span, E0071,
3405 "expected struct, variant or union type, found {}",
3406 ty.sort_string(self.tcx))
3407 .span_label(path_span, "not a struct")
3413 fn check_expr_struct(&self,
3415 expected: Expectation<'tcx>,
3417 fields: &'gcx [hir::Field],
3418 base_expr: &'gcx Option<P<hir::Expr>>) -> Ty<'tcx>
3420 // Find the relevant variant
3421 let (variant, struct_ty) =
3422 if let Some(variant_ty) = self.check_struct_path(qpath, expr.id) {
3425 self.check_struct_fields_on_error(fields, base_expr);
3426 return self.tcx.types.err;
3429 let path_span = match *qpath {
3430 hir::QPath::Resolved(_, ref path) => path.span,
3431 hir::QPath::TypeRelative(ref qself, _) => qself.span
3434 // Prohibit struct expressions when non exhaustive flag is set.
3435 if let ty::TyAdt(adt, _) = struct_ty.sty {
3436 if !adt.did.is_local() && adt.is_non_exhaustive() {
3437 span_err!(self.tcx.sess, expr.span, E0639,
3438 "cannot create non-exhaustive {} using struct expression",
3439 adt.variant_descr());
3443 self.check_expr_struct_fields(struct_ty, expected, expr.id, path_span, variant, fields,
3444 base_expr.is_none());
3445 if let &Some(ref base_expr) = base_expr {
3446 self.check_expr_has_type_or_error(base_expr, struct_ty);
3447 match struct_ty.sty {
3448 ty::TyAdt(adt, substs) if adt.is_struct() => {
3449 let fru_field_types = adt.non_enum_variant().fields.iter().map(|f| {
3450 self.normalize_associated_types_in(expr.span, &f.ty(self.tcx, substs))
3455 .fru_field_types_mut()
3456 .insert(expr.hir_id, fru_field_types);
3459 span_err!(self.tcx.sess, base_expr.span, E0436,
3460 "functional record update syntax requires a struct");
3464 self.require_type_is_sized(struct_ty, expr.span, traits::StructInitializerSized);
3470 /// If an expression has any sub-expressions that result in a type error,
3471 /// inspecting that expression's type with `ty.references_error()` will return
3472 /// true. Likewise, if an expression is known to diverge, inspecting its
3473 /// type with `ty::type_is_bot` will return true (n.b.: since Rust is
3474 /// strict, _|_ can appear in the type of an expression that does not,
3475 /// itself, diverge: for example, fn() -> _|_.)
3476 /// Note that inspecting a type's structure *directly* may expose the fact
3477 /// that there are actually multiple representations for `TyError`, so avoid
3478 /// that when err needs to be handled differently.
3479 fn check_expr_with_expectation_and_lvalue_pref(&self,
3480 expr: &'gcx hir::Expr,
3481 expected: Expectation<'tcx>,
3482 lvalue_pref: LvaluePreference) -> Ty<'tcx> {
3483 debug!(">> typechecking: expr={:?} expected={:?}",
3486 // Warn for expressions after diverging siblings.
3487 self.warn_if_unreachable(expr.id, expr.span, "expression");
3489 // Hide the outer diverging and has_errors flags.
3490 let old_diverges = self.diverges.get();
3491 let old_has_errors = self.has_errors.get();
3492 self.diverges.set(Diverges::Maybe);
3493 self.has_errors.set(false);
3495 let ty = self.check_expr_kind(expr, expected, lvalue_pref);
3497 // Warn for non-block expressions with diverging children.
3500 hir::ExprLoop(..) | hir::ExprWhile(..) |
3501 hir::ExprIf(..) | hir::ExprMatch(..) => {}
3503 _ => self.warn_if_unreachable(expr.id, expr.span, "expression")
3506 // Any expression that produces a value of type `!` must have diverged
3508 self.diverges.set(self.diverges.get() | Diverges::Always);
3511 // Record the type, which applies it effects.
3512 // We need to do this after the warning above, so that
3513 // we don't warn for the diverging expression itself.
3514 self.write_ty(expr.hir_id, ty);
3516 // Combine the diverging and has_error flags.
3517 self.diverges.set(self.diverges.get() | old_diverges);
3518 self.has_errors.set(self.has_errors.get() | old_has_errors);
3520 debug!("type of {} is...", self.tcx.hir.node_to_string(expr.id));
3521 debug!("... {:?}, expected is {:?}", ty, expected);
3526 fn check_expr_kind(&self,
3527 expr: &'gcx hir::Expr,
3528 expected: Expectation<'tcx>,
3529 lvalue_pref: LvaluePreference) -> Ty<'tcx> {
3533 hir::ExprBox(ref subexpr) => {
3534 let expected_inner = expected.to_option(self).map_or(NoExpectation, |ty| {
3536 ty::TyAdt(def, _) if def.is_box()
3537 => Expectation::rvalue_hint(self, ty.boxed_ty()),
3541 let referent_ty = self.check_expr_with_expectation(subexpr, expected_inner);
3542 tcx.mk_box(referent_ty)
3545 hir::ExprLit(ref lit) => {
3546 self.check_lit(&lit, expected)
3548 hir::ExprBinary(op, ref lhs, ref rhs) => {
3549 self.check_binop(expr, op, lhs, rhs)
3551 hir::ExprAssignOp(op, ref lhs, ref rhs) => {
3552 self.check_binop_assign(expr, op, lhs, rhs)
3554 hir::ExprUnary(unop, ref oprnd) => {
3555 let expected_inner = match unop {
3556 hir::UnNot | hir::UnNeg => {
3563 let lvalue_pref = match unop {
3564 hir::UnDeref => lvalue_pref,
3567 let mut oprnd_t = self.check_expr_with_expectation_and_lvalue_pref(&oprnd,
3571 if !oprnd_t.references_error() {
3572 oprnd_t = self.structurally_resolved_type(expr.span, oprnd_t);
3575 if let Some(mt) = oprnd_t.builtin_deref(true, NoPreference) {
3577 } else if let Some(ok) = self.try_overloaded_deref(
3578 expr.span, oprnd_t, lvalue_pref) {
3579 let method = self.register_infer_ok_obligations(ok);
3580 if let ty::TyRef(region, mt) = method.sig.inputs()[0].sty {
3581 self.apply_adjustments(oprnd, vec![Adjustment {
3582 kind: Adjust::Borrow(AutoBorrow::Ref(region, mt.mutbl)),
3583 target: method.sig.inputs()[0]
3586 oprnd_t = self.make_overloaded_lvalue_return_type(method).ty;
3587 self.write_method_call(expr.hir_id, method);
3589 type_error_struct!(tcx.sess, expr.span, oprnd_t, E0614,
3590 "type `{}` cannot be dereferenced",
3592 oprnd_t = tcx.types.err;
3596 let result = self.check_user_unop(expr, oprnd_t, unop);
3597 // If it's builtin, we can reuse the type, this helps inference.
3598 if !(oprnd_t.is_integral() || oprnd_t.sty == ty::TyBool) {
3603 let result = self.check_user_unop(expr, oprnd_t, unop);
3604 // If it's builtin, we can reuse the type, this helps inference.
3605 if !(oprnd_t.is_integral() || oprnd_t.is_fp()) {
3613 hir::ExprAddrOf(mutbl, ref oprnd) => {
3614 let hint = expected.only_has_type(self).map_or(NoExpectation, |ty| {
3616 ty::TyRef(_, ref mt) | ty::TyRawPtr(ref mt) => {
3617 if self.tcx.expr_is_lval(&oprnd) {
3618 // Lvalues may legitimately have unsized types.
3619 // For example, dereferences of a fat pointer and
3620 // the last field of a struct can be unsized.
3621 ExpectHasType(mt.ty)
3623 Expectation::rvalue_hint(self, mt.ty)
3629 let lvalue_pref = LvaluePreference::from_mutbl(mutbl);
3630 let ty = self.check_expr_with_expectation_and_lvalue_pref(&oprnd, hint, lvalue_pref);
3632 let tm = ty::TypeAndMut { ty: ty, mutbl: mutbl };
3633 if tm.ty.references_error() {
3636 // Note: at this point, we cannot say what the best lifetime
3637 // is to use for resulting pointer. We want to use the
3638 // shortest lifetime possible so as to avoid spurious borrowck
3639 // errors. Moreover, the longest lifetime will depend on the
3640 // precise details of the value whose address is being taken
3641 // (and how long it is valid), which we don't know yet until type
3642 // inference is complete.
3644 // Therefore, here we simply generate a region variable. The
3645 // region inferencer will then select the ultimate value.
3646 // Finally, borrowck is charged with guaranteeing that the
3647 // value whose address was taken can actually be made to live
3648 // as long as it needs to live.
3649 let region = self.next_region_var(infer::AddrOfRegion(expr.span));
3650 tcx.mk_ref(region, tm)
3653 hir::ExprPath(ref qpath) => {
3654 let (def, opt_ty, segments) = self.resolve_ty_and_def_ufcs(qpath,
3655 expr.id, expr.span);
3656 let ty = if def != Def::Err {
3657 self.instantiate_value_path(segments, opt_ty, def, expr.span, id)
3659 self.set_tainted_by_errors();
3663 // We always require that the type provided as the value for
3664 // a type parameter outlives the moment of instantiation.
3665 let substs = self.tables.borrow().node_substs(expr.hir_id);
3666 self.add_wf_bounds(substs, expr);
3670 hir::ExprInlineAsm(_, ref outputs, ref inputs) => {
3671 for output in outputs {
3672 self.check_expr(output);
3674 for input in inputs {
3675 self.check_expr(input);
3679 hir::ExprBreak(destination, ref expr_opt) => {
3680 if let Some(target_id) = destination.target_id.opt_id() {
3681 let (e_ty, e_diverges, cause);
3682 if let Some(ref e) = *expr_opt {
3683 // If this is a break with a value, we need to type-check
3684 // the expression. Get an expected type from the loop context.
3685 let opt_coerce_to = {
3686 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
3687 enclosing_breakables.find_breakable(target_id)
3690 .map(|coerce| coerce.expected_ty())
3693 // If the loop context is not a `loop { }`, then break with
3694 // a value is illegal, and `opt_coerce_to` will be `None`.
3695 // Just set expectation to error in that case.
3696 let coerce_to = opt_coerce_to.unwrap_or(tcx.types.err);
3698 // Recurse without `enclosing_breakables` borrowed.
3699 e_ty = self.check_expr_with_hint(e, coerce_to);
3700 e_diverges = self.diverges.get();
3701 cause = self.misc(e.span);
3703 // Otherwise, this is a break *without* a value. That's
3704 // always legal, and is equivalent to `break ()`.
3705 e_ty = tcx.mk_nil();
3706 e_diverges = Diverges::Maybe;
3707 cause = self.misc(expr.span);
3710 // Now that we have type-checked `expr_opt`, borrow
3711 // the `enclosing_loops` field and let's coerce the
3712 // type of `expr_opt` into what is expected.
3713 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
3714 let ctxt = enclosing_breakables.find_breakable(target_id);
3715 if let Some(ref mut coerce) = ctxt.coerce {
3716 if let Some(ref e) = *expr_opt {
3717 coerce.coerce(self, &cause, e, e_ty, e_diverges);
3719 assert!(e_ty.is_nil());
3720 coerce.coerce_forced_unit(self, &cause, &mut |_| (), true);
3723 // If `ctxt.coerce` is `None`, we can just ignore
3724 // the type of the expresison. This is because
3725 // either this was a break *without* a value, in
3726 // which case it is always a legal type (`()`), or
3727 // else an error would have been flagged by the
3728 // `loops` pass for using break with an expression
3729 // where you are not supposed to.
3730 assert!(expr_opt.is_none() || self.tcx.sess.err_count() > 0);
3733 ctxt.may_break = true;
3735 // Otherwise, we failed to find the enclosing loop;
3736 // this can only happen if the `break` was not
3737 // inside a loop at all, which is caught by the
3738 // loop-checking pass.
3739 assert!(self.tcx.sess.err_count() > 0);
3741 // We still need to assign a type to the inner expression to
3742 // prevent the ICE in #43162.
3743 if let Some(ref e) = *expr_opt {
3744 self.check_expr_with_hint(e, tcx.types.err);
3746 // ... except when we try to 'break rust;'.
3747 // ICE this expression in particular (see #43162).
3748 if let hir::ExprPath(hir::QPath::Resolved(_, ref path)) = e.node {
3749 if path.segments.len() == 1 && path.segments[0].name == "rust" {
3750 fatally_break_rust(self.tcx.sess);
3756 // the type of a `break` is always `!`, since it diverges
3759 hir::ExprAgain(_) => { tcx.types.never }
3760 hir::ExprRet(ref expr_opt) => {
3761 if self.ret_coercion.is_none() {
3762 struct_span_err!(self.tcx.sess, expr.span, E0572,
3763 "return statement outside of function body").emit();
3764 } else if let Some(ref e) = *expr_opt {
3765 self.check_return_expr(e);
3767 let mut coercion = self.ret_coercion.as_ref().unwrap().borrow_mut();
3768 let cause = self.cause(expr.span, ObligationCauseCode::ReturnNoExpression);
3769 coercion.coerce_forced_unit(self, &cause, &mut |_| (), true);
3773 hir::ExprAssign(ref lhs, ref rhs) => {
3774 let lhs_ty = self.check_expr_with_lvalue_pref(&lhs, PreferMutLvalue);
3776 let rhs_ty = self.check_expr_coercable_to_type(&rhs, lhs_ty);
3779 ExpectIfCondition => {
3780 self.tcx.sess.delay_span_bug(lhs.span, "invalid lhs expression in if;\
3781 expected error elsehwere");
3784 // Only check this if not in an `if` condition, as the
3785 // mistyped comparison help is more appropriate.
3786 if !self.tcx.expr_is_lval(&lhs) {
3787 struct_span_err!(self.tcx.sess, expr.span, E0070,
3788 "invalid left-hand side expression")
3789 .span_label(expr.span, "left-hand of expression not valid")
3795 self.require_type_is_sized(lhs_ty, lhs.span, traits::AssignmentLhsSized);
3797 if lhs_ty.references_error() || rhs_ty.references_error() {
3803 hir::ExprIf(ref cond, ref then_expr, ref opt_else_expr) => {
3804 self.check_then_else(&cond, then_expr, opt_else_expr.as_ref().map(|e| &**e),
3805 expr.span, expected)
3807 hir::ExprWhile(ref cond, ref body, _) => {
3808 let ctxt = BreakableCtxt {
3809 // cannot use break with a value from a while loop
3814 self.with_breakable_ctxt(expr.id, ctxt, || {
3815 self.check_expr_has_type_or_error(&cond, tcx.types.bool);
3816 let cond_diverging = self.diverges.get();
3817 self.check_block_no_value(&body);
3819 // We may never reach the body so it diverging means nothing.
3820 self.diverges.set(cond_diverging);
3825 hir::ExprLoop(ref body, _, source) => {
3826 let coerce = match source {
3827 // you can only use break with a value from a normal `loop { }`
3828 hir::LoopSource::Loop => {
3829 let coerce_to = expected.coercion_target_type(self, body.span);
3830 Some(CoerceMany::new(coerce_to))
3833 hir::LoopSource::WhileLet |
3834 hir::LoopSource::ForLoop => {
3839 let ctxt = BreakableCtxt {
3841 may_break: false, // will get updated if/when we find a `break`
3844 let (ctxt, ()) = self.with_breakable_ctxt(expr.id, ctxt, || {
3845 self.check_block_no_value(&body);
3849 // No way to know whether it's diverging because
3850 // of a `break` or an outer `break` or `return.
3851 self.diverges.set(Diverges::Maybe);
3854 // If we permit break with a value, then result type is
3855 // the LUB of the breaks (possibly ! if none); else, it
3856 // is nil. This makes sense because infinite loops
3857 // (which would have type !) are only possible iff we
3858 // permit break with a value [1].
3859 assert!(ctxt.coerce.is_some() || ctxt.may_break); // [1]
3860 ctxt.coerce.map(|c| c.complete(self)).unwrap_or(self.tcx.mk_nil())
3862 hir::ExprMatch(ref discrim, ref arms, match_src) => {
3863 self.check_match(expr, &discrim, arms, expected, match_src)
3865 hir::ExprClosure(capture, ref decl, body_id, _, gen) => {
3866 self.check_expr_closure(expr, capture, &decl, body_id, gen, expected)
3868 hir::ExprBlock(ref body) => {
3869 self.check_block_with_expected(&body, expected)
3871 hir::ExprCall(ref callee, ref args) => {
3872 self.check_call(expr, &callee, args, expected)
3874 hir::ExprMethodCall(ref segment, span, ref args) => {
3875 self.check_method_call(expr, segment, span, args, expected, lvalue_pref)
3877 hir::ExprCast(ref e, ref t) => {
3878 // Find the type of `e`. Supply hints based on the type we are casting to,
3880 let t_cast = self.to_ty(t);
3881 let t_cast = self.resolve_type_vars_if_possible(&t_cast);
3882 let t_expr = self.check_expr_with_expectation(e, ExpectCastableToType(t_cast));
3883 let t_cast = self.resolve_type_vars_if_possible(&t_cast);
3884 let diverges = self.diverges.get();
3886 // Eagerly check for some obvious errors.
3887 if t_expr.references_error() || t_cast.references_error() {
3890 // Defer other checks until we're done type checking.
3891 let mut deferred_cast_checks = self.deferred_cast_checks.borrow_mut();
3892 match cast::CastCheck::new(self, e, t_expr, diverges, t_cast, t.span, expr.span) {
3894 deferred_cast_checks.push(cast_check);
3897 Err(ErrorReported) => {
3903 hir::ExprType(ref e, ref t) => {
3904 let typ = self.to_ty(&t);
3905 self.check_expr_eq_type(&e, typ);
3908 hir::ExprArray(ref args) => {
3909 let uty = expected.to_option(self).and_then(|uty| {
3911 ty::TyArray(ty, _) | ty::TySlice(ty) => Some(ty),
3916 let element_ty = if !args.is_empty() {
3917 let coerce_to = uty.unwrap_or_else(
3918 || self.next_ty_var(TypeVariableOrigin::TypeInference(expr.span)));
3919 let mut coerce = CoerceMany::with_coercion_sites(coerce_to, args);
3920 assert_eq!(self.diverges.get(), Diverges::Maybe);
3922 let e_ty = self.check_expr_with_hint(e, coerce_to);
3923 let cause = self.misc(e.span);
3924 coerce.coerce(self, &cause, e, e_ty, self.diverges.get());
3926 coerce.complete(self)
3928 self.next_ty_var(TypeVariableOrigin::TypeInference(expr.span))
3930 tcx.mk_array(element_ty, args.len() as u64)
3932 hir::ExprRepeat(ref element, count) => {
3933 let count_def_id = tcx.hir.body_owner_def_id(count);
3934 let param_env = ty::ParamEnv::empty(traits::Reveal::UserFacing);
3935 let substs = Substs::identity_for_item(tcx.global_tcx(), count_def_id);
3936 let count = tcx.const_eval(param_env.and((count_def_id, substs)));
3938 if let Err(ref err) = count {
3939 err.report(tcx, tcx.def_span(count_def_id), "constant expression");
3942 let uty = match expected {
3943 ExpectHasType(uty) => {
3945 ty::TyArray(ty, _) | ty::TySlice(ty) => Some(ty),
3952 let (element_ty, t) = match uty {
3954 self.check_expr_coercable_to_type(&element, uty);
3958 let t: Ty = self.next_ty_var(TypeVariableOrigin::MiscVariable(element.span));
3959 let element_ty = self.check_expr_has_type_or_error(&element, t);
3964 if let Ok(count) = count {
3965 let zero_or_one = count.val.to_const_int().and_then(|count| {
3966 count.to_u64().map(|count| count <= 1)
3967 }).unwrap_or(false);
3969 // For [foo, ..n] where n > 1, `foo` must have
3971 let lang_item = self.tcx.require_lang_item(lang_items::CopyTraitLangItem);
3972 self.require_type_meets(t, expr.span, traits::RepeatVec, lang_item);
3976 if element_ty.references_error() {
3978 } else if let Ok(count) = count {
3979 tcx.mk_ty(ty::TyArray(t, count))
3984 hir::ExprTup(ref elts) => {
3985 let flds = expected.only_has_type(self).and_then(|ty| {
3986 let ty = self.resolve_type_vars_with_obligations(ty);
3988 ty::TyTuple(ref flds, _) => Some(&flds[..]),
3993 let elt_ts_iter = elts.iter().enumerate().map(|(i, e)| {
3994 let t = match flds {
3995 Some(ref fs) if i < fs.len() => {
3997 self.check_expr_coercable_to_type(&e, ety);
4001 self.check_expr_with_expectation(&e, NoExpectation)
4006 let tuple = tcx.mk_tup(elt_ts_iter, false);
4007 if tuple.references_error() {
4010 self.require_type_is_sized(tuple, expr.span, traits::TupleInitializerSized);
4014 hir::ExprStruct(ref qpath, ref fields, ref base_expr) => {
4015 self.check_expr_struct(expr, expected, qpath, fields, base_expr)
4017 hir::ExprField(ref base, ref field) => {
4018 self.check_field(expr, lvalue_pref, &base, field)
4020 hir::ExprTupField(ref base, idx) => {
4021 self.check_tup_field(expr, lvalue_pref, &base, idx)
4023 hir::ExprIndex(ref base, ref idx) => {
4024 let base_t = self.check_expr_with_lvalue_pref(&base, lvalue_pref);
4025 let idx_t = self.check_expr(&idx);
4027 if base_t.references_error() {
4029 } else if idx_t.references_error() {
4032 let base_t = self.structurally_resolved_type(expr.span, base_t);
4033 match self.lookup_indexing(expr, base, base_t, idx_t, lvalue_pref) {
4034 Some((index_ty, element_ty)) => {
4035 self.demand_coerce(idx, idx_t, index_ty);
4039 let mut err = type_error_struct!(tcx.sess, expr.span, base_t, E0608,
4040 "cannot index into a value of type `{}`",
4042 // Try to give some advice about indexing tuples.
4043 if let ty::TyTuple(..) = base_t.sty {
4044 let mut needs_note = true;
4045 // If the index is an integer, we can show the actual
4046 // fixed expression:
4047 if let hir::ExprLit(ref lit) = idx.node {
4048 if let ast::LitKind::Int(i,
4049 ast::LitIntType::Unsuffixed) = lit.node {
4050 let snip = tcx.sess.codemap().span_to_snippet(base.span);
4051 if let Ok(snip) = snip {
4052 err.span_suggestion(expr.span,
4053 "to access tuple elements, use",
4054 format!("{}.{}", snip, i));
4060 err.help("to access tuple elements, use tuple indexing \
4061 syntax (e.g. `tuple.0`)");
4070 hir::ExprYield(ref value) => {
4071 match self.yield_ty {
4073 self.check_expr_coercable_to_type(&value, ty);
4076 struct_span_err!(self.tcx.sess, expr.span, E0627,
4077 "yield statement outside of generator literal").emit();
4085 // Finish resolving a path in a struct expression or pattern `S::A { .. }` if necessary.
4086 // The newly resolved definition is written into `type_dependent_defs`.
4087 fn finish_resolving_struct_path(&self,
4090 node_id: ast::NodeId)
4094 hir::QPath::Resolved(ref maybe_qself, ref path) => {
4095 let opt_self_ty = maybe_qself.as_ref().map(|qself| self.to_ty(qself));
4096 let ty = AstConv::def_to_ty(self, opt_self_ty, path, true);
4099 hir::QPath::TypeRelative(ref qself, ref segment) => {
4100 let ty = self.to_ty(qself);
4102 let def = if let hir::TyPath(hir::QPath::Resolved(_, ref path)) = qself.node {
4107 let (ty, def) = AstConv::associated_path_def_to_ty(self, node_id, path_span,
4110 // Write back the new resolution.
4111 let hir_id = self.tcx.hir.node_to_hir_id(node_id);
4112 self.tables.borrow_mut().type_dependent_defs_mut().insert(hir_id, def);
4119 // Resolve associated value path into a base type and associated constant or method definition.
4120 // The newly resolved definition is written into `type_dependent_defs`.
4121 pub fn resolve_ty_and_def_ufcs<'b>(&self,
4122 qpath: &'b hir::QPath,
4123 node_id: ast::NodeId,
4125 -> (Def, Option<Ty<'tcx>>, &'b [hir::PathSegment])
4127 let (ty, item_segment) = match *qpath {
4128 hir::QPath::Resolved(ref opt_qself, ref path) => {
4130 opt_qself.as_ref().map(|qself| self.to_ty(qself)),
4131 &path.segments[..]);
4133 hir::QPath::TypeRelative(ref qself, ref segment) => {
4134 (self.to_ty(qself), segment)
4137 let hir_id = self.tcx.hir.node_to_hir_id(node_id);
4138 if let Some(cached_def) = self.tables.borrow().type_dependent_defs().get(hir_id) {
4139 // Return directly on cache hit. This is useful to avoid doubly reporting
4140 // errors with default match binding modes. See #44614.
4141 return (*cached_def, Some(ty), slice::from_ref(&**item_segment))
4143 let item_name = item_segment.name;
4144 let def = match self.resolve_ufcs(span, item_name, ty, node_id) {
4147 let def = match error {
4148 method::MethodError::PrivateMatch(def, _) => def,
4151 if item_name != keywords::Invalid.name() {
4152 self.report_method_error(span, ty, item_name, None, error, None);
4158 // Write back the new resolution.
4159 self.tables.borrow_mut().type_dependent_defs_mut().insert(hir_id, def);
4160 (def, Some(ty), slice::from_ref(&**item_segment))
4163 pub fn check_decl_initializer(&self,
4164 local: &'gcx hir::Local,
4165 init: &'gcx hir::Expr) -> Ty<'tcx>
4167 // FIXME(tschottdorf): contains_explicit_ref_binding() must be removed
4168 // for #42640 (default match binding modes).
4171 let ref_bindings = local.pat.contains_explicit_ref_binding();
4173 let local_ty = self.local_ty(init.span, local.id);
4174 if let Some(m) = ref_bindings {
4175 // Somewhat subtle: if we have a `ref` binding in the pattern,
4176 // we want to avoid introducing coercions for the RHS. This is
4177 // both because it helps preserve sanity and, in the case of
4178 // ref mut, for soundness (issue #23116). In particular, in
4179 // the latter case, we need to be clear that the type of the
4180 // referent for the reference that results is *equal to* the
4181 // type of the lvalue it is referencing, and not some
4182 // supertype thereof.
4183 let init_ty = self.check_expr_with_lvalue_pref(init, LvaluePreference::from_mutbl(m));
4184 self.demand_eqtype(init.span, local_ty, init_ty);
4187 self.check_expr_coercable_to_type(init, local_ty)
4191 pub fn check_decl_local(&self, local: &'gcx hir::Local) {
4192 let t = self.local_ty(local.span, local.id);
4193 self.write_ty(local.hir_id, t);
4195 if let Some(ref init) = local.init {
4196 let init_ty = self.check_decl_initializer(local, &init);
4197 if init_ty.references_error() {
4198 self.write_ty(local.hir_id, init_ty);
4202 self.check_pat_walk(&local.pat, t,
4203 ty::BindingMode::BindByValue(hir::Mutability::MutImmutable),
4205 let pat_ty = self.node_ty(local.pat.hir_id);
4206 if pat_ty.references_error() {
4207 self.write_ty(local.hir_id, pat_ty);
4211 pub fn check_stmt(&self, stmt: &'gcx hir::Stmt) {
4212 // Don't do all the complex logic below for DeclItem.
4214 hir::StmtDecl(ref decl, _) => {
4216 hir::DeclLocal(_) => {}
4217 hir::DeclItem(_) => {
4222 hir::StmtExpr(..) | hir::StmtSemi(..) => {}
4225 self.warn_if_unreachable(stmt.node.id(), stmt.span, "statement");
4227 // Hide the outer diverging and has_errors flags.
4228 let old_diverges = self.diverges.get();
4229 let old_has_errors = self.has_errors.get();
4230 self.diverges.set(Diverges::Maybe);
4231 self.has_errors.set(false);
4234 hir::StmtDecl(ref decl, _) => {
4236 hir::DeclLocal(ref l) => {
4237 self.check_decl_local(&l);
4239 hir::DeclItem(_) => {/* ignore for now */}
4242 hir::StmtExpr(ref expr, _) => {
4243 // Check with expected type of ()
4244 self.check_expr_has_type_or_error(&expr, self.tcx.mk_nil());
4246 hir::StmtSemi(ref expr, _) => {
4247 self.check_expr(&expr);
4251 // Combine the diverging and has_error flags.
4252 self.diverges.set(self.diverges.get() | old_diverges);
4253 self.has_errors.set(self.has_errors.get() | old_has_errors);
4256 pub fn check_block_no_value(&self, blk: &'gcx hir::Block) {
4257 let unit = self.tcx.mk_nil();
4258 let ty = self.check_block_with_expected(blk, ExpectHasType(unit));
4260 // if the block produces a `!` value, that can always be
4261 // (effectively) coerced to unit.
4263 self.demand_suptype(blk.span, unit, ty);
4267 fn check_block_with_expected(&self,
4268 blk: &'gcx hir::Block,
4269 expected: Expectation<'tcx>) -> Ty<'tcx> {
4271 let mut fcx_ps = self.ps.borrow_mut();
4272 let unsafety_state = fcx_ps.recurse(blk);
4273 replace(&mut *fcx_ps, unsafety_state)
4276 // In some cases, blocks have just one exit, but other blocks
4277 // can be targeted by multiple breaks. This cannot happen in
4278 // normal Rust syntax today, but it can happen when we desugar
4279 // a `do catch { ... }` expression.
4283 // 'a: { if true { break 'a Err(()); } Ok(()) }
4285 // Here we would wind up with two coercions, one from
4286 // `Err(())` and the other from the tail expression
4287 // `Ok(())`. If the tail expression is omitted, that's a
4288 // "forced unit" -- unless the block diverges, in which
4289 // case we can ignore the tail expression (e.g., `'a: {
4290 // break 'a 22; }` would not force the type of the block
4292 let tail_expr = blk.expr.as_ref();
4293 let coerce_to_ty = expected.coercion_target_type(self, blk.span);
4294 let coerce = if blk.targeted_by_break {
4295 CoerceMany::new(coerce_to_ty)
4297 let tail_expr: &[P<hir::Expr>] = match tail_expr {
4298 Some(e) => slice::from_ref(e),
4301 CoerceMany::with_coercion_sites(coerce_to_ty, tail_expr)
4304 let prev_diverges = self.diverges.get();
4305 let ctxt = BreakableCtxt {
4306 coerce: Some(coerce),
4310 let (ctxt, ()) = self.with_breakable_ctxt(blk.id, ctxt, || {
4311 for s in &blk.stmts {
4315 // check the tail expression **without** holding the
4316 // `enclosing_breakables` lock below.
4317 let tail_expr_ty = tail_expr.map(|t| self.check_expr_with_expectation(t, expected));
4319 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4320 let ctxt = enclosing_breakables.find_breakable(blk.id);
4321 let coerce = ctxt.coerce.as_mut().unwrap();
4322 if let Some(tail_expr_ty) = tail_expr_ty {
4323 let tail_expr = tail_expr.unwrap();
4324 let cause = self.cause(tail_expr.span,
4325 ObligationCauseCode::BlockTailExpression(blk.id));
4330 self.diverges.get());
4332 // Subtle: if there is no explicit tail expression,
4333 // that is typically equivalent to a tail expression
4334 // of `()` -- except if the block diverges. In that
4335 // case, there is no value supplied from the tail
4336 // expression (assuming there are no other breaks,
4337 // this implies that the type of the block will be
4340 // #41425 -- label the implicit `()` as being the
4341 // "found type" here, rather than the "expected type".
4343 // #44579 -- if the block was recovered during parsing,
4344 // the type would be nonsensical and it is not worth it
4345 // to perform the type check, so we avoid generating the
4346 // diagnostic output.
4347 if !self.diverges.get().always() && !blk.recovered {
4348 coerce.coerce_forced_unit(self, &self.misc(blk.span), &mut |err| {
4349 if let Some(expected_ty) = expected.only_has_type(self) {
4350 self.consider_hint_about_removing_semicolon(blk,
4360 // If we can break from the block, then the block's exit is always reachable
4361 // (... as long as the entry is reachable) - regardless of the tail of the block.
4362 self.diverges.set(prev_diverges);
4365 let mut ty = ctxt.coerce.unwrap().complete(self);
4367 if self.has_errors.get() || ty.references_error() {
4368 ty = self.tcx.types.err
4371 self.write_ty(blk.hir_id, ty);
4373 *self.ps.borrow_mut() = prev;
4377 /// Given a `NodeId`, return the `FnDecl` of the method it is enclosed by and whether a
4378 /// suggestion can be made, `None` otherwise.
4379 pub fn get_fn_decl(&self, blk_id: ast::NodeId) -> Option<(hir::FnDecl, bool)> {
4380 // Get enclosing Fn, if it is a function or a trait method, unless there's a `loop` or
4381 // `while` before reaching it, as block tail returns are not available in them.
4382 if let Some(fn_id) = self.tcx.hir.get_return_block(blk_id) {
4383 let parent = self.tcx.hir.get(fn_id);
4385 if let Node::NodeItem(&hir::Item {
4386 name, node: hir::ItemFn(ref decl, ..), ..
4388 decl.clone().and_then(|decl| {
4389 // This is less than ideal, it will not suggest a return type span on any
4390 // method called `main`, regardless of whether it is actually the entry point,
4391 // but it will still present it as the reason for the expected type.
4392 Some((decl, name != Symbol::intern("main")))
4394 } else if let Node::NodeTraitItem(&hir::TraitItem {
4395 node: hir::TraitItemKind::Method(hir::MethodSig {
4399 decl.clone().and_then(|decl| {
4402 } else if let Node::NodeImplItem(&hir::ImplItem {
4403 node: hir::ImplItemKind::Method(hir::MethodSig {
4407 decl.clone().and_then(|decl| {
4418 /// On implicit return expressions with mismatched types, provide the following suggestions:
4420 /// - Point out the method's return type as the reason for the expected type
4421 /// - Possible missing semicolon
4422 /// - Possible missing return type if the return type is the default, and not `fn main()`
4423 pub fn suggest_mismatched_types_on_tail(&self,
4424 err: &mut DiagnosticBuilder<'tcx>,
4425 expression: &'gcx hir::Expr,
4429 blk_id: ast::NodeId) {
4430 self.suggest_missing_semicolon(err, expression, expected, cause_span);
4432 if let Some((fn_decl, can_suggest)) = self.get_fn_decl(blk_id) {
4433 self.suggest_missing_return_type(err, &fn_decl, expected, found, can_suggest);
4437 /// A common error is to forget to add a semicolon at the end of a block:
4441 /// bar_that_returns_u32()
4445 /// This routine checks if the return expression in a block would make sense on its own as a
4446 /// statement and the return type has been left as default or has been specified as `()`. If so,
4447 /// it suggests adding a semicolon.
4448 fn suggest_missing_semicolon(&self,
4449 err: &mut DiagnosticBuilder<'tcx>,
4450 expression: &'gcx hir::Expr,
4453 if expected.is_nil() {
4454 // `BlockTailExpression` only relevant if the tail expr would be
4455 // useful on its own.
4456 match expression.node {
4458 hir::ExprMethodCall(..) |
4460 hir::ExprWhile(..) |
4462 hir::ExprMatch(..) |
4463 hir::ExprBlock(..) => {
4464 let sp = cause_span.next_point();
4465 err.span_suggestion(sp,
4466 "try adding a semicolon",
4475 /// A possible error is to forget to add a return type that is needed:
4479 /// bar_that_returns_u32()
4483 /// This routine checks if the return type is left as default, the method is not part of an
4484 /// `impl` block and that it isn't the `main` method. If so, it suggests setting the return
4486 fn suggest_missing_return_type(&self,
4487 err: &mut DiagnosticBuilder<'tcx>,
4488 fn_decl: &hir::FnDecl,
4491 can_suggest: bool) {
4492 // Only suggest changing the return type for methods that
4493 // haven't set a return type at all (and aren't `fn main()` or an impl).
4494 match (&fn_decl.output, found.is_suggestable(), can_suggest) {
4495 (&hir::FunctionRetTy::DefaultReturn(span), true, true) => {
4496 err.span_suggestion(span,
4497 "try adding a return type",
4499 self.resolve_type_vars_with_obligations(found)));
4501 (&hir::FunctionRetTy::DefaultReturn(span), false, true) => {
4502 err.span_label(span, "possibly return type missing here?");
4504 (&hir::FunctionRetTy::DefaultReturn(span), _, _) => {
4505 // `fn main()` must return `()`, do not suggest changing return type
4506 err.span_label(span, "expected `()` because of default return type");
4508 (&hir::FunctionRetTy::Return(ref ty), _, _) => {
4509 // Only point to return type if the expected type is the return type, as if they
4510 // are not, the expectation must have been caused by something else.
4511 debug!("suggest_missing_return_type: return type {:?} node {:?}", ty, ty.node);
4513 let ty = AstConv::ast_ty_to_ty(self, ty);
4514 debug!("suggest_missing_return_type: return type sty {:?}", ty.sty);
4515 debug!("suggest_missing_return_type: expected type sty {:?}", ty.sty);
4516 if ty.sty == expected.sty {
4517 err.span_label(sp, format!("expected `{}` because of return type",
4525 /// A common error is to add an extra semicolon:
4528 /// fn foo() -> usize {
4533 /// This routine checks if the final statement in a block is an
4534 /// expression with an explicit semicolon whose type is compatible
4535 /// with `expected_ty`. If so, it suggests removing the semicolon.
4536 fn consider_hint_about_removing_semicolon(&self,
4537 blk: &'gcx hir::Block,
4538 expected_ty: Ty<'tcx>,
4539 err: &mut DiagnosticBuilder) {
4540 // Be helpful when the user wrote `{... expr;}` and
4541 // taking the `;` off is enough to fix the error.
4542 let last_stmt = match blk.stmts.last() {
4546 let last_expr = match last_stmt.node {
4547 hir::StmtSemi(ref e, _) => e,
4550 let last_expr_ty = self.node_ty(last_expr.hir_id);
4551 if self.can_sub(self.param_env, last_expr_ty, expected_ty).is_err() {
4554 let original_span = original_sp(last_stmt.span, blk.span);
4555 let span_semi = original_span.with_lo(original_span.hi() - BytePos(1));
4556 err.span_suggestion(span_semi, "consider removing this semicolon", "".to_string());
4559 // Instantiates the given path, which must refer to an item with the given
4560 // number of type parameters and type.
4561 pub fn instantiate_value_path(&self,
4562 segments: &[hir::PathSegment],
4563 opt_self_ty: Option<Ty<'tcx>>,
4566 node_id: ast::NodeId)
4568 debug!("instantiate_value_path(path={:?}, def={:?}, node_id={})",
4573 // We need to extract the type parameters supplied by the user in
4574 // the path `path`. Due to the current setup, this is a bit of a
4575 // tricky-process; the problem is that resolve only tells us the
4576 // end-point of the path resolution, and not the intermediate steps.
4577 // Luckily, we can (at least for now) deduce the intermediate steps
4578 // just from the end-point.
4580 // There are basically four cases to consider:
4582 // 1. Reference to a constructor of enum variant or struct:
4584 // struct Foo<T>(...)
4585 // enum E<T> { Foo(...) }
4587 // In these cases, the parameters are declared in the type
4590 // 2. Reference to a fn item or a free constant:
4594 // In this case, the path will again always have the form
4595 // `a::b::foo::<T>` where only the final segment should have
4596 // type parameters. However, in this case, those parameters are
4597 // declared on a value, and hence are in the `FnSpace`.
4599 // 3. Reference to a method or an associated constant:
4601 // impl<A> SomeStruct<A> {
4605 // Here we can have a path like
4606 // `a::b::SomeStruct::<A>::foo::<B>`, in which case parameters
4607 // may appear in two places. The penultimate segment,
4608 // `SomeStruct::<A>`, contains parameters in TypeSpace, and the
4609 // final segment, `foo::<B>` contains parameters in fn space.
4611 // 4. Reference to a local variable
4613 // Local variables can't have any type parameters.
4615 // The first step then is to categorize the segments appropriately.
4617 assert!(!segments.is_empty());
4619 let mut ufcs_associated = None;
4620 let mut type_segment = None;
4621 let mut fn_segment = None;
4623 // Case 1. Reference to a struct/variant constructor.
4624 Def::StructCtor(def_id, ..) |
4625 Def::VariantCtor(def_id, ..) => {
4626 // Everything but the final segment should have no
4627 // parameters at all.
4628 let mut generics = self.tcx.generics_of(def_id);
4629 if let Some(def_id) = generics.parent {
4630 // Variant and struct constructors use the
4631 // generics of their parent type definition.
4632 generics = self.tcx.generics_of(def_id);
4634 type_segment = Some((segments.last().unwrap(), generics));
4637 // Case 2. Reference to a top-level value.
4639 Def::Const(def_id) |
4640 Def::Static(def_id, _) => {
4641 fn_segment = Some((segments.last().unwrap(),
4642 self.tcx.generics_of(def_id)));
4645 // Case 3. Reference to a method or associated const.
4646 Def::Method(def_id) |
4647 Def::AssociatedConst(def_id) => {
4648 let container = self.tcx.associated_item(def_id).container;
4650 ty::TraitContainer(trait_did) => {
4651 callee::check_legal_trait_for_method_call(self.tcx, span, trait_did)
4653 ty::ImplContainer(_) => {}
4656 let generics = self.tcx.generics_of(def_id);
4657 if segments.len() >= 2 {
4658 let parent_generics = self.tcx.generics_of(generics.parent.unwrap());
4659 type_segment = Some((&segments[segments.len() - 2], parent_generics));
4661 // `<T>::assoc` will end up here, and so can `T::assoc`.
4662 let self_ty = opt_self_ty.expect("UFCS sugared assoc missing Self");
4663 ufcs_associated = Some((container, self_ty));
4665 fn_segment = Some((segments.last().unwrap(), generics));
4668 // Case 4. Local variable, no generics.
4669 Def::Local(..) | Def::Upvar(..) => {}
4671 _ => bug!("unexpected definition: {:?}", def),
4674 debug!("type_segment={:?} fn_segment={:?}", type_segment, fn_segment);
4676 // Now that we have categorized what space the parameters for each
4677 // segment belong to, let's sort out the parameters that the user
4678 // provided (if any) into their appropriate spaces. We'll also report
4679 // errors if type parameters are provided in an inappropriate place.
4680 let poly_segments = type_segment.is_some() as usize +
4681 fn_segment.is_some() as usize;
4682 AstConv::prohibit_type_params(self, &segments[..segments.len() - poly_segments]);
4685 Def::Local(nid) | Def::Upvar(nid, ..) => {
4686 let ty = self.local_ty(span, nid);
4687 let ty = self.normalize_associated_types_in(span, &ty);
4688 self.write_ty(self.tcx.hir.node_to_hir_id(node_id), ty);
4694 // Now we have to compare the types that the user *actually*
4695 // provided against the types that were *expected*. If the user
4696 // did not provide any types, then we want to substitute inference
4697 // variables. If the user provided some types, we may still need
4698 // to add defaults. If the user provided *too many* types, that's
4700 self.check_path_parameter_count(span, &mut type_segment, false);
4701 self.check_path_parameter_count(span, &mut fn_segment, false);
4702 self.check_impl_trait(span, &mut fn_segment);
4704 let (fn_start, has_self) = match (type_segment, fn_segment) {
4705 (_, Some((_, generics))) => {
4706 (generics.parent_count(), generics.has_self)
4708 (Some((_, generics)), None) => {
4709 (generics.own_count(), generics.has_self)
4711 (None, None) => (0, false)
4713 let substs = Substs::for_item(self.tcx, def.def_id(), |def, _| {
4714 let mut i = def.index as usize;
4716 let segment = if i < fn_start {
4717 i -= has_self as usize;
4723 let lifetimes = segment.map_or(&[][..], |(s, _)| {
4724 s.parameters.as_ref().map_or(&[][..], |p| &p.lifetimes[..])
4727 if let Some(lifetime) = lifetimes.get(i) {
4728 AstConv::ast_region_to_region(self, lifetime, Some(def))
4730 self.re_infer(span, Some(def)).unwrap()
4733 let mut i = def.index as usize;
4735 let segment = if i < fn_start {
4736 // Handle Self first, so we can adjust the index to match the AST.
4737 if has_self && i == 0 {
4738 return opt_self_ty.unwrap_or_else(|| {
4739 self.type_var_for_def(span, def, substs)
4742 i -= has_self as usize;
4748 let (types, infer_types) = segment.map_or((&[][..], true), |(s, _)| {
4749 (s.parameters.as_ref().map_or(&[][..], |p| &p.types[..]), s.infer_types)
4752 // Skip over the lifetimes in the same segment.
4753 if let Some((_, generics)) = segment {
4754 i -= generics.regions.len();
4757 if let Some(ast_ty) = types.get(i) {
4758 // A provided type parameter.
4760 } else if !infer_types && def.has_default {
4761 // No type parameter provided, but a default exists.
4762 let default = self.tcx.type_of(def.def_id);
4765 default.subst_spanned(self.tcx, substs, Some(span))
4768 // No type parameters were provided, we can infer all.
4769 // This can also be reached in some error cases:
4770 // We prefer to use inference variables instead of
4771 // TyError to let type inference recover somewhat.
4772 self.type_var_for_def(span, def, substs)
4776 // The things we are substituting into the type should not contain
4777 // escaping late-bound regions, and nor should the base type scheme.
4778 let ty = self.tcx.type_of(def.def_id());
4779 assert!(!substs.has_escaping_regions());
4780 assert!(!ty.has_escaping_regions());
4782 // Add all the obligations that are required, substituting and
4783 // normalized appropriately.
4784 let bounds = self.instantiate_bounds(span, def.def_id(), &substs);
4785 self.add_obligations_for_parameters(
4786 traits::ObligationCause::new(span, self.body_id, traits::ItemObligation(def.def_id())),
4789 // Substitute the values for the type parameters into the type of
4790 // the referenced item.
4791 let ty_substituted = self.instantiate_type_scheme(span, &substs, &ty);
4793 if let Some((ty::ImplContainer(impl_def_id), self_ty)) = ufcs_associated {
4794 // In the case of `Foo<T>::method` and `<Foo<T>>::method`, if `method`
4795 // is inherent, there is no `Self` parameter, instead, the impl needs
4796 // type parameters, which we can infer by unifying the provided `Self`
4797 // with the substituted impl type.
4798 let ty = self.tcx.type_of(impl_def_id);
4800 let impl_ty = self.instantiate_type_scheme(span, &substs, &ty);
4801 match self.at(&self.misc(span), self.param_env).sup(impl_ty, self_ty) {
4802 Ok(ok) => self.register_infer_ok_obligations(ok),
4805 "instantiate_value_path: (UFCS) {:?} was a subtype of {:?} but now is not?",
4812 debug!("instantiate_value_path: type of {:?} is {:?}",
4815 self.write_substs(self.tcx.hir.node_to_hir_id(node_id), substs);
4819 /// Report errors if the provided parameters are too few or too many.
4820 fn check_path_parameter_count(&self,
4822 segment: &mut Option<(&hir::PathSegment, &ty::Generics)>,
4823 is_method_call: bool) {
4824 let (lifetimes, types, infer_types, bindings) = segment.map_or(
4825 (&[][..], &[][..], true, &[][..]),
4826 |(s, _)| s.parameters.as_ref().map_or(
4827 (&[][..], &[][..], s.infer_types, &[][..]),
4828 |p| (&p.lifetimes[..], &p.types[..],
4829 s.infer_types, &p.bindings[..])));
4830 let infer_lifetimes = lifetimes.len() == 0;
4832 let count_lifetime_params = |n| {
4833 format!("{} lifetime parameter{}", n, if n == 1 { "" } else { "s" })
4835 let count_type_params = |n| {
4836 format!("{} type parameter{}", n, if n == 1 { "" } else { "s" })
4839 // Check provided type parameters.
4840 let type_defs = segment.map_or(&[][..], |(_, generics)| {
4841 if generics.parent.is_none() {
4842 &generics.types[generics.has_self as usize..]
4847 let required_len = type_defs.iter().take_while(|d| !d.has_default).count();
4848 if types.len() > type_defs.len() {
4849 let span = types[type_defs.len()].span;
4850 let expected_text = count_type_params(type_defs.len());
4851 let actual_text = count_type_params(types.len());
4852 struct_span_err!(self.tcx.sess, span, E0087,
4853 "too many type parameters provided: \
4854 expected at most {}, found {}",
4855 expected_text, actual_text)
4856 .span_label(span, format!("expected {}", expected_text))
4859 // To prevent derived errors to accumulate due to extra
4860 // type parameters, we force instantiate_value_path to
4861 // use inference variables instead of the provided types.
4863 } else if types.len() < required_len && !infer_types {
4864 let expected_text = count_type_params(required_len);
4865 let actual_text = count_type_params(types.len());
4866 struct_span_err!(self.tcx.sess, span, E0089,
4867 "too few type parameters provided: \
4868 expected {}, found {}",
4869 expected_text, actual_text)
4870 .span_label(span, format!("expected {}", expected_text))
4874 if !bindings.is_empty() {
4875 AstConv::prohibit_projection(self, bindings[0].span);
4878 // Check provided lifetime parameters.
4879 let lifetime_defs = segment.map_or(&[][..], |(_, generics)| &generics.regions);
4880 let required_len = lifetime_defs.len();
4882 // Prohibit explicit lifetime arguments if late bound lifetime parameters are present.
4883 let has_late_bound_lifetime_defs =
4884 segment.map_or(None, |(_, generics)| generics.has_late_bound_regions);
4885 if let (Some(span_late), false) = (has_late_bound_lifetime_defs, lifetimes.is_empty()) {
4886 // Report this as a lint only if no error was reported previously.
4887 let primary_msg = "cannot specify lifetime arguments explicitly \
4888 if late bound lifetime parameters are present";
4889 let note_msg = "the late bound lifetime parameter is introduced here";
4890 if !is_method_call && (lifetimes.len() > lifetime_defs.len() ||
4891 lifetimes.len() < required_len && !infer_lifetimes) {
4892 let mut err = self.tcx.sess.struct_span_err(lifetimes[0].span, primary_msg);
4893 err.span_note(span_late, note_msg);
4897 let mut multispan = MultiSpan::from_span(lifetimes[0].span);
4898 multispan.push_span_label(span_late, note_msg.to_string());
4899 self.tcx.lint_node(lint::builtin::LATE_BOUND_LIFETIME_ARGUMENTS,
4900 lifetimes[0].id, multispan, primary_msg);
4905 if lifetimes.len() > lifetime_defs.len() {
4906 let span = lifetimes[lifetime_defs.len()].span;
4907 let expected_text = count_lifetime_params(lifetime_defs.len());
4908 let actual_text = count_lifetime_params(lifetimes.len());
4909 struct_span_err!(self.tcx.sess, span, E0088,
4910 "too many lifetime parameters provided: \
4911 expected at most {}, found {}",
4912 expected_text, actual_text)
4913 .span_label(span, format!("expected {}", expected_text))
4915 } else if lifetimes.len() < required_len && !infer_lifetimes {
4916 let expected_text = count_lifetime_params(lifetime_defs.len());
4917 let actual_text = count_lifetime_params(lifetimes.len());
4918 struct_span_err!(self.tcx.sess, span, E0090,
4919 "too few lifetime parameters provided: \
4920 expected {}, found {}",
4921 expected_text, actual_text)
4922 .span_label(span, format!("expected {}", expected_text))
4927 /// Report error if there is an explicit type parameter when using `impl Trait`.
4928 fn check_impl_trait(&self,
4930 segment: &mut Option<(&hir::PathSegment, &ty::Generics)>) {
4931 use hir::SyntheticTyParamKind::*;
4933 segment.map(|(path_segment, generics)| {
4934 let explicit = !path_segment.infer_types;
4935 let impl_trait = generics.types.iter()
4937 match ty_param.synthetic {
4938 Some(ImplTrait) => true,
4943 if explicit && impl_trait {
4944 let mut err = struct_span_err! {
4948 "cannot provide explicit type parameters when `impl Trait` is \
4949 used in argument position."
4957 fn structurally_resolve_type_or_else<F>(&self, sp: Span, ty: Ty<'tcx>, f: F)
4959 where F: Fn() -> Ty<'tcx>
4961 let mut ty = self.resolve_type_vars_with_obligations(ty);
4964 let alternative = f();
4967 if alternative.is_ty_var() || alternative.references_error() {
4968 if !self.is_tainted_by_errors() {
4969 type_error_struct!(self.tcx.sess, sp, ty, E0619,
4970 "the type of this value must be known in this context")
4973 self.demand_suptype(sp, self.tcx.types.err, ty);
4974 ty = self.tcx.types.err;
4976 self.demand_suptype(sp, alternative, ty);
4984 // Resolves `typ` by a single level if `typ` is a type variable. If no
4985 // resolution is possible, then an error is reported.
4986 pub fn structurally_resolved_type(&self, sp: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
4987 self.structurally_resolve_type_or_else(sp, ty, || {
4992 fn with_breakable_ctxt<F: FnOnce() -> R, R>(&self, id: ast::NodeId,
4993 ctxt: BreakableCtxt<'gcx, 'tcx>, f: F)
4994 -> (BreakableCtxt<'gcx, 'tcx>, R) {
4997 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4998 index = enclosing_breakables.stack.len();
4999 enclosing_breakables.by_id.insert(id, index);
5000 enclosing_breakables.stack.push(ctxt);
5004 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
5005 debug_assert!(enclosing_breakables.stack.len() == index + 1);
5006 enclosing_breakables.by_id.remove(&id).expect("missing breakable context");
5007 enclosing_breakables.stack.pop().expect("missing breakable context")
5013 pub fn check_bounds_are_used<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
5014 generics: &hir::Generics,
5016 debug!("check_bounds_are_used(n_tps={}, ty={:?})",
5017 generics.ty_params().count(), ty);
5019 // make a vector of booleans initially false, set to true when used
5020 if generics.ty_params().next().is_none() { return; }
5021 let mut tps_used = vec![false; generics.ty_params().count()];
5023 let lifetime_count = generics.lifetimes().count();
5025 for leaf_ty in ty.walk() {
5026 if let ty::TyParam(ParamTy {idx, ..}) = leaf_ty.sty {
5027 debug!("Found use of ty param num {}", idx);
5028 tps_used[idx as usize - lifetime_count] = true;
5029 } else if let ty::TyError = leaf_ty.sty {
5030 // If there already another error, do not emit an error for not using a type Parameter
5031 assert!(tcx.sess.err_count() > 0);
5036 for (&used, param) in tps_used.iter().zip(generics.ty_params()) {
5038 struct_span_err!(tcx.sess, param.span, E0091,
5039 "type parameter `{}` is unused",
5041 .span_label(param.span, "unused type parameter")
5047 fn fatally_break_rust(sess: &Session) {
5048 let handler = sess.diagnostic();
5049 handler.span_bug_no_panic(
5051 "It looks like you're trying to break rust; would you like some ICE?",
5053 handler.note_without_error("the compiler expectedly panicked. this is a feature.");
5054 handler.note_without_error(
5055 "we would appreciate a joke overview: \
5056 https://github.com/rust-lang/rust/issues/43162#issuecomment-320764675"
5058 handler.note_without_error(&format!("rustc {} running on {}",
5059 option_env!("CFG_VERSION").unwrap_or("unknown_version"),
5060 ::session::config::host_triple(),